Applica automaticamente i tag di sensibilità in Data Catalog a file, database e tabelle BigQuery utilizzando Sensitive Data Protection e Dataflow

Last reviewed 2022-01-11 UTC
Questo documento mostra come utilizzare Data Catalog con una pipeline Dataflow automatizzata per identificare e applicare i tag di sensibilità dei dati ai tuoi dati all'interno di file Cloud Storage, database relazionali (come MySQL, PostgreSQL e altri) e BigQuery.

Questa pipeline Dataflow utilizza la funzionalità Sensitive Data Protection per rilevare dati sensibili, ad esempio informazioni che consentono l'identificazione personale (PII), e poi tagga i risultati in Data Catalog.

La soluzione descritta in questo documento si basa sull'architettura della soluzione di tokenizzazione basata su file descritta nel relativo documento complementare: Tokenizza automaticamente i dati sensibili basati su file con Sensitive Data Protection, Cloud Key Management Service e Dataflow. La differenza principale tra i due documenti è che questo documento descrive una soluzione che crea anche una voce di Data Catalog con uno schema dei tag di origine e di sensibilità dei dati per i risultati di Sensitive Data Protection. Può anche ispezionare i database relazionali utilizzando le connessioni di JDBC (Connettività di database Java).

Questo documento è destinato a un pubblico tecnico le cui responsabilità includono sicurezza dei dati, governance dei dati, trattamento o analisi dei dati. Questo documento presuppone che tu conosca il trattamento e la privacy dei dati, senza essere un esperto. Si presume inoltre che tu abbia una certa familiarità con gli script shell e una conoscenza di base di Google Cloud.

Architettura

Questa architettura definisce una pipeline che esegue le seguenti azioni:

  • Estrae i dati da un database relazionale utilizzando JDBC.
  • Campiona i record utilizzando la clausola LIMIT del database.
  • Elabora i record tramite l'API Cloud Data Loss Prevention (che fa parte di Sensitive Data Protection) per identificare le categorie di sensibilità.
  • Salva i risultati in una tabella BigQuery e in Data Catalog.

Il seguente diagramma illustra le azioni eseguite dalla pipeline:

I dati vengono estratti, campionati, elaborati e salvati.

La soluzione utilizza connessioni JDBC per accedere ai database relazionali. Quando si utilizzano le tabelle BigQuery come origine dati, la soluzione usa l'API BigQuery Storage per migliorare i tempi di caricamento.

La pipeline sample-and-identifica genera i seguenti file in Cloud Storage:

  • Schema Avro (equivalente) dello schema di origine
  • Dati infoTypes rilevati per ciascuna colonna di input (PERSON_NAME, PHONE_NUMBER e STREET_ADDRESS)

Questa soluzione utilizza la suddivisione dei record per gestire i campi nidificati e ripetuti nei record.

Obiettivi

  • Crea tag e gruppo di entità di Data Catalog
  • Esegui il deployment della pipeline di campionamento e identificazione
  • Crea entità Data Catalog personalizzata
  • Applica i tag di sensibilità all'entità Data Catalog personalizzata
  • Verificare che i dati dei tag di sensibilità siano anche in BigQuery

Costi

In questo documento vengono utilizzati 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 possono essere idonei a una prova senza costi aggiuntivi.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

  2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  4. Abilita le API Cloud Build, DLP API, Cloud SQL, Cloud Storage, Compute Engine, Dataflow, Data Catalog, and Secret Manager.

    Abilita le API

    5.

  5. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  7. Abilita le API Cloud Build, DLP API, Cloud SQL, Cloud Storage, Compute Engine, Dataflow, Data Catalog, and Secret Manager.

    Abilita le API

    8.

  8. Nella console Google Cloud, attiva Cloud Shell.

    Attiva Cloud Shell

    Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

Configura l'ambiente

  1. In Cloud Shell, clona il repository di codice sorgente e vai alla directory dei file clonati:

    git clone https://github.com/GoogleCloudPlatform/auto-data-tokenize.git

