Cloud Data Loss Prevention (Cloud DLP) ahora es parte de Sensitive Data Protection. El nombre de la API sigue siendo el mismo: API de Cloud Data Loss Prevention (API de DLP). Para obtener información sobre los servicios que conforman la protección de datos sensibles, consulta la descripción general de la protección de datos sensibles.

Se usó la API de Cloud Translation para traducir esta página.

Crea y programa trabajos de inspección de Sensitive Data Protection

En este tema, se describe en detalle cómo crear un trabajo de inspección de protección de datos sensibles y cómo programar trabajos de inspección recurrentes mediante la creación de un activador de trabajo. Para obtener una explicación rápida sobre cómo crear un activador de trabajo nuevo con la IU de Sensitive Data Protection, consulta la Guía de inicio rápido: Crea un activador de trabajo de Sensitive Data Protection.

Acerca de los trabajos de inspección y activadores de trabajos

Cuando Sensitive Data Protection realiza un análisis de inspección para identificar datos sensibles, cada análisis se ejecuta como un trabajo. Sensitive Data Protection crea y ejecuta un recurso de trabajo cada vez que le indicas que inspeccione tus repositorios de almacenamiento de Google Cloud, incluidos los buckets de Cloud Storage, las tablas de BigQuery, los tipos de Datastore y los datos externos.

Para programar trabajos de análisis de inspección de Sensitive Data Protection, crea activadores de trabajo. Un activador de trabajo automatiza la creación de trabajos de Protección de datos sensibles de forma periódica y también se puede ejecutar a pedido.

Para obtener más información sobre los trabajos y los activadores de trabajo en la Protección de datos sensibles, consulta la página conceptual Activadores de trabajos.

Crea un trabajo de inspección nuevo

Para crear un trabajo de inspección de Sensitive Data Protection nuevo, sigue estos pasos:

Console

En la sección Protección de datos sensibles de la consola de Google Cloud, ve a la página Crear trabajo o activador de trabajo.

Ir a Crear trabajo o activador de trabajo

La página Crear trabajo o activador de trabajo contiene las siguientes secciones:

Elige los datos de entrada
Configurar detección
Agrega acciones
Repaso

Elige los datos de entrada

Name

Ingresa un nombre para el trabajo. Puedes usar letras, números y guiones. Asignar un nombre a tu trabajo es opcional. Si no ingresas un nombre, la Protección de datos sensibles le dará al trabajo un identificador de número único.

Ubicación

En el menú Tipo de almacenamiento, elige el tipo de repositorio que almacena los datos que deseas analizar:

Cloud Storage: ingresa la URL del bucket que deseas analizar o selecciona Incluir/excluir en el menú Tipo de ubicación y, luego, haz clic en Examinar para navegar al bucket o subcarpeta que deseas analizar. Selecciona la casilla de verificación Analizar carpeta de forma recurrente para analizar el directorio especificado y todos los directorios contenidos. Déjalo sin seleccionar para analizar solo el directorio especificado y nada más.
BigQuery: ingresa los identificadores del proyecto, el conjunto de datos y la tabla que deseas analizar.
Datastore: ingresa los identificadores para el proyecto, el espacio de nombres (opcional) y el tipo que deseas analizar.
Híbrido: Puedes agregar etiquetas obligatorias, opcionales y opciones para controlar los datos tabulares. Para obtener más información, consulta Tipos de metadatos que puedes proporcionar.

Muestreo

El muestreo es una forma opcional de ahorrar recursos si tienes una gran cantidad de datos.

En Muestreo, puedes elegir si deseas analizar todos los datos seleccionados o tomar muestras de un porcentaje determinado. El muestreo funciona de manera diferente según el tipo de repositorio de almacenamiento que analices:

Para BigQuery, puedes muestrear un subconjunto del total de filas seleccionadas, que corresponde al porcentaje de archivos que especificas en el análisis.
En el caso de Cloud Storage, si algún archivo excede el tamaño especificado en el tamaño máximo de bytes para analizar por archivo, la Protección de datos sensibles lo escanea hasta ese tamaño máximo y luego pasa al siguiente archivo.

Para activar el muestreo, elige una de las siguientes opciones del primer menú:

Iniciar el muestreo desde la parte superior: Sensitive Data Protection inicia el análisis parcial al comienzo de los datos. Para BigQuery, esto inicia el análisis en la primera fila. En el caso de Cloud Storage, esto inicia el análisis al comienzo de cada archivo y lo detiene una vez que Sensitive Data Protection analiza hasta cualquier tamaño máximo de archivo especificado.
Iniciar el muestreo desde un punto de inicio aleatorio: Sensitive Data Protection inicia el análisis parcial en una ubicación aleatoria dentro de los datos. Para BigQuery, esto inicia el análisis en una fila aleatoria. Para Cloud Storage, esta configuración solo se aplica a los archivos que superan cualquier tamaño máximo especificado. La Protección de datos sensibles analiza los archivos por debajo del tamaño máximo en su totalidad y los archivos por encima del tamaño máximo hasta el máximo.

Para realizar un análisis parcial, también debes elegir qué porcentaje de los datos deseas analizar. Usa el control deslizante para establecer el porcentaje.

También puedes acotar los archivos o registros para analizarlos por fecha. Para obtener información sobre cómo hacerlo, consulta Programación, más adelante en este tema.

Configuración avanzada

Cuando creas un trabajo para un análisis de depósitos de Cloud Storage o tablas de BigQuery, puedes limitar tu búsqueda si especificas una configuración avanzada. Específicamente, puedes configurar lo siguiente:

Archivos (solo Cloud Storage): los tipos de archivo que se deben analizar, incluidos los archivos de texto, binarios e imágenes.
Campos de identificación (solo BigQuery): identificadores de fila únicos dentro de la tabla.
En el caso de Cloud Storage, si algún archivo excede el tamaño especificado en el tamaño máximo de bytes para analizar por archivo, la Protección de datos sensibles lo escanea hasta ese tamaño máximo y luego pasa al siguiente archivo.

Para activar el muestreo, elige el porcentaje de datos que deseas analizar. Usa el control deslizante para establecer el porcentaje. Luego, elige una de las siguientes opciones del primer menú:

Iniciar el muestreo desde la parte superior: Sensitive Data Protection inicia el análisis parcial al comienzo de los datos. Para BigQuery, esto inicia el análisis en la primera fila. En el caso de Cloud Storage, esto inicia el análisis al comienzo de cada archivo y lo detiene una vez que la Protección de datos sensibles analiza hasta cualquier tamaño máximo de archivo (ver arriba).
Iniciar el muestreo desde un punto de inicio aleatorio: Sensitive Data Protection inicia el análisis parcial en una ubicación aleatoria dentro de los datos. Para BigQuery, esto inicia el análisis en una fila aleatoria. Para Cloud Storage, esta configuración solo se aplica a los archivos que superan cualquier tamaño máximo especificado. La Protección de datos sensibles analiza los archivos por debajo del tamaño máximo en su totalidad y los archivos por encima del tamaño máximo hasta el máximo.

Archivos

Para los archivos almacenados en Cloud Storage, puedes especificar los tipos que se incluirán en tu análisis en Archivos.

Puedes elegir entre archivos binarios, de texto, de imagen, CSV, TSV, Microsoft Word, Microsoft Excel, Microsoft PowerPoint, PDF y Apache Avro. Para obtener una lista exhaustiva de las extensiones de archivo que Sensitive Data Protection puede analizar en los buckets de Cloud Storage, consulta FileType. Elegir Binario hace que Sensitive Data Protection analice archivos de tipos que no se reconocen.

Campos de identificación

En el caso de las tablas de BigQuery, en el campo Campos de identificación, puedes indicar a Sensitive Data Protection que incluya los valores de las columnas de clave principales de la tabla en los resultados. De esta manera, puedes vincular los resultados a las filas de la tabla que los contienen.

Ingresa los nombres de las columnas que identifican de forma única cada fila de la tabla. Si es necesario, usa la notación de puntos para especificar campos anidados. Puedes agregar todos los campos que desees.

También debes activar la acción Guardar en BigQuery para exportar los resultados a BigQuery. Cuando los resultados se exportan a BigQuery, cada uno contiene los valores respectivos de los campos de identificación. Para obtener más información, consulta identifyingFields.

Configura la detección

En la sección Configura la detección especificas los tipos de datos sensibles que deseas analizar. Completar esta sección es opcional. Si omites esta sección, la Protección de datos sensibles analizará tus datos en busca de un conjunto predeterminado de infoTypes.

Plantilla

De manera opcional, puedes usar una plantilla de Protección de datos sensibles para reutilizar la información de configuración que especificaste anteriormente.

Si ya creaste una plantilla que deseas usar, haz clic en el campo Nombre de la plantilla para ver una lista de las plantillas de inspección existentes. Elige o escribe el nombre de la plantilla que deseas usar.

Para obtener más información sobre cómo crear plantillas, consulta Cómo crear plantillas de inspección de Protección de datos sensibles.

Infotipos

Los detectores de Infotipo encuentran datos sensibles de un tipo determinado. Por ejemplo, el detector de Infotipo integrado US_SOCIAL_SECURITY_NUMBER de Protección de datos sensibles encuentra números de seguridad social de EE.UU. Además de los detectores de Infotipo integrados, puedes crear tus propios detectores de Infotipo personalizados.

En Infotipos, elige el detector de Infotipo que corresponda al tipo de datos que deseas analizar. No recomendamos dejar esta sección en blanco. De esta manera, la Protección de datos sensibles analizará tus datos con un conjunto predeterminado de infotipos, que podría incluir infotipos que no necesitas. Para obtener más información sobre cada detector, consulta la referencia del detector de Infotipo.

Para obtener más información sobre cómo administrar infotipos integrados y personalizados en esta sección, consulta Administra infotipos a través de la consola de Google Cloud.

Conjuntos de reglas de inspección

Los conjuntos de reglas de inspección te permiten personalizar los detectores de Infotipo integrados y personalizados con reglas de contexto. Los dos tipos de reglas de inspección son los siguientes:

Las reglas de exclusión, que ayudan a excluir resultados falsos o no deseados.
Reglas de palabras clave, que ayudan a detectar resultados adicionales.

Para agregar un nuevo conjunto de reglas, primero especifica uno o más detectores de Infotipo integrados o personalizados en la sección InfoTypes. Estos son los detectores de Infotipo que tus conjuntos de reglas modificarán. A continuación, sigue estos pasos:

Haz clic en el campo Elegir infotipos. El infotipo o los infotipos que especificaste antes aparecen debajo del campo en un menú, como se muestra a continuación:

Captura de pantalla de la configuración de los conjuntos de reglas de inspección de la IU de DLP.

Elige un Infotipo del menú y, luego, haz clic en Agregar regla. Aparecerá un menú con las dos opciones Regla de palabra clave y Regla de exclusión.

Para las reglas de palabras clave, elige Hotword rules. A continuación, sigue estos pasos:

En el campo Palabra clave, ingresa una expresión regular que Sensitive Data Protection debería buscar.
En el menú Hotword proximity, elige si la palabra clave que ingresaste se encuentra antes o después del Infotipo elegido.
En Hotword distance from infoType, ingresa la cantidad aproximada de caracteres entre la palabra clave y el infotipo elegido.
En Ajuste del nivel de confianza, elige si deseas asignar a las coincidencias un nivel fijo de probabilidad o aumentar o disminuir el nivel de probabilidad predeterminado en una cantidad determinada.

Para las reglas de exclusión, elige Reglas de exclusión. A continuación, sigue estos pasos:

En el campo Excluir, ingresa una expresión regular (regex) que Sensitive Data Protection deba buscar.
En el menú Tipo de coincidencia, elige una de las siguientes opciones:

Coincidencia completa: El hallazgo debe coincidir completamente con la regex.
Coincidencia parcial: Una subcadena del resultado puede coincidir con la regex.
Coincidencia inversa: El hallazgo no coincide con la regex.

Puedes agregar reglas de palabras clave o exclusiones adicionales, y conjuntos de reglas para definir mejor los resultados de la búsqueda.

Límite de confianza

Cada vez que Sensitive Data Protection detecta una posible coincidencia con datos sensibles, le asigna un valor de probabilidad en una escala de “Muy improbable” a “Muy probable”. Cuando configuras un valor de probabilidad aquí, le indicas a Sensitive Data Protection que solo haga coincidir los datos que se corresponden con ese valor de probabilidad o uno superior.

El valor predeterminado de “Posible” es suficiente para la mayoría de los propósitos. Si habitualmente obtienes coincidencias demasiado amplias, mueve el control deslizante hacia arriba. Si tienes muy pocas coincidencias, mueve el control deslizante hacia abajo.

Cuando finalices, haz clic en Continuar.

Agrega acciones

En el paso Agrega acciones, selecciona una o más acciones que desees que realice la Protección de datos sensibles después de que se complete el trabajo.

Puedes configurar las siguientes acciones:

Guardar en BigQuery: Guarda los resultados del trabajo de Protección de datos sensibles en una tabla de BigQuery. Antes de ver o analizar los resultados, primero debes asegurarte de que el trabajo se haya completado.

Cada vez que se ejecuta un análisis, Sensitive Data Protection guarda los resultados en la tabla de BigQuery que especifiques. Los resultados exportados contienen detalles sobre la ubicación de cada resultado y la probabilidad de coincidencia. Si deseas que cada resultado incluya la cadena que coincide con el detector de Infotipo, habilita la opción Incluir cita.

Si no especificas un ID de tabla, BigQuery asigna un nombre predeterminado a una tabla nueva la primera vez que se ejecuta el análisis. Si especificas una tabla existente, Sensitive Data Protection le adjunta los resultados del análisis.

Si no guardas los resultados en BigQuery, los resultados del análisis solo contendrá estadísticas sobre la cantidad y los infotipos de los resultados.

Cuando se escriben datos en una tabla de BigQuery, el uso de cuotas y la facturación se aplican al proyecto que contiene la tabla de destino.
Publicar en Pub/Sub: Publica una notificación que contenga el nombre del trabajo de Protección de datos sensibles como un atributo en un canal de Pub/Sub. Puedes especificar uno o más temas a los que se enviará el mensaje de notificación. Asegúrate de que la cuenta de servicio de Sensitive Data Protection que ejecuta el trabajo de análisis tenga acceso de publicación en el tema.

