Anonimizza i dati BigQuery quando vengono eseguite le query

Prepara l'ambiente

1. In Cloud Shell, clona il repository di origine:

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

2. Vai alla directory di questo tutorial:

   cd bigquery-dlp-remote-function/
   

Esegui il deployment delle risorse utilizzando uno script

Se vuoi utilizzare lo script di deployment senza apportare personalizzazioni, segui questi passaggi. Se vuoi personalizzare il deployment, salta questa sezione e consulta Esegui il deployment di una soluzione personalizzata manualmente.

1. Imposta i valori per i campi 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"
   

   Sostituisci quanto segue:

   • PROJECT_ID: l'ID progetto per questo tutorial.
   • REGION: la regione in cui vuoi archiviare ed elaborare i dati, ad esempio us-west1. Fornisci una regione, non una zona.

2. (Facoltativo) Se hai un modello di ispezione che vuoi utilizzare, imposta il campo DLP_INSPECT_TEMPLATE sul nome risorsa completo del modello di ispezione. Il modello di ispezione deve trovarsi nella stessa regione impostata nel campo REGION.

   Assicurati che il modello di ispezione includa tutti gli infoType utilizzati nel modello di anonimizzazione.

   Se salti questo passaggio, Sensitive Data Protection ispeziona i dati con un set predefinito di sistema di rilevatori infoType.

   DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
   

   Sostituisci DLP_INSPECT_TEMPLATE con il nome risorsa completo del tuo modello di ispezione, ad esempio projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

3. Esegui l'autenticazione utilizzando le credenziali predefinite dell'applicazione:

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

4. Inizializza ed esegui lo script Terraform per creare tutte le risorse:

   terraform init && \
   terraform apply \
   -var "project_id=${PROJECT_ID}" \
   -var "region=${REGION}" \
   -var "dlp_inspect_template_full_path=${DLP_INSPECT_TEMPLATE}"
   

   Il sistema mostra tutte le azioni che Terraform eseguirà. Esamina le azioni. Per continuare, inserisci yes.

5. Verifica che i dati possano essere criptati e decriptati.

Implementare manualmente una soluzione personalizzata

Se vuoi personalizzare l'implementazione, segui questi passaggi. Se vuoi utilizzare lo script di deployment fornito senza personalizzazioni o passaggi manuali, consulta Esegui il deployment delle risorse utilizzando uno script.

Imposta le variabili di ambiente

In Cloud Shell, imposta le seguenti variabili di ambiente:

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID progetto per questo tutorial.
• REGION: la regione in cui vuoi archiviare ed elaborare i dati, ad esempio us-west1. Fornisci una regione, non una zona.
• CLOUD_RUN_SERVICE_NAME: un nome per il nuovo servizio Cloud Run. Inserisci fino a 15 caratteri.
• ARTIFACT_REGISTRY_NAME: un nome per il nuovo Artifact Registry per l'archiviazione delle immagini container.

Crea un account di servizio per il servizio Cloud Run

1. Crea un account di servizio:

   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}"
   

2. Concedi i ruoli richiesti per Sensitive Data Protection.

   Concedi il ruolo Lettore DLP:

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

   Concedi il ruolo Utente DLP:

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

Esegui il deployment del servizio Cloud Run

Per eseguire il deployment dell'applicazione:

1. (Facoltativo) Puoi modificare i valori predefiniti modificando le variabili di ambiente o aggiornando il file src/main/resources/aes.properties.

2. Crea un repository Artifact Registry per archiviare l'immagine container della funzione:

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

3. Compila l'applicazione ed esegui il deployment su Cloud Run utilizzando 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}
   

   La fine dell'output è simile alla seguente:

   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
   

4. Recupera l'URL di Cloud Run e salvalo nelle variabili di ambiente:

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

Crea un modello di anonimizzazione Sensitive Data Protection

I modelli di deidentificazione di Sensitive Data Protection ti aiutano a salvare le impostazioni di deidentificazione in modo da poterle riutilizzare in più operazioni e origini dati.

Questo passaggio utilizza il file sample_dlp_deid_config.json, che contiene un esempio di modello di deidentificazione.

In Cloud Shell, crea il modello:

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')"

Google consiglia di utilizzare una chiave sottoposta a wrapping quando esegui la crittografia Sensitive Data Protection su carichi di lavoro sensibili effettivi. A scopo dimostrativo, questo tutorial utilizza una chiave senza wrapping. Per ulteriori informazioni su come creare una chiave di wrapping e utilizzarla nelle richieste di anonimizzazione e reidentificazione, consulta Anonimizzare e reidentificare i dati sensibili.

Crea la connessione BigQuery a Cloud Run

1. In Cloud Shell, crea una connessione BigQuery per accedere a 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}
   

2. Trova e imposta il account di servizio BigQuery utilizzato per la connessione:

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

3. Concedi il ruolo Cloud Run Invoker al account di servizio:

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

Crea il set di dati BigQuery per le funzioni remote

1. Definisci il set di dati BigQuery per le funzioni remote:

   BQ_FUNCTION_DATASET="fns"
   

2. Crea il set di dati, se non esiste già:

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

Crea le funzioni remote di Sensitive Data Protection

1. (Facoltativo) Se hai un modello di ispezione che vuoi utilizzare, imposta la variabile DLP_INSPECT_TEMPLATE sul nome risorsa completo del modello di ispezione. Il modello di ispezione deve trovarsi nella stessa regione impostata nella variabile di ambiente REGION.

   Assicurati che il modello di ispezione includa tutti gli infoType utilizzati nel modello di anonimizzazione.

   Se salti questo passaggio, Sensitive Data Protection esamina i dati con un set predefinito di rilevatori infoType.

   DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
   

   Sostituisci DLP_INSPECT_TEMPLATE con il nome risorsa completo del tuo modello di ispezione, ad esempio projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

2. Crea la funzione di anonimizzazione Sensitive Data Protection:

   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}')]);"
   

3. Crea la funzione di reidentificazione di Sensitive Data Protection:

   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}')]);"
   

Verifica della deidentificazione e della reidentificazione

Per verificare se la soluzione deidentifica e reidentifica i dati:

L'output è simile al seguente:

Considerazioni

Quando adatti questo tutorial alle tue esigenze, tieni presente quanto segue:

• L'anonimizzazione e la reidentificazione vengono elaborate tramite un servizio Cloud Run. Esegui il provisioning della CPU e della memoria di Cloud Run in base ai tuoi requisiti di calcolo. Per i dettagli, consulta i limiti della CPU e i limiti di memoria per Cloud Run.
• Quando utilizzi Sensitive Data Protection, tieni presente i limiti di utilizzo e i suggerimenti per controllare i costi.

• Per contribuire a controllare i costi e il consumo totale della quota di Sensitive Data Protection, limita gli elementi che trasmetti alla funzione remota di Sensitive Data Protection a 10.000 o meno. La soluzione può raggruppare automaticamente le richieste per gestire correttamente i seguenti limiti delle richieste di Protezione dei dati sensibili:

  • Numero massimo di valori della tabella: 50.000
  • Limite predefinito per le dimensioni delle richieste: 0,5 MB

  I risultati finali e filtrati della query devono essere passati alla funzione Sensitive Data Protection anziché all'origine.

  Per questa soluzione, ogni valore nella colonna pii_column è un elemento, ad esempio My name is John Doe. My email is john.doe@example.com è un elemento.

• Assicurati che il set di dati BigQuery, il servizio Cloud Run e i modelli Sensitive Data Protection si trovino nella stessa regione cloud.