cd auto-data-tokenize/

  2. Utilizza un editor di testo per modificare lo script set_variables.sh e impostare le variabili di ambiente richieste. Ignora le altre variabili nello script. Non sono pertinenti in questo documento.

    # The Google Cloud project to use:
export PROJECT_ID="PROJECT_ID"

# The Compute Engine region to use for running dataflow jobs and create a
# temporary storage bucket:
export REGION_ID= "REGION_ID"

# The Cloud Storage bucket to use as a temporary bucket for Dataflow:
export TEMP_GCS_BUCKET="CLOUD_STORAGE_BUCKET_NAME"

# Name of the service account to use (not the email address)
# (For example, tokenizing-runner):
export DLP_RUNNER_SERVICE_ACCOUNT_NAME="DLP_RUNNER_SERVICE_ACCOUNT_NAME"

# Entry Group ID to use for creating/searching for Entries
# in Data Catalog for non-BigQuery entries.
# The ID must begin with a letter or underscore, contain only English
# letters, numbers and underscores, and have 64 characters or fewer.
export
DATA_CATALOG_ENTRY_GROUP_ID="DATA_CATALOG_ENTRY_GROUP_ID"

# The Data Catalog Tag Template ID to use
# for creating sensitivity tags in Data Catalog.
# The ID must contain only lowercase letters (a-z), numbers (0-9), or
# underscores (_), and must start with a letter or underscore.
# The maximum size is 64 bytes when encoded in UTF-8
export INSPECTION_TAG_TEMPLATE_ID="INSPECTION_TAG_TEMPLATE_ID"

    Sostituisci quanto segue:

    • PROJECT_ID: l'ID del tuo progetto.
    • REGION_ID: la regione contenente il bucket o i bucket di archiviazione. Seleziona una località in una regione Data Catalog.
    • CLOUD_STORAGE_BUCKET_NAME: il nome del bucket di archiviazione.
    • DLP_RUNNER_SERVICE_ACCOUNT_NAME: il nome del tuo account di servizio.
    • DATA_CATALOG_ENTRY_GROUP_ID: il nome del tuo gruppo di voci del catalogo dati non BigQuery.
    • INSPECTION_TAG_TEMPLATE_ID: nome assegnato al modello di tag per Data Catalog

  3. Esegui lo script per impostare le variabili di ambiente:

    source set_variables.sh

Creare le risorse

L'architettura descritta in questo documento utilizza le seguenti risorse:

  • Un account di servizio per eseguire pipeline Dataflow, consentendo controllo dell'accesso granulare
  • Un bucket Cloud Storage per archiviare dati temporanei e di test
  • Un modello di tag Data Catalog per associare i tag di sensibilità alle voci
  • Un'istanza MySQL su Cloud SQL come origine JDBC

Creazione di account di servizio

Ti consigliamo di eseguire pipeline con controllo dell'accesso granulare per migliorare il partizionamento degli accessi. Se il progetto non ha un account di servizio creato dall'utente, creane uno.

  1. In Cloud Shell, crea un account di servizio da utilizzare come account di servizio controller gestito dall'utente per Dataflow:

      gcloud iam service-accounts create ${DLP_RUNNER_SERVICE_ACCOUNT_NAME} \
  --project="${PROJECT_ID}" \
  --description="Service Account for Sampling and Cataloging pipelines." \
  --display-name="Sampling and Cataloging pipelines"

  2. Crea un ruolo personalizzato con le autorizzazioni richieste per accedere a Sensitive Data Protection, Dataflow, Cloud SQL e Data Catalog:

      export SAMPLING_CATALOGING_ROLE_NAME="sampling_cataloging_runner"
  gcloud iam roles create ${SAMPLING_CATALOGING_ROLE_NAME} \
  --project="${PROJECT_ID}" \
  --file=tokenizing_runner_permissions.yaml

  3. Applica il ruolo personalizzato e il ruolo Worker Dataflow all'account di servizio per eseguirlo come worker Dataflow:

      gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:${DLP_RUNNER_SERVICE_ACCOUNT_EMAIL}" \
  --role=projects/${PROJECT_ID}/roles/${SAMPLING_CATALOGING_ROLE_NAME}

  gcloud projects add-iam-policy-binding ${PROJECT_ID} \
  --member="serviceAccount:${DLP_RUNNER_SERVICE_ACCOUNT_EMAIL}" \
  --role=roles/dataflow.worker