Nota: Si hay problemas de configuración o permisos con el tema de Pub/Sub, la Protección de datos sensibles reintentará enviar la notificación de Pub/Sub durante hasta dos semanas. Después de dos semanas, se descarta la notificación.
Publicar en Security Command Center: Publica un resumen de los resultados del trabajo en Security Command Center. Para obtener más información, consulta Cómo enviar resultados de análisis de la Protección de datos sensibles a Security Command Center.
Publicar en Dataplex: Envía los resultados de las tareas a Dataplex, el servicio de administración de metadatos de Google Cloud.
Notificar por correo electrónico: Envía un correo electrónico cuando se complete el trabajo. El correo electrónico se envía a los propietarios del proyecto de IAM y a los Contactos esenciales técnicos.
Publicar en Cloud Monitoring: Envía los resultados de la inspección a Cloud Monitoring en Observabilidad de Google Cloud.
Hacer una copia desidentificada: Desidentifica los resultados de los datos inspeccionados y escribe el contenido desidentificado en un archivo nuevo. Luego, puedes usar la copia desidentificada en tus procesos comerciales, en lugar de los datos que contienen información sensible. Para obtener más información, consulta Cómo crear una copia desidentificada de los datos de Cloud Storage con la Protección de datos sensibles en la consola de Google Cloud.

Para obtener más información, consulta Acciones.

Cuando finalices de seleccionar las acciones, haz clic en Continuar.

Repaso

La sección Revisa contiene un resumen con formato JSON de la configuración del trabajo que acabas de especificar.

Haz clic en Crear para crear el trabajo (si no especificaste un programa) y ejecutar el trabajo una vez. Aparecerá la página de información del trabajo, que contiene el estado y otra información. Si el trabajo se encuentra en ejecución, puedes hacer clic en el botón Cancelar para detenerlo. También puedes borrar el trabajo si haces clic en Borrar.

Para volver a la página principal de Protección de datos sensibles, haz clic en la flecha Atrás en la consola de Google Cloud.

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta 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 System.Linq;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using static Google.Cloud.Dlp.V2.StorageConfig.Types;

public class JobsCreate
{
    public static DlpJob CreateJob(string projectId, string gcsPath)
    {
        var dlp = DlpServiceClient.Create();

        var storageConfig = new StorageConfig
        {
            CloudStorageOptions = new CloudStorageOptions
            {
                FileSet = new CloudStorageOptions.Types.FileSet()
                {
                    Url = gcsPath
                }
            },
            TimespanConfig = new TimespanConfig
            {
                EnableAutoPopulationOfTimespanConfig = true
            }
        };

        var inspectConfig = new InspectConfig
        {
            InfoTypes = { new[] { "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER" }.Select(it => new InfoType() { Name = it }) },
            IncludeQuote = true,
            MinLikelihood = Likelihood.Unlikely,
            Limits = new InspectConfig.Types.FindingLimits() { MaxFindingsPerItem = 100 }
        };

        var response = dlp.CreateDlpJob(new CreateDlpJobRequest
        {
            Parent = new LocationName(projectId, "global").ToString(),
            InspectJob = new InspectJobConfig
            {
                InspectConfig = inspectConfig,
                StorageConfig = storageConfig,
            }
        });

        Console.WriteLine($"Job: {response.Name} status: {response.State}");

        return response;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

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

// createJob creates an inspection job
func createJob(w io.Writer, projectID, gcsPath string, infoTypeNames []string) error {
	// projectID := "my-project-id"
	// gcsPath := "gs://" + "your-bucket-name" + "path/to/file.txt";
	// infoTypeNames := []string{"EMAIL_ADDRESS", "PERSON_NAME", "LOCATION", "PHONE_NUMBER"}

	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 GCS file to be inspected.
	storageConfig := &dlppb.StorageConfig{
		Type: &dlppb.StorageConfig_CloudStorageOptions{
			CloudStorageOptions: &dlppb.CloudStorageOptions{
				FileSet: &dlppb.CloudStorageOptions_FileSet{
					Url: gcsPath,
				},
			},
		},

		// Set autoPopulateTimespan to true to scan only new content.
		TimespanConfig: &dlppb.StorageConfig_TimespanConfig{
			EnableAutoPopulationOfTimespanConfig: true,
		},
	}

	// Specify the type of info the inspection will look for.
	// See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types.
	var infoTypes []*dlppb.InfoType
	for _, c := range infoTypeNames {
		infoTypes = append(infoTypes, &dlppb.InfoType{Name: c})
	}

	inspectConfig := &dlppb.InspectConfig{
		InfoTypes:    infoTypes,
		IncludeQuote: true,

		// The minimum likelihood required before returning a match:
		// See: https://cloud.google.com/dlp/docs/likelihood
		MinLikelihood: dlppb.Likelihood_UNLIKELY,

		// The maximum number of findings to report (0 = server maximum)
		Limits: &dlppb.InspectConfig_FindingLimits{
			MaxFindingsPerItem: 100,
		},
	}

	// Create and send the request.
	req := dlppb.CreateDlpJobRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
		Job: &dlppb.CreateDlpJobRequest_InspectJob{
			InspectJob: &dlppb.InspectJobConfig{
				InspectConfig: inspectConfig,
				StorageConfig: storageConfig,
			},
		},
	}

	// Send the request.
	response, err := client.CreateDlpJob(ctx, &req)
	if err != nil {
		return err
	}

	// Print the results.
	fmt.Fprintf(w, "Created a Dlp Job %v and Status is: %v", response.Name, response.State)
	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.Action;
import com.google.privacy.dlp.v2.CloudStorageOptions;
import com.google.privacy.dlp.v2.CreateDlpJobRequest;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectJobConfig;
import com.google.privacy.dlp.v2.Likelihood;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.StorageConfig;
import com.google.privacy.dlp.v2.StorageConfig.TimespanConfig;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class JobsCreate {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String gcsPath = "gs://" + "your-bucket-name" + "path/to/file.txt";
    createJobs(projectId, gcsPath);
  }

  // Creates a DLP Job
  public static void createJobs(String projectId, String gcsPath) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Set autoPopulateTimespan to true to scan only new content
      boolean autoPopulateTimespan = true;
      TimespanConfig timespanConfig =
          TimespanConfig.newBuilder()
              .setEnableAutoPopulationOfTimespanConfig(autoPopulateTimespan)
              .build();

      // Specify the GCS file to be inspected.
      CloudStorageOptions cloudStorageOptions =
          CloudStorageOptions.newBuilder()
              .setFileSet(CloudStorageOptions.FileSet.newBuilder().setUrl(gcsPath))
              .build();
      StorageConfig storageConfig =
          StorageConfig.newBuilder()
              .setCloudStorageOptions(cloudStorageOptions)
              .setTimespanConfig(timespanConfig)
              .build();

      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      List<InfoType> infoTypes =
          Stream.of("EMAIL_ADDRESS", "PERSON_NAME", "LOCATION", "PHONE_NUMBER")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());
      // The minimum likelihood required before returning a match:
      // See: https://cloud.google.com/dlp/docs/likelihood
      Likelihood minLikelihood = Likelihood.UNLIKELY;

      // The maximum number of findings to report (0 = server maximum)
      InspectConfig.FindingLimits findingLimits =
          InspectConfig.FindingLimits.newBuilder().setMaxFindingsPerItem(100).build();

      InspectConfig inspectConfig =
          InspectConfig.newBuilder()
              .addAllInfoTypes(infoTypes)
              .setIncludeQuote(true)
              .setMinLikelihood(minLikelihood)
              .setLimits(findingLimits)
              .build();

      // Specify the action that is triggered when the job completes.
      Action.PublishSummaryToCscc publishSummaryToCscc =
          Action.PublishSummaryToCscc.getDefaultInstance();
      Action action = Action.newBuilder().setPublishSummaryToCscc(publishSummaryToCscc).build();

      // Configure the inspection job we want the service to perform.
      InspectJobConfig inspectJobConfig =
          InspectJobConfig.newBuilder()
              .setInspectConfig(inspectConfig)
              .setStorageConfig(storageConfig)
              .addActions(action)
              .build();

      // Construct the job creation request to be sent by the client.
      CreateDlpJobRequest createDlpJobRequest =
          CreateDlpJobRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectJob(inspectJobConfig)
              .build();

      // Send the job creation request and process the response.
      DlpJob createdDlpJob = dlpServiceClient.createDlpJob(createDlpJobRequest);
      System.out.println("Job created successfully: " + createdDlpJob.getName());
    }
  }
}

Node.js

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

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

// Initialize google DLP Client
const dlp = new DLP.DlpServiceClient();

async function jobsCreate() {
  // Construct cloud storage configuration
  const cloudStorageConfig = {
    cloudStorageOptions: {
      fileSet: {
        url: cloudFileUrl,
      },
    },
    timespanConfig: {
      enableAutoPopulationOfTimespanConfig: true,
    },
  };

  // Construct inspect job configuration
  const inspectJob = {
    storageConfig: cloudStorageConfig,
  };

  // Construct inspect configuration
  const inspectConfig = {
    infoTypes: [
      {name: 'EMAIL_ADDRESS'},
      {name: 'PERSON_NAME'},
      {name: 'LOCATION'},
      {name: 'PHONE_NUMBER'},
    ],
    includeQuote: true,
    minLikelihood: DLP.protos.google.privacy.dlp.v2.Likelihood.LIKELY,
    excludeInfoTypes: false,
  };

  // Combine configurations into a request for the service.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectJob: inspectJob,
    inspectConfig: inspectConfig,
  };

  // Send the request and receive response from the service
  const [response] = await dlp.createDlpJob(request);
  // Print the results
  console.log(`Job created successfully: ${response.name}`);
}

jobsCreate();

PHP

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

use Google\Cloud\Dlp\V2\Action;
use Google\Cloud\Dlp\V2\Action\PublishSummaryToCscc;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStorageOptions;
use Google\Cloud\Dlp\V2\CloudStorageOptions\FileSet;
use Google\Cloud\Dlp\V2\CreateDlpJobRequest;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits;
use Google\Cloud\Dlp\V2\InspectJobConfig;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\StorageConfig;
use Google\Cloud\Dlp\V2\StorageConfig\TimespanConfig;

/**
 * Creates an inspection job with the Cloud Data Loss Prevention API.
 *
 * @param string $callingProjectId  The project ID to run the API call under.
 * @param string $gcsPath           GCS file to be inspected. Example : gs://GOOGLE_STORAGE_BUCKET_NAME/dlp_sample.csv
 */
function create_job(
    string $callingProjectId,
    string $gcsPath
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Set autoPopulateTimespan to true to scan only new content.
    $timespanConfig = (new TimespanConfig())
        ->setEnableAutoPopulationOfTimespanConfig(true);

    // Specify the GCS file to be inspected.
    $cloudStorageOptions = (new CloudStorageOptions())
        ->setFileSet((new FileSet())
            ->setUrl($gcsPath));
    $storageConfig = (new StorageConfig())
        ->setCloudStorageOptions(($cloudStorageOptions))
        ->setTimespanConfig($timespanConfig);

    // ----- Construct inspection config -----
    $emailAddressInfoType = (new InfoType())
        ->setName('EMAIL_ADDRESS');
    $personNameInfoType = (new InfoType())
        ->setName('PERSON_NAME');
    $locationInfoType = (new InfoType())
        ->setName('LOCATION');
    $phoneNumberInfoType = (new InfoType())
        ->setName('PHONE_NUMBER');
    $infoTypes = [$emailAddressInfoType, $personNameInfoType, $locationInfoType, $phoneNumberInfoType];

    // Whether to include the matching string in the response.
    $includeQuote = true;
    // The minimum likelihood required before returning a match.
    $minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED;

    // The maximum number of findings to report (0 = server maximum).
    $limits = (new FindingLimits())
        ->setMaxFindingsPerRequest(100);

    // Create the Inspect configuration object.
    $inspectConfig = (new InspectConfig())
        ->setMinLikelihood($minLikelihood)
        ->setLimits($limits)
        ->setInfoTypes($infoTypes)
        ->setIncludeQuote($includeQuote);

    // Specify the action that is triggered when the job completes.
    $action = (new Action())
        ->setPublishSummaryToCscc(new PublishSummaryToCscc());

    // Configure the inspection job we want the service to perform.
    $inspectJobConfig = (new InspectJobConfig())
        ->setInspectConfig($inspectConfig)
        ->setStorageConfig($storageConfig)
        ->setActions([$action]);

    // Send the job creation request and process the response.
    $parent = "projects/$callingProjectId/locations/global";
    $createDlpJobRequest = (new CreateDlpJobRequest())
        ->setParent($parent)
        ->setInspectJob($inspectJobConfig);
    $job = $dlp->createDlpJob($createDlpJobRequest);

    // Print results.
    printf($job->getName());
}

Python

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


import google.cloud.dlp


def create_dlp_job(
    project: str,
    bucket: str,
    info_types: list[str],
    job_id: str = None,
    max_findings: int = 100,
    auto_populate_timespan: bool = True,
) -> None:
    """Uses the Data Loss Prevention API to create a DLP job.
    Args:
        project: The project id to use as a parent resource.
        bucket: The name of the GCS bucket to scan. This sample scans all
            files in the bucket.
        info_types: A list of strings representing info types to look for.
            A full list of info type categories can be fetched from the API.
        job_id: The id of the job. If omitted, an id will be randomly generated.
        max_findings: The maximum number of findings to report; 0 = no maximum.
        auto_populate_timespan: Automatically populates time span config start
            and end times in order to scan new content only.
    """

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

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

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries (protos are also accepted).
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration dictionary. Keys which are None may
    # optionally be omitted entirely.
    inspect_config = {
        "info_types": info_types,
        "min_likelihood": google.cloud.dlp_v2.Likelihood.UNLIKELY,
        "limits": {"max_findings_per_request": max_findings},
        "include_quote": True,
    }

    # Construct a cloud_storage_options dictionary with the bucket's URL.
    url = f"gs://{bucket}/*"
    storage_config = {
        "cloud_storage_options": {"file_set": {"url": url}},
        # Time-based configuration for each storage object.
        "timespan_config": {
            # Auto-populate start and end times in order to scan new objects
            # only.
            "enable_auto_population_of_timespan_config": auto_populate_timespan
        },
    }

    # Construct the job definition.
    job = {"inspect_config": inspect_config, "storage_config": storage_config}

    # Call the API.
    response = dlp.create_dlp_job(
        request={"parent": parent, "inspect_job": job, "job_id": job_id}
    )

    # Print out the result.
    print(f"Job : {response.name} status: {response.state}")

REST

Un trabajo se representa en la API de DLP con el recurso DlpJobs. Puedes crear un trabajo nuevo mediante el método projects.dlpJobs.create del recurso DlpJob.

Este JSON de muestra se puede enviar en una solicitud POST al extremo REST de Protección de datos sensibles especificado. En este JSON de ejemplo, se muestra cómo crear un trabajo en Protección de datos sensibles. El trabajo es un análisis de inspección de Datastore.

