O Cloud Data Loss Prevention (Cloud DLP) agora faz parte da Proteção de dados sensíveis. O nome da API continua o mesmo: API Cloud Data Loss Prevention (DLP). Para saber mais sobre os serviços que compõem a Proteção de dados sensíveis, consulte Visão geral da Proteção de dados sensíveis.

Esta página foi traduzida pela API Cloud Translation.

Desidentificar dados do BigQuery no momento da consulta

Neste tutorial, mostramos como desidentificar dados ao consultar tabelas do BigQuery usando funções remotas e a Proteção de Dados Sensíveis. Essa abordagem é útil para limpar resultados de consultas em tempo real e minimizar o acesso a dados desnecessários para análise.

Neste tutorial, demonstramos a criptografia e a descriptografia de dados em trânsito. Para informações sobre como usar a Proteção de Dados Sensíveis para criptografar dados em repouso, consulte Desidentificação de dados sensíveis no armazenamento.

Este tutorial é destinado a públicos-alvo cujas responsabilidades incluem segurança, tratamento ou análise de dados. Neste guia, consideramos que você já conhece o tratamento e a privacidade de dados, sem a necessidade de ser um especialista. Neste guia, também pressupomos que você saiba executar scripts básicos do Cloud Shell e do SQL.

Este tutorial usa funções baseadas em SQL, BigQuery, funções remotas, Cloud Run e proteção de dados sensíveis.

Técnicas de desidentificação, como criptografia, ofuscam identificadores brutos sensíveis nos seus dados. Com essas técnicas, é possível preservar a utilidade dos seus dados para mesclar ou analisar e, ao mesmo tempo, reduzir o risco de manipulação.

As empresas podem ter políticas ou requisitos regulatórios para armazenar apenas dados desidentificados no data warehouse em nuvem. Além disso, talvez seja necessário reidentificar com eficiência os dados desidentificados para gerar relatórios.

Para minimizar o risco de manipular grandes volumes de dados sensíveis, use um pipeline de transformação de dados automatizado para criar conjuntos de dados anônimos. Use este tutorial para substituir esse pipeline por uma consulta SQL apenas para reidentificação ou para desidentificação e reidentificação. Este tutorial ajuda você a realizar a desidentificação e a reidentificação usando um serviço central hospedado no Cloud Run. É possível usar esse serviço central em toda a organização sem precisar configurar ou manter um cluster do Dataflow.

A Proteção de Dados Sensíveis pode classificar conjuntos de dados inspecionando as informações sensíveis. A Proteção de Dados Sensíveis tem mais de 200 classificadores integrados, chamados de infoTypes. Para desidentificar dados usando a API Cloud Data Loss Prevention, são necessários pipelines e aplicativos de dados. Este tutorial tem como objetivo ajudar seus analistas, engenheiros ou cientistas de dados a alcançar o mesmo resultado usando funções SQL.

Ao final deste tutorial, você poderá escrever uma consulta semelhante à seguinte. Os dados sensíveis serão desidentificados e reidentificados no resultado da consulta.

SELECT
    pii_column,
    fns.dlp_freetext_encrypt(pii_column) AS dlp_encrypted,
    fns.dlp_freetext_decrypt(fns.dlp_freetext_encrypt(pii_column)) AS dlp_decrypted
FROM
    UNNEST(
    [
        'My name is John Doe. My email is john.doe@example.com']) AS pii_column

O resultado será assim:

Linha	`pii_column`	`dlp_encrypted`	`dlp_decrypted`
`1`	`My name is John Doe. My email is john.doe@example.com`	`My name is John Doe. My email is BQ_TRF_EMAIL(40):AQy6lGvwKR+AiiRqJpEr+nBzZUzOcjXkXamUugU=`	`My name is John Doe. My email is john.doe@example.com`

Arquitetura

O diagrama a seguir mostra como este tutorial usa o BigQuery como o data warehouse, a Proteção de dados sensíveis para desidentificar e reidentificar dados e o Cloud Run para hospedar as funções remotas.

Prepare o ambiente

No Cloud Shell, clone o repositório de origem:

git clone https://github.com/GoogleCloudPlatform/bigquery-dlp-remote-function.git

Acesse o diretório deste tutorial:
```
cd bigquery-dlp-remote-function/
```

Implantar os recursos usando um script

Se quiser usar o script de implantação sem fazer personalizações, siga estas etapas. Se você quiser personalizar a implantação, pule esta seção e consulte Implantar uma solução personalizada manualmente.

Defina os valores dos campos PROJECT_ID e REGION:
```
# Project ID of the Google Cloud project
PROJECT_ID="PROJECT_ID"

# Google Cloud region to use for deployment of resources
# Refer to https://cloud.google.com/about/locations
REGION="REGION"
```
Substitua:
- PROJECT_ID: o ID do projeto para este tutorial.
- REGION: a região em que você quer armazenar e processar os dados, por exemplo, us-west1. Forneça uma região, não uma zona.
Opcional: se você tiver um modelo de inspeção que queira usar, defina o campo DLP_INSPECT_TEMPLATE com o nome completo do recurso desse modelo. O modelo de inspeção precisa estar na mesma região definida no campo REGION.

Verifique se o modelo de inspeção inclui todos os infoTypes usados no modelo de desidentificação.

Se você pular esta etapa, a Proteção de dados sensíveis vai inspecionar os dados com um conjunto padrão do sistema de detectores de infoType.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Substitua DLP_INSPECT_TEMPLATE pelo nome completo do recurso do modelo de inspeção, por exemplo, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Autentique usando o Application Default Credentials:

gcloud auth application-default login && \
gcloud auth application-default set-quota-project "${PROJECT_ID}"

Inicialize e execute o script do Terraform para criar todos os recursos:
```
terraform init && \
terraform apply \
-var "project_id=${PROJECT_ID}" \
-var "region=${REGION}" \
-var "dlp_inspect_template_full_path=${DLP_INSPECT_TEMPLATE}"
```
O sistema mostra todas as ações que o Terraform vai realizar. Revise as ações. Para continuar, digite yes.
Verifique se os dados podem ser criptografados e descriptografados.

Implantar uma solução personalizada manualmente

Se quiser personalizar a implantação, siga estas etapas. Se você quiser usar o script de implantação fornecido sem personalizações ou etapas manuais, consulte Implantar os recursos usando um script.

Definir as variáveis de ambiente

No Cloud Shell, defina as seguintes variáveis de ambiente:

PROJECT_ID="PROJECT_ID"
REGION="REGION"
CLOUD_RUN_SERVICE_NAME="CLOUD-RUN-SERVICE-NAME"
ARTIFACT_REGISTRY_NAME="ARTIFACT-DOCKER-REGISTRY-NAME"

Substitua:

PROJECT_ID: o ID do projeto para este tutorial.
REGION: a região em que você quer armazenar e processar os dados, por exemplo, us-west1. Forneça uma região, não uma zona.
CLOUD_RUN_SERVICE_NAME: um nome para o novo serviço do Cloud Run. Insira até 15 caracteres.
ARTIFACT_REGISTRY_NAME: um nome para o novo Artifact Registry para armazenar imagens de contêiner.

Criar uma conta de serviço para o serviço do Cloud Run

Crie uma conta de serviço:

RUNNER_SA_NAME="${CLOUD_RUN_SERVICE_NAME}-runner"
RUNNER_SA_EMAIL="${RUNNER_SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"
gcloud iam service-accounts create "${RUNNER_SA_NAME}" \
    --project="${PROJECT_ID}" \
    --description "Runner for BigQuery remote function execution" \
    --display-name "${RUNNER_SA_NAME}"

Conceda os papéis necessários para a Proteção de Dados Sensíveis.

Conceda o papel Leitor do DLP:

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${RUNNER_SA_EMAIL}" \
    --role='roles/dlp.reader'

Conceda a função Usuário do DLP:

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${RUNNER_SA_EMAIL}" \
    --role='roles/dlp.user'

Implantar o serviço do Cloud Run

Para implantar o aplicativo, siga estas etapas:

Opcional: é possível mudar os valores padrão alterando as variáveis de ambiente ou atualizando o arquivo src/main/resources/aes.properties.

Crie um repositório do Artifact Registry para armazenar a imagem do contêiner da função:

gcloud artifacts repositories create "${ARTIFACT_REGISTRY_NAME}" \
--repository-format=docker \
--location="${REGION}" \
--description="Container images repository for BigQuery Functions" \
--project="${PROJECT_ID}"

Compile o aplicativo e implante-o no Cloud Run usando o Cloud Build:

gcloud builds submit \
--project ${PROJECT_ID} \
--substitutions=_CONTAINER_IMAGE_NAME="${REGION}-docker.pkg.dev/${PROJECT_ID}/${ARTIFACT_REGISTRY_NAME}/${CLOUD_RUN_SERVICE_NAME}:latest" \
--machine-type=e2-highcpu-8 && \
gcloud beta run deploy ${CLOUD_RUN_SERVICE_NAME} \
--image="${REGION}-docker.pkg.dev/${PROJECT_ID}/${ARTIFACT_REGISTRY_NAME}/${CLOUD_RUN_SERVICE_NAME}:latest" \
--execution-environment=gen2 \
--platform=managed \
--region="${REGION}" \
--service-account="${RUNNER_SA_EMAIL}" \
--cpu=4 \
--memory=8Gi \
--no-allow-unauthenticated \
--project ${PROJECT_ID} \
--update-env-vars=PROJECT_ID=${PROJECT_ID}

O final da saída é semelhante a este:

ID: 403a276e-b0c6-41f3-aaed-f0ec9f9cedba
CREATE_TIME: 2023-02-04T01:52:15+00:00
DURATION: 1M59S
SOURCE: gs://PROJECT_ID_cloudbuild/source/1675475534.124241-9c43787f64e04cfd9e4a1979d3324fe0.tgz
IMAGES: gcr.io/PROJECT_ID/CLOUD_RUN_SERVICE_NAME (+1 more)
STATUS: SUCCESS
Deploying container to Cloud Run service [CLOUD_RUN_SERVICE_NAME] in project [PROJECT_ID] region [REGION]
OK Deploying new service... Done.
 OK Creating Revision... Revision deployment finished. Checking container heal
 th.
 OK Routing traffic...
Done.
Service [CLOUD_RUN_SERVICE_NAME] revision [CLOUD_RUN_SERVICE_NAME-00001-tat] has been deployed and is serving 100 percent of traffic.
Service URL: https://CLOUD_RUN_SERVICE_NAME-j2bpjx2xoq-uw.a.run.app

Recupere o URL do Cloud Run e salve-o nas variáveis de ambiente:

RUN_URL="$(gcloud run services describe ${CLOUD_RUN_SERVICE_NAME} --region \
    ${REGION} --project ${PROJECT_ID} --format="get(status.address.url)")"

Criar um modelo de desidentificação de Proteção de Dados Sensíveis

Os modelos de desidentificação da Proteção de dados sensíveis ajudam a salvar as configurações de desidentificação para que você possa reutilizá-las em várias operações e fontes de dados.

Esta etapa usa o arquivo sample_dlp_deid_config.json, que contém um exemplo de modelo de desidentificação.

No Cloud Shell, crie o modelo:

DEID_TEMPLATE=$(curl -X POST \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "X-Goog-User-Project: ${PROJECT_ID}" \
--data-binary "@sample_dlp_deid_config.json" \
"https://dlp.googleapis.com/v2/projects/${PROJECT_ID}/locations/${REGION}/deidentifyTemplates")

DEID_TEMPLATE_NAME="$(echo ${DEID_TEMPLATE} | jq -r '.name')"

O Google recomenda usar uma chave encapsulada ao realizar a criptografia da Proteção de Dados Sensíveis em cargas de trabalho sensíveis reais. Para fins de demonstração, este tutorial usa uma chave não encapsulada. Para mais informações sobre como criar uma chave encapsulada e usá-la em solicitações de desidentificação e reidentificação, consulte Desidentificar e reidentificar dados sensíveis.

Criar a conexão do BigQuery com o Cloud Run

No Cloud Shell, crie uma conexão do BigQuery para acessar o Cloud Run:

bq mk --connection \
--display_name='External transform function connection' \
--connection_type=CLOUD_RESOURCE \
--project_id="${PROJECT_ID}" \
--location="${REGION}" \
ext-${CLOUD_RUN_SERVICE_NAME}

Encontre e defina a conta de serviço do BigQuery usada para a conexão:

CONNECTION_SA="$(bq --project_id ${PROJECT_ID} --format json show \
    --connection ${PROJECT_ID}.${REGION}.ext-${CLOUD_RUN_SERVICE_NAME} \
    | jq -r '.cloudResource.serviceAccountId')"

Conceda o papel Invocador do Cloud Run à conta de serviço:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:${CONNECTION_SA}" \
    --role='roles/run.invoker'

Criar o conjunto de dados do BigQuery para funções remotas

Defina o conjunto de dados do BigQuery para as funções remotas:
```
BQ_FUNCTION_DATASET="fns"
```

Crie o conjunto de dados se ele ainda não existir:

   bq mk --dataset \
       --project_id ${PROJECT_ID} \
       --location ${REGION} \
       ${BQ_FUNCTION_DATASET}

Criar as funções remotas da Proteção de Dados Sensíveis

Opcional: se você tiver um modelo de inspeção que queira usar, defina a variável DLP_INSPECT_TEMPLATE como o nome completo do recurso desse modelo. O modelo de inspeção precisa estar na mesma região definida na variável de ambiente REGION.

Verifique se o modelo de inspeção inclui todos os infoTypes usados no modelo de desidentificação.

Se você pular esta etapa, a Proteção de dados sensíveis vai inspecionar os dados com um conjunto padrão do sistema de detectores de infoType.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Substitua DLP_INSPECT_TEMPLATE pelo nome completo do recurso do modelo de inspeção, por exemplo, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Crie a função de desidentificação da Proteção de Dados Sensíveis:

bq query --project_id ${PROJECT_ID} \
--use_legacy_sql=false \
"CREATE OR REPLACE FUNCTION ${BQ_FUNCTION_DATASET}.dlp_freetext_encrypt(v STRING)
RETURNS STRING
REMOTE WITH CONNECTION \`${PROJECT_ID}.${REGION}.ext-${CLOUD_RUN_SERVICE_NAME}\`
OPTIONS (endpoint = '${RUN_URL}', user_defined_context = [('mode', 'deidentify'),('algo','dlp'),('dlp-deid-template','${DEID_TEMPLATE_NAME}'),('dlp-inspect-template', '${DLP_INSPECT_TEMPLATE}')]);"

Crie a função de reidentificação da Proteção de Dados Sensíveis:

bq query --project_id ${PROJECT_ID} \
--use_legacy_sql=false \
"CREATE OR REPLACE FUNCTION ${BQ_FUNCTION_DATASET}.dlp_freetext_decrypt(v STRING)
RETURNS STRING
REMOTE WITH CONNECTION \`${PROJECT_ID}.${REGION}.ext-${CLOUD_RUN_SERVICE_NAME}\`
OPTIONS (endpoint = '${RUN_URL}', user_defined_context = [('mode', 'reidentify'),('algo','dlp'),('dlp-deid-template','${DEID_TEMPLATE_NAME}'),('dlp-inspect-template', '${DLP_INSPECT_TEMPLATE}')]);"

Verificar a desidentificação e a reidentificação

Para verificar se a solução desidentifica e reidentifica dados, faça o seguinte:

Console

No console Google Cloud , acesse o BigQuery.

Acessar o BigQuery

O BigQuery é aberto no projeto que foi acessado mais recentemente.
Para abrir um editor de consultas, clique em Criar uma nova consulta.

Digite a seguinte consulta:

SELECT
    pii_column,
    fns.dlp_freetext_encrypt(pii_column) AS dlp_encrypted,
    fns.dlp_freetext_decrypt(fns.dlp_freetext_encrypt(pii_column)) AS dlp_decrypted
FROM
    UNNEST(
    [
        'My name is John Doe. My email is john.doe@example.com',
        'Some non PII data',
        '650-253-0000',
        'some script with simple number 1234']) AS pii_column

Clique em Executar.

bq

Defina a variável de ambiente para o conjunto de dados:
```
BQ_FUNCTION_DATASET="fns"
```

Execute a consulta:

bq query --project_id ${PROJECT_ID} \
--use_legacy_sql=false \
"
SELECT
  pii_column,
  ${BQ_FUNCTION_DATASET}.dlp_freetext_encrypt(pii_column) AS dlp_encrypted,
${BQ_FUNCTION_DATASET}.dlp_freetext_decrypt(${BQ_FUNCTION_DATASET}.dlp_freetext_encrypt(pii_column)) AS dlp_decrypted
FROM
  UNNEST(
    [
      'My name is John Doe. My email is john.doe@example.com',
      'Some non PII data',
      '650-253-0000',
      'some script with simple number 1234']) AS pii_column"