Cloud Data Loss Prevention (Cloud DLP) ahora forma parte de Protección de Datos Sensibles. El nombre de la API sigue siendo el mismo: API Cloud Data Loss Prevention (API DLP). Para obtener información sobre los servicios que componen Protección de Datos Sensibles, consulta el artículo Información general sobre Protección de Datos Sensibles.

Esta página se ha traducido con Cloud Translation API.

Desidentificar los datos de BigQuery en el momento de la consulta

En este tutorial se explica cómo desidentificar datos al consultar tablas de BigQuery con funciones remotas y Protección de Datos Sensibles. Este enfoque es útil para anonimizar los resultados de las consultas en tiempo real y minimizar el acceso a los datos que no se necesitan para el análisis.

En este tutorial se muestra cómo cifrar y descifrar datos en tránsito. Para obtener información sobre cómo usar Protección de Datos Sensibles para cifrar datos en reposo, consulta Desidentificación de datos sensibles en el almacenamiento.

Este tutorial está dirigido a audiencias cuyas responsabilidades incluyen la seguridad, el tratamiento o el análisis de datos. En esta guía se da por hecho que conoces el tratamiento y la privacidad de los datos, pero no es necesario que seas un experto. En esta guía también se da por hecho que puedes ejecutar scripts básicos de Cloud Shell y SQL.

En este tutorial se usan funciones basadas en SQL, BigQuery, funciones remotas, Cloud Run y Protección de Datos Sensibles.

Las técnicas de desidentificación, como el cifrado, ofuscan los identificadores sensibles sin procesar de tus datos. Estas técnicas te permiten seguir usando los datos para uniones o analíticas. Además, para reducir los riesgos inherentes a la gestión de datos, se ofuscan los identificadores sensibles sin procesar.

Las empresas pueden tener políticas o requisitos normativos para almacenar solo datos anonimizados en su almacén de datos en la nube. Además, es posible que necesiten volver a identificar de forma eficiente los datos desidentificados para generar informes.

Para minimizar el riesgo de gestionar grandes volúmenes de datos sensibles, puedes usar un flujo de procesamiento de transformación de datos automatizado para crear conjuntos de datos desidentificados. Puedes usar este tutorial para sustituir esa canalización por una consulta SQL que solo realice la reidentificación o que realice tanto la desidentificación como la reidentificación. En este tutorial se explica cómo anonimizar y volver a identificar datos mediante un servicio central alojado en Cloud Run. Puedes usar este servicio central en toda la organización sin necesidad de configurar ni mantener un clúster de Dataflow.

Protección de Datos Sensibles puede clasificar conjuntos de datos inspeccionando los datos para detectar información sensible. Protección de Datos Sensibles tiene más de 200 clasificadores integrados, llamados infoTypes. Para desidentificar datos con la API Cloud Data Loss Prevention, se necesitan flujos de datos y aplicaciones. Este tutorial tiene como objetivo ayudar a tus analistas, ingenieros o científicos de datos a conseguir el mismo resultado mediante funciones de SQL.

Al final de este tutorial, podrás escribir una consulta similar a la siguiente. Los datos sensibles se anonimizarán y se volverán a identificar en el resultado de la 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

El resultado debería ser similar al siguiente:

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

Arquitectura

En el siguiente diagrama se muestra cómo se usa BigQuery en este tutorial como almacén de datos, Protección de Datos Sensibles para desidentificar y volver a identificar datos, y Cloud Run para alojar las funciones remotas.

Preparar el entorno

En Cloud Shell, clona el repositorio de origen:

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

Ve al directorio de este tutorial:
```
cd bigquery-dlp-remote-function/
```

Implementar los recursos mediante una secuencia de comandos

Si quieres usar la secuencia de comandos de implementación sin hacer personalizaciones, sigue estos pasos. Si quiere personalizar la implementación, sáltese esta sección y consulte Implementar una solución personalizada manualmente.

