Crea un detector de diccionarios personalizado grande

En este tema, se describe cómo crear y volver a compilar diccionarios personalizados grandes. También abarca varias situaciones de error.

Cuándo elegir un diccionario personalizado grande en lugar de uno normal

Los detectores de diccionarios personalizados normales son suficientes cuando tienes decenas de miles de palabras o frases sensibles que quieres analizar en tu contenido. Si tienes más o si tu lista de términos cambia con frecuencia, considera crear un diccionario personalizado grande, que puede admitir decenas de millones de términos.

Nota: Para conocer los límites de uso exactos de los diccionarios, consulta Límites de uso.

En qué se diferencian los diccionarios personalizados grandes de otros tipos de información personalizada

Los diccionarios personalizados grandes se diferencian de otros tipos de información personalizada en que cada diccionario personalizado grande tiene dos componentes:

• Una lista de frases que creas y defines. La lista se almacena como un archivo de texto dentro de Cloud Storage o como una columna en una tabla de BigQuery.
• Los archivos de diccionario, que Sensitive Data Protection genera y almacena en Cloud Storage. Los archivos de diccionario se componen de una copia de tu lista de términos y filtros de Bloom, que ayudan en la búsqueda y la coincidencia.

Advertencia: No modifiques los archivos de diccionarios personalizados directo en Cloud Storage. Si lo haces, el diccionario se volverá no válido y, también, inutilizable.

Crea un diccionario personalizado grande

En esta sección, se describe cómo crear, editar y volver a compilar un diccionario personalizado grande.

Cómo crear una lista de términos

Crea una lista que contenga todas las palabras y frases que deseas que busque el nuevo detector de Infotipo. Realiza una de las siguientes acciones:

• Colocar un archivo de texto con cada palabra o frase en su propia línea en un bucket de Cloud Storage.
• Designa una columna de una tabla de BigQuery como el contenedor de las palabras y frases. Asigna a cada entrada su propia fila en la columna. Puedes usar una tabla de BigQuery existente, siempre y cuando todas las palabras y frases del diccionario estén en una sola columna.

Es posible que se cree una lista de términos demasiado grande para que Sensitive Data Protection la procese. Si ves un mensaje de error, consulta Soluciona problemas de errores más adelante en este tema.

Crea un infotipo almacenado

Después de crear tu lista de términos, usa Sensitive Data Protection para crear un diccionario:

Console

1. En un bucket de Cloud Storage, crea una carpeta nueva en la que Sensitive Data Protection almacenará el diccionario generado.

   Sensitive Data Protection crea carpetas que contienen los archivos de diccionario en la ubicación que especifiques.

2. En la consola de Google Cloud , ve a la página Crear infoType.

   Ir a Crear infotipo

3. En Tipo, selecciona Diccionario personalizado grande.

4. En ID de infotipo, ingresa un identificador para el infotipo almacenado.

   Usarás este identificador cuando configures tus trabajos de inspección y desidentificación. Puedes usar letras, números, guiones y guiones bajos en el nombre.

5. En Nombre visible del tipo de información, ingresa un nombre para el Infotipo almacenado.

   Puedes usar espacios y signos de puntuación en el nombre.

6. En Descripción, ingresa una descripción de lo que detecta tu tipo de Infotipo almacenado.

7. En Tipo de almacenamiento, selecciona la ubicación de tu lista de términos:

   • BigQuery: Ingresa el ID del proyecto, el ID del conjunto de datos y el ID de la tabla. En el campo Nombre del campo, ingresa el identificador de la columna. Puedes designar como máximo una columna de la tabla.
   • Google Cloud Storage: Ingresa la ruta de acceso al archivo.

8. En Bucket o carpeta de salida, ingresa la ubicación de Cloud Storage de la carpeta que creaste en el paso 1.

   Nota: No coloques archivos dentro de las carpetas que Sensitive Data Protection crea cuando compila tu diccionario. Cuando Sensitive Data Protection crea o vuelve a compilar archivos de diccionario, borra cualquier otro archivo almacenado en las carpetas que crea. Se conservan todas las carpetas que se encuentran en el mismo nivel que las carpetas que crea Sensitive Data Protection.

9. Haz clic en Crear.

Aparecerá un resumen del infotipo almacenado. Cuando se genera el diccionario y el nuevo Infotipo almacenado está listo para usarse, el estado del Infotipo muestra Listo.

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

public class CreateStoredInfoTypes
{
    public static StoredInfoType Create(
        string projectId,
        string outputPath,
        string storedInfoTypeId)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the stored infotype config by specifying the public table and 
        // cloud storage output path.
        var storedInfoTypeConfig = new StoredInfoTypeConfig
        {
            DisplayName = "Github Usernames",
            Description = "Dictionary of Github usernames used in commits.",
            LargeCustomDictionary = new LargeCustomDictionaryConfig
            {
                BigQueryField = new BigQueryField
                {
                    Table = new BigQueryTable
                    {
                        DatasetId = "samples",
                        ProjectId = "bigquery-public-data",
                        TableId = "github_nested"
                    },
                    Field = new FieldId
                    {
                        Name = "actor"
                    }
                },
                OutputPath = new CloudStoragePath
                {
                    Path = outputPath
                }
            },
        };

