Aplica etiquetas de sensibilidad automáticamente en Data Catalog a archivos, bases de datos y tablas de BigQuery mediante Sensitive Data Protection y Dataflow.

Last reviewed 2022-01-11 UTC
En este documento, se muestra cómo usar Data Catalog con una canalización automatizada de Dataflow para identificar y aplicar sensibilidad de datos a tus datos en archivos de Cloud Storage, bases de datos relacionales (como MySQL, PostgreSQL y otras) y BigQuery.

Esta canalización de Dataflow usa Sensitive Data Protection para detectar datos sensibles, como información de identificación personal (PII) y, luego, etiqueta los resultados en Data Catalog.

La solución que se describe en este documento se basa en la arquitectura de la solución de asignación de tokens basada en archivos que se describe en el documento complementario Asigna tokens automáticamente a los datos sensibles basados en archivos con Sensitive Data Protection, Cloud Key Management Service y Dataflow. La diferencia principal entre ambos documentos es que en este documento se describe una solución que también crea una entrada de Data Catalog con un esquema de las etiquetas de origen y sensibilidad de datos para los resultados de Sensitive Data Protection. También puede inspeccionar bases de datos relacionales con conexiones de conectividad de bases de datos de Java (JDBC).

Este documento está dirigido a un público técnico cuyas responsabilidades incluyen la seguridad, la administración, el procesamiento o el análisis de datos. En este documento, se supone que estás familiarizado con el procesamiento y la privacidad de los datos, sin ser experto. También se supone que estás familiarizado con las secuencias de comandos de shell y que tienes conocimientos básicos de Google Cloud.

Arquitectura

Esta arquitectura define una canalización que realiza las siguientes acciones:

  • Extrae los datos de una base de datos relacional mediante JDBC.
  • Muestra los registros mediante la cláusula LIMIT de la base de datos.
  • Procesa los registros a través de la API de Cloud Data Loss Prevention (parte de Sensitive Data Protection) para identificar las categorías de sensibilidad.
  • Guarda los resultados en una tabla de BigQuery y Data Catalog.

En el siguiente diagrama, se muestran las acciones que realiza la canalización:

Se extraen los datos, se muestrean, se procesan y se guardan.

La solución usa conexiones JDBC para acceder a bases de datos relacionales. Cuando se usan tablas de BigQuery como fuente de datos, la solución usa la API de BigQuery Storage para mejorar los tiempos de carga.

La canalización sample-and-identify genera los siguientes archivos en Cloud Storage:

  • Esquema de Avro (equivalente) del esquema de la fuente
  • Se detectaron datos de infoTypes para cada una de las columnas de entrada (PERSON_NAME, PHONE_NUMBER y STREET_ADDRESS)

En esta solución, se usa la compactación de registros para controlar los campos anidados y repetidos en los registros.

Objetivos

  • Crear etiquetas de Data Catalog y grupos de entidades
  • Implementar la canalización de identificación y muestreo
  • Crear una entidad de Data Catalog personalizada
  • Aplicar etiquetas de sensibilidad a la entidad de Data Catalog personalizada
  • Verificar que los datos de las etiquetas de sensibilidad también estén en BigQuery

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Antes de comenzar

  1. Accede a tu cuenta de Google Cloud. Si eres nuevo en Google Cloud, crea una cuenta para evaluar el rendimiento de nuestros productos en situaciones reales. Los clientes nuevos también obtienen $300 en créditos gratuitos para ejecutar, probar y, además, implementar cargas de trabajo.

  2. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  3. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  4. Habilita las API de Cloud Build, DLP API, Cloud SQL, Cloud Storage, Compute Engine, Dataflow, Data Catalog, and Secret Manager.

    Habilita las API

    5.

  5. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

    Ir al selector de proyectos

  6. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

  7. Habilita las API de Cloud Build, DLP API, Cloud SQL, Cloud Storage, Compute Engine, Dataflow, Data Catalog, and Secret Manager.

    Habilita las API

    8.

  8. En la consola de Google Cloud, activa Cloud Shell.

    Activar Cloud Shell

    En la parte inferior de la consola de Google Cloud, se inicia una sesión de Cloud Shell en la que se muestra una ventana de línea de comandos. Cloud Shell es un entorno de shell con Google Cloud CLI ya instalada y con valores ya establecidos para el proyecto actual. La sesión puede tardar unos segundos en inicializarse.

Configure su entorno

  1. En Cloud Shell, clona el repositorio de código fuente y ve al directorio de los archivos clonados:

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

cd auto-data-tokenize/

  2. Usa un editor de texto para modificar la secuencia de comandos set_variables.sh a fin de configurar las variables de entorno necesarias. Ignora las otras variables en la secuencia de comandos. No son relevantes en este 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"

    Reemplaza lo siguiente:

    • PROJECT_ID: ID del proyecto
    • REGION_ID: Es la región que contiene tus buckets de almacenamiento. Selecciona una ubicación que esté en una región de Data Catalog.
    • CLOUD_STORAGE_BUCKET_NAME: Es el nombre de tu bucket de almacenamiento.
    • DLP_RUNNER_SERVICE_ACCOUNT_NAME: Es el nombre de la cuenta de servicio.
    • DATA_CATALOG_ENTRY_GROUP_ID: Es el nombre de tu grupo de entradas del catálogo de datos que no es de BigQuery.
    • INSPECTION_TAG_TEMPLATE_ID: El nombre que le asignaste a tu plantilla de etiqueta para Data Catalog.

  3. Ejecuta la secuencia de comandos para configurar las variables de entorno:

    source set_variables.sh

Crea recursos

La arquitectura que se describe en este documento usa los siguientes recursos:

  • Una cuenta de servicio para ejecutar canalizaciones de Dataflow, lo que habilita un control de acceso detallado
  • Un bucket de Cloud Storage para almacenar datos temporales y datos de prueba
  • Una plantilla de etiquetas de Data Catalog para adjuntar etiquetas de sensibilidad a entradas
  • Una instancia de MySQL en Cloud SQL como fuente de JDBC

Crea cuentas de servicio

Te recomendamos que ejecutes canalizaciones con control de acceso detallado para mejorar la partición del acceso. Si tu proyecto no tiene una cuenta de servicio creada por el usuario, crea una.

  1. En Cloud Shell, crea una cuenta de servicio para usarla como cuenta de servicio de controlador administrada por el usuario en 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 rol personalizado con los permisos necesarios para acceder a Sensitive Data Protection, Dataflow, Cloud SQL y 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. Aplica el rol personalizada y la función de trabajador de Dataflow a la cuenta de servicio para permitir que se ejecute como un trabajador de 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 el bucket de Cloud Storage

  • En Cloud Shell, crea un bucket de Cloud Storage para almacenar datos de prueba y como una ubicación de etapa de pruebas de Dataflow:

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

Crea un grupo de entradas de Data Catalog

Data Catalog mantiene una lista de entradas que representan recursos de Google Cloud u otros recursos. Las entradas se organizan en grupos de entradas. Existe un grupo de entradas implícito para BigQuery (@bigquery). Debes crear grupos de entradas para otros tipos de recursos. Para obtener más información sobre las entradas de Data Catalog, consulta Muestra archivos de Cloud Storage con entradas de conjuntos de archivos.

En Data Catalog, un grupo de entradas es como una carpeta que contiene entradas. Una entrada representa un elemento de datos.

  • En Cloud Shell, crea un grupo de entradas nuevo en el que la canalización pueda agregar una entrada para la tabla de MySQL:

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

Crea la plantilla de etiqueta de inspección

  • En Cloud Shell, crea una plantilla de etiqueta de Data Catalog para habilitar las entradas de etiquetado con información de sensibilidad 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

Crea una tabla de resultados de inspección en BigQuery

  • En Cloud Shell, crea una tabla de BigQuery para almacenar los resultados agregados de 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 una instancia de MySQL en Cloud SQL

Para la fuente de datos, usa una instancia de Cloud SQL.

  1. En Cloud Shell, crea una instancia de MySQL en Cloud SQL y cárgala con datos de muestra:

    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. Guarda la contraseña de la base de datos en Secret Manager.

    La contraseña de la base de datos y otra información secreta no se deben almacenar ni registrar. Secret Manager te permite almacenar y recuperar esos secretos de forma segura.

    Almacena la contraseña raíz de la base de datos de MySQL como un secreto de nube:

    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 datos de prueba a la instancia de Cloud SQL

