Créer un détecteur de dictionnaire personnalisé volumineux

Cet article explique comment créer et recompiler des dictionnaires personnalisés volumineux. Il aborde également plusieurs scénarios d'erreur.

Quand choisir un dictionnaire personnalisé volumineux plutôt qu'un dictionnaire personnalisé standard ?

Les détecteurs de dictionnaires personnalisés standards suffisent lorsque vous souhaitez analyser votre contenu pour identifier des dizaines de milliers de mots ou d'expressions sensibles. Si votre liste de termes change fréquemment, ou si votre liste change fréquemment, envisagez de créer un dictionnaire personnalisé volumineux, capable de prendre en charge des dizaines de millions de termes.

Remarque :Pour connaître les limites d'utilisation exactes pour les dictionnaires, consultez la page Limites d'utilisation.

Différence entre les dictionnaires personnalisés volumineux et les autres infoTypes personnalisés

Les dictionnaires personnalisés volumineux sont différents des autres infoTypes personnalisés, car chacun d'eux possède deux composants:

• Une liste d'expressions que vous créez et définissez. Cette liste est stockée sous forme de fichier texte dans Cloud Storage ou de colonne dans une table BigQuery.
• Les fichiers de dictionnaire, que la protection des données sensibles génère et stocke dans Cloud Storage. Les fichiers de dictionnaire se composent d'une copie de votre liste de termes et de filtres de floraison, qui facilitent la recherche et la correspondance.

Avertissement : Ne modifiez pas les fichiers de dictionnaires personnalisés directement dans Cloud Storage. Les dictionnaires deviendraient non valides et inutilisables.

Créer un dictionnaire personnalisé volumineux

Cette section explique comment créer, modifier et recompiler un dictionnaire personnalisé volumineux.

Créer une liste de termes

Créez une liste contenant tous les mots et expressions que le nouveau détecteur d'infoType doit rechercher. Effectuez l'une des opérations suivantes :

• Vous pouvez placer dans un bucket Cloud Storage un fichier texte où chaque mot ou expression figure sur une ligne individuelle.
• Désignez une colonne d'une table BigQuery comme conteneur pour les mots et les expressions. Attribuez à chaque entrée sa propre ligne dans la colonne. Vous pouvez utiliser une table BigQuery existante, à condition que tous les mots et expressions du dictionnaire figurent dans une seule colonne.

Il est possible d'assembler une liste de termes trop longue pour que la protection des données sensibles puisse la traiter. Si un message d'erreur s'affiche, consultez la section Résoudre les erreurs plus loin dans cet article.

Créer un infoType stocké

Après avoir créé votre liste de termes, utilisez la protection des données sensibles pour créer un dictionnaire:

Console

1. Dans un bucket Cloud Storage, créez un dossier dans lequel la protection des données sensibles stockera le dictionnaire généré.

   La protection des données sensibles crée des dossiers contenant les fichiers de dictionnaire à l'emplacement que vous spécifiez.

2. Dans la console Google Cloud, accédez à la page Créer un infoType.

   Accéder à la page "Créer un infoType"

3. Dans le champ Type, sélectionnez Grand dictionnaire personnalisé.

4. Dans le champ ID de l'infoType, saisissez un identifiant pour l'infoType stocké.

   Vous utiliserez cet identifiant lors de la configuration de vos tâches d'inspection et d'anonymisation. Vous pouvez utiliser des lettres, des chiffres, des traits d'union et des traits de soulignement dans le nom.

5. Dans le champ Nom à afficher de l'infoType, saisissez un nom pour votre infoType stocké.

   Vous pouvez utiliser des espaces et des signes de ponctuation.

6. Dans le champ Description, saisissez une description de ce que votre infoType stocké détecte.

7. Dans le champ Type de stockage, sélectionnez l'emplacement de votre liste de termes:

   • BigQuery: saisissez l'ID du projet, l'ID de l'ensemble de données et l'ID de la table. Dans le champ Nom du champ, saisissez l'identifiant de la colonne. Vous pouvez désigner au maximum une colonne de la table.
   • Google Cloud Storage: saisissez le chemin d'accès au fichier.

8. Dans le champ Bucket ou dossier de sortie, saisissez l'emplacement Cloud Storage du dossier que vous avez créé à l'étape 1.

   Remarque : Ne placez pas de fichiers dans les dossiers créés par la protection des données sensibles lorsqu'elle compile votre dictionnaire. Lorsque la protection des données sensibles crée ou recompile des fichiers de dictionnaire, elle supprime tous les autres fichiers stockés dans les dossiers qu'elle crée. Tous les dossiers au même niveau que ceux créés par la protection des données sensibles sont conservés.

9. Cliquez sur Créer.

Un résumé de l'infoType stocké s'affiche. Lorsque le dictionnaire est généré et que le nouvel infoType stocké est prêt à être utilisé, l'état de l'infoType indique Ready (Prêt).

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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. Créez un dossier pour le dictionnaire dans un bucket Cloud Storage. La protection des données sensibles crée des dossiers contenant les fichiers de dictionnaire à l'emplacement que vous spécifiez.
Remarque : Ne placez pas de fichiers dans les dossiers créés par la protection des données sensibles lorsqu'elle compile votre dictionnaire. Lorsqu'elle crée ou recompile des fichiers de dictionnaire, la protection des données sensibles supprime tous les autres fichiers stockés dans les dossiers qu'elle crée. Tous les dossiers situés au même niveau que ceux créés par la protection des données sensibles seront conservés.
2. Créez le dictionnaire à l'aide de la méthode storedInfoTypes.create. La méthode create utilise les paramètres suivants :
   • Un objet StoredInfoTypeConfig, qui contient la configuration de l'infoType stocké. Il inclut les éléments suivants :
     • description : la description du dictionnaire.
     • displayName : le nom que vous souhaitez donner au dictionnaire.
     • LargeCustomDictionaryConfig : contient la configuration du dictionnaire personnalisé volumineux. Il inclut les éléments suivants :
       • BigQueryField : spécifié si la liste de termes est stockée dans BigQuery. Inclut une référence à la table dans laquelle votre liste est stockée, ainsi qu'au champ qui contient chaque expression du dictionnaire.
       • CloudStorageFileSet : spécifié si la liste de termes est stockée dans Cloud Storage. Comprend l'URL de l'emplacement source dans Cloud Storage, au format suivant : "gs://[PATH_TO_GS]". Les caractères génériques sont acceptés.
       Remarque : Vous pouvez spécifier BigQueryField ou CloudStorageFileSet dans LargeCustomDictionaryConfig, mais pas les deux.
       • outputPath : chemin de l'emplacement au sein d'un bucket Cloud Storage où sera stocké le dictionnaire créé.
   • storedInfoTypeId: identifiant de l'infoType stocké. Cet identifiant vous permet de faire référence à l'infoType stocké lorsque vous le recompilez, le supprimez ou l'utilisez dans une tâche d'inspection ou d'anonymisation. Si vous laissez ce champ vide, le système génère un identifiant pour vous.

Voici un exemple de code JSON qui, lorsqu'il est envoyé à la méthode storedInfoTypes.create, crée un infoType stocké, plus précisément un détecteur de dictionnaire personnalisé volumineux. Cet exemple crée un infoType stocké à partir d'une liste de termes stockée dans une base de données BigQuery publique (bigquery-public-data.samples.github_nested). La base de données contient tous les noms d'utilisateur GitHub utilisés dans les commits. Le chemin de sortie du dictionnaire généré est défini sur un bucket Cloud Storage nommé dlptesting, et l'infoType stocké est nommé github-usernames.

Entrée 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"
}

Recompiler le dictionnaire

Si vous souhaitez mettre à jour votre dictionnaire, vous devez d'abord mettre à jour votre liste source de termes, puis demander à la protection des données sensibles de recompiler l'infoType stocké.

1. Mettez à jour la liste source de termes existante dans Cloud Storage ou BigQuery.

   Ajoutez, supprimez ou modifiez les termes ou les expressions selon vos besoins.

2. Créez une nouvelle version de l'infoType stocké en la "recompilant" à l'aide de la console Google Cloud ou de la méthode storedInfoTypes.patch.

   La recompilation entraîne la création d'une nouvelle version du dictionnaire, qui remplace l'ancien.

Lorsque vous recompilez un infoType stocké dans une nouvelle version, l'ancienne version est supprimée. Pendant que la protection des données sensibles met à jour l'infoType stocké, son état est "en attente". Pendant ce temps, l'ancienne version de l'infoType stocké existe toujours. Toutes les analyses que vous exécutez alors que l'infoType stocké est en attente seront exécutées en utilisant l'ancienne version de l'infoType stocké.

Pour recompiler l'infoType stocké:

Console

1. Mettez à jour et enregistrez votre liste de termes dans Cloud Storage ou BigQuery.

2. Dans la console Google Cloud, accédez à la liste des infoTypes stockés.

   Accéder à la page "infoTypes stockés"

3. Cliquez sur l'ID de l'infoType stocké que vous souhaitez mettre à jour.

4. Sur la page Détails de l'infoType, cliquez sur Recompiler les données.

La protection des données sensibles recompile l'infoType stocké avec les modifications que vous avez apportées à la liste source des termes. Une fois que l'infoType stocké affiche l'état "Prêt", vous pouvez l'utiliser. Tous les modèles ou déclencheurs de tâche qui utilisent l'infoType stocké utilisent automatiquement la version recompilée.

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Mettre à jour la liste de termes

Si vous ne mettez à jour que la liste de termes du dictionnaire personnalisé volumineux, votre requête storedInfoTypes.patch ne requiert que le champ name. Indiquez le nom de ressource complet de l'infoType stocké que vous souhaitez recompiler.

Les schémas suivants représentent des saisies valides pour le champ name :

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

Remplacez STORED_INFOTYPE_ID par l'identifiant de l'infoType stocké que vous souhaitez recompiler.

Si vous ne connaissez pas l'identifiant de l'infoType stocké, appelez la méthode storedInfoTypes.list pour afficher la liste de tous les infoTypes stockés actuels.

Remarque :Bien que les infoTypes stockés n'aient pas de numéro de version, chacun d'eux possède un champ createTime, qui est actualisé à chaque recompilation. Utilisez la méthode storedInfoTypes.get pour récupérer des informations sur l'infoType stocké, puis utilisez le champ createTime pour déterminer la date de sa dernière recompilation.

Exemple

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

Dans ce cas, le corps de la requête n'est pas obligatoire.

Changer de liste source de termes

Vous pouvez modifier la liste source de termes associée à un infoType stocké, en passant d'un infoType stocké dans BigQuery à un autre stocké dans Cloud Storage. Utilisez la méthode storedInfoTypes.patch, mais incluez un objet CloudStorageFileSet dans LargeCustomDictionaryConfig là où vous aviez utilisé un objet BigQueryField auparavant. Ensuite, définissez le paramètre updateMask sur le paramètre d'infoType stocké que vous avez recompilé, au format FieldMask. Par exemple, l'exemple JSON suivant indique dans le paramètre updateMask que l'URL du chemin d'accès Cloud Storage a été mise à jour (large_custom_dictionary.cloud_storage_file_set.url):

Exemple

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

De même, vous pouvez passer d'une liste de termes stockée dans une table BigQuery à une liste stockée dans un bucket Cloud Storage.

Analyser du contenu à l'aide d'un détecteur de dictionnaire personnalisé volumineux

L'analyse de contenu à l'aide d'un détecteur de dictionnaire personnalisé volumineux est semblable à l'analyse de contenu à l'aide de tout autre détecteur d'infoType personnalisé.

Cette procédure suppose que vous disposez déjà d'un infoType stocké. Pour en savoir plus, consultez la section Créer un infoType stocké sur cette page.

Console

Vous pouvez appliquer un détecteur de dictionnaire personnalisé volumineux lorsque vous effectuez les opérations suivantes:

• Créer une tâche
• Créer ou modifier un déclencheur de tâche
• Créer ou modifier un modèle
• Configurer le profilage des données

Dans la section Configurer la détection, dans la sous-section InfoTypes, vous pouvez spécifier votre infoType de dictionnaire personnalisé volumineux.

1. Cliquez sur Gérer les infoTypes.
2. Dans le volet InfoTypes, cliquez sur l'onglet Personnalisé.
3. Cliquez sur Ajouter un infoType personnalisé.

4. Dans le volet Ajouter un infoType personnalisé, procédez comme suit:

   1. Dans le champ Type, sélectionnez Stored infoType (infoType stocké).
   2. Pour InfoType, saisissez un nom pour l'infoType personnalisé. Vous pouvez utiliser des lettres, des chiffres et des traits de soulignement.

   3. Dans le champ Probabilité, sélectionnez le niveau de probabilité par défaut que vous souhaitez attribuer à tous les résultats correspondant à cet infoType personnalisé. Vous pouvez affiner le niveau de probabilité de résultats individuels à l'aide de règles relatives aux mots clés.

      Si vous ne spécifiez pas de valeur par défaut, le niveau de probabilité par défaut est défini sur VERY_LIKELY. Pour en savoir plus, consultez la section Probabilité de correspondance.

   4. Pour Sensibilité, sélectionnez le niveau de sensibilité que vous souhaitez attribuer à tous les résultats correspondant à cet infoType personnalisé. Si vous ne spécifiez pas de valeur, les niveaux de sensibilité de ces résultats sont définis sur HIGH.

      Les scores de sensibilité sont utilisés dans les profils de données. Lors du profilage des données, la protection des données sensibles utilise les scores de sensibilité des infoTypes pour calculer le niveau de sensibilité.

   5. Dans le champ Nom de l'infoType stocké, sélectionnez l'infoType stocké sur lequel vous souhaitez baser le nouvel infoType personnalisé.

   6. Cliquez sur OK pour fermer le volet Ajouter un infoType personnalisé.

5. Facultatif: Dans l'onglet Intégré, modifiez votre sélection d'infoTypes intégrés.

6. Cliquez sur OK pour fermer le volet InfoTypes.

   L'infoType personnalisé est ajouté à la liste des infoTypes que la protection des données sensibles recherche. Toutefois, cette sélection n'est pas définitive tant que vous n'avez pas enregistré la tâche, le déclencheur de tâche, le modèle ou la configuration de l'analyse.

7. Lorsque vous avez terminé de créer ou de modifier la configuration, cliquez sur Enregistrer.

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

Afficher sur GitHub Commentaires

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

Lorsqu'il est envoyé à la méthode content.inspect, l'exemple suivant analyse le texte donné à l'aide du détecteur d'infoType stocké spécifié. Le paramètre infoType est obligatoire, car tous les infoTypes personnalisés doivent avoir un nom qui n'entre pas en conflit avec les infoTypes intégrés ni avec les autres infoTypes personnalisés. Le paramètre storedType contient le chemin d'accès complet à la ressource de l'infoType stocké.

Entrée 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."
  }
}

Résoudre les erreurs

Si vous rencontrez une erreur lorsque vous tentez de créer un infoType stocké à partir d'une liste de termes stockée dans Cloud Storage, voici les causes possibles:

• Vous avez atteint une limite supérieure pour les infoTypes stockés. Selon le problème, il existe plusieurs solutions de contournement :
  • Si vous avez atteint la limite supérieure pour un seul fichier d'entrée dans Cloud Storage (200 Mo), essayez de le diviser en plusieurs fichiers. Vous pouvez utiliser plusieurs fichiers pour assembler un seul dictionnaire personnalisé, à condition que la taille combinée de tous les fichiers ne dépasse pas 1 Go.
  • BigQuery n'a pas les mêmes limites que Cloud Storage. Envisagez de déplacer les termes dans une table BigQuery. La taille maximale d'une colonne de dictionnaire personnalisé dans BigQuery est de 1 Go, et le nombre maximal de lignes est de 5 000 000.
  • Si votre fichier de liste de termes dépasse toutes les limites applicables aux listes sources de termes, vous devez le diviser en plusieurs fichiers et créer un dictionnaire pour chacun d'eux. Créez ensuite une tâche d'analyse distincte pour chaque dictionnaire.
• Un ou plusieurs de vos termes ne contiennent pas au moins une lettre ou un chiffre. La protection des données sensibles ne peut pas rechercher de termes composés uniquement d'espaces ou de symboles. Un terme doit comporter au moins une lettre ou un chiffre. Vérifiez si votre liste inclut de tels termes. Le cas échéant, corrigez-les ou supprimez-les.
• Votre liste de termes contient une expression avec trop de "composants". Dans ce contexte, un composant est une séquence continue ne contenant que des lettres, que des chiffres, ou que des caractères autres que des lettres et des chiffres, tels que des espaces ou des symboles. Vérifiez si votre liste inclut de tels termes. Le cas échéant, corrigez-les ou supprimez-les.
• L'agent de service de protection des données sensibles n'a pas accès aux données sources du dictionnaire ni au bucket Cloud Storage pour stocker les fichiers du dictionnaire. Pour résoudre ce problème, attribuez à l'agent de service de protection des données sensibles les rôles Administrateur de l'espace de stockage (roles/storage.admin) ou Propriétaire de données BigQuery (roles/bigquery.dataOwner) et Utilisateur de tâche BigQuery (roles/bigquery.jobUser).

Présentation de l'API

La création d'un infoType stocké est nécessaire si vous créez un détecteur de dictionnaire personnalisé volumineux.

Remarque :Si vous créez un détecteur de dictionnaire personnalisé standard ou un détecteur d'expression régulière, vous n'avez pas besoin de créer un infoType stocké. Il est plus simple de les définir directement dans l'objet CustomInfoType.

Un infoType stocké est représenté dans la protection des données sensibles par l'objet StoredInfoType. Il se compose des objets associés suivants:

• StoredInfoTypeVersion inclut la date et l'heure de création, ainsi que les cinq derniers messages d'erreur survenus lors de la création de la version actuelle.

  • StoredInfoTypeConfig contient la configuration de l'infoType stocké, y compris son nom et sa description. Pour un dictionnaire personnalisé volumineux, type doit être un LargeCustomDictionaryConfig.

    • LargeCustomDictionaryConfig spécifie les deux éléments suivants :
      • L'emplacement dans Cloud Storage ou BigQuery où votre liste d'expressions est stockée
      • L'emplacement dans Cloud Storage qui sert à stocker les fichiers de dictionnaire générés

  • StoredInfoTypeState contient l'état de la version la plus récente de l'infoType stocké, ainsi que toutes ses versions en attente. Les informations d'état indiquent si l'infoType stocké est en cours de recompilation, prêt à être utilisé ou non valide.

Caractéristiques des correspondances avec le dictionnaire

Vous trouverez ci-dessous des conseils sur la manière dont la protection des données sensibles établit une correspondance avec les mots et les expressions du dictionnaire. Les points suivants s'appliquent aux dictionnaires personnalisés standards et volumineux:

• Les mots du dictionnaire sont insensibles à la casse. Si votre dictionnaire inclut le nom Abby, il y aura correspondance avec les noms abby, ABBY, Abby, etc.
• Tous les caractères (dans les dictionnaires ou dans les contenus à analyser) autres que les lettres et les chiffres figurant dans le plan multilingue de base d'Unicode sont considérés comme des espaces lors de la recherche de correspondances. Si votre dictionnaire recherche Abby Abernathy, il y aura correspondance avec abby abernathy, Abby, Abernathy, Abby (ABERNATHY), etc.
• Les caractères entourant une correspondance doivent être d'un type différent (lettres ou chiffres) des caractères adjacents au sein du mot. Si votre dictionnaire recherche le nom Abi, il y aura correspondance avec les trois premiers caractères de Abi904, mais pas de Abigail.
• Les mots du dictionnaire contenant des caractères du plan multilingue supplémentaire de la norme Unicode peuvent produire des résultats inattendus. comme le chinois, le japonais, le coréen ou les emoji.

Pour créer, modifier ou supprimer un infoType stocké, servez-vous des méthodes suivantes :

• storedInfoTypes.create : crée un infoType stocké en fonction de la configuration StoredInfoTypeConfig spécifiée.
• storedInfoTypes.patch : recompile l'infoType stocké avec un nouveau StoredInfoTypeConfig que vous spécifiez. Si aucune valeur n'est spécifiée, cette méthode crée une nouvelle version de l'infoType stocké avec l'élément StoredInfoTypeConfig existant.
• storedInfoTypes.get : récupère l'objet StoredInfoTypeConfig et toutes les versions en attente de l'infoType stocké spécifié.
• storedInfoTypes.list : répertorie tous les infoTypes stockés actuels.
• storedInfoTypes.delete : supprime l'infoType stocké spécifié.