Inspecciona datos de fuentes externas con trabajos híbridos

En este tema, se describe cómo usar trabajos híbridos y activadores de trabajos híbridos para inspeccionar datos externos en busca de información sensible. Para obtener más información sobre los trabajos híbridos y los activadores de trabajos híbridos, incluidos ejemplos de entornos híbridos, consulta Trabajos híbridos y activadores de trabajos híbridos.

Introducción a los trabajos híbridos y los activadores de trabajos híbridos

Los trabajos híbridos y los activadores de trabajos híbridos te permiten ampliar el alcance de la protección que proporciona Sensitive Data Protection más allá de las solicitudes de inspección de contenido simple y el Google Cloud análisis del repositorio de almacenamiento. Con los trabajos híbridos y los activadores de trabajos híbridos, puedes transmitir datos desde prácticamente cualquier fuente, incluso fuera de Google Cloud, directamente a la Protección de datos sensibles y permitir que la Protección de datos sensibles inspeccione los datos en busca de información sensible. Sensitive Data Protection guarda y agrega automáticamente los resultados del análisis para su posterior análisis.

Comparación de trabajos híbridos y activadores de trabajos híbridos

Cuando creas trabajos híbridos, estos se ejecutan hasta que los detienes. Aceptan todos los datos entrantes, siempre y cuando se enruten y formateen correctamente.

Los activadores de trabajos híbridos funcionan de manera similar a los trabajos híbridos, pero no es necesario detener explícitamente un trabajo dentro de un activador de trabajos híbrido. La Protección de datos sensibles detiene automáticamente los trabajos dentro de los activadores de trabajos híbridos al final de cada día.

Además, con un activador de trabajo híbrido, puedes detener e iniciar trabajos nuevos dentro del activador sin tener que volver a configurar tus solicitudes de hybridInspect. Por ejemplo, puedes enviar datos a un activador de trabajo híbrido, detener el trabajo activo, cambiar su configuración, iniciar un trabajo nuevo dentro de ese activador y, luego, seguir enviando datos al mismo activador.

Para obtener más orientación sobre qué opción se adapta a tu caso de uso, consulta Situaciones típicas de inspección híbrida en esta página.

Definición de términos

En este tema, se usan los siguientes términos:

• Datos externos: Son los datos almacenados fuera de Google Cloud o los datos que la Protección de datos sensibles no admite de forma nativa.

• Trabajo híbrido: Es un trabajo de inspección configurado para analizar datos de prácticamente cualquier fuente.

• Activador de trabajo híbrido: Es un activador de trabajo que se configura para analizar datos de prácticamente cualquier fuente.

• Solicitud hybridInspect: Es una solicitud que contiene los datos externos que deseas inspeccionar. Cuando envías esta solicitud, especificas el trabajo híbrido o el activador de trabajo híbrido al que se enviará la solicitud.

Para obtener información general sobre los trabajos y los activadores de trabajo, consulta Trabajos y activadores de trabajo.

Proceso de inspección híbrida

El proceso de inspección híbrida consta de tres pasos.

1. Elige los datos que quieres enviar a la Protección de datos sensibles.

   Los datos pueden provenir de dentro Google Cloud o fuera de él. Por ejemplo, puedes configurar una aplicación o un secuencia de comandos personalizada para enviar datos a Protección de datos sensibles, lo que te permite inspeccionar datos en tránsito, desde otro servicio en la nube, un repositorio de datos local o prácticamente cualquier otra fuente de datos.

2. Configura un trabajo híbrido o un activador de trabajo híbrido en Sensitive Data Protection desde cero o con una plantilla de inspección.

   Después de configurar un trabajo híbrido o un activador de trabajo híbrido, Sensitive Data Protection escucha de forma activa los datos que se le envían. Cuando tu aplicación o secuencia de comandos personalizada envía datos a este trabajo híbrido o activador de trabajo híbrido, los datos se inspeccionan y sus resultados se almacenan según la configuración.

   Cuando configuras el trabajo híbrido o el activador de trabajo híbrido, puedes especificar dónde deseas guardar o publicar los resultados. Las opciones incluyen guardar en BigQuery y publicar notificaciones en Pub/Sub, Cloud Monitoring o por correo electrónico.

3. Envía una solicitud de hybridInspect al trabajo híbrido o al activador de trabajo híbrido.

   Una solicitud hybridInspect contiene los datos que se analizarán. En la solicitud, incluye metadatos (también denominados etiquetas y identificadores de tabla) que describan el contenido y permitan que la Protección de datos sensibles identifique la información que deseas hacer un seguimiento. Por ejemplo, si analizas datos relacionados en varias solicitudes (como filas en la misma tabla de la base de datos), puedes usar los mismos metadatos en esas solicitudes relacionadas. Luego, puedes recopilar, tabular y analizar los resultados de esa tabla de la base de datos.

A medida que se ejecuta el trabajo híbrido y se inspeccionan las solicitudes, los resultados de la inspección están disponibles cuando Sensitive Data Protection los genera. En cambio, las acciones, como las notificaciones de Pub/Sub, no se producen hasta que tu aplicación finaliza el trabajo híbrido.

Consideraciones

Cuando trabajes con trabajos híbridos y activadores de trabajos, ten en cuenta los siguientes puntos:

• Los trabajos híbridos y los activadores de trabajos híbridos no admiten el filtrado ni el muestreo.
• Los trabajos y los activadores de trabajos no están sujetos a objetivos de nivel de servicio (SLO), pero puedes seguir algunos pasos para reducir la latencia. Para obtener más información, consulta Latencia del trabajo.

Antes de comenzar

Antes de configurar y usar trabajos híbridos o activadores de trabajos híbridos, asegúrate de haber hecho lo siguiente:

Crea un proyecto nuevo, habilita la facturación y habilita Sensitive Data Protection

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.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

1. Enable the Sensitive Data Protection API.

   Enable the API

Configurar la fuente de datos.

Antes de que Sensitive Data Protection pueda inspeccionar tus datos, debes enviárselos. Independientemente del método que uses para configurar el trabajo híbrido o el activador de trabajo híbrido, debes configurar tu fuente externa para que envíe datos a la API de DLP.

Para obtener información sobre el formato requerido para las solicitudes de inspección híbrida, consulta Formato de elementos de contenido híbrido. Para obtener información sobre los tipos de metadatos que puedes incluir con los datos de tu solicitud, consulta Tipos de metadatos que puedes proporcionar.

Crea un trabajo híbrido o un activador de trabajo híbrido

Para permitir que la Protección de datos sensibles inspeccione los datos que le envías, primero debes configurar un trabajo híbrido o un activador de trabajo híbrido. Para obtener información sobre cuál crear, consulta Situaciones típicas de inspección híbrida en esta página.

Console

En la consola de Google Cloud , ve a la página Crear trabajo o activador de trabajo:

Ir a Crear trabajo o activador de trabajo

En las siguientes secciones, se describe cómo completar las secciones de la página Crear trabajo o activador de trabajo que son relevantes para las operaciones de inspección híbrida.

Elige los datos de entrada

En esta sección, especificarás los datos de entrada que inspeccionará Sensitive Data Protection.

1. Opcional: En Nombre, asígnale un nombre al trabajo ingresando un valor en el campo ID del trabajo. Si dejas este campo en blanco, Sensitive Data Protection generará automáticamente un identificador.
2. Opcional: En el menú Ubicación del recurso, elige la región en la que deseas almacenar el trabajo híbrido o el activador de trabajo híbrido. Para obtener más información, consulta Cómo especificar las ubicaciones de procesamiento.

3. En Tipo de almacenamiento, selecciona Híbrido.

4. Opcional: En Descripción, describe el trabajo híbrido o el activador de trabajo híbrido que estás creando. Por ejemplo, puedes incluir información sobre la fuente de los datos que se inspeccionarán.

5. Opcional: En Etiquetas obligatorias, haz clic en Agregar etiqueta y, luego, ingresa una etiqueta que quieras solicitar en las solicitudes de hybridInspect. Un trabajo híbrido o un activador de trabajo híbrido no procesan una solicitud de hybridInspect que no especifica esta etiqueta. Puedes agregar hasta 10 etiquetas obligatorias. Para obtener más información, consulta Cómo solicitar etiquetas en las solicitudes de hybridInspect en esta página.

6. Opcional: En Optional labels, ingresa los pares clave-valor que desees adjuntar a los resultados de todas las solicitudes de hybridInspect enviadas a este trabajo o activador de trabajo. Puedes agregar hasta 10 etiquetas opcionales. Para obtener más información, consulta Etiquetas opcionales.

7. Opcional: En Opciones de datos tabulares, ingresa el nombre del campo de la columna de clave primaria si planeas enviar datos tabulares en tus solicitudes de hybridInspect. Para obtener más información, consulta Opciones de datos tabulares.

8. Haz clic en Continuar.

Configura la detección

En esta sección, especificas los tipos de datos sensibles para los que Sensitive Data Protection inspeccionará los datos de entrada. Tus opciones son las siguientes:

• Plantilla: Si ya creaste una plantilla en el proyecto actual que deseas usar para definir los parámetros de detección de Sensitive Data Protection, haz clic en el campo Nombre de la plantilla y, luego, elige la plantilla en la lista que aparece.
• InfoTypes: Sensitive Data Protection selecciona los infotipos integrados más comunes para detectar. Para cambiar los infotipos o elegir un infotipo personalizado para usar, haz clic en Administrar infotipos. También puedes ajustar los criterios de detección en las secciones Conjuntos de reglas de inspección y Umbral de confianza. Para obtener más detalles, consulta Configura la detección.

Después de configurar los parámetros de detección, haz clic en Continuar.

Agregar acciones

En esta sección, debes especificar dónde guardar los resultados de cada análisis de inspección y si deseas recibir una notificación por correo electrónico o un mensaje de notificación de Pub/Sub cada vez que se complete un análisis. Si no guardas los resultados en BigQuery, solo contendrán estadísticas sobre la cantidad y los infoTypes de los resultados.

• Guardar en BigQuery: Cada vez que se ejecuta un análisis, la protección de datos sensibles guarda los resultados del análisis en la tabla de BigQuery que especifiques aquí. Si no especificas un ID de tabla, BigQuery asignará un nombre predeterminado a una tabla nueva la primera vez que se ejecute el análisis. Si especificas una tabla existente, Sensitive Data Protection le agrega los resultados del análisis.

• Publicar en Pub/Sub: Cuando finaliza un trabajo, se emite un mensaje de Pub/Sub.

• Notificar por correo electrónico: Cuando se termina un trabajo, se envía un mensaje de correo electrónico.

• Publicar en Cloud Monitoring: Cuando se completa un trabajo, sus resultados se publican en Monitoring

Después de elegir las acciones, haz clic en Continuar.

Programar

En esta sección, se especifica si se debe crear un solo trabajo que se ejecute de inmediato o un activador de trabajo que se ejecute cada vez que Sensitive Data Protection reciba datos con el formato y el enrutamiento adecuados.

Realiza una de las siguientes acciones:

• Para ejecutar el trabajo híbrido de inmediato, elige Ninguna (ejecutar el trabajo de un solo uso inmediatamente después de su creación).

• Para configurar el trabajo de modo que los datos recibidos de la fuente lo activen, elige Crear un activador para ejecutar el trabajo de forma periódica.

  Los activadores de trabajos híbridos agregan llamadas a la API, lo que te permite ver los resultados de los hallazgos y las tendencias a lo largo del tiempo.

Para obtener más información, consulta Comparación de trabajos híbridos y activadores de trabajos híbridos.

Revisar

Aquí puedes revisar un resumen en formato JSON del análisis. Asegúrate de anotar el nombre del objeto híbrido o del activador de trabajo híbrido, ya que necesitarás esta información cuando envíes datos a la Protección de datos sensibles para su inspección.

Después de revisar el resumen en formato JSON, haz clic en Crear.

La Protección de datos sensibles inicia el trabajo híbrido o el activador de trabajo híbrido de inmediato. Se inicia un análisis de inspección cuando envías una hybridInspectsolicitud a este trabajo híbrido o activador de trabajo híbrido.

API

Un trabajo se representa en la API de DLP con el recurso DlpJobs. Para crear un trabajo híbrido, llama al método projects.locations.dlpJobs.create.

Un activador de trabajo se representa en la API de DLP con el recurso JobTrigger. Para crear un activador de trabajo híbrido, llama al método projects.locations.jobTriggers.create.

El objeto DlpJobs o JobTrigger que crees debe tener los siguientes parámetros de configuración:

1. En el campo inspectJob, configura un objeto InspectJobConfig.
2. En el objeto InspectJobConfig, en el campo storageConfig, configura un objeto StorageConfig.
3. En el objeto StorageConfig, en el campo hybridOptions, configura un objeto HybridOptions. Este objeto contiene metadatos sobre los datos que deseas inspeccionar.

4. En el objeto InspectJobConfig, en el campo actions, agrega las acciones (Action) que deseas que la Protección de datos sensibles realice al final de cada trabajo.

   Las acciones publishSummaryToCscc y publishFindingsToCloudDataCatalog no son compatibles con esta operación. Para obtener más información sobre las acciones, consulta Acciones.

5. Para especificar qué buscar y cómo hacerlo, realiza una o ambas de las siguientes acciones:

   • Configura el campo inspectTemplateName en el nombre completo del recurso de una plantilla de inspección que quieras usar, si está disponible.

   • Configura el campo inspectConfig.

   Si configuras los campos inspectTemplateName y inspectConfig, se combinarán sus parámetros de configuración.

Acerca de los ejemplos de JSON

Las siguientes pestañas contienen ejemplos de JSON que puedes enviar a la Protección de datos sensibles para crear un trabajo híbrido o un activador de trabajo híbrido. Estos ejemplos de trabajos híbridos y activadores de trabajos híbridos están configurados para hacer lo siguiente:

• Procesa cualquier solicitud de hybridInspect si tiene la etiqueta appointment-bookings-comments.
• Analiza el contenido de la solicitud hybridInspect en busca de direcciones de correo electrónico.
• Adjunta la etiqueta "env": "prod" a los hallazgos.
• Para los datos tabulares, obtén el valor de la celda en la columna booking_id (la clave primaria) que se encuentra en la misma fila que la celda en la que se encontraron los datos sensibles. Sensitive Data Protection adjunta este identificador al hallazgo para que puedas rastrearlo hasta la fila específica de la que proviene.
• Se envía un correo electrónico cuando se detiene el trabajo. El correo electrónico se envía a los propietarios del proyecto de IAM y a los contactos esenciales técnicos.
• Envía los resultados a Cloud Monitoring cuando se detenga el trabajo.

Para ver los ejemplos de JSON, consulta las siguientes pestañas.

Trabajo híbrido

Esta pestaña contiene un ejemplo de JSON que puedes usar para crear un trabajo híbrido.

Para crear un trabajo híbrido, envía una solicitud POST al siguiente extremo.

Método HTTP y URL

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs

Reemplaza lo siguiente:

• PROJECT_ID: El ID del proyecto en el que deseas almacenar el trabajo híbrido.
• REGION: Es la región geográfica en la que deseas almacenar el trabajo híbrido.

Entrada de JSON

{
  "jobId": "postgresql-table-comments",
  "inspectJob": {
    "actions": [
      {
        "jobNotificationEmails": {}
      },
      {
        "publishToStackdriver": {}
      }
    ],
    "inspectConfig": {
      "infoTypes": [
        {
          "name": "EMAIL_ADDRESS"
        }
      ],
      "minLikelihood": "POSSIBLE",
      "includeQuote": true
    },
    "storageConfig": {
      "hybridOptions": {
        "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
        "requiredFindingLabelKeys": [
          "appointment-bookings-comments"
        ],
        "labels": {
          "env": "prod"
        },
        "tableOptions": {
          "identifyingFields": [
            {
              "name": "booking_id"
            }
          ]
        }
      }
    }
  }
}

Salida de JSON

{
"name": "projects/PROJECT_ID/locations/REGION/dlpJobs/i-postgresql-table-comments",
"type": "INSPECT_JOB",
"state": "ACTIVE",
"inspectDetails": {
  "requestedOptions": {
    "snapshotInspectTemplate": {},
    "jobConfig": {
      "storageConfig": {
        "hybridOptions": {
          "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
          "requiredFindingLabelKeys": [
            "appointment-bookings-comments"
          ],
          "labels": {
            "env": "prod"
          },
          "tableOptions": {
            "identifyingFields": [
              {
                "name": "booking_id"
              }
            ]
          }
        }
      },
      "inspectConfig": {
        "infoTypes": [
          {
            "name": "EMAIL_ADDRESS"
          }
        ],
        "minLikelihood": "POSSIBLE",
        "limits": {},
        "includeQuote": true
      },
      "actions": [
        {
          "jobNotificationEmails": {}
        },
        {
          "publishToStackdriver": {}
        }
      ]
    }
  },
  "result": {
    "hybridStats": {}
  }
},
"createTime": "JOB_CREATION_DATETIME",
"startTime": "JOB_START_DATETIME"
}

Sensitive Data Protection crea el trabajo híbrido y genera un ID de trabajo. En este ejemplo, el ID del trabajo es i-postgresql-table-comments. Toma nota del ID del trabajo. Lo necesitarás en tu solicitud de hybridInspect.

Para detener un trabajo híbrido, debes llamar al método projects.locations.dlpJobs.finish de forma explícita. La API de DLP no detiene automáticamente los trabajos híbridos. En cambio, la API de DLP detiene automáticamente los trabajos dentro de los activadores de trabajos híbridos al final de cada día.

Activador de trabajo híbrido

Esta pestaña contiene un ejemplo de JSON que puedes usar para crear un activador de trabajo híbrido.

