Cloud Data Loss Prevention (Cloud DLP) ora fa parte di Sensitive Data Protection. Il nome dell'API rimane invariato: API Cloud Data Loss Prevention (API DLP). Per informazioni sui servizi che compongono Sensitive Data Protection, consulta la panoramica di Sensitive Data Protection.

Questa pagina è stata tradotta dall'API Cloud Translation.

Anonimizza i dati BigQuery quando vengono eseguite le query

Questo tutorial mostra come anonimizzare i dati durante l'esecuzione di query sulle tabelle di BigQuery utilizzando le funzioni remote e la Protezione dei dati sensibili. Questo approccio è utile per eseguire la sanificazione dei risultati delle query in tempo reale al fine di ridurre al minimo l'accesso ai dati non necessari per l'analisi.

Questo tutorial mostra la crittografia e la decrittografia dei dati in transito. Per informazioni sull'utilizzo della protezione dei dati sensibili per criptare i dati at-rest, consulta Anonimizzazione dei dati sensibili nello stoccaggio.

Questo tutorial è rivolto a un pubblico le cui responsabilità includono la sicurezza, l'elaborazione o l'analisi dei dati. Questa guida presuppone che tu abbia familiarità con il trattamento dei dati e la privacy dei dati, ma non è necessario essere un esperto. Questa guida presuppone inoltre che tu possa eseguire script di Cloud Shell e SQL di base.

Questo tutorial utilizza funzioni basate su SQL, BigQuery, funzioni remote, Cloud Run e Protezione dei dati sensibili.

Le tecniche di anonimizzazione, come la crittografia, offuscano gli identificatori sensibili non elaborati nei dati. Queste tecniche ti consentono di preservare l'utilità dei tuoi dati per le attività di unione o analisi, riducendo al contempo il rischio di manipolare i dati.

Le aziende potrebbero avere norme o requisiti normativi che prevedono di archiviare solo dati anonimizzati nel data warehouse sul cloud. Inoltre, potrebbe essere necessario reidentificare in modo efficiente i dati anonimizzati per la generazione di report.

Per ridurre al minimo il rischio di gestire grandi volumi di dati sensibili, puoi utilizzare una pipeline di trasformazione dei dati automatizzata per creare set di dati anonimizzati. Puoi utilizzare questo tutorial per sostituire la pipeline con una query SQL solo per la reidentificazione o sia per la deidentificazione sia per la reidentificazione. Questo tutorial ti aiuta a eseguire sia la spersonalizzazione che la reidentificazione utilizzando un servizio centralizzato ospitato su Cloud Run. Puoi utilizzare questo servizio centrale in tutta l'organizzazione senza dover configurare o gestire un cluster Dataflow.

Sensitive Data Protection può classificare i set di dati ispezionandoli per rilevare informazioni sensibili. Sensitive Data Protection dispone di oltre 150 classificatori integrati, chiamati infoTypes. L'utilizzo dell'API Cloud Data Loss Prevention per anonimizzare i dati richiede pipeline di dati e applicazioni. Questo tutorial ha lo scopo di aiutare i tuoi data analyst, data engineer o data scientist a ottenere lo stesso risultato tramite le funzioni SQL.

Al termine di questo tutorial, potrai scrivere una query simile alla seguente. I dati sensibili verranno anonimizzati e reidentificati nel risultato della query.

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

L'output è simile al seguente:

Riga	`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`

Architettura

Il seguente diagramma mostra come questo tutorial utilizza BigQuery come data warehouse, Sensitive Data Protection per anonimizzare e reidentificare i dati e Cloud Run per ospitare le funzioni remote.

Obiettivi

Esegui il deployment di un servizio Cloud Run che fornisce la funzionalità di anonimizzazione di Sensitive Data Protection.
Crea funzioni remote BigQuery che utilizzano i modelli di anonimizzazione Sensitive Data Protection.
Verifica la crittografia dei dati in BigQuery utilizzando una query SQL.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Create or select a Google Cloud 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.

Make sure that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, BigQuery, BigQuery Connection API, Cloud Build, Cloud Data Loss Prevention API, Cloud Key Management Service, Cloud Run, Container Registry, Identity and Access Management, Resource Manager, Secret Manager, and 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

Install the Google Cloud CLI.

To initialize the gcloud CLI, run the following command:

gcloud init

Create or select a Google Cloud 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.