Para intentar realizar esto con rapidez, puedes usar el Explorador de API que se incorpora a continuación. Ten en cuenta que una solicitud correcta, incluso una creada en el Explorador de API, creará un trabajo. 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.

Entrada de JSON:

{
  "inspectJob": {
    "storageConfig": {
      "bigQueryOptions": {
        "tableReference": {
          "projectId": "bigquery-public-data",
          "datasetId": "san_francisco_sfpd_incidents",
          "tableId": "sfpd_incidents"
        }
      },
      "timespanConfig": {
        "startTime": "2020-01-01T00:00:01Z",
        "endTime": "2020-01-31T23:59:59Z",
        "timestampField": {
          "name": "timestamp"
        }
      }
    },
    "inspectConfig": {
      "infoTypes": [
        {
          "name": "PERSON_NAME"
        },
        {
          "name": "STREET_ADDRESS"
        }
      ],
      "excludeInfoTypes": false,
      "includeQuote": true,
      "minLikelihood": "LIKELY"
    },
    "actions": [
      {
        "saveFindings": {
          "outputConfig": {
            "table": {
              "projectId": "[PROJECT-ID]",
              "datasetId": "[DATASET-ID]"
            }
          }
        }
      }
    ]
  }
}

Salida de JSON:

El siguiente resultado indica que el trabajo se creó de forma correcta.

{
  "name": "projects/[PROJECT-ID]/dlpJobs/[JOB-ID]",
  "type": "INSPECT_JOB",
  "state": "PENDING",
  "inspectDetails": {
    "requestedOptions": {
      "snapshotInspectTemplate": {},
      "jobConfig": {
        "storageConfig": {
          "bigQueryOptions": {
            "tableReference": {
              "projectId": "bigquery-public-data",
              "datasetId": "san_francisco_sfpd_incidents",
              "tableId": "sfpd_incidents"
            }
          },
          "timespanConfig": {
            "startTime": "2020-01-01T00:00:01Z",
            "endTime": "2020-01-31T23:59:59Z",
            "timestampField": {
              "name": "timestamp"
            }
          }
        },
        "inspectConfig": {
          "infoTypes": [
            {
              "name": "PERSON_NAME"
            },
            {
              "name": "STREET_ADDRESS"
            }
          ],
          "minLikelihood": "LIKELY",
          "limits": {},
          "includeQuote": true
        },
        "actions": [
          {
            "saveFindings": {
              "outputConfig": {
                "table": {
                  "projectId": "[PROJECT-ID]",
                  "datasetId": "[DATASET-ID]",
                  "tableId": "[TABLE-ID]"
                }
              }
            }
          }
        ]
      }
    },
    "result": {}
  },
  "createTime": "2020-07-10T07:26:33.643Z"
}

Crea un activador de trabajo nuevo

Para crear un nuevo activador de trabajo de protección de datos sensibles, sigue estos pasos:

Console

En la sección Protección de datos sensibles de la consola de Google Cloud, ve a la página Crear trabajo o activador de trabajo.

Ir a Crear trabajo o activador de trabajo

La página Crear trabajo o activador de trabajo contiene las siguientes secciones:

Elige los datos de entrada
Configurar detección
Agrega acciones
Programa
Repaso

Elige los datos de entrada

Name

Ingresa un nombre para el activador de trabajo. Puedes usar letras, números y guiones. Asignar un nombre al activador de trabajo es opcional. Si no ingresas un nombre, la Protección de datos sensibles le dará un identificador de número único al activador de trabajo.

Ubicación

En el menú Tipo de almacenamiento, elige el tipo de repositorio que almacena los datos que deseas analizar:

Cloud Storage: ingresa la URL del bucket que deseas analizar o selecciona Incluir/excluir en el menú Tipo de ubicación y, luego, haz clic en Examinar para navegar al bucket o subcarpeta que deseas analizar. Selecciona la casilla de verificación Analizar carpeta de forma recurrente para analizar el directorio especificado y todos los directorios contenidos. Déjalo sin seleccionar para analizar solo el directorio especificado y nada más.
BigQuery: ingresa los identificadores del proyecto, el conjunto de datos y la tabla que deseas analizar.
Datastore: ingresa los identificadores para el proyecto, el espacio de nombres (opcional) y el tipo que deseas analizar.

Muestreo

El muestreo es una forma opcional de ahorrar recursos si tienes una gran cantidad de datos.

Para BigQuery, puedes muestrear un subconjunto del total de filas seleccionadas, que corresponde al porcentaje de archivos que especificas en el análisis.
En el caso de Cloud Storage, si algún archivo excede el tamaño especificado en el tamaño máximo de bytes para analizar por archivo, la Protección de datos sensibles lo escanea hasta ese tamaño máximo y luego pasa al siguiente archivo.

Para activar el muestreo, elige una de las siguientes opciones del primer menú:

Iniciar el muestreo desde la parte superior: Sensitive Data Protection inicia el análisis parcial al comienzo de los datos. Para BigQuery, esto inicia el análisis en la primera fila. En el caso de Cloud Storage, esto inicia el análisis al comienzo de cada archivo y lo detiene una vez que la Protección de datos sensibles analiza hasta cualquier tamaño máximo de archivo (ver arriba).
Iniciar el muestreo desde un punto de inicio aleatorio: Sensitive Data Protection inicia el análisis parcial en una ubicación aleatoria dentro de los datos. Para BigQuery, esto inicia el análisis en una fila aleatoria. Para Cloud Storage, esta configuración solo se aplica a los archivos que superan cualquier tamaño máximo especificado. La Protección de datos sensibles analiza los archivos por debajo del tamaño máximo en su totalidad y los archivos por encima del tamaño máximo hasta el máximo.

Para realizar un análisis parcial, también debes elegir qué porcentaje de los datos deseas analizar. Usa el control deslizante para establecer el porcentaje.

Configuración avanzada

Cuando creas un trabajo de activador para un análisis de depósitos de Cloud Storage o tablas de BigQuery, puedes limitar la búsqueda si especificas una configuración avanzada. Específicamente, puedes configurar lo siguiente:

Archivos (solo Cloud Storage): los tipos de archivo que se deben analizar, incluidos los archivos de texto, binarios e imágenes.
Campos de identificación (solo BigQuery): identificadores de fila únicos dentro de la tabla.
En el caso de Cloud Storage, si algún archivo excede el tamaño especificado en el tamaño máximo de bytes para analizar por archivo, la Protección de datos sensibles lo escanea hasta ese tamaño máximo y luego pasa al siguiente archivo.

Para activar el muestreo, elige el porcentaje de datos que deseas analizar. Usa el control deslizante para establecer el porcentaje. Luego, elige una de las siguientes opciones del primer menú:

Iniciar el muestreo desde la parte superior: Sensitive Data Protection inicia el análisis parcial al comienzo de los datos. Para BigQuery, esto inicia el análisis en la primera fila. En el caso de Cloud Storage, esto inicia el análisis al comienzo de cada archivo y lo detiene una vez que la Protección de datos sensibles analiza hasta cualquier tamaño máximo de archivo (ver arriba).
Iniciar el muestreo desde un punto de inicio aleatorio: Sensitive Data Protection inicia el análisis parcial en una ubicación aleatoria dentro de los datos. Para BigQuery, esto inicia el análisis en una fila aleatoria. Para Cloud Storage, esta configuración solo se aplica a los archivos que superan cualquier tamaño máximo especificado. La Protección de datos sensibles analiza los archivos por debajo del tamaño máximo en su totalidad y los archivos por encima del tamaño máximo hasta el máximo.

Archivos

Para los archivos almacenados en Cloud Storage, puedes especificar los tipos que se incluirán en tu análisis en Archivos.

Puedes elegir entre archivos binarios, de texto, de imagen, de Microsoft Word, Microsoft Excel, Microsoft PowerPoint, PDF y Apache Avro. Para obtener una lista exhaustiva de las extensiones de archivo que Sensitive Data Protection puede analizar en los buckets de Cloud Storage, consulta FileType. Elegir Binario hace que Sensitive Data Protection analice archivos de tipos que no se reconocen.

Campos de identificación

También debes activar la acción Guardar en BigQuery para exportar los resultados a BigQuery. Cuando los resultados se exportan a BigQuery, cada resultado contiene los valores respectivos de los campos de identificación. Para obtener más información, consulta identifyingFields.

Configura la detección

Plantilla

De manera opcional, puedes usar una plantilla de Protección de datos sensibles para reutilizar la información de configuración que especificaste anteriormente.

Para obtener más información sobre cómo crear plantillas, consulta Cómo crear plantillas de inspección de Protección de datos sensibles.

Infotipos

Los detectores de Infotipo encuentran datos sensibles de un tipo determinado. Por ejemplo, el detector de Infotipo integrado US_SOCIAL_SECURITY_NUMBER de Protección de datos sensibles encuentra números de seguridad social de EE.UU. Además de los detectores de Infotipo incorporados, puedes crear tus propios detectores de Infotipo personalizados.

En Infotipos, elige el detector de Infotipo que corresponda al tipo de datos que deseas analizar. También puedes dejar este campo en blanco para buscar todos los Infotipos predeterminados. Para obtener más información sobre cada detector, consulta la referencia del detector de Infotipo.

También puedes agregar detectores de Infotipo personalizados en la sección Infotipos personalizados y personalizar los detectores de Infotipos integrados y personalizados en la sección Conjuntos de reglas de inspección.

Infotipos personalizados

Conjuntos de reglas de inspección

Las reglas de exclusión, que ayudan a excluir resultados falsos o no deseados.
Reglas de palabras clave, que ayudan a detectar resultados adicionales.

Haz clic en el campo Elegir infotipos. El infotipo o los infotipos que especificaste antes aparecen debajo del campo en un menú, como se muestra a continuación:

Elige un Infotipo del menú y, luego, haz clic en Agregar regla. Aparecerá un menú con las dos opciones Regla de palabra clave y Regla de exclusión.

Para las reglas de palabras clave, elige Hotword rules. A continuación, sigue estos pasos:

En el campo Palabra clave, ingresa una expresión regular que Sensitive Data Protection debería buscar.
En el menú Hotword proximity, elige si la palabra clave que ingresaste se encuentra antes o después del Infotipo elegido.
En Hotword distance from infoType, ingresa la cantidad aproximada de caracteres entre la palabra clave y el infotipo elegido.
En Ajuste del nivel de confianza, elige si deseas asignar a las coincidencias un nivel fijo de probabilidad o aumentar o disminuir el nivel de probabilidad predeterminado en una cantidad determinada.

Para las reglas de exclusión, elige Reglas de exclusión. A continuación, sigue estos pasos:

En el campo Excluir, ingresa una expresión regular (regex) que Sensitive Data Protection deba buscar.
En el menú Tipo de coincidencia, elige una de las siguientes opciones:

Coincidencia completa: El hallazgo debe coincidir completamente con la regex.
Coincidencia parcial: Una subcadena del resultado puede coincidir con la regex.
Coincidencia inversa: El hallazgo no coincide con la regex.

Puedes agregar reglas de palabras clave o exclusiones adicionales, y conjuntos de reglas para definir mejor los resultados de la búsqueda.

Límite de confianza

Cuando finalices, haz clic en Continuar.

Agrega acciones

En el paso Agrega acciones, selecciona una o más acciones que desees que realice la Protección de datos sensibles después de que se complete el trabajo.

Puedes configurar las siguientes acciones:

Guardar en BigQuery: Guarda los resultados del trabajo de Protección de datos sensibles en una tabla de BigQuery. Antes de ver o analizar los resultados, primero debes asegurarte de que el trabajo se haya completado.

Cada vez que se ejecuta un análisis, Sensitive Data Protection guarda los resultados en la tabla de BigQuery que especifiques. Los resultados exportados contienen detalles sobre la ubicación de cada resultado y la probabilidad de coincidencia. Si deseas que cada resultado incluya la cadena que coincide con el detector de Infotipo, habilita la opción Incluir cita.

Si no especificas un ID de tabla, BigQuery asigna un nombre predeterminado a una tabla nueva la primera vez que se ejecuta el análisis. Si especificas una tabla existente, Sensitive Data Protection le adjunta los resultados del análisis.

Si no guardas los resultados en BigQuery, los resultados del análisis solo contendrá estadísticas sobre la cantidad y los infotipos de los resultados.

Cuando se escriben datos en una tabla de BigQuery, el uso de cuotas y la facturación se aplican al proyecto que contiene la tabla de destino.
Publicar en Pub/Sub: Publica una notificación que contenga el nombre del trabajo de Protección de datos sensibles como un atributo en un canal de Pub/Sub. Puedes especificar uno o más temas a los que se enviará el mensaje de notificación. Asegúrate de que la cuenta de servicio de Sensitive Data Protection que ejecuta el trabajo de análisis tenga acceso de publicación en el tema.

Nota: Si hay problemas de configuración o permisos con el tema de Pub/Sub, la Protección de datos sensibles reintentará enviar la notificación de Pub/Sub durante hasta dos semanas. Después de dos semanas, se descarta la notificación.
Publicar en Security Command Center: Publica un resumen de los resultados del trabajo en Security Command Center. Para obtener más información, consulta Cómo enviar resultados de análisis de la Protección de datos sensibles a Security Command Center.
Publicar en Dataplex: Envía los resultados de las tareas a Dataplex, el servicio de administración de metadatos de Google Cloud.
Notificar por correo electrónico: Envía un correo electrónico cuando se complete el trabajo. El correo electrónico se envía a los propietarios del proyecto de IAM y a los Contactos esenciales técnicos.
Publicar en Cloud Monitoring: Envía los resultados de la inspección a Cloud Monitoring en Observabilidad de Google Cloud.
Hacer una copia desidentificada: Desidentifica los resultados de los datos inspeccionados y escribe el contenido desidentificado en un archivo nuevo. Luego, puedes usar la copia desidentificada en tus procesos comerciales, en lugar de los datos que contienen información sensible. Para obtener más información, consulta Cómo crear una copia desidentificada de los datos de Cloud Storage con la Protección de datos sensibles en la consola de Google Cloud.

Para obtener más información, consulta Acciones.

Cuando finalices de seleccionar las acciones, haz clic en Continuar.

Programa

En la sección Programación, tienes las siguientes dos opciones:

Especificar intervalo de tiempo: se limitan los archivos o las filas para analizar por fecha. Haz clic en Hora de inicio para especificar la marca de tiempo del archivo más antigua que se debe incluir. Deja este valor en blanco para especificar todos los archivos. Haz clic en Hora de finalización para especificar la marca de tiempo del archivo más reciente. Deja este valor en blanco para no especificar un límite de marca de tiempo superior.
Crear un activador para ejecutar el trabajo de forma periódica: Esta opción convierte el trabajo en un activador de trabajo que se ejecuta de forma periódica. Si no especificas un programa, debes crear un solo trabajo que se inicie de inmediato y se ejecute una vez. Para crear un activador de trabajo que se ejecute con regularidad, debes configurar esta opción.

El valor predeterminado también es el valor mínimo: 24 horas. El valor máximo es de 60 días.

Si deseas que la Protección de datos sensibles analice solo archivos o filas nuevos, selecciona Limitar análisis solo a contenido nuevo. Para la inspección de BigQuery, solo se incluyen en el análisis las filas que tengan al menos tres horas de antigüedad. Consulta el problema conocido relacionado con esta operación.

Revisar

La sección Revisa contiene un resumen con formato JSON de la configuración del trabajo que acabas de especificar.

Haz clic en Crear para crear el activador de trabajo (si especificaste un programa). Aparecerá la página de información del activador de trabajo, que contiene el estado y otra información. Si el trabajo se encuentra en ejecución, puedes hacer clic en el botón Cancelar para detenerlo. También puedes borrar el activador de trabajo si haces clic en Borrar.

Para volver a la página principal de Protección de datos sensibles, haz clic en la flecha Atrás en la consola de Google Cloud.

C#

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


using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using System;
using System.Collections.Generic;
using static Google.Cloud.Dlp.V2.CloudStorageOptions.Types;
using static Google.Cloud.Dlp.V2.InspectConfig.Types;
using static Google.Cloud.Dlp.V2.JobTrigger.Types;
using static Google.Cloud.Dlp.V2.StorageConfig.Types;

public class TriggersCreate
{
    public static JobTrigger Create(
        string projectId,
        string bucketName,
        Likelihood minLikelihood,
        int maxFindings,
        bool autoPopulateTimespan,
        int scanPeriod,
        IEnumerable<InfoType> infoTypes,
        string triggerId,
        string displayName,
        string description)
    {
        var dlp = DlpServiceClient.Create();

        var jobConfig = new InspectJobConfig
        {
            InspectConfig = new InspectConfig
            {
                MinLikelihood = minLikelihood,
                Limits = new FindingLimits
                {
                    MaxFindingsPerRequest = maxFindings
                },
                InfoTypes = { infoTypes }
            },
            StorageConfig = new StorageConfig
            {
                CloudStorageOptions = new CloudStorageOptions
                {
                    FileSet = new FileSet
                    {
                        Url = $"gs://{bucketName}/*"
                    }
                },
                TimespanConfig = new TimespanConfig
                {
                    EnableAutoPopulationOfTimespanConfig = autoPopulateTimespan
                }
            }
        };

        var jobTrigger = new JobTrigger
        {
            Triggers =
            {
                new Trigger
                {
                    Schedule = new Schedule
                    {
                        RecurrencePeriodDuration = new Google.Protobuf.WellKnownTypes.Duration
                        {
                            Seconds = scanPeriod * 60 * 60 * 24
                        }
                    }
                }
            },
            InspectJob = jobConfig,
            Status = Status.Healthy,
            DisplayName = displayName,
            Description = description
        };

        var response = dlp.CreateJobTrigger(
            new CreateJobTriggerRequest
            {
                Parent = new LocationName(projectId, "global").ToString(),
                JobTrigger = jobTrigger,
                TriggerId = triggerId
            });

        Console.WriteLine($"Successfully created trigger {response.Name}");
        return response;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"github.com/golang/protobuf/ptypes/duration"
)

// createTrigger creates a trigger with the given configuration.
func createTrigger(w io.Writer, projectID string, triggerID, displayName, description, bucketName string, infoTypeNames []string) error {
	// projectID := "my-project-id"
	// triggerID := "my-trigger"
	// displayName := "My Trigger"
	// description := "My trigger description"
	// bucketName := "my-bucket"
	// infoTypeNames := []string{"US_SOCIAL_SECURITY_NUMBER"}

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Convert the info type strings to a list of InfoTypes.
	var infoTypes []*dlppb.InfoType
	for _, it := range infoTypeNames {
		infoTypes = append(infoTypes, &dlppb.InfoType{Name: it})
	}

	// Create a configured request.
	req := &dlppb.CreateJobTriggerRequest{
		Parent:    fmt.Sprintf("projects/%s/locations/global", projectID),
		TriggerId: triggerID,
		JobTrigger: &dlppb.JobTrigger{
			DisplayName: displayName,
			Description: description,
			Status:      dlppb.JobTrigger_HEALTHY,
			// Triggers control when the job will start.
			Triggers: []*dlppb.JobTrigger_Trigger{
				{
					Trigger: &dlppb.JobTrigger_Trigger_Schedule{
						Schedule: &dlppb.Schedule{
							Option: &dlppb.Schedule_RecurrencePeriodDuration{
								RecurrencePeriodDuration: &duration.Duration{
									Seconds: 10 * 60 * 60 * 24, // 10 days in seconds.
								},
							},
						},
					},
				},
			},
			// Job configures the job to run when the trigger runs.
			Job: &dlppb.JobTrigger_InspectJob{
				InspectJob: &dlppb.InspectJobConfig{
					InspectConfig: &dlppb.InspectConfig{
						InfoTypes:     infoTypes,
						MinLikelihood: dlppb.Likelihood_POSSIBLE,
						Limits: &dlppb.InspectConfig_FindingLimits{
							MaxFindingsPerRequest: 10,
						},
					},
					StorageConfig: &dlppb.StorageConfig{
						Type: &dlppb.StorageConfig_CloudStorageOptions{
							CloudStorageOptions: &dlppb.CloudStorageOptions{
								FileSet: &dlppb.CloudStorageOptions_FileSet{
									Url: "gs://" + bucketName + "/*",
								},
							},
						},
						// Time-based configuration for each storage object. See more at
						// https://cloud.google.com/dlp/docs/reference/rest/v2/InspectJobConfig#TimespanConfig
						TimespanConfig: &dlppb.StorageConfig_TimespanConfig{
							// Auto-populate start and end times in order to scan new objects only.
							EnableAutoPopulationOfTimespanConfig: true,
						},
					},
				},
			},
		},
	}

	// Send the request.
	resp, err := client.CreateJobTrigger(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateJobTrigger: %w", err)
	}
	fmt.Fprintf(w, "Successfully created trigger: %v", resp.GetName())
	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CloudStorageOptions;
import com.google.privacy.dlp.v2.CreateJobTriggerRequest;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectJobConfig;
import com.google.privacy.dlp.v2.JobTrigger;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.Schedule;
import com.google.privacy.dlp.v2.StorageConfig;
import com.google.privacy.dlp.v2.StorageConfig.TimespanConfig;
import com.google.protobuf.Duration;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TriggersCreate {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String gcsPath = "gs://" + "your-bucket-name" + "path/to/file.txt";
    createTrigger(projectId, gcsPath);
  }

  public static void createTrigger(String projectId, String gcsPath) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Set autoPopulateTimespan to true to scan only new content
      boolean autoPopulateTimespan = true;
      TimespanConfig timespanConfig =
          TimespanConfig.newBuilder()
              .setEnableAutoPopulationOfTimespanConfig(autoPopulateTimespan)
              .build();

      // Specify the GCS file to be inspected.
      CloudStorageOptions cloudStorageOptions =
          CloudStorageOptions.newBuilder()
              .setFileSet(CloudStorageOptions.FileSet.newBuilder().setUrl(gcsPath))
              .build();
      StorageConfig storageConfig =
          StorageConfig.newBuilder()
              .setCloudStorageOptions(cloudStorageOptions)
              .setTimespanConfig(timespanConfig)
              .build();

      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      List<InfoType> infoTypes =
          Stream.of("PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());

      InspectConfig inspectConfig = InspectConfig.newBuilder().addAllInfoTypes(infoTypes).build();

      // Configure the inspection job we want the service to perform.
      InspectJobConfig inspectJobConfig =
          InspectJobConfig.newBuilder()
              .setInspectConfig(inspectConfig)
              .setStorageConfig(storageConfig)
              .build();

      // Set scanPeriod to the number of days between scans (minimum: 1 day)
      int scanPeriod = 1;

      // Optionally set a display name of max 100 chars and a description of max 250 chars
      String displayName = "Daily Scan";
      String description = "A daily inspection for personally identifiable information.";

      // Schedule scan of GCS bucket every scanPeriod number of days (minimum = 1 day)
      Duration duration = Duration.newBuilder().setSeconds(scanPeriod * 24 * 3600).build();
      Schedule schedule = Schedule.newBuilder().setRecurrencePeriodDuration(duration).build();
      JobTrigger.Trigger trigger = JobTrigger.Trigger.newBuilder().setSchedule(schedule).build();
      JobTrigger jobTrigger =
          JobTrigger.newBuilder()
              .setInspectJob(inspectJobConfig)
              .setDisplayName(displayName)
              .setDescription(description)
              .setStatus(JobTrigger.Status.HEALTHY)
              .addTriggers(trigger)
              .build();

      // Create scan request to be sent by client
      CreateJobTriggerRequest createJobTriggerRequest =
          CreateJobTriggerRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setJobTrigger(jobTrigger)
              .build();

      // Send the scan request and process the response
      JobTrigger createdJobTrigger = dlpServiceClient.createJobTrigger(createJobTriggerRequest);

      System.out.println("Created Trigger: " + createdJobTrigger.getName());
      System.out.println("Display Name: " + createdJobTrigger.getDisplayName());
      System.out.println("Description: " + createdJobTrigger.getDescription());
    }
  }
}

Node.js

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

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

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

// The project ID to run the API call under
// const projectId = 'my-project';

// (Optional) The name of the trigger to be created.
// const triggerId = 'my-trigger';

// (Optional) A display name for the trigger to be created
// const displayName = 'My Trigger';

// (Optional) A description for the trigger to be created
// const description = "This is a sample trigger.";

// The name of the bucket to scan.
// const bucketName = 'YOUR-BUCKET';

// Limit scan to new content only.
// const autoPopulateTimespan = true;

// How often to wait between scans, in days (minimum = 1 day)
// const scanPeriod = 1;

// The infoTypes of information to match
// const infoTypes = [{ name: 'PHONE_NUMBER' }, { name: 'EMAIL_ADDRESS' }, { name: 'CREDIT_CARD_NUMBER' }];

// The minimum likelihood required before returning a match
// const minLikelihood = 'LIKELIHOOD_UNSPECIFIED';

// The maximum number of findings to report per request (0 = server maximum)
// const maxFindings = 0;

async function createTrigger() {
  // Get reference to the bucket to be inspected
  const storageItem = {
    cloudStorageOptions: {
      fileSet: {url: `gs://${bucketName}/*`},
    },
    timeSpanConfig: {
      enableAutoPopulationOfTimespanConfig: autoPopulateTimespan,
    },
  };

  // Construct job to be triggered
  const job = {
    inspectConfig: {
      infoTypes: infoTypes,
      minLikelihood: minLikelihood,
      limits: {
        maxFindingsPerRequest: maxFindings,
      },
    },
    storageConfig: storageItem,
  };

  // Construct trigger creation request
  const request = {
    parent: `projects/${projectId}/locations/global`,
    jobTrigger: {
      inspectJob: job,
      displayName: displayName,
      description: description,
      triggers: [
        {
          schedule: {
            recurrencePeriodDuration: {
              seconds: scanPeriod * 60 * 60 * 24, // Trigger the scan daily
            },
          },
        },
      ],
      status: 'HEALTHY',
    },
    triggerId: triggerId,
  };

  // Run trigger creation request
  const [trigger] = await dlp.createJobTrigger(request);
  console.log(`Successfully created trigger ${trigger.name}.`);
}

createTrigger();

PHP

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

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStorageOptions;
use Google\Cloud\Dlp\V2\CloudStorageOptions\FileSet;
use Google\Cloud\Dlp\V2\CreateJobTriggerRequest;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits;
use Google\Cloud\Dlp\V2\InspectJobConfig;
use Google\Cloud\Dlp\V2\JobTrigger;
use Google\Cloud\Dlp\V2\JobTrigger\Status;
use Google\Cloud\Dlp\V2\JobTrigger\Trigger;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\Schedule;
use Google\Cloud\Dlp\V2\StorageConfig;
use Google\Cloud\Dlp\V2\StorageConfig\TimespanConfig;
use Google\Protobuf\Duration;

/**
 * Create a Data Loss Prevention API job trigger.
 *
 * @param string $callingProjectId     The project ID to run the API call under
 * @param string $bucketName           The name of the bucket to scan
 * @param string $triggerId            (Optional) The name of the trigger to be created
 * @param string $displayName          (Optional) The human-readable name to give the trigger
 * @param string $description          (Optional) A description for the trigger to be created
 * @param int    $scanPeriod           (Optional) How often to wait between scans, in days (minimum = 1 day)
 * @param bool   $autoPopulateTimespan (Optional) Automatically limit scan to new content only
 * @param int    $maxFindings          (Optional) The maximum number of findings to report per request (0 = server maximum)
 */
function create_trigger(
    string $callingProjectId,
    string $bucketName,
    string $triggerId,
    string $displayName,
    string $description,
    int $scanPeriod,
    bool $autoPopulateTimespan,
    int $maxFindings
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // ----- Construct job config -----
    // The infoTypes of information to match
    $personNameInfoType = (new InfoType())
        ->setName('PERSON_NAME');
    $phoneNumberInfoType = (new InfoType())
        ->setName('PHONE_NUMBER');
    $infoTypes = [$personNameInfoType, $phoneNumberInfoType];

    // The minimum likelihood required before returning a match
    $minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED;

    // Specify finding limits
    $limits = (new FindingLimits())
        ->setMaxFindingsPerRequest($maxFindings);

    // Create the inspectConfig object
    $inspectConfig = (new InspectConfig())
        ->setMinLikelihood($minLikelihood)
        ->setLimits($limits)
        ->setInfoTypes($infoTypes);

    // Create triggers
    $duration = (new Duration())
        ->setSeconds($scanPeriod * 60 * 60 * 24);

    $schedule = (new Schedule())
        ->setRecurrencePeriodDuration($duration);

    $triggerObject = (new Trigger())
        ->setSchedule($schedule);

    // Create the storageConfig object
    $fileSet = (new FileSet())
        ->setUrl('gs://' . $bucketName . '/*');

    $storageOptions = (new CloudStorageOptions())
        ->setFileSet($fileSet);

    // Auto-populate start and end times in order to scan new objects only.
    $timespanConfig = (new TimespanConfig())
        ->setEnableAutoPopulationOfTimespanConfig($autoPopulateTimespan);

    $storageConfig = (new StorageConfig())
        ->setCloudStorageOptions($storageOptions)
        ->setTimespanConfig($timespanConfig);

    // Construct the jobConfig object
    $jobConfig = (new InspectJobConfig())
        ->setInspectConfig($inspectConfig)
        ->setStorageConfig($storageConfig);

    // ----- Construct trigger object -----
    $jobTriggerObject = (new JobTrigger())
        ->setTriggers([$triggerObject])
        ->setInspectJob($jobConfig)
        ->setStatus(Status::HEALTHY)
        ->setDisplayName($displayName)
        ->setDescription($description);

    // Run trigger creation request
    $parent = $dlp->locationName($callingProjectId, 'global');
    $createJobTriggerRequest = (new CreateJobTriggerRequest())
        ->setParent($parent)
        ->setJobTrigger($jobTriggerObject)
        ->setTriggerId($triggerId);
    $trigger = $dlp->createJobTrigger($createJobTriggerRequest);

    // Print results
    printf('Successfully created trigger %s' . PHP_EOL, $trigger->getName());
}

