O Cloud Data Loss Prevention (Cloud DLP) agora faz parte da Proteção de dados confidenciais. O nome da API continua o mesmo: API Cloud Data Loss Prevention (API DLP). Saiba mais sobre os serviços que fazem parte da Proteção de dados confidenciais.

Desidentificar dados do BigQuery no momento da consulta

Neste tutorial, mostramos como desidentificar dados ao consultar tabelas do BigQuery usando funções remotas e proteção de dados sensíveis. Essa abordagem é útil para limpar os resultados da consulta em tempo real e minimizar o acesso a dados que não são necessários para análise.

Neste tutorial, demonstramos a criptografia e 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 confidenciais no armazenamento.

Este tutorial é destinado a públicos-alvo com responsabilidades que incluem segurança, processamento ou análise de dados. Neste guia, presumimos que você conheça processamento e privacidade de dados, não precisa ser um especialista. Neste guia, também pressupomos que você pode executar scripts básicos do Cloud Shell e SQL.

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

As técnicas de desidentificação, como criptografia, ofuscam identificadores sensíveis brutos nos seus dados. Essas técnicas permitem preservar a utilidade dos dados para mesclagem ou análise, além de reduzir o risco de tratamento dos dados.

As empresas podem ter políticas ou requisitos regulamentares para armazenar apenas dados desidentificados no armazenamento de dados em nuvem. Além disso, eles podem precisar reidentificar de maneira eficiente os dados desidentificados para a geração de relatórios.

Para minimizar o risco de lidar com grandes volumes de dados confidenciais, use um pipeline automatizado de transformação de dados para criar conjuntos de dados desidentificados. É possível usar este tutorial para substituir esse pipeline por uma consulta SQL para apenas reidentificação ou desidentificação e reidentificação. Com este tutorial, você realiza 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 os dados em busca de informações sensíveis. A proteção de dados sensíveis tem mais de 150 classificadores integrados, chamados infoTypes. O uso da API Cloud Data Loss Prevention para desidentificar dados exige pipelines e aplicativos de dados. O objetivo deste tutorial é ajudar seus analistas, engenheiros ou cientistas de dados a alcançar o mesmo resultado por meio de funções SQL.

No final deste tutorial, você poderá escrever uma consulta semelhante à que aparece a seguir. Os dados confidenciais 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:

Row	`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.

Objetivos

Implante um serviço do Cloud Run que fornece a funcionalidade de desidentificação da proteção de dados sensíveis.
Criar funções remotas do BigQuery que usem modelos de desidentificação da proteção de dados confidenciais.
Verifique a criptografia de dados no BigQuery usando uma consulta SQL.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

Install the Google Cloud CLI.
Configure the gcloud CLI to use your federated identity.

For more information, see Browser-based sign-in with the gcloud CLI.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
Create or select a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
- Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
  Replace PROJECT_ID with a name for the Google Cloud project you are creating.
- Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
  Replace PROJECT_ID with your Google Cloud project name.

Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

Enable the Artifact Registry, BigQuery, API BigQuery Connection, Cloud Build, API Cloud Data Loss Prevention, Cloud Key Management Service, Cloud Run, Container Registry, Identity and Access Management, Resource Manager, Secret Manager e Service Usage APIs:

gcloud services enable artifactregistry.googleapis.com bigquery.googleapis.com bigqueryconnection.googleapis.com cloudbuild.googleapis.com cloudkms.googleapis.com cloudresourcemanager.googleapis.com containerregistry.googleapis.com dlp.googleapis.com iam.googleapis.com run.googleapis.com secretmanager.googleapis.com serviceusage.googleapis.com

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 você 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. Informe uma região, não uma zona.
Opcional: se você quiser usar um modelo de inspeção, defina o campo DLP_INSPECT_TEMPLATE como 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 essa etapa, a proteção de dados confidenciais 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 seu modelo de inspeção, por exemplo, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Faça a autenticação 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, insira yes.
Verifique se os dados podem ser criptografados e descriptografados.

Implantar uma solução personalizada manualmente

Se você 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 variáveis de ambiente a seguir:

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. Informe 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.

Crie 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 de Leitor de DLP:

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

Conceda o papel de Usuário de 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 alterar 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 será semelhante ao seguinte:

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 e salve o URL do Cloud Run nas suas 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 da proteção de dados sensíveis

Os modelos de desidentificação da proteção de dados confidenciais ajudam a salvar suas configurações de desidentificação para que seja possível 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 o uso de uma chave encapsulada ao executar a criptografia da proteção de dados confidenciais em cargas de trabalho confidenciais reais. Para fins de demonstração, este tutorial usa uma chave desencapsulada. Para mais informações sobre como criar uma chave encapsulada e usá-la nas solicitações de desidentificação e reidentificação, consulte Desidentificar e reidentificar dados confidenciais.

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ê quiser usar um modelo de inspeção, 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 essa etapa, a proteção de dados confidenciais 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 seu 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 os dados, faça o seguinte:

Console

No console do 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"

O resultado será assim:

Row	`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`
`2`	`Some non PII data`	`Some non PII data`	`Some non PII data`
`3`	`650-253-0000`	`BQ_TRF_PH(40):AeKpGU5KBXaTyecCun7dv1hHht5w5Q2PTpvkRC4=`	`650-253-0000`
`4`	`some script with simple number 1234`	`some script with simple number 1234`	`some script with simple number 1234`

Considerações

Ao adaptar este tutorial às suas necessidades, considere o seguinte:

A desidentificação e a reidentificação são processadas por um serviço do Cloud Run. Provisione a CPU e a memória do Cloud Run de acordo com seus requisitos de computação. Para mais detalhes, consulte os limites de CPU e de memória do Cloud Run.
Ao utilizar a proteção de dados sensíveis, considere os limites de uso e as recomendações para controlar os custos.
Para ajudar a controlar os custos e o consumo total da cota de proteção de dados sensíveis, limite os itens transmitidos pela função remota de proteção de dados sensíveis a 10.000 ou menos. A solução pode agrupar automaticamente as solicitações para lidar com os seguintes limites de solicitações de proteção de dados sensíveis:
- Número máximo de valores da tabela: 50.000
- Limite de tamanho da solicitação padrão: 0,5 MB
Os resultados finais e filtrados da consulta precisam ser transmitidos para a função de proteção de dados sensíveis, e não para a origem.

Para esta solução, cada valor na coluna pii_column é um item. Por exemplo, My name is John Doe. My email is john.doe@example.com é um item.
Verifique se o conjunto de dados do BigQuery, o serviço do Cloud Run e os modelos de proteção de dados sensíveis estão na mesma região da nuvem.

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Cuidado: excluir um projeto tem os seguintes efeitos:

Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

A seguir

Saiba mais sobre as funções remotas do BigQuery.
Aprenda a desidentificar dados confidenciais.
Confira um exemplo que demonstre como criar uma chave encapsulada, tokenizar o conteúdo e reidentificar o conteúdo tokenizado.
Saiba como lidar com a desidentificação e reidentificação de PIIs em conjuntos de dados de grande escala usando a proteção de dados confidenciais.
Saiba mais sobre o Cloud KMS.