crea il bucket Cloud Storage

  • In Cloud Shell, crea un bucket Cloud Storage per archiviare i dati di test e come località temporanea Dataflow:

    gsutil mb -p ${PROJECT_ID} -l ${REGION_ID} "gs://${TEMP_GCS_BUCKET}"

Crea un gruppo di voci di Data Catalog

Data Catalog gestisce un elenco di voci che rappresentano le risorse Google Cloud o altre risorse. Le voci sono organizzate in gruppi di voci. Esiste un gruppo di voci implicite per BigQuery (@bigquery). Devi creare gruppi di voci per altri tipi di risorse. Per scoprire di più sulle voci di Data Catalog, vedi Visualizzare i file da Cloud Storage con le voci dei set di file.

In Data Catalog, un gruppo di voci è simile a una cartella che contiene voci. Una voce rappresenta un asset di dati.

  • In Cloud Shell, crea un nuovo gruppo di voci in cui la pipeline può aggiungere una voce per la tabella MySQL:

    gcloud data-catalog entry-groups create \
"${DATA_CATALOG_ENTRY_GROUP_ID}" \
--project="${PROJECT_ID}" \
--location="${REGION_ID}"

Creazione del modello di tag di ispezione

  • In Cloud Shell, crea un modello di tag di Data Catalog per attivare il tagging delle voci con informazioni di sensibilità con Sensitive Data Protection:

    gcloud data-catalog tag-templates create ${INSPECTION_TAG_TEMPLATE_ID} \
--project="${PROJECT_ID}"  \
--location="${REGION_ID}" \
--display-name="Auto DLP sensitive categories" \
--field=id=infoTypes,type=string,display-name="DLP infoTypes",required=TRUE \
--field=id=inspectTimestamp,type=timestamp,display-name="Inspection run timestamp",required=TRUE

Creare una tabella dei risultati di ispezione in BigQuery

  • In Cloud Shell, crea una tabella BigQuery per archiviare i risultati aggregati di Sensitive Data Protection:

    bq mk --dataset \
--location="${REGION_ID}" \
--project_id="${PROJECT_ID}"  \
inspection_results

bq mk --table \
--project_id="${PROJECT_ID}"  \
inspection_results.SensitivityInspectionResults \
inspection_results_bigquery_schema.json

Configura un'istanza MySQL su Cloud SQL

Per l'origine dati, utilizzi un'istanza Cloud SQL.

  1. In Cloud Shell, crea un'istanza di MySQL su Cloud SQL e caricala con dati di esempio:

    export SQL_INSTANCE="mysql-autodlp-instance"
export SQL_ROOT_PASSWORD="root1234"

gcloud sql instances create "${SQL_INSTANCE}" \
--project="${PROJECT_ID}"  \
--region="${REGION_ID}" \
--database-version=MYSQL_5_7 \
--root-password="${SQL_ROOT_PASSWORD}"

  2. Salva la password del database in Secret Manager.

    La password del database e altre informazioni secret non devono essere archiviate o registrate. Secret Manager ti consente di archiviare e recuperare questi secret in modo sicuro.

    Archivia la password root del database MySQL come cloud secret:

    export SQL_PASSWORD_SECRET_NAME="mysql-password"

printf $SQL_ROOT_PASSWORD |
gcloud secrets create "${SQL_PASSWORD_SECRET_NAME}" \
--data-file=- \
--locations="${REGION_ID}" \
--replication-policy="user-managed" \
--project="${PROJECT_ID}"

Copia i dati di test nell'istanza Cloud SQL