        // Construct the request.
        var request = new CreateStoredInfoTypeRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            Config = storedInfoTypeConfig,
            StoredInfoTypeId = storedInfoTypeId
        };

        // Call the API.
        StoredInfoType response = dlp.CreateStoredInfoType(request);

        // Inspect the response.
        Console.WriteLine($"Created the stored infotype at path: {response.Name}");

        return response;
    }
}

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import (
	"context"
	"fmt"
	"io"

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

// createStoredInfoType creates a custom stored info type based on your input data.
func createStoredInfoType(w io.Writer, projectID, outputPath string) error {
	// projectId := "my-project-id"
	// outputPath := "gs://" + "your-bucket-name" + "path/to/directory"

	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 name you want to give the dictionary.
	displayName := "Github Usernames"

	// Specify a description of the dictionary.
	description := "Dictionary of GitHub usernames used in commits"

	// Specify the path to the location in a Cloud Storage
	// bucket to store the created dictionary.
	cloudStoragePath := &dlppb.CloudStoragePath{
		Path: outputPath,
	}

	// Specify your term list is stored in BigQuery.
	bigQueryField := &dlppb.BigQueryField{
		Table: &dlppb.BigQueryTable{
			ProjectId: "bigquery-public-data",
			DatasetId: "samples",
			TableId:   "github_nested",
		},
		Field: &dlppb.FieldId{
			Name: "actor",
		},
	}

	// Specify the configuration of the large custom dictionary.
	largeCustomDictionaryConfig := &dlppb.LargeCustomDictionaryConfig{
		OutputPath: cloudStoragePath,
		Source: &dlppb.LargeCustomDictionaryConfig_BigQueryField{
			BigQueryField: bigQueryField,
		},
	}

	// Specify the configuration for stored infoType.
	storedInfoTypeConfig := &dlppb.StoredInfoTypeConfig{
		DisplayName: displayName,
		Description: description,
		Type: &dlppb.StoredInfoTypeConfig_LargeCustomDictionary{
			LargeCustomDictionary: largeCustomDictionaryConfig,
		},
	}

	// Combine configurations into a request for the service.
	req := &dlppb.CreateStoredInfoTypeRequest{
		Parent:           fmt.Sprintf("projects/%s/locations/global", projectID),
		Config:           storedInfoTypeConfig,
		StoredInfoTypeId: "github-usernames",
	}

	// Send the request and receive response from the service.
	resp, err := client.CreateStoredInfoType(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "output: %v", resp.Name)
	return nil

}

Java

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.BigQueryField;
import com.google.privacy.dlp.v2.BigQueryTable;
import com.google.privacy.dlp.v2.CloudStoragePath;
import com.google.privacy.dlp.v2.CreateStoredInfoTypeRequest;
import com.google.privacy.dlp.v2.FieldId;
import com.google.privacy.dlp.v2.LargeCustomDictionaryConfig;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.StoredInfoType;
import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
import java.io.IOException;

public class CreateStoredInfoType {

  public static void main(String[] args) throws IOException {
    // 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 path to the location in a GCS bucket to store the created dictionary.
    String outputPath = "gs://" + "your-bucket-name" + "path/to/directory";
    createStoredInfoType(projectId, outputPath);
  }

  // Creates a custom stored info type that contains GitHub usernames used in commits.
  public static void createStoredInfoType(String projectId, String outputPath)
      throws IOException {
    try (DlpServiceClient dlp = DlpServiceClient.create()) {

      // Optionally set a display name and a description.
      String displayName = "GitHub usernames";
      String description = "Dictionary of GitHub usernames used in commits";

      // The output path where the custom dictionary containing the GitHub usernames will be stored.
      CloudStoragePath cloudStoragePath =
          CloudStoragePath.newBuilder()
              .setPath(outputPath)
              .build();

      // The reference to the table containing the GitHub usernames.
      BigQueryTable table = BigQueryTable.newBuilder()
              .setProjectId("bigquery-public-data")
              .setDatasetId("samples")
              .setTableId("github_nested")
              .build();

      // The reference to the BigQuery field that contains the GitHub usernames.
      BigQueryField bigQueryField = BigQueryField.newBuilder()
              .setTable(table)
              .setField(FieldId.newBuilder().setName("actor").build())
              .build();

      LargeCustomDictionaryConfig largeCustomDictionaryConfig =
          LargeCustomDictionaryConfig.newBuilder()
              .setOutputPath(cloudStoragePath)
              .setBigQueryField(bigQueryField)
              .build();

      StoredInfoTypeConfig storedInfoTypeConfig = StoredInfoTypeConfig.newBuilder()
              .setDisplayName(displayName)
              .setDescription(description)
              .setLargeCustomDictionary(largeCustomDictionaryConfig)
              .build();

      // Combine configurations into a request for the service.
      CreateStoredInfoTypeRequest createStoredInfoType = CreateStoredInfoTypeRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setConfig(storedInfoTypeConfig)
              .setStoredInfoTypeId("github-usernames")
              .build();

      // Send the request and receive response from the service.
      StoredInfoType response = dlp.createStoredInfoType(createStoredInfoType);

      // Print the results.
      System.out.println("Created Stored InfoType: " + response.getName());
    }
  }
}

Node.js

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

// Import the required libraries
const dlp = require('@google-cloud/dlp');

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

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

// The identifier for the stored infoType
// const infoTypeId = 'github-usernames';

// The path to the location in a Cloud Storage bucket to store the created dictionary
// const outputPath = 'cloud-bucket-path';

// The project ID the table is stored under
// This may or (for public datasets) may not equal the calling project ID
// const dataProjectId = 'my-project';

// The ID of the dataset to inspect, e.g. 'my_dataset'
// const datasetId = 'my_dataset';

// The ID of the table to inspect, e.g. 'my_table'
// const tableId = 'my_table';

// Field ID to be used for constructing dictionary
// const fieldName = 'field_name';

async function createStoredInfoType() {
  // The name you want to give the dictionary.
  const displayName = 'GitHub usernames';
  // A description of the dictionary.
  const description = 'Dictionary of GitHub usernames used in commits';

  // Specify configuration for the large custom dictionary
  const largeCustomDictionaryConfig = {
    outputPath: {
      path: outputPath,
    },
    bigQueryField: {
      table: {
        datasetId: datasetId,
        projectId: dataProjectId,
        tableId: tableId,
      },
      field: {
        name: fieldName,
      },
    },
  };

  // Stored infoType configuration that uses large custom dictionary.
  const storedInfoTypeConfig = {
    displayName: displayName,
    description: description,
    largeCustomDictionary: largeCustomDictionaryConfig,
  };

  // Construct the job creation request to be sent by the client.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    config: storedInfoTypeConfig,
    storedInfoTypeId: infoTypeId,
  };

  // Send the job creation request and process the response.
  const [response] = await dlpClient.createStoredInfoType(request);

  // Print results
  console.log(`InfoType stored successfully: ${response.name}`);
}
await createStoredInfoType();

PHP

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

use Google\Cloud\Dlp\V2\BigQueryField;
use Google\Cloud\Dlp\V2\BigQueryTable;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStoragePath;
use Google\Cloud\Dlp\V2\CreateStoredInfoTypeRequest;
use Google\Cloud\Dlp\V2\FieldId;
use Google\Cloud\Dlp\V2\LargeCustomDictionaryConfig;
use Google\Cloud\Dlp\V2\StoredInfoTypeConfig;

/**
 * Create a stored infoType.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $outputgcsPath     The path to the location in a Cloud Storage bucket to store the created dictionary.
 * @param string $storedInfoTypeId  The name of the custom stored info type.
 * @param string $displayName       The human-readable name to give the stored infoType.
 * @param string $description       A description for the stored infoType to be created.
 */