Make sure that billing is enabled for your Google Cloud project.

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

Prepara l'ambiente

In Cloud Shell, clona il repository di origine:

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

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 Eseguire il deployment manuale di una soluzione personalizzata.

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 del 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.
(Facoltativo) Se hai un modello di ispezione che vuoi utilizzare, imposta il campo DLP_INSPECT_TEMPLATE sul nome completo della risorsa 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 insieme predefinito di rivelatori infoType.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Sostituisci DLP_INSPECT_TEMPLATE con il nome completo della risorsa del tuo modello di ispezione, ad esempio projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Esegui l'autenticazione utilizzando le Credenziali predefinite dell'applicazione:

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

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.
Verifica che i dati possano essere criptati e decriptati.

Esegui il deployment di una soluzione personalizzata manualmente

Se vuoi personalizzare il deployment, segui questi passaggi. Se vuoi utilizzare lo script di deployment fornito senza personalizzazioni o passaggi manualmente, consulta Eseguire 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 del 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

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

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:

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

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

Compila l'applicazione ed eseguine 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 al 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

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

Creare un modello di anonimizzazione Sensitive Data Protection

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

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

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 con wrapping quando esegui la crittografia di 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 con wrapping e utilizzarla nelle richieste di anonimizzazione e reidentificazione, consulta Anonimizzare e reidentificare i dati sensibili.

Crea la connessione BigQuery a Cloud Run

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}

Individua e imposta l'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')"

Concedi il ruolo Approvvigionatore Cloud Run all'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

Definisci il set di dati BigQuery per le funzioni remote:
```
BQ_FUNCTION_DATASET="fns"
```

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

(Facoltativo) Se hai un modello di ispezione che vuoi utilizzare, imposta la variabile DLP_INSPECT_TEMPLATE sul nome completo della risorsa 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 ispeziona i dati con un insieme predefinito di rivelatori infoType.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Sostituisci DLP_INSPECT_TEMPLATE con il nome completo della risorsa del tuo modello di ispezione, ad esempio projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Crea la funzione di anonimizzazione di 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}')]);"

Crea la funzione di identificazione 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}')]);"

Verificare la spersonalizzazione e la reidentificazione

Per verificare se la soluzione anonimizza e reidentifica i dati, svolgi quanto segue:

Console

Nella console Google Cloud, vai a BigQuery.

Vai a BigQuery

BigQuery si apre nel progetto a cui hai eseguito l'accesso più di recente.
Per aprire un editor di query, fai clic su Crea una nuova query.

Inserisci la seguente query:

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

Fai clic su Esegui.

bq

Imposta la variabile di ambiente per il set di dati:
```
BQ_FUNCTION_DATASET="fns"
```

Esegui la query:

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"

L'output è simile al seguente:

Riga	`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`

Considerazioni

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

L'anonimizzazione e la reidentificazione vengono elaborate tramite un servizio Cloud Run. Provisiona la CPU e la memoria di Cloud Run in base ai tuoi requisiti di calcolo. Per maggiori dettagli, consulta i limiti della CPU e i limiti della memoria per Cloud Run.
Quando utilizzi Sensitive Data Protection, tieni conto dei limiti di utilizzo e dei suggerimenti per il controllo dei costi.
Per contribuire a controllare i costi e il consumo totale della quota di Sensitive Data Protection, limita gli elementi che trasmetti tramite la funzione remota di Sensitive Data Protection a un massimo di 10.000. La soluzione può raggruppare automaticamente le richieste per gestire in modo corretto i seguenti limiti per le richieste di protezione dei dati sensibili:
- Numero massimo di valori di tabella: 50.000
- Dimensione massima della richiesta predefinita: 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 di protezione dei dati sensibili si trovino nella stessa regione cloud.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini elimini anche tutto il lavoro svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, il riuso dei progetti può aiutarti a non superare i limiti di quota.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Passaggi successivi

Scopri di più sulle funzioni remote di BigQuery.
Scopri come anonimizzare i dati sensibili.
Esamina un esempio che mostra come creare una chiave con wrapping, tokenizzare i contenuti e reidentificare i contenuti tokenizzati.
Scopri come gestire l'anonimizzazione e la reidentificazione delle PII in set di dati su larga scala utilizzando la Protezione dei dati sensibili.
Scopri di più su Cloud KMS.