Para crear un activador de trabajo híbrido, envía una solicitud POST al siguiente extremo.

Método HTTP y URL

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers

Reemplaza lo siguiente:

• PROJECT_ID: Es el ID del proyecto en el que deseas almacenar el activador de trabajo híbrido.
• REGION: Es la región geográfica en la que deseas almacenar el activador del trabajo híbrido.

Entrada de JSON

{
    "triggerId": "postgresql-table-comments",
    "jobTrigger": {
      "triggers": [
        {
          "manual": {}
        }
      ],
      "inspectJob": {
        "actions": [
          {
            "jobNotificationEmails": {}
          },
          {
            "publishToStackdriver": {}
          }
        ],
        "inspectConfig": {
          "infoTypes": [
              {
                "name": "EMAIL_ADDRESS"
              }
          ],
          "minLikelihood": "POSSIBLE",
          "limits": {},
          "includeQuote": true
        },
        "storageConfig": {
          "hybridOptions": {
            "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
            "requiredFindingLabelKeys": [
                "appointment-bookings-comments"
              ],
            "labels": {
              "env": "prod"
            },
            "tableOptions": {
              "identifyingFields": [
                {
                  "name": "booking_id"
                }
              ]
            }
          }
        }
      }
    }
  }

Salida de JSON

{
"name": "projects/PROJECT_ID/locations/REGION/jobTriggers/postgresql-table-comments",
"inspectJob": {
  "storageConfig": {
    "hybridOptions": {
      "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
      "requiredFindingLabelKeys": [
        "appointment-bookings-comments"
      ],
      "labels": {
        "env": "prod"
      },
      "tableOptions": {
        "identifyingFields": [
          {
            "name": "booking_id"
          }
        ]
      }
    }
  },
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "EMAIL_ADDRESS"
      }
    ],
    "minLikelihood": "POSSIBLE",
    "limits": {},
    "includeQuote": true
  },
  "actions": [
    {
      "jobNotificationEmails": {}
    },
    {
      "publishToStackdriver": {}
    }
  ]
},
"triggers": [
  {
    "manual": {}
  }
],
"createTime": ""JOB_CREATION_DATETIME",
"updateTime": "TRIGGER_UPDATE_DATETIME",
"status": "HEALTHY"
}

Sensitive Data Protection crea el activador de trabajo híbrido. El resultado contiene el nombre del activador del trabajo híbrido. En este ejemplo, es postgresql-table-comments. Toma nota del nombre. Lo necesitarás en tu solicitud de hybridInspect.

A diferencia de los trabajos híbridos, la API de DLP detiene automáticamente los trabajos dentro de los activadores de trabajos híbridos al final de cada día. Por lo tanto, no es necesario que llames de forma explícita al método projects.locations.dlpJobs.finish.

Cuando creas un trabajo híbrido o un activador de trabajo híbrido, puedes usar el Explorador de APIs en las siguientes páginas de referencia de la API, respectivamente:

• projects.locations.dlpJobs.create
• projects.locations.jobTriggers.create

En el campo Parámetros de solicitud, ingresa projects/PROJECT_ID/locations/REGION. Luego, en el campo Cuerpo de la solicitud, pega el código JSON de muestra del objeto que intentas crear.

Una solicitud exitosa, incluso una creada en el Explorador de APIs, crea un trabajo híbrido o un activador de trabajo híbrido.

Si quieres obtener información general sobre el uso de JSON para enviar solicitudes a la API de DLP, consulta la guía de inicio rápido de JSON.

Envía datos al trabajo híbrido o al activador de trabajo híbrido

Para inspeccionar datos, debes enviar una solicitud hybridInspect, en el formato correcto, a un trabajo híbrido o a un activador de trabajo híbrido.

Formato de elementos de contenido híbridos

A continuación, se muestra un ejemplo simple de una solicitud de hybridInspect enviada a Sensitive Data Protection para que la procese un trabajo híbrido o un activador de trabajo híbrido. Ten en cuenta la estructura del objeto JSON, incluido el campo hybridItem, que contiene los siguientes campos:

• item: Contiene el contenido real que se debe inspeccionar.
• findingDetails: Contiene metadatos para asociar con el contenido.

{
  "hybridItem": {
    "item": {
      "value": "My email is test@example.org"
    },
    "findingDetails": {
      "containerDetails": {
        "fullPath": "10.0.0.2:logs1:app1",
        "relativePath": "app1",
        "rootPath": "10.0.0.2:logs1",
        "type": "logging_sys",
        "version": "1.2"
      },
      "labels": {
        "env": "prod",
        "appointment-bookings-comments": ""
      }
    }
  }
}

Para obtener información completa sobre el contenido de los elementos de inspección híbrida, consulta el contenido de referencia de la API para el objeto HybridContentItem.

Extremos de inspección híbrida

Para que los datos se inspeccionen con un trabajo híbrido o un activador de trabajo híbrido, debes enviar una solicitud hybridInspect al extremo correcto.

Método HTTP y URL para trabajos híbridos

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs/JOB_ID:hybridInspect

Para obtener más información sobre este extremo, consulta la página de referencia de la API del método projects.locations.dlpJobs.hybridInspect.

Método HTTP y URL para activadores de trabajos híbridos

https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers/TRIGGER_NAME:hybridInspect

Para obtener más información sobre este extremo, consulta la página de referencia de la API del método projects.locations.jobTriggers.hybridInspect.

Reemplaza lo siguiente:

• PROJECT_ID: Es el identificador de tu proyecto.
• REGION: Es la región geográfica en la que deseas almacenar la solicitud de hybridInspect. Esta región debe ser la misma que la del trabajo híbrido.

• JOB_ID: Es el ID que le asignaste al trabajo híbrido, con el prefijo i-.

  Para buscar el ID del trabajo, en Sensitive Data Protection, haz clic en Inspección > Trabajos de inspección.

• TRIGGER_NAME: Es el nombre que le asignaste al activador del trabajo híbrido.

  Para buscar el nombre del activador de trabajo, en Protección de datos sensibles, haz clic en Inspección > Activadores de trabajos.