function create_stored_infotype(
    string $callingProjectId,
    string $outputgcsPath,
    string $storedInfoTypeId,
    string $displayName,
    string $description
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // The reference to the table containing the GitHub usernames.
    // The reference to the BigQuery field that contains the GitHub usernames.
    // Note: we have used public data
    $bigQueryField = (new BigQueryField())
        ->setTable((new BigQueryTable())
            ->setDatasetId('samples')
            ->setProjectId('bigquery-public-data')
            ->setTableId('github_nested'))
        ->setField((new FieldId())
            ->setName('actor'));

    $largeCustomDictionaryConfig = (new LargeCustomDictionaryConfig())
        // The output path where the custom dictionary containing the GitHub usernames will be stored.
        ->setOutputPath((new CloudStoragePath())
            ->setPath($outputgcsPath))
        ->setBigQueryField($bigQueryField);

    // Configure the StoredInfoType we want the service to perform.
    $storedInfoTypeConfig = (new StoredInfoTypeConfig())
        ->setDisplayName($displayName)
        ->setDescription($description)
        ->setLargeCustomDictionary($largeCustomDictionaryConfig);

    // Send the stored infoType creation request and process the response.
    $parent = "projects/$callingProjectId/locations/global";
    $createStoredInfoTypeRequest = (new CreateStoredInfoTypeRequest())
        ->setParent($parent)
        ->setConfig($storedInfoTypeConfig)
        ->setStoredInfoTypeId($storedInfoTypeId);
    $response = $dlp->createStoredInfoType($createStoredInfoTypeRequest);

    // Print results.
    printf('Successfully created Stored InfoType : %s', $response->getName());
}

Python

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import google.cloud.dlp


def create_stored_infotype(
    project: str,
    stored_info_type_id: str,
    output_bucket_name: str,
) -> None:
    """Uses the Data Loss Prevention API to create stored infoType.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        stored_info_type_id: The identifier for large custom dictionary.
        output_bucket_name: The name of the bucket in Google Cloud Storage
            that would store the created dictionary.
    """

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

    # Construct the stored infoType Configuration dictionary. This example creates
    # a stored infoType from a term list stored in a publicly available BigQuery
    # database (bigquery-public-data.samples.github_nested).
    # The database contains all GitHub usernames used in commits.
    stored_info_type_config = {
        "display_name": "GitHub usernames",
        "description": "Dictionary of GitHub usernames used in commits",
        "large_custom_dictionary": {
            "output_path": {"path": f"gs://{output_bucket_name}"},
            # We can either use bigquery field or gcs file as a term list input option.
            "big_query_field": {
                "table": {
                    "project_id": "bigquery-public-data",
                    "dataset_id": "samples",
                    "table_id": "github_nested",
                },
                "field": {"name": "actor"},
            },
        },
    }

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

    # Call the API.
    response = dlp.create_stored_info_type(
        request={
            "parent": parent,
            "config": stored_info_type_config,
            "stored_info_type_id": stored_info_type_id,
        }
    )

    # Print the result
    print(f"Created Stored InfoType: {response.name}")

REST

1. Crea una carpeta nueva para el diccionario en un bucket de Cloud Storage. Sensitive Data Protection crea carpetas que contienen los archivos de diccionario en la ubicación que especifiques.
Nota: No coloques archivos dentro de las carpetas que crea Sensitive Data Protection cuando compila tu diccionario. Cuando Sensitive Data Protection cree o vuelva a compilar archivos de diccionario, borrará cualquier otro archivo almacenado en las carpetas que cree. Se mantendrán todas las carpetas que estén en el mismo nivel que las carpetas que crea Sensitive Data Protection.
2. Crea el diccionario con el método storedInfoTypes.create. El método create incluye los siguientes parámetros:
   • Un objeto StoredInfoTypeConfig, que contiene la configuración del Infotipo almacenado. Incluye lo siguiente:
     • description: es una descripción del diccionario.
     • displayName: es el nombre que deseas asignar al diccionario.
     • LargeCustomDictionaryConfig: Contiene la configuración del diccionario personalizado grande. Encontrarás la siguiente información:
       • BigQueryField: se especifica si tu lista de términos se almacena en BigQuery. Incluye una referencia a la tabla en la que se almacena tu lista, además del campo que contiene cada frase del diccionario.
       • CloudStorageFileSet: se especifica si tu lista de términos se almacena en Cloud Storage. Incluye la URL a la ubicación de origen en Cloud Storage, de la siguiente manera: "gs://[PATH_TO_GS]". Se admiten comodines.
       Nota: Puedes especificar BigQueryField o CloudStorageFileSet en LargeCustomDictionaryConfig, pero no ambos.
       • outputPath: es la ruta a la ubicación en un bucket de Cloud Storage para almacenar el diccionario creado.
   • storedInfoTypeId: Es el identificador del Infotipo almacenado. Usa este identificador para hacer referencia al Infotipo almacenado cuando lo vuelvas a compilar, lo borres o lo uses en un trabajo de inspección o desidentificación. Si dejas este campo vacío, el sistema generará un identificador para ti.

A continuación, se muestra un ejemplo de JSON que, cuando se envía al método storedInfoTypes.create, crea un nuevo Infotipo almacenado, específicamente, un detector de diccionario personalizado grande. En este ejemplo, se crea un Infotipo almacenado a partir de una lista de términos almacenada en una base de datos de BigQuery disponible de forma pública (bigquery-public-data.samples.github_nested). La base de datos contiene todos los nombres de usuario de GitHub que se usan en las confirmaciones. La ruta de acceso de salida para el diccionario generado se establece en un bucket de Cloud Storage llamado dlptesting, y el Infotipo almacenado se llama github-usernames.

Entrada de JSON

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes

{
  "config":{
    "displayName":"GitHub usernames",
    "description":"Dictionary of GitHub usernames used in commits",
    "largeCustomDictionary":{
      "outputPath":{
        "path":"gs://[PATH_TO_GS]"
      },
      "bigQueryField":{
        "table":{
          "datasetId":"samples",
          "projectId":"bigquery-public-data",
          "tableId":"github_nested"
        }
      }
    }
  },
  "storedInfoTypeId":"github-usernames"
}

Vuelve a compilar el diccionario

Si quieres actualizar tu diccionario, primero actualiza la lista de términos de origen y, luego, indica a Sensitive Data Protection que vuelva a compilar el Infotipo almacenado.

1. Actualiza la lista de términos de origen existente en Cloud Storage o BigQuery.

   Agrega, quita o cambia los términos o las frases según sea necesario.

2. Para crear una versión nueva del Infotipo sensible almacenado, vuelve a compilarla con la consola de Google Cloud o el método storedInfoTypes.patch.

   La reconstrucción crea una versión nueva del diccionario, que reemplaza al diccionario anterior.

Cuando vuelves a compilar un tipo de información sensible almacenado en una versión nueva, se borra la versión anterior. Mientras Sensitive Data Protection actualiza el infotipo almacenado, su estado es "pendiente". Durante este tiempo, la versión anterior del Infotipo almacenado aún existe. Cualquier análisis que ejecutes mientras el Infotipo almacenado esté en estado pendiente se ejecutará con la versión anterior del Infotipo almacenado.

Para volver a compilar el infotipo almacenado, sigue estos pasos:

Console

1. Actualiza y guarda tu lista de términos en Cloud Storage o BigQuery.

2. En la consola de Google Cloud , ve a la lista de tipos de información almacenados.

   Ir a Infotipos almacenados

3. Haz clic en el ID del Infotipo almacenado que deseas actualizar.

4. En la página Detalles del infotipo, haz clic en Recompilar datos.

Sensitive Data Protection vuelve a compilar el Infotipo almacenado con los cambios que realizaste en la lista de términos de origen. Una vez que el estado del Infotipo almacenado sea "Listo", podrás usarlo. Cualquier plantilla o activador de trabajo que use el Infotipo almacenado usará automáticamente la versión reconstruida.

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

public class UpdateStoredInfoTypes
{
    public static StoredInfoType Update(
        string gcsFileUri,
        string storedInfoTypePath,
        string outputPath)
    {
        // Instantiate the client.
        var dlp = DlpServiceClient.Create();

        // Construct the stored infotype config. Here, we will change the source from bigquery table to GCS file.
        var storedConfig = new StoredInfoTypeConfig
        {
            LargeCustomDictionary = new LargeCustomDictionaryConfig
            {
                CloudStorageFileSet = new CloudStorageFileSet
                {
                    Url = gcsFileUri
                },
                OutputPath = new CloudStoragePath
                {
                    Path = outputPath
                }
            }
        };

        // Construct the request using the stored config by specifying the update mask object
        // which represent the path of field to be updated.
        var request = new UpdateStoredInfoTypeRequest
        {
            Config = storedConfig,
            Name = storedInfoTypePath,
            UpdateMask = new FieldMask
            {
                Paths =
                {
                    "large_custom_dictionary.cloud_storage_file_set.url"
                }
            }
        };

        // Call the API.
        StoredInfoType response = dlp.UpdateStoredInfoType(request);

        // Inspect the result.
        Console.WriteLine(response);
        return response;
    }
}

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

// updateStoredInfoType uses the Data Loss Prevention API to update stored infoType
// detector by changing the source term list from one stored in Bigquery
// to one stored in Cloud Storage.
func updateStoredInfoType(w io.Writer, projectID, gcsUri, fileSetUrl, infoTypeId string) error {
	// projectId := "your-project-id"
	// gcsUri := "gs://" + "your-bucket-name" + "/path/to/your/file.txt"
	// fileSetUrl := "your-cloud-storage-file-set"
	// infoTypeId := "your-stored-info-type-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()

	// Set path in Cloud Storage.
	cloudStoragePath := &dlppb.CloudStoragePath{
		Path: gcsUri,
	}
	cloudStorageFileSet := &dlppb.CloudStorageFileSet{
		Url: fileSetUrl,
	}

	// Configuration for a custom dictionary created from a data source of any size
	largeCustomDictionaryConfig := &dlppb.LargeCustomDictionaryConfig{
		OutputPath: cloudStoragePath,
		Source: &dlppb.LargeCustomDictionaryConfig_CloudStorageFileSet{
			CloudStorageFileSet: cloudStorageFileSet,
		},
	}

	// Set configuration for stored infoTypes.
	storedInfoTypeConfig := &dlppb.StoredInfoTypeConfig{
		Type: &dlppb.StoredInfoTypeConfig_LargeCustomDictionary{
			LargeCustomDictionary: largeCustomDictionaryConfig,
		},
	}

	// Set mask to control which fields get updated.
	fieldMask := &fieldmaskpb.FieldMask{
		Paths: []string{"large_custom_dictionary.cloud_storage_file_set.url"},
	}
	// Construct the job creation request to be sent by the client.
	req := &dlppb.UpdateStoredInfoTypeRequest{
		Name:       fmt.Sprint("projects/" + projectID + "/storedInfoTypes/" + infoTypeId),
		Config:     storedInfoTypeConfig,
		UpdateMask: fieldMask,
	}

	// Use the client to send the API request.
	resp, err := client.UpdateStoredInfoType(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "output: %v", resp.Name)
	return nil
}

Java

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CloudStorageFileSet;
import com.google.privacy.dlp.v2.CloudStoragePath;
import com.google.privacy.dlp.v2.LargeCustomDictionaryConfig;
import com.google.privacy.dlp.v2.StoredInfoType;
import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
import com.google.privacy.dlp.v2.StoredInfoTypeName;
import com.google.privacy.dlp.v2.UpdateStoredInfoTypeRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateStoredInfoType {
  public static void main(String[] args) throws IOException {
    // 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 path to file in GCS bucket that holds a collection of words and phrases to be searched by
    // the new infoType detector.
    String filePath = "gs://" + "your-bucket-name" + "/path/to/your/file.txt";
    // The path to the location in a GCS bucket to store the created dictionary.
    String outputPath = "your-cloud-storage-file-set";
    // The name of the stored InfoType which is to be updated.
    String infoTypeId = "your-stored-info-type-id";
    updateStoredInfoType(projectId, filePath, outputPath, infoTypeId);
  }

  // Update the stored info type rebuilding the Custom dictionary.
  public static void updateStoredInfoType(
      String projectId, String filePath, String outputPath, String infoTypeId) 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 dlp = DlpServiceClient.create()) {
      // Set path in Cloud Storage.
      CloudStoragePath cloudStoragePath = CloudStoragePath.newBuilder().setPath(outputPath).build();
      CloudStorageFileSet cloudStorageFileSet =
          CloudStorageFileSet.newBuilder().setUrl(filePath).build();

      // Configuration for a custom dictionary created from a data source of any size
      LargeCustomDictionaryConfig largeCustomDictionaryConfig =
          LargeCustomDictionaryConfig.newBuilder()
              .setOutputPath(cloudStoragePath)
              .setCloudStorageFileSet(cloudStorageFileSet)
              .build();

      // Set configuration for stored infoTypes.
      StoredInfoTypeConfig storedInfoTypeConfig =
          StoredInfoTypeConfig.newBuilder()
              .setLargeCustomDictionary(largeCustomDictionaryConfig)
              .build();

      // Set mask to control which fields get updated.
      // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
      FieldMask fieldMask =
          FieldMask.newBuilder()
              .addPaths("large_custom_dictionary.cloud_storage_file_set.url")
              .build();

      // Construct the job creation request to be sent by the client.
      UpdateStoredInfoTypeRequest updateStoredInfoTypeRequest =
          UpdateStoredInfoTypeRequest.newBuilder()
              .setName(
                  StoredInfoTypeName.ofProjectStoredInfoTypeName(projectId, infoTypeId).toString())
              .setConfig(storedInfoTypeConfig)
              .setUpdateMask(fieldMask)
              .build();

      // Send the job creation request and process the response.
      StoredInfoType response = dlp.updateStoredInfoType(updateStoredInfoTypeRequest);

      // Print the results.
      System.out.println("Updated stored InfoType successfully: " + response.getName());
    }
  }
}

Node.js

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

// Import the required libraries
const dlp = require('@google-cloud/dlp');

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

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

// The identifier for the stored infoType
// const infoTypeId = 'github-usernames';

// The path to the location in a Cloud Storage bucket to store the created dictionary
// const outputPath = 'cloud-bucket-path';

// Path of file containing term list
// const cloudStorageFileSet = 'gs://[PATH_TO_GS]';

async function updateStoredInfoType() {
  // Specify configuration of the large custom dictionary including cloudStorageFileSet and outputPath
  const largeCustomDictionaryConfig = {
    outputPath: {
      path: outputPath,
    },
    cloudStorageFileSet: {
      url: fileSetUrl,
    },
  };

  // Construct the job creation request to be sent by the client.
  const updateStoredInfoTypeRequest = {
    name: `projects/${projectId}/storedInfoTypes/${infoTypeId}`,
    config: {
      largeCustomDictionary: largeCustomDictionaryConfig,
    },
    updateMask: {
      paths: ['large_custom_dictionary.cloud_storage_file_set.url'],
    },
  };

  // Send the job creation request and process the response.
  const [response] = await dlpClient.updateStoredInfoType(
    updateStoredInfoTypeRequest
  );

  // Print the results.
  console.log(`InfoType updated successfully: ${JSON.stringify(response)}`);
}
await updateStoredInfoType();

PHP

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStorageFileSet;
use Google\Cloud\Dlp\V2\CloudStoragePath;
use Google\Cloud\Dlp\V2\LargeCustomDictionaryConfig;
use Google\Cloud\Dlp\V2\StoredInfoTypeConfig;
use Google\Cloud\Dlp\V2\UpdateStoredInfoTypeRequest;
use Google\Protobuf\FieldMask;

/**
 * Rebuild/Update the stored infoType.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $gcsPath           The path to file in GCS bucket that holds a collection of words and phrases to be searched by the new infoType detector.
 * @param string $outputgcsPath     The path to the location in a Cloud Storage bucket to store the created dictionary.
 * @param string $storedInfoTypeId  The name of the stored InfoType which is to be updated.
 *
 */