I dati del test sono un set di dati dimostrativo che contiene 5000 nomi e cognomi e numeri di telefono in stile statunitense generati casualmente. La tabella demonstration-dataset contiene quattro colonne: row_id, person_name, contact_type, contact_number. Puoi anche utilizzare il tuo set di dati. Se utilizzi un tuo set di dati, ricordati di modificare i valori suggeriti nella sezione Verifica in BigQuery di questo documento. Per copiare il set di dati dimostrativo incluso (contacts5k.sql.gz) nella tua istanza Cloud SQL, segui questi passaggi:

  1. In Cloud Shell, copia il set di dati di esempio in Cloud Storage per la gestione temporanea in Cloud SQL:

    gsutil cp contacts5k.sql.gz gs://${TEMP_GCS_BUCKET}

  2. Crea un nuovo database nell'istanza Cloud SQL:

    export DATABASE_ID="auto_dlp_test"

gcloud sql databases create "${DATABASE_ID}" \
--project="${PROJECT_ID}"  \
--instance="${SQL_INSTANCE}"

  3. Concedi il ruolo Amministratore oggetti Storage al tuo account di servizio Cloud SQL in modo che possa accedere allo spazio di archiviazione:

    export SQL_SERVICE_ACCOUNT=$(gcloud sql instances describe
"${SQL_INSTANCE}" --project="${PROJECT_ID}" | grep
serviceAccountEmailAddress: | sed "s/serviceAccountEmailAddress: //g")

gsutil iam ch "serviceAccount:${SQL_SERVICE_ACCOUNT}:objectAdmin" \
gs://${TEMP_GCS_BUCKET}

  4. Carica i dati in una nuova tabella:

    gcloud sql import sql "${SQL_INSTANCE}" \
"gs://${TEMP_GCS_BUCKET}/contacts5k.sql.gz" \
--project="${PROJECT_ID}"  \
--database="${DATABASE_ID}"

    Per scoprire di più sull'importazione dei dati in Cloud SQL, consulta Best practice per l'importazione e l'esportazione dei dati.

Compila moduli

  • In Cloud Shell, compila i moduli per creare gli eseguibili per il deployment della pipeline di campionamento e identificazione e della pipeline di tokenizzazione:

     ./gradlew clean buildNeeded shadowJar -x test

    Se vuoi, per eseguire il test delle unità e di integrazione, rimuovi il flag -x test. Se non hai già installato libncurses5, installalo in Cloud Shell con: sudo apt-get install libncurses5.

Esegui la pipeline di campionamento e identificazione

La pipeline di identificazione di Sensitive Data Protection e di campionamento esegue le attività seguenti nel seguente ordine:

  1. Estrae i record dall'origine fornita. Ad esempio, il metodo di identificazione di Sensitive Data Protection supporta solo tabelle fisse, pertanto la pipeline appiattisce i record Avro, Parquet o BigQuery, poiché questi record possono contenere campi nidificati e ripetuti.
  2. Campiona le singole colonne per gli esempi obbligatori, esclusi i valori null o vuoti.
  3. Identifica i dati infoTypes sensibili utilizzando Sensitive Data Protection, raggruppando i campioni in dimensioni batch accettabili per Sensitive Data Protection (valori inferiori a 500 kB e <50.000).
  4. Scrive report in Cloud Storage e BigQuery per riferimento futuro.
  5. Crea entità Data Catalog, quando fornisci informazioni sul modello di tag e sui gruppi di voci. Quando fornisci queste informazioni, la pipeline crea tag di sensibilità per le voci in Data Catalog in base alle colonne appropriate.

Crea un modello flessibile Dataflow

I modelli Dataflow Flex ti consentono di utilizzare la console Google Cloud, Google Cloud CLI o le chiamate API REST per configurare ed eseguire le tue pipeline su Google Cloud. Questo documento fornisce istruzioni per la console Google Cloud. I modelli classici vengono inseriti in un'area intermedia di grafici di esecuzione in Cloud Storage, mentre i modelli flessibili raggruppano la pipeline come immagine container nel Container Registry del tuo progetto. I modelli flessibili consentono di disaccoppiare le pipeline di creazione ed esecuzione e di integrarsi con i sistemi di orchestrazione per le esecuzioni pianificate delle pipeline. Per ulteriori informazioni sui modelli flessibili di Dataflow, consulta Valutazione del tipo di modello da utilizzare.