Python

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

from typing import Optional

import google.cloud.dlp


def create_trigger(
    project: str,
    bucket: str,
    scan_period_days: int,
    info_types: List[str],
    trigger_id: Optional[str] = None,
    display_name: Optional[str] = None,
    description: Optional[str] = None,
    min_likelihood: Optional[int] = None,
    max_findings: Optional[int] = None,
    auto_populate_timespan: Optional[bool] = False,
) -> None:
    """Creates a scheduled Data Loss Prevention API inspect_content trigger.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        bucket: The name of the GCS bucket to scan. This sample scans all
            files in the bucket using a wildcard.
        scan_period_days: How often to repeat the scan, in days.
            The minimum is 1 day.
        info_types: A list of strings representing info types to look for.
            A full list of info type categories can be fetched from the API.
        trigger_id: The id of the trigger. If omitted, an id will be randomly
            generated.
        display_name: The optional display name of the trigger.
        description: The optional description of the trigger.
        min_likelihood: A string representing the minimum likelihood threshold
            that constitutes a match. One of: 'LIKELIHOOD_UNSPECIFIED',
            'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE', 'LIKELY', 'VERY_LIKELY'.
        max_findings: The maximum number of findings to report; 0 = no maximum.
        auto_populate_timespan: Automatically populates time span config start
            and end times in order to scan new content only.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries (protos are also accepted).
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration dictionary. Keys which are None may
    # optionally be omitted entirely.
    inspect_config = {
        "info_types": info_types,
        "min_likelihood": min_likelihood,
        "limits": {"max_findings_per_request": max_findings},
    }

    # Construct a cloud_storage_options dictionary with the bucket's URL.
    url = f"gs://{bucket}/*"
    storage_config = {
        "cloud_storage_options": {"file_set": {"url": url}},
        # Time-based configuration for each storage object.
        "timespan_config": {
            # Auto-populate start and end times in order to scan new objects
            # only.
            "enable_auto_population_of_timespan_config": auto_populate_timespan
        },
    }

    # Construct the job definition.
    job = {"inspect_config": inspect_config, "storage_config": storage_config}

    # Construct the schedule definition:
    schedule = {
        "recurrence_period_duration": {"seconds": scan_period_days * 60 * 60 * 24}
    }

    # Construct the trigger definition.
    job_trigger = {
        "inspect_job": job,
        "display_name": display_name,
        "description": description,
        "triggers": [{"schedule": schedule}],
        "status": google.cloud.dlp_v2.JobTrigger.Status.HEALTHY,
    }

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

    # Call the API.
    response = dlp.create_job_trigger(
        request={"parent": parent, "job_trigger": job_trigger, "trigger_id": trigger_id}
    )

    print(f"Successfully created trigger {response.name}")

REST

Un recurso de trabajo se representa en la API de DLP con el recurso JobTrigger. Puedes crear un activador de trabajo nuevo mediante el método projects.jobTriggers.create del recurso JobTrigger.

Este JSON de muestra se puede enviar en una solicitud POST al extremo REST de Protección de datos sensibles especificado. En este JSON de ejemplo, se muestra cómo crear un activador de trabajo en Protección de datos sensibles. El trabajo que iniciará este activador es un análisis de inspección de Datastore. El activador de trabajo que se crea se ejecuta cada 86,400 segundos (o 24 horas).

Para intentar realizar esto con rapidez, puedes usar el Explorador de API que se incorpora a continuación. Ten en cuenta que una solicitud correcta, incluso una creada en el Explorador de API, creará un activador de trabajo programado nuevo. 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.

Entrada de JSON:

{
  "jobTrigger":{
    "displayName":"JobTrigger1",
    "description":"Starts an inspection of a Datastore kind",
    "triggers":[
      {
        "schedule":{
          "recurrencePeriodDuration":"86400s"
        }
      }
    ],
    "status":"HEALTHY",
    "inspectJob":{
      "storageConfig":{
        "datastoreOptions":{
          "kind":{
            "name":"Example-Kind"
          },
          "partitionId":{
            "projectId":"[PROJECT_ID]",
            "namespaceId":"[NAMESPACE_ID]"
          }
        }
      },
      "inspectConfig":{
        "infoTypes":[
          {
            "name":"PHONE_NUMBER"
          }
        ],
        "excludeInfoTypes":false,
        "includeQuote":true,
        "minLikelihood":"LIKELY"
      },
      "actions":[
        {
          "saveFindings":{
            "outputConfig":{
              "table":{
                "projectId":"[PROJECT_ID]",
                "datasetId":"[BIGQUERY_DATASET_NAME]",
                "tableId":"[BIGQUERY_TABLE_NAME]"
              }
            }
          }
        }
      ]
    }
  }
}

Salida de JSON:

En el resultado siguiente, se indica que el activador de trabajo se creó de manera correcta.

{
  "name":"projects/[PROJECT_ID]/jobTriggers/[JOB_TRIGGER_NAME]",
  "displayName":"JobTrigger1",
  "description":"Starts an inspection of a Datastore kind",
  "inspectJob":{
    "storageConfig":{
      "datastoreOptions":{
        "partitionId":{
          "projectId":"[PROJECT_ID]",
          "namespaceId":"[NAMESPACE_ID]"
        },
        "kind":{
          "name":"Example-Kind"
        }
      }
    },
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"PHONE_NUMBER"
        }
      ],
      "minLikelihood":"LIKELY",
      "limits":{

      },
      "includeQuote":true
    },
    "actions":[
      {
        "saveFindings":{
          "outputConfig":{
            "table":{
              "projectId":"[PROJECT_ID]",
              "datasetId":"[BIGQUERY_DATASET_NAME]",
              "tableId":"[BIGQUERY_TABLE_NAME]"
            }
          }
        }
      }
    ]
  },
  "triggers":[
    {
      "schedule":{
        "recurrencePeriodDuration":"86400s"
      }
    }
  ],
  "createTime":"2018-11-30T01:52:41.171857Z",
  "updateTime":"2018-11-30T01:52:41.171857Z",
  "status":"HEALTHY"
}

Enumera todos los trabajos

Para enumerar todos los trabajos del proyecto actual, sigue estos pasos:

Console

En la consola de Google Cloud, ve a la página Protección de datos sensibles.

Ir a Protección de datos sensibles
Haz clic en la pestaña Inspección y, luego, en la subpestaña Inspeccionar trabajos.

La consola muestra una lista de todos los trabajos del proyecto actual, incluidos sus identificadores de trabajo, el estado, la hora de creación y la hora de finalización. Para obtener más información sobre cualquier trabajo, incluido un resumen de sus resultados, haz clic en su identificador.

C#

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


using Google.Api.Gax;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;

public class JobsList
{
    public static PagedEnumerable<ListDlpJobsResponse, DlpJob> ListDlpJobs(string projectId, string filter, DlpJobType jobType)
    {
        var dlp = DlpServiceClient.Create();

        var response = dlp.ListDlpJobs(new ListDlpJobsRequest
        {
            Parent = new LocationName(projectId, "global").ToString(),
            Filter = filter,
            Type = jobType
        });

        // Uncomment to print jobs
        // foreach (var job in response)
        // {
        //     Console.WriteLine($"Job: {job.Name} status: {job.State}");
        // }

        return response;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"google.golang.org/api/iterator"
)

// listJobs lists jobs matching the given optional filter and optional jobType.
func listJobs(w io.Writer, projectID, filter, jobType string) error {
	// projectID := "my-project-id"
	// filter := "`state` = FINISHED"
	// jobType := "RISK_ANALYSIS_JOB"
	ctx := context.Background()
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Create a configured request.
	req := &dlppb.ListDlpJobsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
		Filter: filter,
		Type:   dlppb.DlpJobType(dlppb.DlpJobType_value[jobType]),
	}
	// Send the request and iterate over the results.
	it := client.ListDlpJobs(ctx, req)
	for {
		j, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %w", err)
		}
		fmt.Fprintf(w, "Job %v status: %v\n", j.GetName(), j.GetState())
	}
	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.DlpJobType;
import com.google.privacy.dlp.v2.ListDlpJobsRequest;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

public class JobsList {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    listJobs(projectId);
  }

  // Lists DLP jobs
  public static void listJobs(String projectId) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Construct the request to be sent by the client.
      // For more info on filters and job types,
      // see https://cloud.google.com/dlp/docs/reference/rest/v2/projects.dlpJobs/list
      ListDlpJobsRequest listDlpJobsRequest =
          ListDlpJobsRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setFilter("state=DONE")
              .setType(DlpJobType.valueOf("INSPECT_JOB"))
              .build();

      // Send the request to list jobs and process the response
      DlpServiceClient.ListDlpJobsPagedResponse response =
          dlpServiceClient.listDlpJobs(listDlpJobsRequest);

      System.out.println("DLP jobs found:");
      for (DlpJob dlpJob : response.getPage().getValues()) {
        System.out.println(dlpJob.getName() + " -- " + dlpJob.getState());
      }
    }
  }
}

Node.js

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

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

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

// The project ID to run the API call under
// const projectId = 'my-project';

// The filter expression to use
// For more information and filter syntax, see https://cloud.google.com/dlp/docs/reference/rest/v2/projects.dlpJobs/list
// const filter = `state=DONE`;

// The type of job to list (either 'INSPECT_JOB' or 'RISK_ANALYSIS_JOB')
// const jobType = 'INSPECT_JOB';
async function listJobs() {
  // Construct request for listing DLP scan jobs
  const request = {
    parent: `projects/${projectId}/locations/global`,
    filter: filter,
    type: jobType,
  };

  // Run job-listing request
  const [jobs] = await dlp.listDlpJobs(request);
  jobs.forEach(job => {
    console.log(`Job ${job.name} status: ${job.state}`);
  });
}

listJobs();

PHP

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

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\DlpJobType;
use Google\Cloud\Dlp\V2\ListDlpJobsRequest;

/**
 * List Data Loss Prevention API jobs corresponding to a given filter.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 * @param string $filter            The filter expression to use
 */
function list_jobs(string $callingProjectId, string $filter): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // The type of job to list (either 'INSPECT_JOB' or 'REDACT_JOB')
    $jobType = DlpJobType::INSPECT_JOB;

    // Run job-listing request
    // For more information and filter syntax,
    // @see https://cloud.google.com/dlp/docs/reference/rest/v2/projects.dlpJobs/list
    $parent = "projects/$callingProjectId/locations/global";
    $listDlpJobsRequest = (new ListDlpJobsRequest())
        ->setParent($parent)
        ->setFilter($filter)
        ->setType($jobType);
    $response = $dlp->listDlpJobs($listDlpJobsRequest);

    // Print job list
    $jobs = $response->iterateAllElements();
    foreach ($jobs as $job) {
        printf('Job %s status: %s' . PHP_EOL, $job->getName(), $job->getState());
        $infoTypeStats = $job->getInspectDetails()->getResult()->getInfoTypeStats();

        if ($job->getState() == JobState::DONE) {
            if (count($infoTypeStats) > 0) {
                foreach ($infoTypeStats as $infoTypeStat) {
                    printf(
                        '  Found %s instance(s) of type %s' . PHP_EOL,
                        $infoTypeStat->getCount(),
                        $infoTypeStat->getInfoType()->getName()
                    );
                }
            } else {
                print('  No findings.' . PHP_EOL);
            }
        }
    }
}

Python

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


from typing import Optional

import google.cloud.dlp


def list_dlp_jobs(
    project: str, filter_string: Optional[str] = None, job_type: Optional[str] = None
) -> None:
    """Uses the Data Loss Prevention API to lists DLP jobs that match the
        specified filter in the request.
    Args:
        project: The project id to use as a parent resource.
        filter: (Optional) Allows filtering.
            Supported syntax:
            * Filter expressions are made up of one or more restrictions.
            * Restrictions can be combined by 'AND' or 'OR' logical operators.
            A sequence of restrictions implicitly uses 'AND'.
            * A restriction has the form of '<field> <operator> <value>'.
            * Supported fields/values for inspect jobs:
                - `state` - PENDING|RUNNING|CANCELED|FINISHED|FAILED
                - `inspected_storage` - DATASTORE|CLOUD_STORAGE|BIGQUERY
                - `trigger_name` - The resource name of the trigger that
                                   created job.
            * Supported fields for risk analysis jobs:
                - `state` - RUNNING|CANCELED|FINISHED|FAILED
            * The operator must be '=' or '!='.
            Examples:
            * inspected_storage = cloud_storage AND state = done
            * inspected_storage = cloud_storage OR inspected_storage = bigquery
            * inspected_storage = cloud_storage AND
                                  (state = done OR state = canceled)
        type: (Optional) The type of job. Defaults to 'INSPECT'.
            Choices:
            DLP_JOB_TYPE_UNSPECIFIED
            INSPECT_JOB: The job inspected content for sensitive data.
            RISK_ANALYSIS_JOB: The job executed a Risk Analysis computation.

    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Job type dictionary
    job_type_to_int = {
        "DLP_JOB_TYPE_UNSPECIFIED": google.cloud.dlp.DlpJobType.DLP_JOB_TYPE_UNSPECIFIED,
        "INSPECT_JOB": google.cloud.dlp.DlpJobType.INSPECT_JOB,
        "RISK_ANALYSIS_JOB": google.cloud.dlp.DlpJobType.RISK_ANALYSIS_JOB,
    }
    # If job type is specified, convert job type to number through enums.
    if job_type:
        job_type = job_type_to_int[job_type]

    # Call the API to get a list of jobs.
    response = dlp.list_dlp_jobs(
        request={"parent": parent, "filter": filter_string, "type_": job_type}
    )

    # Iterate over results.
    for job in response:
        print(f"Job: {job.name}; status: {job.state.name}")