Los datos de prueba son un conjunto de datos de demostración que contiene 5,000 nombres y apellidos generados de forma aleatoria, además de números de teléfono con formato de Estados Unidos. La tabla demonstration-dataset contiene cuatro columnas: row_id, person_name, contact_type, contact_number. También puedes usar tu propio conjunto de datos. Si usas tu propio conjunto de datos, recuerda ajustar los valores sugeridos en Verificar en BigQuery en este documento. Para copiar el conjunto de datos de demostración incluido (contacts5k.sql.gz) en tu instancia de Cloud SQL, haz lo siguiente:

  1. En Cloud Shell, copia el conjunto de datos de muestra en Cloud Storage para su etapa de pruebas en Cloud SQL:

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

  2. Crea una base de datos nueva en la instancia de Cloud SQL:

    export DATABASE_ID="auto_dlp_test"

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

  3. Otorga el rol de administrador de objetos de almacenamiento a tu cuenta de servicio de Cloud SQL para que pueda acceder al almacenamiento:

    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. Carga los datos en una tabla nueva:

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

    Si deseas obtener más información para importar datos a Cloud SQL, consulta Prácticas recomendadas para la importación y exportación de datos.

Módulos de compilación

  • En Cloud Shell, compila los módulos para compilar los ejecutables que permiten implementar la canalización de identificación y muestreo, y la canalización de asignación de tokens:

     ./gradlew clean buildNeeded shadowJar -x test

    De manera opcional, quita la marca -x test para ejecutar la prueba de integración y unidad. Si aún no tienes libncurses5 instalado, instálalo en Cloud Shell con sudo apt-get install libncurses5.

Ejecuta la canalización de identificación y muestreo

La canalización de identificación de muestreo y Sensitive Data Protection realiza las siguientes tareas en el siguiente orden:

  1. Extrae los registros de la fuente proporcionada. Por ejemplo, el método de identificación de Sensitive Data Protection solo admite tablas planas, por lo que la canalización compacta los registros de Avro, Parquet o BigQuery, ya que esos registros pueden contener campos anidados y repetidos.
  2. Toma muestas de las columnas individuales para muestras obligatorias, sin incluir null o valores vacíos.
  3. Identifica datos sensibles infoTypes con Sensitive Data Protection mediante el agrupamiento de las muestras en tamaños de lote aceptables para Sensitive Data Protection (valores <500 KB y <50,000).
  4. Escribe informes en Cloud Storage y en BigQuery para referencia futura.
  5. Crea entidades de Data Catalog cuando proporcionas información de plantillas de etiquetas y grupos de entradas. Cuando proporcionas esta información, la canalización crea etiquetas de sensibilidad para las entradas en Data Catalog en las columnas adecuadas.

Crea una plantilla flexible de Dataflow

Las plantillas de Flex de Dataflow te permiten usar la consola de Google Cloud, la Google Cloud CLI o las llamadas a la API de REST para configurar y ejecutar las canalizaciones en Google Cloud. En este documento, se proporcionan instrucciones para la consola de Google Cloud. Las plantillas clásicas se almacenan en etapa intermedia como grafos de ejecución en Cloud Storage, mientras que las plantillas de Flex agrupan la canalización como una imagen de contenedor en el Container Registry de tu proyecto. Las plantillas de Flex te permiten separar la compilación y ejecución de canalizaciones, y se integran a los sistemas de organización para las ejecuciones de canalizaciones programadas. Para obtener más información sobre las plantillas de Flex de Dataflow, consulta Evalúa qué tipo de plantilla usar.

Las plantillas de Flex de Dataflow separan los pasos de compilación y etapa de pruebas de los pasos de ejecución. Para ello, permiten iniciar una canalización de Dataflow desde una llamada a la API y desde Cloud Composer mediante el módulo DataflowStartFlexTemplateOperator.

  1. En Cloud Shell, define la ubicación a fin de almacenar el archivo de especificación de la plantilla que contiene la información necesaria para ejecutar el trabajo de 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. Compila la plantilla de Flex de 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\""

Ejecuta la canalización

La canalización de identificación y muestreo extrae el número de registros que especifica el valor sampleSize. Luego, compacta cada registro y, además, identifica los campos infoTypes mediante Sensitive Data Protection (para identificar los tipos de información sensible). Los valores infoTypes se cuentan y, luego, se agregan por el nombre de la columna y por el campo infoType para compilar un informe de sensibilidad.

  • En Cloud Shell, inicia la canalización de identificación y muestreo para identificar columnas sensibles en la fuente de datos:

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

El parámetro jdbcConnectionUrl especifica una URL de conexión de bases de datos de JDBC con detalles de nombre de usuario y contraseña. Los detalles de la compilación de la URL de conexión exacta dependen de tu proveedor de base de datos y tu socio de hosting. Para comprender los detalles de la conexión a las bases de datos relacionales basadas en Cloud SQL, consulta Conéctate mediante conectores de Cloud SQL.

La canalización construye una consulta como SELECT * FROM [TableName] a fin de leer los registros de la tabla para su inspección.