function update_stored_infotype(
    string $callingProjectId,
    string $gcsPath,
    string $outputgcsPath,
    string $storedInfoTypeId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Set path in Cloud Storage.
    $cloudStorageFileSet = (new CloudStorageFileSet())
        ->setUrl($gcsPath);

    // Configuration for a custom dictionary created from a data source of any size
    $largeCustomDictionaryConfig = (new LargeCustomDictionaryConfig())
        ->setOutputPath((new CloudStoragePath())
            ->setPath($outputgcsPath))
        ->setCloudStorageFileSet($cloudStorageFileSet);

    // Set configuration for stored infoTypes.
    $storedInfoTypeConfig = (new StoredInfoTypeConfig())
        ->setLargeCustomDictionary($largeCustomDictionaryConfig);

    // Send the stored infoType creation request and process the response.

    $name = "projects/$callingProjectId/locations/global/storedInfoTypes/" . $storedInfoTypeId;
    // Set mask to control which fields get updated.
    // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
    $fieldMask = (new FieldMask())
        ->setPaths([
            'large_custom_dictionary.cloud_storage_file_set.url'
        ]);

    // Run request
    $updateStoredInfoTypeRequest = (new UpdateStoredInfoTypeRequest())
        ->setName($name)
        ->setConfig($storedInfoTypeConfig)
        ->setUpdateMask($fieldMask);
    $response = $dlp->updateStoredInfoType($updateStoredInfoTypeRequest);

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

Python

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import google.cloud.dlp


def update_stored_infotype(
    project: str,
    stored_info_type_id: str,
    gcs_input_file_path: str,
    output_bucket_name: str,
) -> None:
    """Uses the Data Loss Prevention API to update stored infoType
    detector by changing the source term list from one stored in Bigquery
    to one stored in Cloud Storage.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        stored_info_type_id: The identifier of stored infoType which is to
            be updated.
        gcs_input_file_path: The url in the format <bucket>/<path_to_file>
            for the location of the source term list.
        output_bucket_name: The name of the bucket in Google Cloud Storage
            where large dictionary is stored.
    """

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

    # Construct the stored infoType configuration dictionary.
    stored_info_type_config = {
        "large_custom_dictionary": {
            "output_path": {"path": f"gs://{output_bucket_name}"},
            "cloud_storage_file_set": {"url": f"gs://{gcs_input_file_path}"},
        }
    }

    # Set mask to control which fields get updated. For more details, refer
    # https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
    # for constructing the field mask paths.
    field_mask = {"paths": ["large_custom_dictionary.cloud_storage_file_set.url"]}

    # Convert the stored infoType id into a full resource id.
    stored_info_type_name = (
        f"projects/{project}/locations/global/storedInfoTypes/{stored_info_type_id}"
    )

    # Call the API.
    response = dlp.update_stored_info_type(
        request={
            "name": stored_info_type_name,
            "config": stored_info_type_config,
            "update_mask": field_mask,
        }
    )

    # Print the result
    print(f"Updated stored infoType successfully: {response.name}")

REST

Actualiza la lista de términos

Si solo actualizas la lista de términos en el diccionario personalizado grande, tu solicitud storedInfoTypes.patch solo requiere el campo name. Proporciona el nombre completo del recurso del tipo de información sensible almacenado que deseas volver a compilar.

Los siguientes patrones representan entradas válidas para el campo name:

• organizations/ORGANIZATION_ID/storedInfoTypes/STORED_INFOTYPE_ID
• projects/PROJECT_ID/storedInfoTypes/STORED_INFOTYPE_ID

Reemplaza STORED_INFOTYPE_ID por el identificador del Infotipo almacenado que deseas volver a compilar.

Si no conoces el identificador del infotipo almacenado, llama al método storedInfoTypes.list para ver una lista de todos los infotipos almacenados actuales.

Nota: Aunque los tipos de información almacenados no tienen números de versión, cada uno tiene un campo createTime, que se actualiza con cada reconstrucción. Usa el método storedInfoTypes.get para recuperar información sobre el Infotipo almacenado y usa el campo createTime para determinar cuándo se volvió a compilar por última vez.

Ejemplo

PATCH https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes/STORED_INFOTYPE_ID

En este caso, no se requiere un cuerpo de la solicitud.

Cambia la lista de términos de origen

Puedes cambiar la lista de términos de origen de un Infotipo almacenado de uno almacenado en BigQuery a uno almacenado en Cloud Storage. Usa el método storedInfoTypes.patch, pero incluye un objeto CloudStorageFileSet en LargeCustomDictionaryConfig donde antes usabas un objeto BigQueryField. Luego, configura el parámetro updateMask como el parámetro Infotipo almacenado que volviste a compilar, en formato FieldMask. Por ejemplo, el siguiente JSON indica en el parámetro updateMask que se actualizó la URL de la ruta de acceso de Cloud Storage (large_custom_dictionary.cloud_storage_file_set.url):

Ejemplo

PATCH https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes/github-usernames

{
  "config":{
    "largeCustomDictionary":{
      "cloudStorageFileSet":{
        "url":"gs://[BUCKET_NAME]/[PATH_TO_FILE]"
      }
    }
  },
  "updateMask":"large_custom_dictionary.cloud_storage_file_set.url"
}

Del mismo modo, puedes cambiar tu lista de términos de una almacenada en una tabla de BigQuery a una almacenada en un bucket de Cloud Storage.

Analiza contenido con un detector de diccionario personalizado grande

Analizar contenido con un detector de diccionario personalizado grande es similar a analizar contenido con cualquier otro detector de Infotipo personalizado.

En este procedimiento, se supone que tienes un Infotipo almacenado existente. Para obtener más información, consulta Crea un tipo de información almacenado en esta página.

Console

Puedes aplicar un detector de diccionario personalizado grande cuando hagas lo siguiente:

• Crea un trabajo nuevo
• Crea o edita un activador de trabajo
• Crear o editar una plantilla
• Configura la creación de perfiles de datos

En la sección Configurar detección de la página, en el apartado Infotipos, puedes especificar el infotipo de diccionario personalizado grande.

1. Haz clic en Administrar tipos de información.
2. En el panel Infotipos, haz clic en la pestaña Personalizados.
3. Haz clic en Agregar infotipo personalizado.

4. En el panel Agregar tipo de información personalizado, haz lo siguiente:

   1. En Tipo, selecciona Infotipo almacenado.
   2. En InfoType, ingresa un nombre para el infotipo personalizado. Puedes usar letras, números y guiones bajos.

   3. En Probabilidad, selecciona el nivel de probabilidad predeterminado que deseas asignar a todos los hallazgos que coincidan con este tipo de Infotipo sensible personalizado. Puedes ajustar aún más el nivel de probabilidad de los hallazgos individuales con las reglas de palabras clave.

      Si no especificas un valor predeterminado, el nivel de probabilidad predeterminado se establece en VERY_LIKELY. Para obtener más información, consulta Probabilidad de coincidencia.

   4. En Sensibilidad, selecciona el nivel de sensibilidad que deseas asignar a todos los hallazgos que coincidan con este tipo de Infotipo sensible personalizado. Si no especificas un valor, los niveles de sensibilidad de esos hallazgos se establecen en HIGH.

      Las puntuaciones de sensibilidad se usan en los perfiles de datos. Cuando se genera un perfil de tus datos, Sensitive Data Protection usa las puntuaciones de sensibilidad de los infotipos para calcular el nivel de sensibilidad.

   5. En Nombre del infotipo almacenado, selecciona el infotipo almacenado en el que deseas basar el nuevo infotipo personalizado.

   6. Haz clic en Listo para cerrar el panel Agregar tipo de información personalizado.

5. Opcional: En la pestaña Integrados, edita tu selección de infotipos integrados.

6. Haz clic en Listo para cerrar el panel Tipos de información.

   El infotipo personalizado se agrega a la lista de infotipos que busca Sensitive Data Protection. Sin embargo, esta selección no es definitiva hasta que guardes el trabajo, el activador de trabajos, la plantilla o la configuración de análisis.

7. Cuando termines de crear o editar la configuración, haz clic en Guardar.

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

public class InspectDataWithStoredInfotypes
{
    public static InspectContentResponse Inspect(
        string projectId,
        string storedInfotypePath,
        string text,
        InfoType infoType = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the infotype if null.
        var infotype = infoType ?? new InfoType { Name = "GITHUB_LOGINS" };

        // Construct the inspect config using stored infotype.
        var inspectConfig = new InspectConfig
        {
            CustomInfoTypes =
            {
                new CustomInfoType
                {
                    InfoType = infotype,
                    StoredType = new StoredType { Name = storedInfotypePath }
                }
            },
            IncludeQuote = true
        };

        // Construct the request using inspect config.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            InspectConfig = inspectConfig,
            Item = new ContentItem { Value = text }
        };

        // Call the API.
        InspectContentResponse response = dlp.InspectContent(request);

        // Inspect the results.
        var findings = response.Result.Findings;
        Console.WriteLine($"Findings: {findings.Count}");
        foreach (var f in findings)
        {
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tInfo type: " + f.InfoType.Name);
            Console.WriteLine("\tLikelihood: " + f.Likelihood);
        }

        return response;
    }
}

Go

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import (
	"context"
	"fmt"
	"io"

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

// inspectWithStoredInfotype inspects the given text using the specified stored infoType detector.
func inspectWithStoredInfotype(w io.Writer, projectID, infoTypeId, textToDeidentify string) error {
	// projectId := "your-project-id"
	// infoTypeId := "your-info-type-id"
	// textToDeidentify := "This commit was made by kewin2010"

	ctx := context.Background()

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

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

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

	// Specify the info type the inspection will look for.
	infoType := &dlppb.InfoType{
		Name: "GITHUB_LOGINS",
	}

	// Specify the stored info type the inspection will look for.
	storedType := &dlppb.StoredType{
		Name: infoTypeId,
	}

	customInfoType := &dlppb.CustomInfoType{
		InfoType: infoType,
		Type: &dlppb.CustomInfoType_StoredType{
			StoredType: storedType,
		},
	}

	// Specify how the content should be inspected.
	inspectConfig := &dlppb.InspectConfig{
		CustomInfoTypes: []*dlppb.CustomInfoType{
			customInfoType,
		},
		IncludeQuote: true,
	}

	// Construct the Inspect request to be sent by the client.
	req := &dlppb.InspectContentRequest{
		Parent:        fmt.Sprintf("projects/%s/locations/global", projectID),
		InspectConfig: inspectConfig,
		Item:          contentItem,
	}

	// Use the client to send the API request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return err
	}

	// Process the results.
	fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
	for _, f := range resp.Result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.CustomInfoType;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.ProjectStoredInfoTypeName;
import com.google.privacy.dlp.v2.StoredType;
import java.io.IOException;

public class InspectWithStoredInfotype {

  public static void main(String[] args) throws IOException {
    // 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 sample assumes that you have an existing stored infoType.
    // To create a stored InfoType refer:
    // https://cloud.google.com/dlp/docs/creating-stored-infotypes#create-storedinfotye 
    String storedInfoTypeId = "your-info-type-id";
    // The string to de-identify.
    String textToInspect =
        "My phone number is [phone] and my email address is [e-mail].";
    inspectWithStoredInfotype(projectId, storedInfoTypeId, textToInspect);
  }

  //  Inspects the given text using the specified stored infoType detector.
  public static void inspectWithStoredInfotype(
      String projectId, String storedInfoTypeId, String textToInspect) 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 dlp = DlpServiceClient.create()) {

      // Specify the content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToInspect).build();

      InfoType infoType = InfoType.newBuilder().setName("STORED_TYPE").build();

      // Reference to the existing StoredInfoType to inspect the data.
      StoredType storedType = StoredType.newBuilder()
              .setName(ProjectStoredInfoTypeName.of(projectId, storedInfoTypeId).toString())
              .build();

      CustomInfoType customInfoType =
          CustomInfoType.newBuilder().setInfoType(infoType).setStoredType(storedType).build();

      // Construct the configuration for the Inspect request.
      InspectConfig inspectConfig =
          InspectConfig.newBuilder()
              .addCustomInfoTypes(customInfoType)
              .setIncludeQuote(true)
              .build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest inspectContentRequest =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectConfig(inspectConfig)
              .setItem(contentItem)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(inspectContentRequest);

      // Parse the response and process results.
      System.out.println("Findings: " + "" + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfoType: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood() + "\n");
      }
    }
  }
}

Node.js

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

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

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

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

// The custom info-type id created and stored in the bucket.
// const infoTypeId = 'your-info-type-id';

// The string to inspect.
// const string = 'My phone number is [phone] and my email address is [e-mail].';

async function inspectWithStoredInfotype() {
  // Reference to the existing StoredInfoType to inspect the data.
  const customInfoType = {
    infoType: {
      name: 'GITHUB_LOGINS',
    },
    storedType: {
      name: infoTypeId,
    },
  };

  // Construct the configuration for the Inspect request.
  const inspectConfig = {
    customInfoTypes: [customInfoType],
    includeQuote: true,
  };

  // Construct the Inspect request to be sent by the client.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectConfig: inspectConfig,
    item: {
      value: string,
    },
  };
  // Run request
  const [response] = await dlp.inspectContent(request);

  // Print Findings
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log(`Findings: ${findings.length}\n`);
    findings.forEach(finding => {
      console.log(`InfoType: ${finding.infoType.name}`);
      console.log(`\tQuote: ${finding.quote}`);
      console.log(`\tLikelihood: ${finding.likelihood} \n`);
    });
  } else {
    console.log('No findings.');
  }
}
await inspectWithStoredInfotype();

PHP

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\CustomInfoType;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectContentRequest;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\StoredType;

/**
 * Inspect with stored infoType.
 * Scan content using a large custom dictionary detector.
 *
 * @param string $projectId             The Google Cloud Project ID to run the API call under.
 * @param string $storedInfoTypeName    The name of the stored infotype whose This value must be in the format
 * projects/projectName/(locations/locationId)/storedInfoTypes/storedInfoTypeName.
 * @param string $textToInspect         The string to inspect.
 */