REST

El recurso DlpJob tiene un método projects.dlpJobs.list con el que puedes enumerar todos los trabajos.

Para enumerar todos los trabajos definidos actualmente en tu proyecto, envía una solicitud GET al extremo dlpJobs, como se muestra aquí:

URL:

GET https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/dlpJobs?key={YOUR_API_KEY}

En el siguiente resultado de JSON, se enumera uno de los trabajos que se muestran. Ten en cuenta que la estructura del trabajo refleja la del recurso DlpJob.

Salida de JSON:

{
  "jobs":[
    {
      "name":"projects/[PROJECT-ID]/dlpJobs/i-5270277269264714623",
      "type":"INSPECT_JOB",
      "state":"DONE",
      "inspectDetails":{
        "requestedOptions":{
          "snapshotInspectTemplate":{
          },
          "jobConfig":{
            "storageConfig":{
              "cloudStorageOptions":{
                "fileSet":{
                  "url":"[CLOUD-STORAGE-URL]"
                },
                "fileTypes":[
                  "FILE_TYPE_UNSPECIFIED"
                ],
                "filesLimitPercent":100
              },
              "timespanConfig":{
                "startTime":"2019-09-08T22:43:16.623Z",
                "enableAutoPopulationOfTimespanConfig":true
              }
            },
            "inspectConfig":{
              "infoTypes":[
                {
                  "name":"US_SOCIAL_SECURITY_NUMBER"
                },
                {
                  "name":"CANADA_SOCIAL_INSURANCE_NUMBER"
                }
              ],
              "minLikelihood":"LIKELY",
              "limits":{
              },
              "includeQuote":true
            },
            "actions":[
              {
                "saveFindings":{
                  "outputConfig":{
                    "table":{
                      "projectId":"[PROJECT-ID]",
                      "datasetId":"[DATASET-ID]",
                      "tableId":"[TABLE-ID]"
                    }
                  }
                }
              }
            ]
          }
        },
        "result":{
          ...
        }
      },
      "createTime":"2019-09-09T22:43:16.918Z",
      "startTime":"2019-09-09T22:43:16.918Z",
      "endTime":"2019-09-09T22:43:53.091Z",
      "jobTriggerName":"projects/[PROJECT-ID]/jobTriggers/sample-trigger2"
    },
    ...

Para intentar realizar esto con rapidez, puedes usar el Explorador de API que se incorpora a continuación. 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.

Enumera todos los activadores de trabajo

Para enumerar todos los activadores de trabajo del proyecto actual, sigue estos pasos:

Console

En la consola de Google Cloud, ve a la página Protección de datos sensibles.

Ir a Protección de datos sensibles

En la pestaña Inspección, en la subpestaña Activadores de trabajo, la consola muestra una lista de todos los activadores de trabajo del proyecto actual.

C#

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


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

public class TriggersList
{
    public static PagedEnumerable<ListJobTriggersResponse, JobTrigger> List(string projectId)
    {
        var dlp = DlpServiceClient.Create();

        var response = dlp.ListJobTriggers(
            new ListJobTriggersRequest
            {
                Parent = new LocationName(projectId, "global").ToString(),
            });

        foreach (var trigger in response)
        {
            Console.WriteLine($"Name: {trigger.Name}");
            Console.WriteLine($"  Created: {trigger.CreateTime}");
            Console.WriteLine($"  Updated: {trigger.UpdateTime}");
            Console.WriteLine($"  Display Name: {trigger.DisplayName}");
            Console.WriteLine($"  Description: {trigger.Description}");
            Console.WriteLine($"  Status: {trigger.Status}");
            Console.WriteLine($"  Error count: {trigger.Errors.Count}");
        }

        return response;
    }
}

Go

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

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

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"github.com/golang/protobuf/ptypes"
	"google.golang.org/api/iterator"
)

// listTriggers lists the triggers for the given project.
func listTriggers(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Create a configured request.
	req := &dlppb.ListJobTriggersRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}
	// Send the request and iterate over the results.
	it := client.ListJobTriggers(ctx, req)
	for {
		t, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %w", err)
		}
		fmt.Fprintf(w, "Trigger %v\n", t.GetName())
		c, err := ptypes.Timestamp(t.GetCreateTime())
		if err != nil {
			return fmt.Errorf("CreateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Created: %v\n", c.Format(time.RFC1123))
		u, err := ptypes.Timestamp(t.GetUpdateTime())
		if err != nil {
			return fmt.Errorf("UpdateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Updated: %v\n", u.Format(time.RFC1123))
		fmt.Fprintf(w, "  Display Name: %q\n", t.GetDisplayName())
		fmt.Fprintf(w, "  Description: %q\n", t.GetDescription())
		fmt.Fprintf(w, "  Status: %v\n", t.GetStatus())
		fmt.Fprintf(w, "  Error Count: %v\n", len(t.GetErrors()))
	}

	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.JobTrigger;
import com.google.privacy.dlp.v2.ListJobTriggersRequest;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

class TriggersList {
  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    listTriggers(projectId);
  }

  public static void listTriggers(String projectId) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {
      // Build the request to be sent by the client
      ListJobTriggersRequest listJobTriggersRequest =
          ListJobTriggersRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .build();

      // Use the client to send the API request.
      DlpServiceClient.ListJobTriggersPagedResponse response =
          dlpServiceClient.listJobTriggers(listJobTriggersRequest);

      // Parse the response and process the results
      System.out.println("DLP triggers found:");
      for (JobTrigger trigger : response.getPage().getValues()) {
        System.out.println("Trigger: " + trigger.getName());
        System.out.println("\tCreated: " + trigger.getCreateTime());
        System.out.println("\tUpdated: " + trigger.getUpdateTime());
        if (trigger.getDisplayName() != null) {
          System.out.println("\tDisplay name: " + trigger.getDisplayName());
        }
        if (trigger.getDescription() != null) {
          System.out.println("\tDescription: " + trigger.getDescription());
        }
        System.out.println("\tStatus: " + trigger.getStatus());
        System.out.println("\tError count: " + trigger.getErrorsCount());
      }
      ;
    }
  }
}

Node.js

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

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

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

// The project ID to run the API call under
// const projectId = 'my-project'

async function listTriggers() {
  // Construct trigger listing request
  const request = {
    parent: `projects/${projectId}/locations/global`,
  };

  // Helper function to pretty-print dates
  const formatDate = date => {
    const msSinceEpoch = parseInt(date.seconds, 10) * 1000;
    return new Date(msSinceEpoch).toLocaleString('en-US');
  };

  // Run trigger listing request
  const [triggers] = await dlp.listJobTriggers(request);
  triggers.forEach(trigger => {
    // Log trigger details
    console.log(`Trigger ${trigger.name}:`);
    console.log(`  Created: ${formatDate(trigger.createTime)}`);
    console.log(`  Updated: ${formatDate(trigger.updateTime)}`);
    if (trigger.displayName) {
      console.log(`  Display Name: ${trigger.displayName}`);
    }
    if (trigger.description) {
      console.log(`  Description: ${trigger.description}`);
    }
    console.log(`  Status: ${trigger.status}`);
    console.log(`  Error count: ${trigger.errors.length}`);
  });
}

listTriggers();

PHP

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

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ListJobTriggersRequest;

/**
 * List Data Loss Prevention API job triggers.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 */
function list_triggers(string $callingProjectId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $parent = "projects/$callingProjectId/locations/global";

    // Run request
    $listJobTriggersRequest = (new ListJobTriggersRequest())
        ->setParent($parent);
    $response = $dlp->listJobTriggers($listJobTriggersRequest);

    // Print results
    $triggers = $response->iterateAllElements();
    foreach ($triggers as $trigger) {
        printf('Trigger %s' . PHP_EOL, $trigger->getName());
        printf('  Created: %s' . PHP_EOL, $trigger->getCreateTime()->getSeconds());
        printf('  Updated: %s' . PHP_EOL, $trigger->getUpdateTime()->getSeconds());
        printf('  Display Name: %s' . PHP_EOL, $trigger->getDisplayName());
        printf('  Description: %s' . PHP_EOL, $trigger->getDescription());
        printf('  Status: %s' . PHP_EOL, $trigger->getStatus());
        printf('  Error count: %s' . PHP_EOL, count($trigger->getErrors()));
        $timespanConfig = $trigger->getInspectJob()->getStorageConfig()->getTimespanConfig();
        printf('  Auto-populates timespan config: %s' . PHP_EOL,
            ($timespanConfig && $timespanConfig->getEnableAutoPopulationOfTimespanConfig() ? 'yes' : 'no'));
    }
}

Python

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

import google.cloud.dlp


def list_triggers(project: str) -> None:
    """Lists all Data Loss Prevention API triggers.
    Args:
        project: The Google Cloud project id to use as a parent resource.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Call the API.
    response = dlp.list_job_triggers(request={"parent": parent})

    for trigger in response:
        print(f"Trigger {trigger.name}:")
        print(f"  Created: {trigger.create_time}")
        print(f"  Updated: {trigger.update_time}")
        if trigger.display_name:
            print(f"  Display Name: {trigger.display_name}")
        if trigger.description:
            print(f"  Description: {trigger.description}")
        print(f"  Status: {trigger.status}")
        print(f"  Error count: {len(trigger.errors)}")

REST

El recurso JobTrigger tiene un método projects.jobTriggers.list con el que puedes enumerar todos los activadores de trabajo.

Para enumerar todos los activadores de trabajo definidos actualmente en tu proyecto, envía una solicitud GET al extremo jobTriggers, como se muestra a continuación:

URL:

GET https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/jobTriggers?key={YOUR_API_KEY}

En la siguiente salida de JSON, se muestra el activador de trabajo que se creó en la sección anterior. Ten en cuenta que la estructura del activador de trabajo refleja la del recurso JobTrigger.

Salida de JSON:

{
  "jobTriggers":[
    {
      "name":"projects/[PROJECT_ID]/jobTriggers/[JOB_TRIGGER_NAME]",
      "displayName":"JobTrigger1",
      "description":"Starts an inspection of a Datastore kind",
      "inspectJob":{
        "storageConfig":{
          "datastoreOptions":{
            "partitionId":{
              "projectId":"[PROJECT_ID]",
              "namespaceId":"[NAMESPACE_ID]"
            },
            "kind":{
              "name":"Example-Kind"
            }
          }
        },
        "inspectConfig":{
          "infoTypes":[
            {
              "name":"PHONE_NUMBER"
            }
          ],
          "minLikelihood":"LIKELY",
          "limits":{

          },
          "includeQuote":true
        },
        "actions":[
          {
            "saveFindings":{
              "outputConfig":{
                "table":{
                  "projectId":"[PROJECT_ID]",
                  "datasetId":"[BIGQUERY_DATASET_NAME]",
                  "tableId":"[BIGQUERY_TABLE_NAME]"
                }
              }
            }
          }
        ]
      },
      "triggers":[
        {
          "schedule":{
            "recurrencePeriodDuration":"86400s"
          }
        }
      ],
      "createTime":"2018-11-30T01:52:41.171857Z",
      "updateTime":"2018-11-30T01:52:41.171857Z",
      "status":"HEALTHY"
    },

    ...

],
  "nextPageToken":"KkwKCQjivJ2UpPreAgo_Kj1wcm9qZWN0cy92ZWx2ZXR5LXN0dWR5LTE5NjEwMS9qb2JUcmlnZ2Vycy8xNTA5NzEyOTczMDI0MDc1NzY0"
}

Borra un trabajo

Para borrar un trabajo de tu proyecto, que incluye sus resultados, haz lo siguiente. Cualquier resultado guardado externamente (como en BigQuery) no se ve afectado por esta operación.

Console

En la consola de Google Cloud, ve a la página Protección de datos sensibles.

Ir a Protección de datos sensibles
Haz clic en la pestaña Inspección y, luego, en la subpestaña Inspeccionar trabajos. Google Cloud Console muestra una lista de todos los trabajos para el proyecto actual.
En la columna Actions (Acciones) para el activador de trabajo que deseas borrar, haz clic en el menú Más acciones (que se muestra como tres puntos ordenados verticalmente) y, luego, haz clic en Delete (Borrar).

De forma alternativa, en la lista de trabajos, haz clic en el identificador del trabajo que deseas borrar. En la página de detalles del trabajo, haz clic en Borrar.

C#

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


using System;
using Google.Cloud.Dlp.V2;

public class JobsDelete
{
    public static void DeleteJob(string jobName)
    {
        var dlp = DlpServiceClient.Create();

        dlp.DeleteDlpJob(new DeleteDlpJobRequest
        {
            Name = jobName
        });

        Console.WriteLine($"Successfully deleted job {jobName}.");
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

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

// deleteJob deletes the job with the given name.
func deleteJob(w io.Writer, jobName string) error {
	// jobName := "job-example"
	ctx := context.Background()
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()
	req := &dlppb.DeleteDlpJobRequest{
		Name: jobName,
	}
	if err = client.DeleteDlpJob(ctx, req); err != nil {
		return fmt.Errorf("DeleteDlpJob: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted job")
	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DeleteDlpJobRequest;
import com.google.privacy.dlp.v2.DlpJobName;
import java.io.IOException;

public class JobsDelete {
  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String jobId = "your-job-id";
    deleteJobs(projectId, jobId);
  }

  // Deletes a DLP Job with the given jobId
  public static void deleteJobs(String projectId, String jobId) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Construct the complete job name from the projectId and jobId
      DlpJobName jobName = DlpJobName.of(projectId, jobId);

      // Construct the job deletion request to be sent by the client.
      DeleteDlpJobRequest deleteDlpJobRequest =
          DeleteDlpJobRequest.newBuilder().setName(jobName.toString()).build();

      // Send the job deletion request
      dlpServiceClient.deleteDlpJob(deleteDlpJobRequest);
      System.out.println("Job deleted successfully.");
    }
  }
}

Node.js

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

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

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

// The project ID to run the API call under
// const projectId = 'my-project';

// The name of the job whose results should be deleted
// Parent project ID is automatically extracted from this parameter
// const jobName = 'projects/my-project/dlpJobs/X-#####'

function deleteJob() {
  // Construct job deletion request
  const request = {
    name: jobName,
  };

  // Run job deletion request
  dlp
    .deleteDlpJob(request)
    .then(() => {
      console.log(`Successfully deleted job ${jobName}.`);
    })
    .catch(err => {
      console.log(`Error in deleteJob: ${err.message || err}`);
    });
}

deleteJob();

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.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\DeleteDlpJobRequest;

/**
 * Delete results of a Data Loss Prevention API job
 *
 * @param string $jobId The name of the job whose results should be deleted
 */
function delete_job(string $jobId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Run job-deletion request
    // The Parent project ID is automatically extracted from this parameter
    $deleteDlpJobRequest = (new DeleteDlpJobRequest())
        ->setName($jobId);
    $dlp->deleteDlpJob($deleteDlpJobRequest);

    // Print status
    printf('Successfully deleted job %s' . PHP_EOL, $jobId);
}

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.


import google.cloud.dlp


def delete_dlp_job(project: str, job_name: str) -> None:
    """Uses the Data Loss Prevention API to delete a long-running DLP job.
    Args:
        project: The project id to use as a parent resource.
        job_name: The name of the DlpJob resource to be deleted.

    Returns:
        None; the response from the API is printed to the terminal.
    """

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

    # Convert the project id and job name into a full resource id.
    name = f"projects/{project}/dlpJobs/{job_name}"

    # Call the API to delete job.
    dlp.delete_dlp_job(request={"name": name})

    print(f"Successfully deleted {job_name}")

REST

Para borrar un trabajo del proyecto actual, envía una solicitud DELETE al extremo dlpJobs, como se muestra aquí. Reemplaza el campo [JOB-IDENTIFIER] con el identificador del trabajo, que comienza con i-.

URL:

DELETE https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/dlpJobs/[JOB-IDENTIFIER]?key={YOUR_API_KEY}

Si la solicitud se realizó correctamente, la API de DLP mostrará una respuesta exitosa. Para verificar que el trabajo se borró correctamente, enumera todos los trabajos.

Borra un activador de trabajo

Console

En la consola de Google Cloud, ve a la página Protección de datos sensibles.

Ir a Protección de datos sensibles

En la pestaña Inspección, en la subpestaña Activadores de trabajo, Console muestra una lista de todos los activadores de trabajo para el proyecto actual.
En la columna Actions (Acciones) para el activador de trabajo que deseas borrar, haz clic en el menú Más acciones (que se muestra como tres puntos ordenados verticalmente) y, luego, haz clic en Delete (Borrar).

Como alternativa, en la lista de activadores de trabajo, haz clic en el nombre del activador de trabajo que deseas borrar. En la página de detalles del activador de trabajo, haz clic en Delete (Borrar).

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.


using Google.Cloud.Dlp.V2;
using System;

public class TriggersDelete
{

    public static void Delete(string triggerName)
    {
        var dlp = DlpServiceClient.Create();

        dlp.DeleteJobTrigger(
            new DeleteJobTriggerRequest
            {
                Name = triggerName
            });

        Console.WriteLine($"Successfully deleted trigger {triggerName}.");
    }
}

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.

import (
	"context"
	"fmt"
	"io"

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

// deleteTrigger deletes the given trigger.
func deleteTrigger(w io.Writer, triggerID string) error {
	// triggerID := "my-trigger"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	req := &dlppb.DeleteJobTriggerRequest{
		Name: triggerID,
	}

	if err := client.DeleteJobTrigger(ctx, req); err != nil {
		return fmt.Errorf("DeleteJobTrigger: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted trigger %v", triggerID)
	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.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DeleteJobTriggerRequest;
import com.google.privacy.dlp.v2.ProjectJobTriggerName;
import java.io.IOException;

class TriggersDelete {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String triggerId = "your-trigger-id";
    deleteTrigger(projectId, triggerId);
  }

  public static void deleteTrigger(String projectId, String triggerId) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Get the full trigger name from the given triggerId and ProjectId
      ProjectJobTriggerName triggerName = ProjectJobTriggerName.of(projectId, triggerId);

      // Construct the trigger deletion request to be sent by the client
      DeleteJobTriggerRequest deleteJobTriggerRequest =
          DeleteJobTriggerRequest.newBuilder().setName(triggerName.toString()).build();

      // Send the trigger deletion request
      dlpServiceClient.deleteJobTrigger(deleteJobTriggerRequest);
      System.out.println("Trigger deleted: " + triggerName.toString());
    }
  }
}

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.

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

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

// The project ID to run the API call under
// const projectId = 'my-project'

// The name of the trigger to be deleted
// Parent project ID is automatically extracted from this parameter
// const triggerId = 'projects/my-project/triggers/my-trigger';

async function deleteTrigger() {
  // Construct trigger deletion request
  const request = {
    name: triggerId,
  };

  // Run trigger deletion request
  await dlp.deleteJobTrigger(request);
  console.log(`Successfully deleted trigger ${triggerId}.`);
}

deleteTrigger();

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.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\DeleteJobTriggerRequest;

/**
 * Delete a Data Loss Prevention API job trigger.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 * @param string $triggerId         The name of the trigger to be deleted.
 */
function delete_trigger(string $callingProjectId, string $triggerId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Run request
    // The Parent project ID is automatically extracted from this parameter
    $triggerName = "projects/$callingProjectId/locations/global/jobTriggers/$triggerId";
    $deleteJobTriggerRequest = (new DeleteJobTriggerRequest())
        ->setName($triggerName);
    $dlp->deleteJobTrigger($deleteJobTriggerRequest);

    // Print the results
    printf('Successfully deleted trigger %s' . PHP_EOL, $triggerName);
}

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.

import google.cloud.dlp


def delete_trigger(project: str, trigger_id: str) -> None:
    """Deletes a Data Loss Prevention API trigger.
    Args:
        project: The id of the Google Cloud project which owns the trigger.
        trigger_id: The id of the trigger to delete.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Combine the trigger id with the parent id.
    trigger_resource = f"{parent}/jobTriggers/{trigger_id}"

    # Call the API.
    dlp.delete_job_trigger(request={"name": trigger_resource})

    print(f"Trigger {trigger_resource} successfully deleted.")