Esta consulta puede provocar la carga en la base de datos y también en la canalización, en especial para una tabla grande. De manera opcional, puedes optimizar tu muestra de los registros que deseas inspeccionar en el lado de la base de datos. Para ello, inserta jdbcFilterClause como la cláusula WHERE de la consulta que aparece en la muestra de código que se ofrece en la sección Verifica en BigQuery más adelante en este documento.

Puedes elegir uno o más de los siguientes receptores de informes, para ejecutar un informe:

  • reportLocation para almacenar el informe en un bucket de Cloud Storage
  • report BIGQUERY_TABLE para almacenar el informe en una BigQueryTable
  • dataCatalogEntryGroupId para crear y etiquetar la entrada en Data Catalog (omite este parámetro si sourceType es BIGQUERY_TABLE)

La canalización admite los siguientes tipos de fuentes. Para determinar la combinación correcta de los argumentos sourceType y inputPattern, usa las opciones que se enumeran en la siguiente tabla.

En este caso, solo usas la tabla JDBC_TABLE.

sourceType Fuente de datos inputPattern

JDBC_TABLE

Bases de datos relacionales (mediante JDBC)

TABLE_NAME

AVRO

Archivo Avro en Cloud Storage
Para seleccionar varios archivos que coinciden con un patrón, puedes usar un solo comodín. Con el siguiente patrón, se seleccionan todos los archivos que comienzan con el prefijo (data-):

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

gs://LOCATION_OF_FILES

PARQUET

Archivo Parquet en Cloud Storage
Para seleccionar varios archivos que coinciden con un patrón, puedes usar un solo comodín. Con el siguiente patrón, se seleccionan todos los archivos que comienzan con el prefijo (data-):

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

gs://LOCATION_OF_FILES

BIGQUERY_TABLE

Tabla de BigQuery.
Lee todas las filas y, luego, realiza muestras de forma aleatoria mediante la canalización.

PROJECT_ID:=DATASET.=TABLE

La canalización detecta todos los infoTypes estándares compatibles con Sensitive Data Protection. Puedes proporcionar infoTypes personalizados adicionales con el parámetro --observableinfoTypes.

Gráfico acíclico dirigido (DAG) de la canalización y la identificación de canalización

En el diagrama siguiente, se muestra el DAG de ejecución de Dataflow. El DAG tiene dos ramas. Ambas ramas comienzan en ReadJdbcTable y terminan en ExtractReport. A partir de ahí, se generan informes o se almacenan los datos.

Flujo de datos de canalización de identificación y muestreo.

Recupera el informe

La canalización de identificación y muestreo genera los siguientes archivos:

  • Archivo de esquema de Avro (o un esquema convertido en Avro) de la fuente
  • Un archivo para cada una de las columnas sensibles con recuentos e información de infoType

Para recuperar el informe, haz lo siguiente:

  1. En Cloud Shell, recupera el informe:

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

  2. Enumera todos los nombres de columnas identificadas:

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

    El resultado es el siguiente:

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

  3. Observa los detalles de una columna identificada con el comando cat para el archivo:

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

    El siguiente es un fragmento de la columna cc:

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

    • El valor columnName es inusual debido a la conversión implícita de una fila de la base de datos en un registro de Avro.
    • El valor count varía según las muestras seleccionadas al azar durante la ejecución.

Verifica las etiquetas de sensibilidad en Data Catalog

La canalización de identificación y muestreo crea una entrada nueva y aplica las etiquetas de sensibilidad a las columnas correspondientes.

  1. En Cloud Shell, recupera la entrada creada para la tabla de contactos:

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

    Con este comando, se muestran los detalles de la tabla, incluido su esquema.

  2. Muestra todas las etiquetas de sensibilidad que se adjuntan a esta entrada:

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

  3. Verifica que las etiquetas de sensibilidad estén presentes en las siguientes columnas: contact_number, person_name.

    Los datos infoTypes identificados por Sensitive Data Protection pueden contener algunos tipos falsos. Por ejemplo, puede identificar el tipo person_name como un tipo DATE, porque algunas strings person_names aleatorias pueden ser abril, mayo, junio u otras.

    Los detalles de la etiqueta de sensibilidad que se muestran son los siguientes:

    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 en BigQuery

La canalización de Dataflow adjunta los resultados agregados a la tabla de BigQuery proporcionada. La consulta imprime los resultados de la inspección recuperados de la tabla de BigQuery.

  • En Cloud Shell, verifica los resultados:

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

    El resultado es el siguiente:

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

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

  1. En la consola de Google Cloud, ve a la página Administrar recursos.

    Ir a Administrar recursos

  2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
  3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?