I modelli flessibili di Dataflow separano i passaggi di creazione e gestione temporanea da quelli di esecuzione. Per farlo è possibile avviare una pipeline Dataflow da una chiamata API e da Cloud Composer, utilizzando il modulo DataflowStartFlexTemplateOperator.

  1. In Cloud Shell, definisci la località in cui archiviare il file di specifica del modello contenente le informazioni necessarie per eseguire il job Dataflow:

    export
FLEX_TEMPLATE_PATH="gs://${TEMP_GCS_BUCKET}/dataflow/templates/sample-inspect-tag-pipeline.json"

export
FLEX_TEMPLATE_IMAGE="us.gcr.io/${PROJECT_ID}/dataflow/sample-inspect-tag-pipeline:latest"

  2. Crea il modello flessibile di Dataflow:

    gcloud dataflow flex-template build "${FLEX_TEMPLATE_PATH}" \
--image-gcr-path="${FLEX_TEMPLATE_IMAGE}" \
--service-account-email="${DLP_RUNNER_SERVICE_ACCOUNT_EMAIL}" \
--sdk-language="JAVA" \
--flex-template-base-image=JAVA11 \
--metadata-file="sample_identify_tag_pipeline_metadata.json" \
--jar="build/libs/auto-data-tokenize-all.jar" \
--env="FLEX_TEMPLATE_JAVA_MAIN_CLASS=\"com.google.cloud.solutions.autotokenize.pipeline.DlpInspectionPipeline\""

esegui la pipeline.

La pipeline di campionamento e identificazione estrae il numero di record specificati dal valore sampleSize. Quindi, suddivide ogni record e identifica i campi infoTypes utilizzando la protezione dei dati sensibili (per identificare i tipi di informazioni sensibili). I valori infoTypes vengono conteggiati e poi aggregati per nome colonna e per campo infoType per creare un report sulla sensibilità.

  • In Cloud Shell, avvia la pipeline di campionamento e identificazione per identificare le colonne sensibili nell'origine dati:

    export
CLOUD_SQL_JDBC_CONNECTION_URL="jdbc:mysql:///${DATABASE_ID}?cloudSqlInstance=${PROJECT_ID}%3A${REGION_ID}%3A${SQL_INSTANCE}&socketFactory=com.google.cloud.sql.mysql.SocketFactory"

gcloud dataflow flex-template run "sample-inspect-tag-`date +%Y%m%d-%H%M%S`" \
  --template-file-gcs-location "${FLEX_TEMPLATE_PATH}" \
  --region "${REGION_ID}" \
  --service-account-email "${DLP_RUNNER_SERVICE_ACCOUNT_EMAIL}" \
  --staging-location "gs://${TEMP_GCS_BUCKET}/staging" \
  --worker-machine-type "n1-standard-1" \
  --parameters sampleSize=2000 \
  --parameters sourceType="JDBC_TABLE" \
  --parameters inputPattern="Contacts" \
  --parameters reportLocation="gs://${TEMP_GCS_BUCKET}/auto_dlp_report/" \
  --parameters reportBigQueryTable="${PROJECT_ID}:inspection_results.SensitivityInspectionResults" \
  --parameters jdbcConnectionUrl="${CLOUD_SQL_JDBC_CONNECTION_URL}" \
  --parameters jdbcDriverClass="com.mysql.cj.jdbc.Driver" \
  --parameters jdbcUserName="root" \
  --parameters jdbcPasswordSecretsKey="projects/${PROJECT_ID}/secrets/${SQL_PASSWORD_SECRET_NAME}/versions/1" \
  --parameters ^:^jdbcFilterClause="ROUND(RAND() * 10) IN (1,3)" \
  --parameters dataCatalogEntryGroupId="projects/${PROJECT_ID}/locations/${REGION_ID}/entryGroups/${DATA_CATALOG_ENTRY_GROUP_ID}" \
  --parameters dataCatalogInspectionTagTemplateId="projects/${PROJECT_ID}/locations/${REGION_ID}/tagTemplates/${INSPECTION_TAG_TEMPLATE_ID}"