REST

Para borrar un activador de trabajo del proyecto actual, envía una solicitud DELETE al extremo jobTriggers, como se muestra aquí. Reemplaza el campo [JOB-TRIGGER-NAME] con el nombre del activador del trabajo.

URL:

DELETE https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/jobTriggers/[JOB-TRIGGER-NAME]?key={YOUR_API_KEY}

Si la solicitud se realizó correctamente, la API de DLP mostrará una respuesta exitosa. Para verificar si se borró el activador de trabajo de manera correcta, enumera todos los activadores de trabajo.

Obtener un trabajo

Para obtener un trabajo de tu proyecto, que incluye sus resultados, haz lo siguiente. Cualquier resultado guardado externamente (como en BigQuery) no se ve afectado por esta operación.

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.


using Google.Cloud.Dlp.V2;
using System;

public class JobsGet
{
    public static DlpJob GetDlpJob(string jobName)
    {
        var dlp = DlpServiceClient.Create();

        var response = dlp.GetDlpJob(jobName);

        Console.WriteLine($"Job: {response.Name} status: {response.State}");

        return response;
    }
}

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.

import (
	"context"
	"fmt"
	"io"

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

// jobsGet gets an inspection job using jobName
func jobsGet(w io.Writer, projectID string, jobName string) error {
	// projectId := "my-project-id"
	// jobName := "your-job-id"

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

	// Construct the request to be sent by the client.
	req := &dlppb.GetDlpJobRequest{
		Name: jobName,
	}

	// Send the request.
	resp, err := client.GetDlpJob(ctx, req)
	if err != nil {
		return err
	}

	// Print the results.
	fmt.Fprintf(w, "Job Name: %v Job Status: %v", resp.Name, resp.State)
	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.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DlpJobName;
import com.google.privacy.dlp.v2.GetDlpJobRequest;
import java.io.IOException;

public class JobsGet {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String jobId = "your-job-id";
    getJobs(projectId, jobId);
  }

  // Gets a DLP Job with the given jobId
  public static void getJobs(String projectId, String jobId) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Construct the complete job name from the projectId and jobId
      DlpJobName jobName = DlpJobName.of(projectId, jobId);

      // Construct the get job request to be sent by the client.
      GetDlpJobRequest getDlpJobRequest =
          GetDlpJobRequest.newBuilder().setName(jobName.toString()).build();

      // Send the get job request
      dlpServiceClient.getDlpJob(getDlpJobRequest);
      System.out.println("Job got successfully.");
    }
  }
}

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.

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

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

// Job name to look for
// const jobName = 'your-job-name';

async function getJob() {
  // Construct request for finding job using job name.
  const request = {
    name: jobName,
  };

  // Send the request and receive response from the service
  const [job] = await dlp.getDlpJob(request);

  // Print results.
  console.log(`Job ${job.name} status: ${job.state}`);
}

getJob();

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.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\GetDlpJobRequest;

/**
 * Get DLP inspection job.
 * @param string $jobName           Dlp job name
 */
function get_job(
    string $jobName
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();
    try {
        // Send the get job request
        $getDlpJobRequest = (new GetDlpJobRequest())
            ->setName($jobName);
        $response = $dlp->getDlpJob($getDlpJobRequest);
        printf('Job %s status: %s' . PHP_EOL, $response->getName(), $response->getState());
    } finally {
        $dlp->close();
    }
}

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.


import google.cloud.dlp


def get_dlp_job(project: str, job_name: str) -> None:
    """Uses the Data Loss Prevention API to retrieve a DLP job.
    Args:
        project: The project id to use as a parent resource.
        job_name: The name of the DlpJob resource to be retrieved.
    """

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

    # Convert the project id and job name into a full resource id.
    job_name = f"projects/{project}/locations/global/dlpJobs/{job_name}"

    # Call the API
    response = dlp.get_dlp_job(request={"name": job_name})

    print(f"Job: {response.name} Status: {response.state}")

REST

Para obtener un trabajo del proyecto actual, envía una solicitud GET al extremo dlpJobs, como se muestra aquí. Reemplaza el campo [JOB-IDENTIFIER] con el identificador del trabajo, que comienza con i-.

URL:

GET https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/dlpJobs/[JOB-IDENTIFIER]?key={YOUR_API_KEY}

Si la solicitud se realizó correctamente, la API de DLP mostrará una respuesta exitosa.

Cómo forzar la ejecución inmediata de un activador de trabajo

Después de crear un activador de trabajo, puedes forzar una ejecución inmediata del activador para probarlo activándolo. Para ello, ejecuta el siguiente comando:

curl --request POST \
    -H "Content-Type: application/json" \
    -H "Accept: application/json" \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "X-Goog-User-Project: PROJECT_ID" \
    'https://dlp.googleapis.com/v2/JOB_TRIGGER_NAME:activate'

Reemplaza lo siguiente:

PROJECT_ID: El ID del proyecto de Google Cloud para facturar los cargos de acceso asociados con la solicitud.
JOB_TRIGGER_NAME: Es el nombre completo del recurso del activador de trabajos, por ejemplo, projects/my-project/locations/global/jobTriggers/123456789.

Actualiza un activador de trabajo existente

Además de crear, enumerar y borrar activadores de trabajo, también puedes actualizar un activador de trabajo existente. Para cambiar la configuración de un activador de trabajo existente, sigue estos pasos:

Console

En la consola de Google Cloud, ve a la página Protección de datos sensibles.

Ir a Protección de datos sensibles
Haz clic en la pestaña Inspección y, luego, en la subpestaña Activadores de trabajos.

La consola muestra una lista de todos los activadores de trabajo para el proyecto actual.
En la columna Acciones para el activador de trabajo que deseas borrar, haz clic en Más , y luego haz clic en Ver detalles.
En la página de detalles del activador de trabajo, haz clic en Edit (Editar).
En la página del activador de edición, puedes cambiar la ubicación de los datos de entrada; detalles de detección, como plantillas, Infotipos o probabilidades; las acciones posteriores al análisis y la programación del activador de trabajo. Cuando finalices de realizar cambios, haz clic en Guardar.

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.


using Google.Cloud.Dlp.V2;
using Google.Protobuf.WellKnownTypes;
using System;
using System.Collections.Generic;

public class TriggersUpdate
{
    public static JobTrigger UpdateJob(
        string projectId,
        string triggerId,
        IEnumerable<InfoType> infoTypes = null,
        Likelihood minLikelihood = Likelihood.Likely)
    {
        // Instantiate the client.
        var dlp = DlpServiceClient.Create();

        // Construct the update job trigger request object by providing the trigger name,
        // job trigger object which will specify the type of info to be inspected and
        // update mask object which specifies the field to be updated.
        // Refer to https://cloud.google.com/dlp/docs/reference/rest/v2/Container for specifying the paths in container object.
        var request = new UpdateJobTriggerRequest
        {
            JobTriggerName = new JobTriggerName(projectId, triggerId),
            JobTrigger = new JobTrigger
            {
                InspectJob = new InspectJobConfig
                {
                    InspectConfig = new InspectConfig
                    {
                        InfoTypes =
                        {
                            infoTypes ?? new InfoType[]
                            {
                                new InfoType { Name = "US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER" }
                            }
                        },
                        MinLikelihood = minLikelihood
                    }
                }
            },
            // Specify fields of the jobTrigger resource to be updated when the job trigger is modified.
            // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
            UpdateMask = new FieldMask
            {
                Paths =
                {
                    "inspect_job.inspect_config.info_types",
                    "inspect_job.inspect_config.min_likelihood"
                }
            }
        };

        // Call the API.
        JobTrigger response = dlp.UpdateJobTrigger(request);

        // Inspect the result.
        Console.WriteLine($"Job Trigger Name: {response.Name}");
        Console.WriteLine($"InfoType updated: {response.InspectJob.InspectConfig.InfoTypes[0]}");
        Console.WriteLine($"Likelihood updated: {response.InspectJob.InspectConfig.MinLikelihood}");
        return response;
    }
}

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.