function inspect_with_stored_infotype(
    string $projectId,
    string $storedInfoTypeName,
    string $textToInspect
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

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

    // Specify the content to be inspected.
    $item = (new ContentItem())
        ->setValue($textToInspect);

    // Reference to the existing StoredInfoType to inspect the data.
    $customInfoType = (new CustomInfoType())
        ->setInfoType((new InfoType())
            ->setName('STORED_TYPE'))
        ->setStoredType((new StoredType())
            ->setName($storedInfoTypeName));

    // Construct the configuration for the Inspect request.
    $inspectConfig = (new InspectConfig())
        ->setCustomInfoTypes([$customInfoType])
        ->setIncludeQuote(true);

    // Run request.
    $inspectContentRequest = (new InspectContentRequest())
        ->setParent($parent)
        ->setInspectConfig($inspectConfig)
        ->setItem($item);
    $response = $dlp->inspectContent($inspectContentRequest);

    // Print the results.
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        printf('No findings.' . PHP_EOL);
    } else {
        printf('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            printf('  Quote: %s' . PHP_EOL, $finding->getQuote());
            printf('  Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
            printf('  Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
        }
    }
}

Python

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Sensitive Data Protection, consulta las bibliotecas cliente de Sensitive Data Protection.

Para autenticarte en Sensitive Data Protection, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta Configura la autenticación para un entorno de desarrollo local.

import google.cloud.dlp


def inspect_with_stored_infotype(
    project: str,
    stored_info_type_id: str,
    content_string: str,
) -> None:
    """Uses the Data Loss Prevention API to inspect/scan content using stored
    infoType.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        content_string: The string to inspect.
        stored_info_type_id: The identifier of stored infoType used to inspect.
    """

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

    # Convert stored infoType id into full resource id
    stored_type_name = f"projects/{project}/storedInfoTypes/{stored_info_type_id}"

    # Construct a custom info type dictionary using stored infoType.
    custom_info_types = [
        {
            "info_type": {"name": "STORED_TYPE"},
            "stored_type": {
                "name": stored_type_name,
            },
        }
    ]

    # Construct the inspection configuration dictionary.
    inspect_config = {
        "custom_info_types": custom_info_types,
        "include_quote": True,
    }

    # Construct the `item` to be inspected using stored infoType.
    item = {"value": content_string}

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

    # Call the API.
    response = dlp.inspect_content(
        request={
            "parent": parent,
            "inspect_config": inspect_config,
            "item": item,
        }
    )

    # Print out the results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")

REST

Cuando se envía al método content.inspect, el siguiente ejemplo analiza el texto proporcionado con el detector de Infotipo almacenado especificado. El parámetro infoType es obligatorio porque todos los infoTypes personalizados deben tener un nombre que no entre en conflicto con los infoTypes integrados ni con otros infoTypes personalizados. El parámetro storedType contiene la ruta de acceso completa al recurso del Infotipo almacenado.

Entrada de JSON

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/content:inspect

{
  "inspectConfig":{
    "customInfoTypes":[
      {
        "infoType":{
          "name":"GITHUB_LOGINS"
        },
        "storedType":{
          "name":"projects/PROJECT_ID/storedInfoTypes/github-logins"
        }
      }
    ]
  },
  "item":{
    "value":"The commit was made by githubuser."
  }
}

Solucionar errores

Si recibes un error cuando intentas crear un Infotipo almacenado a partir de una lista de términos almacenada en Cloud Storage, las siguientes son las posibles causas:

• Alcanzaste un límite superior para los infoTypes almacenados. Según el problema, existen varias soluciones alternativas:
  • Si alcanzas el límite superior para un solo archivo de entrada en Cloud Storage (200 MB), intenta dividirlo en varios archivos. Puedes usar varios archivos para ensamblar un solo diccionario personalizado, siempre que el tamaño combinado de todos los archivos no supere 1 GB.
  • BigQuery no tiene los mismos límites que Cloud Storage. Considera mover los términos a una tabla de BigQuery. El tamaño máximo de una columna de diccionario personalizado en BigQuery es de 1 GB y la cantidad máxima de filas es de 5,000,000.
  • Si el archivo de la lista de términos supera todos los límites aplicables para las listas de términos de origen, debes dividir el archivo de la lista de términos en varios archivos y crear un diccionario para cada archivo. Luego, crea un trabajo de análisis independiente para cada diccionario.
• Uno o más de tus términos no contienen, al menos, una letra o número. Sensitive Data Protection no puede analizar términos que se compongan solo de espacios o símbolos. Debe tener al menos una letra o número. Mira tu lista de términos y fíjate si hay alguno de esos términos incluido y, luego, corrígelo o bórralo.
• Tu lista de términos contiene una frase con demasiados “componentes”. Un componente en este contexto es una secuencia continua que contiene solo letras, solo números o solo caracteres que no son letras ni dígitos, como espacios o símbolos. Mira tu lista de términos y fíjate si hay alguno de esos términos incluido y, luego, corrígelo o bórralo.
• El agente de servicio de Sensitive Data Protection no tiene acceso a los datos de origen del diccionario ni al bucket de Cloud Storage para almacenar los archivos del diccionario. Para solucionar este problema, otorga al agente de servicio de Sensitive Data Protection el rol de administrador de Storage (roles/storage.admin) o los roles de propietario de datos de BigQuery (roles/bigquery.dataOwner) y usuario de trabajos de BigQuery (roles/bigquery.jobUser).

Descripción general de la API

Es necesario crear un infotipo almacenado si estás creando un detector de diccionario personalizado grande.

Nota: Si creas un detector de diccionario personalizado normal o un detector de expresiones regulares, no necesitas crear un Infotipo almacenado. Es más sencillo definirlos directamente en el objeto CustomInfoType.

Un Infotipo almacenado se representa en Sensitive Data Protection con el objeto StoredInfoType. Consta de los siguientes objetos relacionados:

• StoredInfoTypeVersion incluye la fecha y hora de creación, y los últimos cinco mensajes de error que se produjeron cuando se creó la versión actual.

  • StoredInfoTypeConfig contiene la configuración del Infotipo almacenado, incluidos su nombre y descripción. Para un diccionario personalizado grande, el type debe ser un LargeCustomDictionaryConfig.

    • LargeCustomDictionaryConfig especifica lo siguiente:
      • Dónde se almacena tu lista de frases dentro de Cloud Storage o BigQuery.
      • Dónde se almacenan los archivos de diccionario generados en Cloud Storage.

  • StoredInfoTypeState contiene el estado de la versión más reciente y cualquier versión pendiente del Infotipo almacenado. La información de estado incluye si el Infotipo almacenado se está recopilando de nuevo, si está listo para usar o si no es válido.

Detalles de coincidencias en el diccionario

A continuación, se incluye orientación sobre cómo Sensitive Data Protection hace coincidir las palabras y frases del diccionario. Estos puntos se aplican a los diccionarios personalizados normales y grandes:

• Las palabras del diccionario no distinguen mayúsculas de minúsculas. Si tu diccionario incluye Abby, coincidirá con abby, ABBY, Abby, etcétera.
• Todos los caracteres (en diccionarios o en el contenido que se analizará) que no sean letras, dígitos ni otros caracteres alfabéticos incluidos en el plano multilingüe básico de Unicode se consideran espacios en blanco cuando se buscan coincidencias. Si tu diccionario analiza Abby Abernathy, coincidirá con abby abernathy, Abby, Abernathy, Abby (ABERNATHY), etcétera.
• Los caracteres que rodean cualquier coincidencia deben ser de un tipo diferente (letras o dígitos) de los caracteres adyacentes dentro de la palabra. Si tu diccionario analiza Abi, coincidirá con los tres primeros caracteres de Abi904, pero no de Abigail.
• Las palabras del diccionario que contienen caracteres en el plano multilingüe complementario del estándar Unicode pueden generar resultados inesperados. Algunos ejemplos de estos caracteres son los emojis, los símbolos científicos y las escrituras históricas.

Las letras, los dígitos y otros caracteres alfabéticos se definen de la siguiente manera:

• Letras: caracteres con categorías generales Lu, Ll, Lt, Lm o Lo en la especificación de Unicode
• Dígitos: caracteres con la categoría general Nd en la especificación de Unicode
• Otros caracteres alfabéticos: caracteres con la categoría general Nl en la especificación de Unicode o con la propiedad contributiva Other_Alphabetic, según lo define el estándar Unicode

Para crear, editar o borrar un Infotipo almacenado, utiliza los siguientes métodos:

• storedInfoTypes.create: crea un nuevo Infotipo almacenado según el objeto StoredInfoTypeConfig que especifiques.
• storedInfoTypes.patch: Vuelve a compilar el Infotipo almacenado con un StoredInfoTypeConfig nuevo que especifiques. Si no se especifica ninguno, este método crea una versión nueva del Infotipo almacenado con el StoredInfoTypeConfig existente.
• storedInfoTypes.get: recupera el objeto StoredInfoTypeConfig y las versiones pendientes del Infotipo almacenado especificado.
• storedInfoTypes.list: enumera todos los Infotipos almacenados actualmente.
• storedInfoTypes.delete: borra el Infotipo almacenado especificado.