Il parametro jdbcConnectionUrl specifica un URL di connessione al database JDBC con i dettagli nome utente e password. I dettagli per la creazione dell'esatto URL di connessione dipendono dal fornitore del database e dal partner di hosting. Per informazioni dettagliate sulla connessione ai database relazionali basati su Cloud SQL, consulta Connessione tramite i connettori Cloud SQL.

La pipeline crea una query come SELECT * FROM [TableName] per leggere i record della tabella per l'ispezione.

Questa query può comportare il caricamento sul database e anche nella pipeline, soprattutto per una tabella di grandi dimensioni. Se vuoi, puoi ottimizzare l'esempio dei record che vuoi ispezionare sul lato database. Per farlo, inserisci jdbcFilterClause come clausola WHERE della query visualizzata nell'esempio di codice offerto nella sezione Verifica in BigQuery più avanti in questo documento.

Per eseguire un report, puoi scegliere uno o più dei seguenti sink di report:

  • reportLocation per archiviare il report in un bucket Cloud Storage
  • report BIGQUERY_TABLE per archiviare il report in un BigQueryTable
  • dataCatalogEntryGroupId per creare e taggare la voce in Data Catalog (ometti questo parametro se sourceType è BIGQUERY_TABLE)

La pipeline supporta i seguenti tipi di origine. Per determinare la combinazione corretta di argomenti sourceType e inputPattern, utilizza le opzioni elencate nella tabella seguente.

In questo caso, utilizzerai solo la tabella JDBC_TABLE.

sourceType Origine dati inputPattern

JDBC_TABLE

Database relazionali (con JDBC)

TABLE_NAME

AVRO

Avro in Cloud Storage.
Per selezionare più file che corrispondono a un pattern, puoi utilizzare un singolo carattere jolly. Il seguente pattern seleziona tutti i file che iniziano con il prefisso (data-):

gs://my-bucket/path/to/folder/data-*

gs://LOCATION_OF_FILES

PARQUET

File Parquet in Cloud Storage.
Per selezionare più file che corrispondono a un pattern, puoi utilizzare un singolo carattere jolly. Il seguente pattern seleziona tutti i file che iniziano con il prefisso (data-):

gs://my-bucket/path/to/folder/data-*

gs://LOCATION_OF_FILES

BIGQUERY_TABLE

BigQuery.
Legge tutte le righe, quindi esegue un campionamento casuale utilizzando la pipeline.

PROJECT_ID:=DATASET.=TABLE

La pipeline rileva tutti gli standard infoTypes supportati da Sensitive Data Protection. Puoi fornire ulteriori infoTypes personalizzati utilizzando il parametro --observableinfoTypes.

Grafo diretto aciclico (DAG) della pipeline di campionamento e identificazione

Il seguente diagramma mostra il DAG di esecuzione di Dataflow. Il DAG ha due rami. Entrambi i rami iniziano da ReadJdbcTable e terminano a ExtractReport. Da qui, vengono generati i report o archiviati i dati.

Flusso di dati delle pipeline di campionamento e identificazione.

Recupera il report

La pipeline di campionamento e identificazione restituisce i seguenti file:

  • Il file di schema Avro (o uno schema convertito in Avro) dell'origine
  • Un file per ogni colonna sensibile con informazioni e conteggi infoType

Per recuperare il report:

  1. In Cloud Shell, recupera il report:

    mkdir -p auto_dlp_report/
