Como calcular k-anonimato de um conjunto de dados

k-anonimato é uma propriedade que indica a capacidade de reidentificação dos registros de um conjunto de dados. Um conjunto de dados é k-anônimo quando os semi-identificadores de cada pessoa contida nele são idênticos a uma quantidade de, no mínimo, k – 1 outra pessoa também contida no conjunto.

É possível calcular o valor de k-anonimato com base em uma ou mais colunas ou campos de um conjunto de dados. Neste tópico, demonstramos como calcular valores de k-anonimato para um conjunto de dados usando a Proteção de dados sensíveis. Para mais informações sobre k-anonimato ou análise de risco em geral, consulte o tópico sobre o conceito de análise de risco antes de continuar.

Antes de começar

Antes de continuar, verifique se você fez o seguinte:

  1. Faça login na sua Conta do Google.
  2. No console do Google Cloud , na página do seletor de projetos, selecione ou crie um projeto do Google Cloud .
    3. Acessar o seletor de projetos
  3. Verifique se o faturamento foi ativado para o projeto Google Cloud . Saiba como confirmar se a cobrança está ativada para seu projeto.
  4. Ative a proteção de dados sensíveis.
    5. Ativar a Proteção de Dados Sensíveis

  5. Selecione um conjunto de dados do BigQuery para a análise. A Proteção de Dados Sensíveis calcula a métrica k-anonimato verificando uma tabela do BigQuery.
  6. Determine um identificador (se aplicável) e pelo menos um semi-identificador no conjunto de dados. Para mais informações, consulte Termos e técnicas de análise de risco.

Calcular o k-anonimato

A Proteção de Dados Sensíveis realiza a análise de risco sempre que um job de análise de risco é executado. É preciso criar o job primeiro, usando o console doGoogle Cloud , enviando uma solicitação de API DLP ou usando uma biblioteca de cliente da Proteção de Dados Sensíveis.

Console

  1. No console do Google Cloud , acesse a página Criar análise de risco.

    Acessar "Criar análise de risco"

  2. Na seção Escolher dados de entrada, especifique a tabela do BigQuery a ser verificada inserindo o ID do projeto que contém a tabela, o ID do conjunto de dados e o nome da tabela.

  3. Em Métrica de privacidade a calcular, selecione k-anonimato.

  4. Na seção código da tarefa, é possível atribuir um identificador personalizado ao job e selecionar um local de recursos em que a Proteção de Dados Sensíveis vai processar seus dados. Quando terminar, clique em Continuar.

  5. Na seção Definir campos, especifique identificadores e semi-identificadores para o job de risco k-anonimato. A Proteção de dados sensíveis acessa os metadados da tabela do BigQuery especificada na etapa anterior e tenta preencher a lista de campos.

    1. Marque a caixa de seleção apropriada para especificar um campo como identificador (ID) ou semi-identificador (QI). É preciso selecionar 0 ou 1 identificador e pelo menos um semi-identificador.
    2. Se a Proteção de dados sensíveis não conseguir preencher os campos, clique em Inserir nome do campo para inserir manualmente um ou mais campos e definir cada um deles como identificador ou semi-identificador. Quando terminar, clique em Continuar.

  6. Na seção Adicionar ações, é possível adicionar ações opcionais que serão realizadas quando o job de risco for concluído. As opções disponíveis são estas:

    • Salvar no BigQuery: salva os resultados da verificação de análise de risco em uma tabela do BigQuery.

    • Publicar no Pub/Sub: publica uma notificação em um tópico do Pub/Sub.

    • Notificar por e-mail: envia um e-mail com resultados. Quando terminar, clique em Criar.

O job de análise de risco de k-anonimato começará imediatamente.

C#

Para saber como instalar e usar a biblioteca de cliente da proteção de dados sensíveis, consulte Bibliotecas de cliente da proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using Google.Cloud.PubSub.V1;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using static Google.Cloud.Dlp.V2.Action.Types;
using static Google.Cloud.Dlp.V2.PrivacyMetric.Types;

public class RiskAnalysisCreateKAnonymity
{
    public static AnalyzeDataSourceRiskDetails.Types.KAnonymityResult KAnonymity(
        string callingProjectId,
        string tableProjectId,
        string datasetId,
        string tableId,
        string topicId,
        string subscriptionId,
        IEnumerable<FieldId> quasiIds)
    {
        var dlp = DlpServiceClient.Create();

        // Construct + submit the job
        var KAnonymityConfig = new KAnonymityConfig
        {
            QuasiIds = { quasiIds }
        };

        var config = new RiskAnalysisJobConfig
        {
            PrivacyMetric = new PrivacyMetric
            {
                KAnonymityConfig = KAnonymityConfig
            },
            SourceTable = new BigQueryTable
            {
                ProjectId = tableProjectId,
                DatasetId = datasetId,
                TableId = tableId
            },
            Actions =
            {
                new Google.Cloud.Dlp.V2.Action
                {
                    PubSub = new PublishToPubSub
                    {
                        Topic = $"projects/{callingProjectId}/topics/{topicId}"
                    }
                }
            }
        };

        var submittedJob = dlp.CreateDlpJob(
            new CreateDlpJobRequest
            {
                ParentAsProjectName = new ProjectName(callingProjectId),
                RiskJob = config
            });

        // Listen to pub/sub for the job
        var subscriptionName = new SubscriptionName(callingProjectId, subscriptionId);
        var subscriber = SubscriberClient.CreateAsync(
            subscriptionName).Result;

        // SimpleSubscriber runs your message handle function on multiple
        // threads to maximize throughput.
        var done = new ManualResetEventSlim(false);
        subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
        {
            if (message.Attributes["DlpJobName"] == submittedJob.Name)
            {
                Thread.Sleep(500); // Wait for DLP API results to become consistent
                done.Set();
                return Task.FromResult(SubscriberClient.Reply.Ack);
            }
            else
            {
                return Task.FromResult(SubscriberClient.Reply.Nack);
            }
        });

        done.Wait(TimeSpan.FromMinutes(10)); // 10 minute timeout; may not work for large jobs
        subscriber.StopAsync(CancellationToken.None).Wait();

        // Process results
        var resultJob = dlp.GetDlpJob(new GetDlpJobRequest
        {
            DlpJobName = DlpJobName.Parse(submittedJob.Name)
        });

        var