import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateTrigger updates an existing job trigger in Google Cloud Data Loss Prevention (DLP).
// It modifies the configuration of the specified job trigger with the provided updated settings.
func updateTrigger(w io.Writer, jobTriggerName string) error {
	// jobTriggerName := "your-job-trigger-name" (projects/<projectID>/locations/global/jobTriggers/my-trigger)

	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 type of info the inspection will look for.
	// See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
	infoType := &dlppb.InfoType{
		Name: "PERSON_NAME",
	}

	// Specify the inspectConfig that represents the configuration settings for inspecting sensitive data in
	// DLP API. It includes detection types, custom info types, inspection methods, and actions
	// to be taken on detection.
	inspectConfig := &dlppb.InspectConfig{
		InfoTypes: []*dlppb.InfoType{
			infoType,
		},
		MinLikelihood: dlppb.Likelihood_LIKELY,
	}

	// Configure the inspection job we want the service to perform.
	inspectJobConfig := &dlppb.InspectJobConfig{
		InspectConfig: inspectConfig,
	}

	// Specify the jobTrigger that represents a DLP job trigger configuration.
	// It defines the conditions, actions, and schedule for executing inspections
	// on sensitive data in the specified data storage.
	jobTrigger := &dlppb.JobTrigger{
		Job: &dlppb.JobTrigger_InspectJob{
			InspectJob: inspectJobConfig,
		},
	}

	// fieldMask represents a set of fields to be included in an update operation.
	// It is used to specify which fields of a resource should be updated.
	updateMask := &fieldmaskpb.FieldMask{
		Paths: []string{"inspect_job.inspect_config.info_types", "inspect_job.inspect_config.min_likelihood"},
	}

	// Combine configurations into a request for the service.
	req := &dlppb.UpdateJobTriggerRequest{
		Name:       jobTriggerName,
		JobTrigger: jobTrigger,
		UpdateMask: updateMask,
	}

	// Send the scan request and process the response
	resp, err := client.UpdateJobTrigger(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "Successfully Updated trigger: %v", resp)
	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.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectJobConfig;
import com.google.privacy.dlp.v2.JobTrigger;
import com.google.privacy.dlp.v2.JobTriggerName;
import com.google.privacy.dlp.v2.Likelihood;
import com.google.privacy.dlp.v2.UpdateJobTriggerRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class TriggersPatch {

  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 name of the job trigger to be updated.
    String jobTriggerName = "your-job-trigger-name";
    patchTrigger(projectId, jobTriggerName);
  }

  // Uses the Data Loss Prevention API to update an existing job trigger.
  public static void patchTrigger(String projectId, String jobTriggerName) throws IOException {
    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      InfoType infoType = InfoType.newBuilder().setName("PERSON_NAME").build();

      InspectConfig inspectConfig = InspectConfig.newBuilder()
              .addInfoTypes(infoType)
              .setMinLikelihood(Likelihood.LIKELY)
              .build();

      InspectJobConfig inspectJobConfig = InspectJobConfig.newBuilder()
              .setInspectConfig(inspectConfig)
              .build();

      JobTrigger jobTrigger = JobTrigger.newBuilder()
              .setInspectJob(inspectJobConfig)
              .build();

      // Specify fields of the jobTrigger resource to be updated when the job trigger is modified.
      // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
      FieldMask fieldMask = FieldMask.newBuilder()
              .addPaths("inspect_job.inspect_config.info_types")
              .addPaths("inspect_job.inspect_config.min_likelihood")
              .build();

      // Update the job trigger with the new configuration.
      UpdateJobTriggerRequest updateJobTriggerRequest = UpdateJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerName).toString())
              .setJobTrigger(jobTrigger)
              .setUpdateMask(fieldMask)
              .build();

      // Call the API to update the job trigger.
      JobTrigger updatedJobTrigger = dlpServiceClient.updateJobTrigger(updateJobTriggerRequest);

      System.out.println("Job Trigger Name: " + updatedJobTrigger.getName());
      System.out.println(
          "InfoType updated: "
              + updatedJobTrigger.getInspectJob().getInspectConfig().getInfoTypes(0).getName());
      System.out.println(
          "Likelihood updated: "
              + updatedJobTrigger.getInspectJob().getInspectConfig().getMinLikelihood());
    }
  }
}

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.

// 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 = 'my-project';

// The job trigger ID to run the API call under
// const jobTriggerName = 'your-job-trigger-name';

async function updateTrigger() {
  // Construct inspect configuration to match PERSON_NAME infotype
  const inspectConfig = {
    infoTypes: [{name: 'PERSON_NAME'}],
    minLikelihood: 'LIKELY',
  };

  // Configure the job trigger we want to update.
  const jobTrigger = {inspectJob: {inspectConfig}};

  const updateMask = {
    paths: [
      'inspect_job.inspect_config.info_types',
      'inspect_job.inspect_config.min_likelihood',
    ],
  };

  // Combine configurations into a request for the service.
  const request = {
    name: `projects/${projectId}/jobTriggers/${jobTriggerName}`,
    jobTrigger,
    updateMask,
  };

  // Send the request and receive response from the service
  const [updatedJobTrigger] = await dlpClient.updateJobTrigger(request);

  // Print the results
  console.log(`Updated Trigger: ${JSON.stringify(updatedJobTrigger)}`);
}
updateTrigger(projectId, jobTriggerName);

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.

use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectJobConfig;
use Google\Cloud\Dlp\V2\JobTrigger;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Protobuf\FieldMask;

/**
 * Update an existing job trigger.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $jobTriggerName    The job trigger name to update.
 *
 */
function update_trigger(
    string $callingProjectId,
    string $jobTriggerName
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Configure the inspectConfig.
    $inspectConfig = (new InspectConfig())
        ->setInfoTypes([
            (new InfoType())
                ->setName('US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER')
        ])
        ->setMinLikelihood(Likelihood::LIKELY);

    // Configure the Job Trigger we want the service to perform.
    $jobTrigger = (new JobTrigger())
        ->setInspectJob((new InspectJobConfig())
            ->setInspectConfig($inspectConfig));

    // Specify fields of the jobTrigger resource to be updated when the job trigger is modified.
    // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
    $fieldMask = (new FieldMask())
        ->setPaths([
            'inspect_job.inspect_config.info_types',
            'inspect_job.inspect_config.min_likelihood'
        ]);

    // Send the update job trigger request and process the response.
    $name = "projects/$callingProjectId/locations/global/jobTriggers/" . $jobTriggerName;

    $response = $dlp->updateJobTrigger($name, [
        'jobTrigger' => $jobTrigger,
        'updateMask' => $fieldMask
    ]);

    // Print results.
    printf('Successfully update trigger %s' . PHP_EOL, $response->getName());
}

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.

from typing import List

import google.cloud.dlp


def update_trigger(
    project: str,
    info_types: List[str],
    trigger_id: str,
) -> None:
    """Uses the Data Loss Prevention API to update an existing job trigger.
    Args:
        project: The Google Cloud project id to use as a parent resource
        info_types: A list of strings representing infoTypes to update trigger with.
            A full list of infoType categories can be fetched from the API.
        trigger_id: The id of job trigger which needs to be updated.
    """

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

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries.
    info_types = [{"name": info_type} for info_type in info_types]

    # Specify fields of the jobTrigger resource to be updated when the
    # job trigger is modified.
    job_trigger = {
        "inspect_job": {
            "inspect_config": {
                "info_types": info_types,
                "min_likelihood": google.cloud.dlp_v2.Likelihood.LIKELY,
            }
        }
    }

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

    # Call the API.
    # Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
    # for constructing the field mask paths.
    response = dlp.update_job_trigger(
        request={
            "name": trigger_name,
            "job_trigger": job_trigger,
            "update_mask": {
                "paths": [
                    "inspect_job.inspect_config.info_types",
                    "inspect_job.inspect_config.min_likelihood",
                ]
            },
        }
    )

    # Print out the result.
    print(f"Successfully updated trigger: {response.name}")
    print(
        f"Updated InfoType: {response.inspect_job.inspect_config.info_types[0].name}"
        f" \nUpdates Likelihood: {response.inspect_job.inspect_config.min_likelihood}\n",
    )

REST

Usa el método projects.jobTriggers.patch para enviar valores JobTrigger nuevos a la API de DLP y actualizar esos valores dentro de un activador de trabajo especificado.

Por ejemplo, considera el siguiente activador de trabajo simple. Este JSON representa el activador del trabajo y se mostró después de enviar una solicitud GET al extremo del activador de trabajo del proyecto actual.

Salida de JSON:

{
  "name":"projects/[PROJECT_ID]/jobTriggers/[JOB_TRIGGER_NAME]",
  "inspectJob":{
    "storageConfig":{
      "cloudStorageOptions":{
        "fileSet":{
          "url":"gs://dlptesting/*"
        },
        "fileTypes":[
          "FILE_TYPE_UNSPECIFIED"
        ],
        "filesLimitPercent":100
      },
      "timespanConfig":{
        "enableAutoPopulationOfTimespanConfig":true
      }
    },
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"US_SOCIAL_SECURITY_NUMBER"
        }
      ],
      "minLikelihood":"POSSIBLE",
      "limits":{

      }
    },
    "actions":[
      {
        "jobNotificationEmails":{

        }
      }
    ]
  },
  "triggers":[
    {
      "schedule":{
        "recurrencePeriodDuration":"86400s"
      }
    }
  ],
  "createTime":"2019-03-06T21:19:45.774841Z",
  "updateTime":"2019-03-06T21:19:45.774841Z",
  "status":"HEALTHY"
}

El siguiente JSON, cuando se envía con una solicitud PATCH al extremo especificado, actualiza el activador de trabajo determinado con un nuevo Infotipo para analizar, así como una nueva probabilidad mínima. Ten en cuenta que también debes especificar el atributo updateMask y que su valor está en formato FieldMask.

Entrada de JSON:

PATCH https://dlp.googleapis.com/v2/projects/[PROJECT_ID]/jobTriggers/[JOB_TRIGGER_NAME]?key={YOUR_API_KEY}

{
  "jobTrigger":{
    "inspectJob":{
      "inspectConfig":{
        "infoTypes":[
          {
            "name":"US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER"
          }
        ],
        "minLikelihood":"LIKELY"
      }
    }
  },
  "updateMask":"inspectJob(inspectConfig(infoTypes,minLikelihood))"
}

Después de enviar este JSON a la URL especificada, muestra lo siguiente, que representa el activador de trabajo actualizado. Ten en cuenta que los valores de Infotipo y probabilidad originales se reemplazaron por los nuevos.

Salida de JSON:

{
  "name":"projects/[PROJECT_ID]/jobTriggers/[JOB_TRIGGER_NAME]",
  "inspectJob":{
    "storageConfig":{
      "cloudStorageOptions":{
        "fileSet":{
          "url":"gs://dlptesting/*"
        },
        "fileTypes":[
          "FILE_TYPE_UNSPECIFIED"
        ],
        "filesLimitPercent":100
      },
      "timespanConfig":{
        "enableAutoPopulationOfTimespanConfig":true
      }
    },
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"US_INDIVIDUAL_TAXPAYER_IDENTIFICATION_NUMBER"
        }
      ],
      "minLikelihood":"LIKELY",
      "limits":{

      }
    },
    "actions":[
      {
        "jobNotificationEmails":{

        }
      }
    ]
  },
  "triggers":[
    {
      "schedule":{
        "recurrencePeriodDuration":"86400s"
      }
    }
  ],
  "createTime":"2019-03-06T21:19:45.774841Z",
  "updateTime":"2019-03-06T21:27:01.650183Z",
  "lastRunTime":"1970-01-01T00:00:00Z",
  "status":"HEALTHY"
}

Latencia del trabajo

No hay objetivos de nivel de servicio (SLO) garantizados para las tareas ni los activadores de tareas. La latencia se ve afectada por varios factores, como la cantidad de datos que se analizarán, el repositorio de almacenamiento que se analiza, el tipo y la cantidad de infotipos que se buscan, la región en la que se procesa la tarea y los recursos de procesamiento disponibles en esa región. Por lo tanto, la latencia de los trabajos de inspección no se puede determinar con anticipación.

Para ayudar a reducir la latencia del trabajo, puedes probar con las siguientes opciones:

Si el muestreo está disponible para tu trabajo o activador de trabajo, habilítalo.
Evita habilitar infoTypes que no necesites. Si bien los siguientes son útiles en ciertas situaciones, estos infoTypes pueden hacer que las solicitudes se ejecuten mucho más lentamente que las que no los incluyen:
- PERSON_NAME
- FEMALE_NAME
- MALE_NAME
- FIRST_NAME
- LAST_NAME
- DATE_OF_BIRTH
- LOCATION
- STREET_ADDRESS
- ORGANIZATION_NAME
Especifica siempre los Infotipos de forma explícita. No uses una lista de Infotipos vacía.
Si es posible, usa una región de procesamiento diferente.

Si aún tienes problemas de latencia con las tareas después de probar estas técnicas, considera usar solicitudes content.inspect o content.deidentify en lugar de tareas. Estos métodos se incluyen en el Acuerdo de Nivel de Servicio. Para obtener más información, consulta el Acuerdo de nivel de servicio de Protección de datos sensibles.

Limita el análisis solo al contenido nuevo

Puedes configurar el activador de trabajo para que establezca automáticamente la fecha del período de los archivos almacenados en Cloud Storage o BigQuery. Cuando configuras el objeto TimespanConfig para que se complete automáticamente, la Protección de datos sensibles solo analiza los datos que se agregaron o modificaron desde la última ejecución del activador:

...
  timespan_config {
        enable_auto_population_of_timespan_config: true
      }
...

Para la inspección de BigQuery, solo se incluyen en el análisis las filas que tengan al menos tres horas de antigüedad. Consulta el problema conocido relacionado con esta operación.

Activa trabajos en la carga de archivos

Además de la compatibilidad con activadores de trabajo, que está integrada en Sensitive Data Protection, Google Cloud también tiene una variedad de otros componentes que puedes usar para integrar o activar trabajos de Sensitive Data Protection. Por ejemplo, puedes usar funciones de Cloud Run para activar un análisis de Protección de datos sensibles cada vez que se suba un archivo a Cloud Storage.

Para obtener información sobre cómo configurar esta operación, consulta Cómo automatizar la clasificación de datos subidos a Cloud Storage.

Trabajos exitosos sin datos inspeccionados

Un trabajo se puede completar correctamente incluso si no se analizaron datos. Los siguientes ejemplos de situaciones pueden causar que esto suceda:

La tarea está configurada para inspeccionar un recurso de datos específico, como un archivo, que existe, pero está vacío.
El trabajo está configurado para inspeccionar un recurso de datos que no existe o que ya no existe.
La tarea está configurada para inspeccionar un bucket de Cloud Storage que está vacío.
El trabajo está configurado para inspeccionar un bucket y el análisis recursivo está inhabilitado. En el nivel superior, el bucket solo contiene carpetas que, a su vez, contienen los archivos.
La tarea está configurada para inspeccionar solo un tipo de archivo específico en un bucket, pero el bucket no tiene ningún archivo de ese tipo.
La tarea está configurada para inspeccionar solo el contenido nuevo, pero no hubo actualizaciones después de la última vez que se ejecutó.

En la consola de Google Cloud, en la página Detalles del trabajo, el campo Bytes analizados especifica cuántos datos inspeccionó el trabajo. En la API de DLP, el campo processedBytes especifica cuántos datos se inspeccionaron.

¿Qué sigue?

Obtén más información para crear una copia desidentificada de los datos en el almacenamiento.