gsutil -m cp
"gs://${TEMP_GCS_BUCKET}/auto_dlp_report/*.json"
auto_dlp_report/

  2. Elenca tutti i nomi di colonna identificati:

    cat auto_dlp_report/col-*.json | jq .columnName

    L'output è il seguente:

    "$.topLevelRecord.contact_number" "$.topLevelRecord.person_name"

  3. Visualizza i dettagli di una colonna identificata con il comando cat per il file:

    cat auto_dlp_report/col-topLevelRecord-contact_number-00000-of-00001.json

    Di seguito è riportato uno snippet della colonna cc:

    { "columnName": "$.topLevelRecord.contact_number", "infoTypes": [{ "infoType": "PHONE_NUMBER", "count": "990" }] }

    • Il valore columnName è insolito a causa della conversione implicita di una riga di database in un record Avro.
    • Il valore di count varia in base ai campioni selezionati casualmente durante l'esecuzione.

Verificare i tag di sensibilità in Data Catalog

La pipeline di campionamento e identificazione crea una nuova voce e applica i tag di sensibilità alle colonne appropriate.

  1. In Cloud Shell, recupera la voce creata per la tabella Contatti:

    gcloud data-catalog entries describe Contacts \
  --entry-group=${DATA_CATALOG_ENTRY_GROUP_ID} \
  --project="${PROJECT_ID}"  \
  --location="${REGION_ID}"

    Questo comando mostra i dettagli della tabella, incluso lo schema.

  2. Mostra tutti i tag di sensibilità associati a questa voce:

    gcloud data-catalog tags list --entry=Contacts
  --entry-group=${DATA_CATALOG_ENTRY_GROUP_ID} \
  --project="${PROJECT_ID}"  \
  --location="${REGION_ID}"

  3. Verifica che i tag di sensibilità siano presenti nelle seguenti colonne: contact_number, person_name.

    I dati infoTypes identificati da Sensitive Data Protection possono contenere alcuni tipi falsi. Ad esempio, può identificare il tipo person_name come un tipo DATE, perché alcune stringhe person_names casuali possono essere aprile, maggio, giugno o altre.

    I dettagli del tag di sensibilità restituiti sono i seguenti:

    column: contact_number
fields:
  infoTypes:
    displayName: DLP infoTypes
    stringValue: '[PHONE_NUMBER]'
  inspectTimestamp:
    displayName: Inspection run timestamp
    timestampValue: '2021-05-20T16:34:29.596Z'
name: projects/auto-dlp/locations/asia-southeast1/entryGroups/sql_databases/entries/Contacts/tags/CbS0CtGSpZyJ
template: projects/auto-dlp/locations/asia-southeast1/tagTemplates/auto_dlp_inspection
templateDisplayName: Auto DLP sensitive categories
---
column: person_name
fields:
  infoTypes:
    displayName: DLP infoTypes
    stringValue: '[DATE, PERSON_NAME]'
  inspectTimestamp:
    displayName: Inspection run timestamp
    timestampValue: '2021-05-20T16:34:29.594Z'
name: projects/auto-dlp/locations/asia-southeast1/entryGroups/sql_databases/entries/Contacts/tags/Cds1aiO8R0pT
template: projects/auto-dlp/locations/asia-southeast1/tagTemplates/auto_dlp_inspection
templateDisplayName: Auto DLP sensitive categories

Verifica in BigQuery

La pipeline Dataflow aggiunge i risultati aggregati alla tabella BigQuery fornita. La query stampa i risultati dell'ispezione recuperati dalla tabella BigQuery.

  • In Cloud Shell, controlla i risultati:

    bq query \
  --location="${REGION_ID}"  \
  --project="${PROJECT_ID}"  \
  --use_legacy_sql=false \
'SELECT
   input_pattern AS table_name,
   ColumnReport.column_name AS column_name,
   ColumnReport.info_types AS info_types
 FROM
   `inspection_results.SensitivityInspectionResults`,
   UNNEST(column_report) ColumnReport;
 WHERE column_name="$.topLevelRecord.contact_number"'

    L'output è il seguente:

    +------------+---------------------------------+----------------------------------------------+
| table_name |           column_name           |                  info_types                  |
+------------+---------------------------------+----------------------------------------------+
| Contacts   | $.topLevelRecord.contact_number | [{"info_type":"PHONE_NUMBER","count":"990"}] |
+------------+---------------------------------+----------------------------------------------+

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.

Elimina il progetto

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi