Creare un rilevatore di dizionari personalizzati di grandi dimensioni

Questo argomento descrive come creare e ricostruire dizionari personalizzati di grandi dimensioni. Inoltre, copre diversi scenari di errore.

Quando scegliere un dizionario personalizzato grande anziché uno normale

I rivelatori di dizionari personalizzati standard sono sufficienti quando hai decine di migliaia di parole o frasi sensibili per le quali vuoi eseguire la scansione dei contenuti. Se hai più termini o se il tuo elenco di termini cambia spesso, ti consigliamo di creare un grande dizionario personalizzato, che può supportare decine di milioni di termini.

Nota: per gli importi esatti dei limiti di utilizzo per i dizionari, consulta Limiti di utilizzo.

Differenze tra i dizionari personalizzati di grandi dimensioni e gli altri infoType personalizzati

I dizionari personalizzati di grandi dimensioni sono diversi dagli altri infoType personalizzati in quanto ogni dizionario personalizzato di grandi dimensioni ha due componenti:

• Un elenco di frasi che crei e definisci. L'elenco viene archiviato come file di testo in Cloud Storage o come colonna in una tabella BigQuery.
• I file del dizionario, che Sensitive Data Protection genera e archivia in Cloud Storage. I file del dizionario sono composti da una copia dell'elenco di termini e da filtri Bloom, che aiutano nella ricerca e nella corrispondenza.

Avviso: non modificare i file del dizionario personalizzato direttamente in Cloud Storage. In questo modo, il dizionario diventerà non valido e inutilizzabile.

Creare un dizionario personalizzato di grandi dimensioni

Questa sezione descrive come creare, modificare e ricostruire un dizionario personalizzato di grandi dimensioni.

Creare un elenco di termini

Crea un elenco contenente tutte le parole e le frasi che vuoi che il nuovo rilevatore infoType cerchi. Esegui una di queste operazioni:

• Inserisci un file di testo con ogni parola o frase su una riga in un bucket Cloud Storage.
• Designa una colonna di una tabella BigQuery come contenitore per le parole e le frasi. Assegna a ogni voce una riga nella colonna. Puoi utilizzare una tabella BigQuery esistente, a condizione che tutte le parole e le frasi del dizionario siano in un'unica colonna.

È possibile creare un elenco di termini troppo grande per essere elaborato da Sensitive Data Protection. Se viene visualizzato un messaggio di errore, consulta Risolvere i problemi relativi agli errori più avanti in questo argomento.

Creare un infoType archiviato

Dopo aver creato l'elenco di termini, utilizza Sensitive Data Protection per creare un dizionario:

Console

1. In un bucket Cloud Storage, crea una nuova cartella in cui Protezione dei dati sensibili memorizzerà il dizionario generato.

   La funzionalità Protezione dei dati sensibili crea cartelle contenenti i file del dizionario nella posizione specificata.

2. Nella console Google Cloud, vai alla pagina Crea infoType.

   Vai a Crea infoType

3. In Tipo, seleziona Dizionario personalizzato grande.

4. In ID InfoType, inserisci un identificatore per l'infoType archiviato.

   Lo utilizzerai per configurare i job di ispezione e anonimizzazione. Nel nome puoi utilizzare lettere, numeri, trattini e trattini bassi.

5. In Nome visualizzato InfoType, inserisci un nome per l'infoType archiviato.

   Puoi utilizzare spazi e punteggiatura nel nome.

6. In Descrizione, inserisci una descrizione di ciò che viene rilevato dall'infoType archiviato.

7. Per Tipo di archiviazione, seleziona la posizione dell'elenco di termini:

   • BigQuery: inserisci l'ID progetto, l'ID set di dati e l'ID tabella. Nel campo Nome campo, inserisci l'identificatore della colonna. Puoi designare al massimo una colonna della tabella.
   • Google Cloud Storage: inserisci il percorso del file.

8. In Bucket o cartella di output, inserisci la posizione in Cloud Storage della cartella che hai creato nel passaggio 1.

   Nota: non inserire file nelle cartelle create da Protezione dei dati sensibili quando viene creato il dizionario. Quando la funzionalità Protezione dei dati sensibili crea o ricostruisce i file del dizionario, elimina tutti gli altri file archiviati nelle cartelle che crea. Tutte le cartelle allo stesso livello di quelle create da Protezione dei dati sensibili vengono mantenute.

9. Fai clic su Crea.

Viene visualizzato un riepilogo dell'infoType archiviato. Quando il dizionario viene generato e il nuovo infoType archiviato è pronto per l'uso, lo stato dell'infoType è Pronto.

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

// 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

use Google\Cloud\Dlp\V2\BigQueryField;
use Google\Cloud\Dlp\V2\BigQueryTable;
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStoragePath;
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";
    $response = $dlp->createStoredInfoType($parent, $storedInfoTypeConfig, [
        'storedInfoTypeId' => $storedInfoTypeId
    ]);

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

Python

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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 nuova cartella per il dizionario in un bucket Cloud Storage. La funzionalità Protezione dei dati sensibili crea cartelle contenenti i file del dizionario nella posizione specificata.
Nota: non inserire file nelle cartelle create da Protezione dei dati sensibili quando viene compilato il dizionario. Quando crea o ricostruisce i file di dizionario, la funzionalità Protezione dei dati sensibili elimina tutti gli altri file archiviati nelle cartelle che crea. Tutte le cartelle allo stesso livello di quelle create da Protezione dati sensibili verranno mantenute.
2. Crea il dizionario utilizzando il metodo storedInfoTypes.create. Il metodo create accetta i seguenti parametri:
   • Un oggetto StoredInfoTypeConfig che contiene la configurazione dell'infoType archiviato. Sono inclusi:
     • description: una descrizione del dizionario.
     • displayName: il nome che vuoi assegnare al dizionario.
     • LargeCustomDictionaryConfig: contiene la configurazione del dizionario personalizzato di grandi dimensioni. Sono inclusi:
       • BigQueryField: specificato se l'elenco di termini è archiviato in BigQuery. Include un riferimento alla tabella in cui è archiviato l'elenco, oltre al campo contenente ogni frase del dizionario.
       • CloudStorageFileSet: Specificato se l'elenco di termini è archiviato in Cloud Storage. Include l'URL della posizione di origine in Cloud Storage, nel seguente formato: "gs://[PATH_TO_GS]". I caratteri jolly sono supportati.
       Nota: puoi specificare BigQueryField o CloudStorageFileSet in LargeCustomDictionaryConfig, ma non entrambi.
       • outputPath: il percorso della posizione in un bucket Cloud Storage in cui memorizzare il dizionario creato.
   • storedInfoTypeId: l'identificatore per l'infoType archiviato. Utilizza questo identificatore per fare riferimento al infoType memorizzato quando lo ricostruisci, lo elimini o lo utilizzi in un'ispezione o un job di anonimizzazione. Se lasci vuoto questo campo, il sistema genera un identificatore per te.

Di seguito è riportato un esempio di JSON che, se inviato al metodo storedInfoTypes.create, crea un nuovo infoType archiviato, in particolare un rilevatore di dizionario personalizzato di grandi dimensioni. Questo esempio crea un infoType archiviato da un elenco di termini memorizzato in un database BigQuery (bigquery-public-data.samples.github_nested) disponibile pubblicamente. Il database contiene tutti i nomi utente di GitHub utilizzati nei commit. Il percorso di output per il dizionario generato è impostato su un bucket Cloud Storage denominato dlptesting e l'infoType archiviato è denominato github-usernames.

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

Ricostruire il dizionario

Se vuoi aggiornare il dizionario, aggiorna prima l'elenco dei termini di origine, quindi chiedi a Sensitive Data Protection di ricostruire l'elemento infoType archiviato.

1. Aggiorna l'elenco dei termini di origine esistenti in Cloud Storage o BigQuery.

   Aggiungi, rimuovi o modifica i termini o le frasi in base alle esigenze.

2. Crea una nuova versione dell'elemento infoType archiviato "ricostruendolo" utilizzando la console Google Cloud o il metodo storedInfoTypes.patch.

   La ricostruzione crea una nuova versione del dizionario, che sostituisce il vecchio dizionario.

Quando ricostruisci un infoType archiviato in una nuova versione, la versione precedente viene eliminata. Mentre Sensitive Data Protection aggiorna l'infoType archiviato, il relativo stato è "in attesa". Durante questo periodo, la vecchia versione dell'infoType archiviato è ancora presente. Eventuali scansioni eseguite mentre l'infoType archiviato è in stato di attesa verranno eseguite utilizzando la versione precedente dell'infoType archiviato.

Per ricostruire l'infoType archiviato:

Console

1. Aggiorna e salva l'elenco di termini in Cloud Storage o BigQuery.

2. Nella console Google Cloud, vai all'elenco degli infoType archiviati.

   Vai agli infoType archiviati

3. Fai clic sull'ID dell'elemento infoType archiviato che vuoi aggiornare.

4. Nella pagina Dettagli InfoType, fai clic su Ricompila i dati.

Sensitive Data Protection ricostruisce l'infoType archiviato con le modifiche apportate all'elenco dei termini di origine. Quando lo stato dell'infoType archiviato è "Pronto", puoi utilizzarlo. Tutti i modelli o gli attivatori dei job che utilizzano il valore infoType archiviato utilizzeranno automaticamente la versione ricostruita.

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

// 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

use Google\Cloud\Dlp\V2\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\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
    $response = $dlp->updateStoredInfoType($name, [
        'config' => $storedInfoTypeConfig,
        'updateMask' => $fieldMask
    ]);

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

Python

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Aggiornare l'elenco di termini

Se aggiorni solo l'elenco dei termini nel dizionario personalizzato di grandi dimensioni, la richiesta storedInfoTypes.patch richiede solo il campo name. Fornisci il nome completo della risorsa dell'infoType archiviato che vuoi ricostruire.

I seguenti pattern rappresentano voci valide per il campo name:

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

Sostituisci STORED_INFOTYPE_ID con l'identificatore del infoType memorizzato che vuoi ricostruire.

Se non conosci l'identificatore dell'infoType archiviato, chiama il metodo storedInfoTypes.list per visualizzare un elenco di tutti gli infoType attualmente archiviati.

Nota: anche se gli infoType archiviati non hanno numeri di versione, ognuno ha un campo createTime, che viene aggiornato a ogni ricostruzioni. Utilizza il metodo storedInfoTypes.get per recuperare le informazioni sull'infoType archiviato e utilizza il campo createTime per determinare quando è stata eseguita l'ultima ricostruzione.

Esempio

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

In questo caso, non è richiesto un corpo della richiesta.

Cambia l'elenco dei termini di origine

Puoi modificare l'elenco di termini di origine per un infoType archiviato da uno archiviato in BigQuery a uno archiviato in Cloud Storage. Utilizza il metodo storedInfoTypes.patch, ma includi un oggetto CloudStorageFileSet in LargeCustomDictionaryConfig dove in precedenza avevi utilizzato un oggetto BigQueryField. Imposta quindi il parametro updateMask sul parametro infoType almacenato che hai ricostruito, in formato FieldMask. Ad esempio, il seguente JSON indica nel parametro updateMask che l'URL del percorso Cloud Storage è stato aggiornato (large_custom_dictionary.cloud_storage_file_set.url):

Esempio

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

Analogamente, puoi passare da un elenco di termini archiviato in una tabella BigQuery a uno archiviato in un bucket Cloud Storage.

Eseguire la scansione dei contenuti utilizzando un rilevatore di dizionari personalizzati di grandi dimensioni

La scansione dei contenuti utilizzando un rilevatore di dizionari personalizzati di grandi dimensioni è simile alla scansione dei contenuti utilizzando qualsiasi altro rilevatore di infoType personalizzato.

Questa procedura presuppone che tu abbia un infoType archiviato esistente. Per ulteriori informazioni, consulta Creare un infoType archiviato in questa pagina.

Console

Puoi applicare un rilevatore di dizionari personalizzati di grandi dimensioni quando esegui le seguenti operazioni:

• Creazione di un nuovo job
• Creazione o modifica di un attivatore di job
• Creazione o modifica di un modello
• Configurare la profilazione dei dati

Nella sezione Configura rilevamento della pagina, nella sottosezione InfoType, puoi specificare l'infoType del dizionario personalizzato di grandi dimensioni.

1. Fai clic su Gestisci infoType.
2. Nel riquadro InfoType, fai clic sulla scheda Personalizzato.
3. Fai clic su Aggiungi infoType personalizzato.

4. Nel riquadro Aggiungi infoType personalizzato, segui questi passaggi:

   1. In Tipo, seleziona infoType archiviato.
   2. In InfoType, inserisci un nome per l'infoType personalizzato. Puoi utilizzare lettere, numeri e trattini bassi.

   3. Per Probabilità, seleziona il livello di probabilità predefinito da assegnare a tutti i risultati corrispondenti a questo infoType personalizzato. Puoi perfezionare ulteriormente il livello di probabilità dei singoli risultati utilizzando le regole hotword.

      Se non specifichi un valore predefinito, il livello di probabilità predefinito è impostato su VERY_LIKELY. Per ulteriori informazioni, consulta la sezione Probabilità di corrispondenza.

   4. Per Sensibilità, seleziona il livello di sensibilità da assegnare a tutti i risultati corrispondenti a questo infoType personalizzato. Se non specifichi un valore, i livelli di sensibilità di questi risultati vengono impostati su HIGH.

      I punteggi di sensibilità vengono utilizzati nei profili dei dati. Quando esegue il profilo dei tuoi dati, Sensitive Data Protection utilizza i punteggi di sensibilità degli infoType per calcolare il livello di sensibilità.

   5. In Nome infoType archiviato, seleziona l'infoType archiviato su cui vuoi basare il nuovo infoType personalizzato.

   6. Fai clic su Fine per chiudere il riquadro Aggiungi infoType personalizzato.

5. (Facoltativo) Nella scheda Integrato, modifica la selezione degli infoType integrati.

6. Fai clic su Fine per chiudere il riquadro InfoType.

   L'infoType personalizzato viene aggiunto all'elenco di infoType rilevati da Sensitive Data Protection. Tuttavia, questa selezione non è definitiva finché non salvi il job, l'attivatore del job, il modello o la configurazione della scansione.

7. Al termine della creazione o della modifica della configurazione, fai clic su Salva.

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

// 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

use Google\Cloud\Dlp\V2\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\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.
    $response = $dlp->inspectContent([
        'parent' => $parent,
        'inspectConfig' => $inspectConfig,
        'item' => $item
    ]);

    // 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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

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

Quando viene inviato al metodo content.inspect, l'esempio seguente analizza il testo specificato utilizzando il rilevatore infoType memorizzato specificato. Il parametro infoType è obbligatorio perché tutti gli infoType personalizzati devono avere un nome che non entri in conflitto con gli infoType integrati o con altri infoType personalizzati. Il parametro storedType contiene il percorso completo della risorsa dell'infoType archiviato.

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

Risolvere gli errori

Se ricevi un errore durante il tentativo di creare un infoType archiviato da un elenco di termini archiviato in Cloud Storage, le seguenti sono possibili cause:

• Hai raggiunto un limite superiore per gli infoType archiviati. A seconda del problema, esistono diverse soluzioni alternative:
  • Se raggiungi il limite massimo per un singolo file di input in Cloud Storage (200 MB), prova a suddividerlo in più file. Puoi utilizzare più file per assemblare un singolo dizionario personalizzato, a condizione che le dimensioni combinate di tutti i file non superino 1 GB.
  • BigQuery non ha gli stessi limiti di Cloud Storage. Valuta la possibilità di spostare i termini in una tabella BigQuery. La dimensione massima di una colonna del dizionario personalizzato in BigQuery è 1 GB e il numero massimo di righe è 5.000.000.
  • Se il file dell'elenco di termini supera tutti i limiti applicabili per gli elenchi di termini di origine, devi suddividerlo in più file e creare un dizionario per ogni file. Quindi, crea un job di scansione separato per ogni dizionario.
• Uno o più termini non contengono almeno una lettera o un numero. Sensitive Data Protection non può cercare termini composti esclusivamente da spazi o simboli. Deve contenere almeno una lettera o un numero. Esamina l'elenco dei termini per verificare se sono inclusi termini di questo tipo, quindi correggili o eliminali.
• L'elenco di termini contiene una frase con troppi "componenti". Un componente in questo contesto è una sequenza continua contenente solo lettere, solo numeri o solo caratteri non alfabetici e non numerici, come spazi o simboli. Esamina l'elenco dei termini per verificare se sono inclusi termini di questo tipo, quindi correggili o eliminali.
• L'agente di servizio Sensitive Data Protection non ha accesso ai dati dell'origine del dizionario o al bucket Cloud Storage per l'archiviazione dei file del dizionario. Per risolvere il problema, concedi all'agente di servizio Protezione dei dati sensibili il ruolo Amministratore Storage (roles/storage.admin) o i ruoli Proprietario dati BigQuery (roles/bigquery.dataOwner) e Utente job BigQuery (roles/bigquery.jobUser).

Panoramica dell'API

La creazione di un infoType archiviato è obbligatoria se stai creando un rilevatore di dizionari personalizzati di grandi dimensioni.

Nota: se crei un rilevatore di dizionari personalizzati normale o un rilevatore di espressioni regolari, non devi creare un infoType archiviato. È più semplice definirli direttamente nell'oggetto CustomInfoType.

Un infoType archiviato è rappresentato in Sensitive Data Protection dall'oggetto StoredInfoType. È costituito dai seguenti oggetti correlati:

• StoredInfoTypeVersion include la data e l'ora di creazione e gli ultimi cinque messaggi di errore che si sono verificati quando è stata creata la versione corrente.

  • StoredInfoTypeConfig contiene la configurazione dell'elemento infoType archiviato, inclusi il nome e la descrizione. Per un dizionario personalizzato di grandi dimensioni, type deve essere un LargeCustomDictionaryConfig.

    • LargeCustomDictionaryConfig specifica entrambe le seguenti condizioni:
      • La posizione in Cloud Storage o BigQuery dove è archiviato l'elenco di frasi.
      • La posizione in Cloud Storage in cui archiviare i file del dizionario generato.

  • StoredInfoTypeState contiene lo stato della versione più recente e di eventuali versioni in attesa dell'infoType archiviato. Le informazioni sullo stato indicano se il valore infoType memorizzato è in fase di ricostruzione, è pronto per l'uso o non è valido.

Dettagli sulla corrispondenza del dizionario

Di seguito sono riportate indicazioni su come Sensitive Data Protection abbina le parole e le frasi del dizionario. Questi punti si applicano sia ai dizionari personalizzati regolari che a quelli di grandi dimensioni:

• Le parole del dizionario non fanno distinzione tra maiuscole e minuscole. Se il tuo dizionario include Abby, verrà trovata una corrispondenza per abby, ABBY, Abby e così via.
• Tutti i caratteri, nei dizionari o nei contenuti da scansionare, diversi da lettere, cifre e altri caratteri alfabetici contenuti nel piano multilingue di base Unicode sono considerati spazi vuoti durante la ricerca di corrispondenze. Se il dizionario cerca Abby Abernathy, corrisponderà a abby abernathy, Abby, Abernathy, Abby (ABERNATHY) e così via.
• I caratteri che circondano una corrispondenza devono essere di tipo diverso (lettere o cifre) rispetto ai caratteri adiacenti all'interno della parola. Se il dizionario cerca Abi, corrisponderà ai primi tre caratteri di Abi904, ma non di Abigail.
• Le parole del dizionario contenenti caratteri nel piano multilinguale supplementare dello standard Unicode possono produrre risultati imprevisti. Esempi di questi caratteri sono emoji, simboli scientifici e scritture storiche.

Le lettere, i numeri e altri caratteri alfabetici sono definiti come segue:

• Lettere: caratteri con categorie generali Lu, Ll, Lt, Lm o Lo nella specifica Unicode
• Cifre: caratteri con categoria generale Nd nella specifica Unicode
• Altri caratteri alfabetici: caratteri con categoria generale Nl nella specifica Unicode o con proprietà contributiva Other_Alphabetic come definito dallo standard Unicode

Per creare, modificare o eliminare un infoType archiviato, utilizza i seguenti metodi:

• storedInfoTypes.create: crea un nuovo infoType archiviato in base al StoredInfoTypeConfig specificato.
• storedInfoTypes.patch: ricostruisce l'infoType archiviato con un nuovo StoredInfoTypeConfig specificato. Se non viene specificato alcun valore, questo metodo crea una nuova versione dell'infoType memorizzato con il StoredInfoTypeConfig esistente.
• storedInfoTypes.get: recupera il StoredInfoTypeConfig e eventuali versioni in attesa dell'infoType archiviato specificato.
• storedInfoTypes.list: elenca tutti gli infoType attualmente archiviati.
• storedInfoTypes.delete: elimina l'infoType archiviato specificato.