Se requieren etiquetas de las solicitudes de hybridInspect

Si deseas controlar qué solicitudes de hybridInspect se pueden procesar con un trabajo híbrido o un activador de trabajo híbrido, puedes establecer etiquetas obligatorias. Se rechazan todas las solicitudes de hybridInspect para ese trabajo híbrido o activador de trabajo híbrido que no incluyan estas etiquetas obligatorias.

Para establecer una etiqueta obligatoria, haz lo siguiente:

1. Cuando crees el trabajo híbrido o el activador de trabajo híbrido, establece el campo requiredFindingLabelKeys en una lista de etiquetas obligatorias.

   En el siguiente ejemplo, se establece appointment-bookings-comments como una etiqueta obligatoria en un trabajo híbrido o un activador de trabajo híbrido.

   "hybridOptions": {
     ...
     "requiredFindingLabelKeys": [
       "appointment-bookings-comments"
     ],
     "labels": {
       "env": "prod"
     },
     ...
   }
   

2. En la solicitud hybridInspect, en el campo labels, agrega cada etiqueta obligatoria como una clave en un par clave-valor. El valor correspondiente puede ser una cadena vacía.

   En el siguiente ejemplo, se establece la etiqueta obligatoria, appointment-bookings-comments, en una solicitud hybridInspect.

   {
     "hybridItem": {
       "item": {
         "value": "My email is test@example.org"
       },
       "findingDetails": {
         "containerDetails": {...},
         "labels": {
           "appointment-bookings-comments": ""
         }
       }
     }
   }
   

Si no incluyes la etiqueta obligatoria en tu solicitud de hybridInspect, recibirás un error como el siguiente:

{
  "error": {
    "code": 400,
    "message": "Trigger required labels that were not included: [appointment-bookings-comments]",
    "status": "INVALID_ARGUMENT"
  }
}

Ejemplo de código: Crea un activador de trabajo híbrido y envíale datos

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

using System;
using Google.Api.Gax.ResourceNames;
using Google.Api.Gax;
using Google.Cloud.Dlp.V2;
using Grpc.Core;

public class SendDataToTheHybridJobTrigger
{
    public static DlpJob SendToHybridJobTrigger(
       string projectId,
       string jobTriggerId,
       string text = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the hybrid finding details which will be used as metadata with the content.
        // Refer to this for more information: https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#google.privacy.dlp.v2.Container
        var findingDetails = new HybridFindingDetails
        {
            ContainerDetails = new Container
            {
                FullPath = "10.0.0.2:logs1:aap1",
                RelativePath = "app1",
                RootPath = "10.0.0.2:logs1",
                Type = "System Logs"
            }
        };

        // Construct the hybrid content item using the finding details and text to be inspected.
        var hybridContentItem = new HybridContentItem
        {
            Item = new ContentItem { Value = text ?? "My email is ariel@example.org and name is Ariel." },
            FindingDetails = findingDetails
        };

        var jobTriggerName = new JobTriggerName(projectId, jobTriggerId);

        // Construct the request to activate the Job Trigger.
        var activate = new ActivateJobTriggerRequest
        {
            JobTriggerName = jobTriggerName
        };

        DlpJob triggerJob = null;

        try
        {
            // Call the API to activate the trigger.
            triggerJob = dlp.ActivateJobTrigger(activate);
        }
        catch (RpcException)
        {
            ListDlpJobsRequest listJobsRequest = new ListDlpJobsRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Filter = $"trigger_name={jobTriggerName}"
            };

            PagedEnumerable<ListDlpJobsResponse, DlpJob> res = dlp.ListDlpJobs(listJobsRequest);
            foreach (DlpJob j in res)
            {
                triggerJob = j;
            }
        }

        // Construct the request using hybrid content item.
        var request = new HybridInspectJobTriggerRequest
        {
            HybridItem = hybridContentItem,
            JobTriggerName = jobTriggerName
        };

        // Call the API.
        HybridInspectResponse _ = dlp.HybridInspectJobTrigger(request);

        Console.WriteLine($"Hybrid job created successfully. Job name: {triggerJob.Name}");

        return triggerJob;
    }
}

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import (
	"context"
	"fmt"
	"io"
	"log"
	"time"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectDataToHybridJobTrigger uses the Data Loss Prevention API to inspect sensitive
// information using Hybrid jobs trigger that scans payloads of data sent from
// virtually any source and stores findings in Google Cloud.
func inspectDataToHybridJobTrigger(w io.Writer, projectID, textToDeIdentify, jobTriggerName string) error {
	// projectId := "your-project-id"
	// jobTriggerName := "your-job-trigger-name"
	// textToDeIdentify := "My email is test@example.org"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Specify the content to be inspected.
	contentItem := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_Value{
			Value: textToDeIdentify,
		},
	}

	// Contains metadata to associate with the content.
	// Refer to https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#container for specifying the paths in container object.
	container := &dlppb.Container{
		Type:         "logging_sys",
		FullPath:     "10.0.0.2:logs1:app1",
		RelativePath: "app1",
		RootPath:     "10.0.0.2:logs1",
		Version:      "1.2",
	}

	// Set the required label.
	labels := map[string]string{
		"env":                           "prod",
		"appointment-bookings-comments": "",
	}

	hybridFindingDetails := &dlppb.HybridFindingDetails{
		ContainerDetails: container,
		Labels:           labels,
	}

	hybridContentItem := &dlppb.HybridContentItem{
		Item:           contentItem,
		FindingDetails: hybridFindingDetails,
	}

	// Activate the job trigger.
	activateJobreq := &dlppb.ActivateJobTriggerRequest{
		Name: jobTriggerName,
	}

	dlpJob, err := client.ActivateJobTrigger(ctx, activateJobreq)
	if err != nil {
		log.Printf("Error from return part %v", err)
		return err
	}
	// Build the hybrid inspect request.
	req := &dlppb.HybridInspectJobTriggerRequest{
		Name:       jobTriggerName,
		HybridItem: hybridContentItem,
	}

	// Send the hybrid inspect request.
	_, err = client.HybridInspectJobTrigger(ctx, req)
	if err != nil {
		return err
	}

	getDlpJobReq := &dlppb.GetDlpJobRequest{
		Name: dlpJob.Name,
	}

	var result *dlppb.DlpJob
	for i := 0; i < 5; i++ {
		// Get DLP job
		result, err = client.GetDlpJob(ctx, getDlpJobReq)
		if err != nil {
			fmt.Printf("Error getting DLP job: %v\n", err)
			return err
		}

		// Check if processed bytes is greater than 0
		if result.GetInspectDetails().GetResult().GetProcessedBytes() > 0 {
			break
		}

		// Wait for 5 seconds before checking again
		time.Sleep(5 * time.Second)
		i++
	}

	fmt.Fprintf(w, "Job Name: %v\n", result.Name)
	fmt.Fprintf(w, "Job State: %v\n", result.State)

	inspectionResult := result.GetInspectDetails().GetResult()
	fmt.Fprint(w, "Findings: \n")
	for _, v := range inspectionResult.GetInfoTypeStats() {
		fmt.Fprintf(w, "Infotype: %v\n", v.InfoType.Name)
		fmt.Fprintf(w, "Likelihood: %v\n", v.GetCount())
	}

	fmt.Fprint(w, "successfully inspected data using hybrid job trigger ")
	return nil
}

Java

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import com.google.api.gax.rpc.InvalidArgumentException;
import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ActivateJobTriggerRequest;
import com.google.privacy.dlp.v2.Container;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.GetDlpJobRequest;
import com.google.privacy.dlp.v2.HybridContentItem;
import com.google.privacy.dlp.v2.HybridFindingDetails;
import com.google.privacy.dlp.v2.HybridInspectJobTriggerRequest;
import com.google.privacy.dlp.v2.InfoTypeStats;
import com.google.privacy.dlp.v2.InspectDataSourceDetails;
import com.google.privacy.dlp.v2.JobTriggerName;
import com.google.privacy.dlp.v2.ListDlpJobsRequest;

public class InspectDataToHybridJobTrigger {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    // The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The job trigger id used to for processing a hybrid job trigger.
    String jobTriggerId = "your-job-trigger-id";
    // The string to de-identify.
    String textToDeIdentify = "My email is test@example.org and my name is Gary.";
    inspectDataToHybridJobTrigger(textToDeIdentify, projectId, jobTriggerId);
  }

  // Inspects data using a hybrid job trigger.
  // Hybrid jobs trigger allows to scan payloads of data sent from virtually any source for
  // sensitive information and then store the findings in Google Cloud.
  public static void inspectDataToHybridJobTrigger(
      String textToDeIdentify, String projectId, String jobTriggerId) throws Exception {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpClient = DlpServiceClient.create()) {
      // Specify the content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToDeIdentify).build();

      // Contains metadata to associate with the content.
      // Refer to https://cloud.google.com/dlp/docs/reference/rest/v2/Container for specifying the
      // paths in container object.
      Container container =
          Container.newBuilder()
              .setFullPath("10.0.0.2:logs1:app1")
              .setRelativePath("app1")
              .setRootPath("10.0.0.2:logs1")
              .setType("logging_sys")
              .setVersion("1.2")
              .build();

      HybridFindingDetails hybridFindingDetails =
          HybridFindingDetails.newBuilder().setContainerDetails(container).build();

      HybridContentItem hybridContentItem =
          HybridContentItem.newBuilder()
              .setItem(contentItem)
              .setFindingDetails(hybridFindingDetails)
              .build();

      // Activate the job trigger.
      ActivateJobTriggerRequest activateJobTriggerRequest =
          ActivateJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .build();

      DlpJob dlpJob;

      try {
        dlpJob = dlpClient.activateJobTrigger(activateJobTriggerRequest);
      } catch (InvalidArgumentException e) {
        ListDlpJobsRequest request =
            ListDlpJobsRequest.newBuilder()
                .setParent(JobTriggerName.of(projectId, jobTriggerId).toString())
                .setFilter("trigger_name=" + JobTriggerName.of(projectId, jobTriggerId).toString())
                .build();

        // Retrieve the DLP jobs triggered by the job trigger
        DlpServiceClient.ListDlpJobsPagedResponse response = dlpClient.listDlpJobs(request);
        dlpJob = response.getPage().getResponse().getJobs(0);
      }

      // Build the hybrid inspect request.
      HybridInspectJobTriggerRequest request =
          HybridInspectJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .setHybridItem(hybridContentItem)
              .build();

      // Send the hybrid inspect request.
      dlpClient.hybridInspectJobTrigger(request);

      // Build a request to get the completed job
      GetDlpJobRequest getDlpJobRequest =
          GetDlpJobRequest.newBuilder().setName(dlpJob.getName()).build();

      DlpJob result = null;

      do {
        result = dlpClient.getDlpJob(getDlpJobRequest);
        Thread.sleep(5000);
      } while (result.getInspectDetails().getResult().getProcessedBytes() <= 0);

      System.out.println("Job status: " + result.getState());
      System.out.println("Job name: " + result.getName());
      // Parse the response and process results.
      InspectDataSourceDetails.Result inspectionResult = result.getInspectDetails().getResult();
      System.out.println("Findings: ");
      for (InfoTypeStats infoTypeStat : inspectionResult.getInfoTypeStatsList()) {
        System.out.println("\tInfoType: " + infoTypeStat.getInfoType().getName());
        System.out.println("\tCount: " + infoTypeStat.getCount() + "\n");
      }
    }
  }
}

Node.js

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');

// Instantiates a client
const dlpClient = new DLP.DlpServiceClient();

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The string to de-identify
// const string = 'My email is test@example.org';

// Job Trigger ID
// const jobTriggerId = 'your-job-trigger-id';

async function inspectDataToHybridJobTrigger() {
  // Contains metadata to associate with the content.
  const container = {
    full_path: '10.0.0.2:logs1:app1',
    relative_path: 'app1',
    root_path: '10.0.0.2:logs1',
    type: 'logging_sys',
    version: '1.2',
  };

  const labels = {env: 'prod', 'appointment-bookings-comments': ''};

  // Build the hybrid content item.
  const hybridContentItem = {
    item: {value: string},
    findingDetails: {
      containerDetails: container,
      labels,
    },
  };
  let jobName;
  const fullTriggerName = `projects/${projectId}/jobTriggers/${jobTriggerId}`;
  // Activate the job trigger.
  try {
    const response = await dlpClient.activateJobTrigger({
      name: fullTriggerName,
    });
    jobName = response[0].name;
  } catch (err) {
    console.log(err);
    if (err.code === 3) {
      const response = await dlpClient.listDlpJobs({
        parent: fullTriggerName,
        filter: `trigger_name=${fullTriggerName}`,
      });
      jobName = response[0][0].name;
    }
    // Ignore error related to job trigger already active
    if (err.code !== 3) {
      console.log(err.message);
      return;
    }
  }
  // Build the hybrid inspect request.
  const request = {
    name: `projects/${projectId}/jobTriggers/${jobTriggerId}`,
    hybridItem: hybridContentItem,
  };
  // Send the hybrid inspect request.
  await dlpClient.hybridInspectJobTrigger(request);
  // Waiting for a maximum of 15 minutes for the job to get complete.
  let job;
  let numOfAttempts = 30;
  while (numOfAttempts > 0) {
    // Fetch DLP Job status
    [job] = await dlpClient.getDlpJob({name: jobName});

    if (job.state === 'FAILED') {
      console.log('Job Failed, Please check the configuration.');
      return;
    }
    // Check if the job has completed.
    if (job.inspectDetails.result.processedBytes > 0) {
      break;
    }
    // Sleep for a short duration before checking the job status again.
    await new Promise(resolve => {
      setTimeout(() => resolve(), 30000);
    });
    numOfAttempts -= 1;
  }
  // Finish the job once the inspection is complete.
  await dlpClient.finishDlpJob({name: jobName});

  // Print out the results.
  const infoTypeStats = job.inspectDetails.result.infoTypeStats;
  if (infoTypeStats.length > 0) {
    infoTypeStats.forEach(infoTypeStat => {
      console.log(
        `  Found ${infoTypeStat.count} instance(s) of infoType ${infoTypeStat.infoType.name}.`
      );
    });
  } else {
    console.log('No findings.');
  }
}
await inspectDataToHybridJobTrigger();

PHP

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

use Google\ApiCore\ApiException;
use Google\Cloud\Dlp\V2\ActivateJobTriggerRequest;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\GetDlpJobRequest;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;
use Google\Cloud\Dlp\V2\HybridInspectJobTriggerRequest;
use Google\Cloud\Dlp\V2\ListDlpJobsRequest;

/**
 * Inspect data hybrid job trigger.
 * Send data to the hybrid job or hybrid job trigger.
 *
 * @param string $callingProjectId  The Google Cloud project id to use as a parent resource.
 * @param string $string            The string to inspect (will be treated as text).
 */

function inspect_send_data_to_hybrid_job_trigger(
    // TODO(developer): Replace sample parameters before running the code.
    string $callingProjectId,
    string $jobTriggerId,
    string $string
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $content = (new ContentItem())
        ->setValue($string);

    $container = (new Container())
        ->setFullPath('10.0.0.2:logs1:app1')
        ->setRelativePath('app1')
        ->setRootPath('10.0.0.2:logs1')
        ->setType('logging_sys')
        ->setVersion('1.2');

    $findingDetails = (new HybridFindingDetails())
        ->setContainerDetails($container)
        ->setLabels([
            'env' => 'prod',
            'appointment-bookings-comments' => ''
        ]);

    $hybridItem = (new HybridContentItem())
        ->setItem($content)
        ->setFindingDetails($findingDetails);

    $parent = "projects/$callingProjectId/locations/global";
    $name = "projects/$callingProjectId/locations/global/jobTriggers/" . $jobTriggerId;

    $triggerJob = null;
    try {
        $activateJobTriggerRequest = (new ActivateJobTriggerRequest())
            ->setName($name);
        $triggerJob = $dlp->activateJobTrigger($activateJobTriggerRequest);
    } catch (ApiException $e) {
        $listDlpJobsRequest = (new ListDlpJobsRequest())
            ->setParent($parent)
            ->setFilter('trigger_name=' . $name);
        $result = $dlp->listDlpJobs($listDlpJobsRequest);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }
    $hybridInspectJobTriggerRequest = (new HybridInspectJobTriggerRequest())
        ->setName($name)
        ->setHybridItem($hybridItem);

    $dlp->hybridInspectJobTrigger($hybridInspectJobTriggerRequest);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $getDlpJobRequest = (new GetDlpJobRequest())
            ->setName($triggerJob->getName());
        $job = $dlp->getDlpJob($getDlpJobRequest);
        if ($job->getState() != JobState::RUNNING) {
            break;
        }
        $numOfAttempts--;
    } while ($numOfAttempts > 0);

    // Print finding counts.
    printf('Job %s status: %s' . PHP_EOL, $job->getName(), JobState::name($job->getState()));
    switch ($job->getState()) {
        case JobState::DONE:
            $infoTypeStats = $job->getInspectDetails()->getResult()->getInfoTypeStats();
            if (count($infoTypeStats) === 0) {
                printf('No findings.' . PHP_EOL);
            } else {
                foreach ($infoTypeStats as $infoTypeStat) {
                    printf(
                        '  Found %s instance(s) of infoType %s' . PHP_EOL,
                        $infoTypeStat->getCount(),
                        $infoTypeStat->getInfoType()->getName()
                    );
                }
            }
            break;
        case JobState::FAILED:
            printf('Job %s had errors:' . PHP_EOL, $job->getName());
            $errors = $job->getErrors();
            foreach ($errors as $error) {
                var_dump($error->getDetails());
            }
            break;
        case JobState::PENDING:
            printf('Job has not completed. Consider a longer timeout or an asynchronous execution model' . PHP_EOL);
            break;
        default:
            printf('Unexpected job state. Most likely, the job is either running or has not yet started.');
    }
}

Python

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import time

import google.cloud.dlp


def inspect_data_to_hybrid_job_trigger(
    project: str,
    trigger_id: str,
    content_string: str,
) -> None:
    """
    Uses the Data Loss Prevention API to inspect sensitive information
    using Hybrid jobs trigger that scans payloads of data sent from
    virtually any source and stores findings in Google Cloud.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        trigger_id: The job trigger identifier for hybrid job trigger.
        content_string: The string to inspect.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Construct the `item` to inspect.
    item = {"value": content_string}

    # Construct the container details that contains metadata to be
    # associated with the content. For more details, please refer to
    # https://cloud.google.com/dlp/docs/reference/rest/v2/Container
    container_details = {
        "full_path": "10.0.0.2:logs1:app1",
        "relative_path": "app1",
        "root_path": "10.0.0.2:logs1",
        "type_": "logging_sys",
        "version": "1.2",
    }

    # Construct hybrid inspection configuration.
    hybrid_config = {
        "item": item,
        "finding_details": {
            "container_details": container_details,
            "labels": {
                "env": "prod",
                "appointment-bookings-comments": "",
            },
        },
    }

    # Convert the trigger id into a full resource id.
    trigger_id = f"projects/{project}/jobTriggers/{trigger_id}"

    # Activate the job trigger.
    dlp_job = dlp.activate_job_trigger(request={"name": trigger_id})

    # Call the API.
    dlp.hybrid_inspect_job_trigger(
        request={
            "name": trigger_id,
            "hybrid_item": hybrid_config,
        }
    )

    # Get inspection job details.
    job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Wait for dlp job to get finished.
    while job.inspect_details.result.processed_bytes <= 0:
        time.sleep(5)
        job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Print the results.
    print(f"Job name: {dlp_job.name}")
    if job.inspect_details.result.info_type_stats:
        for finding in job.inspect_details.result.info_type_stats:
            print(f"Info type: {finding.info_type.name}; Count: {finding.count}")
    else:
        print("No findings.")

Situaciones típicas de inspección híbrida

En las siguientes secciones, se describen los usos típicos de la inspección híbrida y sus flujos de trabajo correspondientes.

Cómo realizar un análisis puntual

Ejecuta un análisis único de una base de datos fuera de Google Cloud como parte de una verificación de datos trimestral.

1. Crea un trabajo híbrido con la consolaGoogle Cloud o la API de DLP.

2. Llama a projects.locations.dlpJobs.hybridInspect para enviar datos al trabajo. Si deseas inspeccionar más datos, repite este paso tantas veces como sea necesario.

3. Después de enviar los datos para su inspección, llama al método projects.locations.dlpJobs.finish.

   La Protección de datos sensibles realiza las acciones especificadas en tu solicitud de projects.locations.dlpJobs.create.

Configura la supervisión continua

Supervisar todo el contenido nuevo que se agrega a diario en una base de datos que Sensitive Data Protection no admite de forma nativa

1. Crea un activador de trabajo híbrido con la consolaGoogle Cloud o la API de DLP.

2. Activa el activador del trabajo llamando al método projects.locations.jobTriggers.activate.

3. Llama a projects.locations.jobTriggers.hybridInspect para enviar datos al activador del trabajo. Si deseas inspeccionar más datos, repite este paso tantas veces como sea necesario.

En este caso, no necesitas llamar al método projects.locations.dlpJobs.finish. La Protección de datos sensibles particiona automáticamente los datos que envías. Mientras el activador de trabajo esté activo, al final de cada día, la Protección de datos sensibles realizará las acciones que especificaste cuando creaste el activador de trabajo híbrido.

Analiza los datos que ingresan a una base de datos

Analizar los datos que ingresan a una base de datos y controlar cómo se particionan los datos Cada trabajo en un activador de trabajos es una sola partición.

1. Crea un activador de trabajo híbrido con la consolaGoogle Cloud o la API de DLP.

2. Activa el activador del trabajo llamando al método projects.locations.jobTriggers.activate.

   El sistema devuelve el ID de un solo trabajo. Necesitarás este ID de trabajo en el siguiente paso.

3. Llama a projects.locations.dlpJobs.hybridInspect para enviar datos al trabajo.

   En este caso, envías los datos al trabajo en lugar de al activador del trabajo. Este enfoque te permite controlar cómo se particionan los datos que envías para su inspección. Si deseas agregar más datos para la inspección en la partición actual, repite este paso.

4. Después de enviar datos al trabajo, llama al método projects.locations.dlpJobs.finish.

   La Protección de datos sensibles realiza las acciones especificadas en tu solicitud de projects.locations.jobTriggers.create.

5. Si quieres crear otro trabajo para la siguiente partición, vuelve a activar el activador del trabajo y, luego, envía los datos al trabajo resultante.

Supervisa el tráfico desde un proxy

Supervisar el tráfico desde un proxy instalado entre dos aplicaciones personalizadas

1. Crea un activador de trabajo híbrido con la consolaGoogle Cloud o la API de DLP.

2. Activa el activador del trabajo llamando al método projects.locations.jobTriggers.activate.

3. Llama a projects.locations.jobTriggers.hybridInspect para enviar datos al activador del trabajo. Si deseas inspeccionar más datos, repite este paso tantas veces como sea necesario.

   Puedes llamar a esta solicitud de forma indefinida para todo el tráfico de la red. Asegúrate de incluir metadatos en cada solicitud.

En este caso, no necesitas llamar al método projects.locations.dlpJobs.finish. La Protección de datos sensibles particiona automáticamente los datos que envías. Mientras el activador de trabajo esté activo, al final de cada día, la Protección de datos sensibles realizará las acciones que especificaste cuando creaste el activador de trabajo híbrido.

¿Qué sigue?

• Obtén más información sobre cómo funcionan los trabajos híbridos y los activadores de trabajos híbridos.