Define los valores de los campos PROJECT_ID y 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"
```
Haz los cambios siguientes:
- PROJECT_ID: el ID del proyecto de este tutorial.
- REGION: la región en la que quieras almacenar y tratar los datos (por ejemplo, us-west1). Proporciona una región, no una zona.
Opcional: Si tienes una plantilla de inspección que quieras usar, asigna al campo DLP_INSPECT_TEMPLATE el nombre de recurso completo de esa plantilla de inspección. La plantilla de inspección debe estar en la misma región que hayas definido en el campo REGION.

Asegúrate de que la plantilla de inspección incluya todos los infoTypes que se usen en la plantilla de desidentificación.

Si omite este paso, Protección de Datos Sensibles inspeccionará los datos con un conjunto predeterminado del sistema de detectores de infoType.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Sustituye DLP_INSPECT_TEMPLATE por el nombre completo del recurso de tu plantilla de inspección. Por ejemplo, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Autentica con las credenciales de aplicación predeterminadas:

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

Inicializa y ejecuta la secuencia de comandos de Terraform para crear todos los recursos:
```
terraform init && \
terraform apply \
-var "project_id=${PROJECT_ID}" \
-var "region=${REGION}" \
-var "dlp_inspect_template_full_path=${DLP_INSPECT_TEMPLATE}"
```
El sistema muestra todas las acciones que realizará Terraform. Revisa las acciones. Para continuar, introduce yes.
Verifica que los datos se puedan cifrar y descifrar.

Desplegar una solución personalizada manualmente

Si quieres personalizar la implementación, sigue estos pasos. Si quieres usar la secuencia de comandos de implementación proporcionada sin personalizaciones ni pasos manuales, consulta Implementar los recursos con una secuencia de comandos.

Definir las variables de entorno

En Cloud Shell, define las siguientes variables de entorno:

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

Haz los cambios siguientes:

PROJECT_ID: el ID del proyecto de este tutorial.
REGION: la región en la que quieras almacenar y tratar los datos (por ejemplo, us-west1). Proporciona una región, no una zona.
CLOUD_RUN_SERVICE_NAME: nombre del nuevo servicio de Cloud Run. Escribe un máximo de 15 caracteres.
ARTIFACT_REGISTRY_NAME: nombre del nuevo Artifact Registry para almacenar imágenes de contenedor.

Crear una cuenta de servicio para el servicio de Cloud Run

Crea una cuenta de servicio:

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

Asigna los roles necesarios para Protección de Datos Sensibles.

Concede el rol Lector de DLP:

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

Asigna el rol Usuario de protección de datos:

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

Desplegar el servicio de Cloud Run

Para implementar la aplicación, sigue estos pasos:

Opcional: Puedes cambiar los valores predeterminados modificando las variables de entorno o actualizando el archivo src/main/resources/aes.properties.

Crea un repositorio de Artifact Registry para almacenar la imagen de contenedor de la función:

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

Compila la aplicación y despliégala en Cloud Run con 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}

El final de la salida es similar al siguiente:

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

Obtén la URL de Cloud Run y guárdala en las variables de entorno:

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

Crear una plantilla de desidentificación de Protección de Datos Sensibles

Las plantillas de desidentificación de Protección de Datos Sensibles te ayudan a guardar tus ajustes de desidentificación para que puedas reutilizarlos en varias operaciones y fuentes de datos.

En este paso se usa el archivo sample_dlp_deid_config.json, que contiene una plantilla de anonimización de ejemplo.

En Cloud Shell, crea la plantilla:

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 recomienda usar una clave envuelta al cifrar cargas de trabajo sensibles reales con Protección de Datos Sensibles. Con fines de demostración, en este tutorial se usa una clave desencapsulada. Para obtener más información sobre cómo crear una clave envuelta y usarla en solicitudes de desidentificación y reidentificación, consulta Desidentificar y reidentificar datos sensibles.

Crear la conexión de BigQuery a Cloud Run

En Cloud Shell, crea una conexión de BigQuery para acceder 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}

Busca y define la cuenta de servicio de BigQuery que se usa para la conexión:

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

Asigna el rol Invocador de Cloud Run a la cuenta de servicio:

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

Crear el conjunto de datos de BigQuery para funciones remotas

Define el conjunto de datos de BigQuery para las funciones remotas:
```
BQ_FUNCTION_DATASET="fns"
```

Crea el conjunto de datos si aún no existe:

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

Crear las funciones remotas de Protección de Datos Sensibles

Opcional: Si tiene una plantilla de inspección que quiera usar, asigne a la variable DLP_INSPECT_TEMPLATE el nombre de recurso completo de esa plantilla. La plantilla de inspección debe estar en la misma región que la que hayas definido en la variable de entorno REGION.

Asegúrate de que la plantilla de inspección incluya todos los infoTypes que se usen en la plantilla de desidentificación.

Si omite este paso, Protección de Datos Sensibles inspeccionará los datos con un conjunto predeterminado del sistema de detectores de infoType.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Sustituye DLP_INSPECT_TEMPLATE por el nombre completo del recurso de tu plantilla de inspección. Por ejemplo, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID.

Crea la función de desidentificación de Protección de Datos Sensibles:

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 función de reidentificación de Protección de Datos Sensibles:

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 la anonimización y la reidentificación

Para verificar si la solución anonimiza y vuelve a identificar los datos, haz lo siguiente:

Consola

En la Google Cloud consola, ve a BigQuery.

Ir a BigQuery

BigQuery se abre en el proyecto al que has accedido más recientemente.
Para abrir un editor de consultas, haz clic en Crear una consulta.

Introduce la siguiente 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

Haz clic en Ejecutar.

bq

Define la variable de entorno del conjunto de datos:
```
BQ_FUNCTION_DATASET="fns"
```

Ejecuta la 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"