Cloud Data Loss Prevention (Cloud DLP) fait désormais partie de la protection des données sensibles. Le nom de l'API reste le même: API Cloud Data Loss Prevention (API DLP). Pour en savoir plus sur les services qui composent la protection des données sensibles, consultez Présentation de la protection des données sensibles.

Cette page a été traduite par l'API Cloud Translation.

Créer des modèles d'inspection Sensitive Data Protection

Cette rubrique explique en détail comment créer un modèle d'inspection. Pour savoir rapidement comment créer un modèle d'inspection à l'aide de la console Google Cloud, consultez le guide de démarrage rapide: Créer un modèle d'inspection Sensitive Data Protection.

À propos des modèles

Vous pouvez utiliser des modèles pour créer et conserver des informations de configuration à utiliser avec la protection des données sensibles. Les modèles sont utiles pour dissocier les informations de configuration : d'un côté, les éléments que vous inspectez, et d'un autre côté, la méthode utilisée dans la mise en œuvre des requêtes pour supprimer l'identification de ces éléments. Les modèles constituent une solution pour réutiliser des configurations. Ils garantissent en outre une plus grande cohérence pour les utilisateurs et pour les ensembles de données. En outre, chaque fois que vous mettez à jour un modèle, la mise à jour s'applique également dans n'importe quel déclencheur de tâche qui l'utilise.

Sensitive Data Protection prend en charge les modèles d'inspection (décrits dans cette rubrique) et les modèles de suppression de l'identification (décrits dans la section Créer des modèles d'anonymisation Sensitive Data Protection).

Pour obtenir des informations sur le concept de modèle dans la protection des données sensibles, consultez la page Modèles.

Créer un modèle d'inspection

Console

Dans la console Google Cloud, accédez à la page Créer un modèle.

Accéder à la page "Créer un modèle"

La page Créer un modèle contient les sections suivantes:

Définir le modèle
Configurer la détection

Définir le modèle

Dans le champ Définir le modèle, saisissez un identifiant pour le modèle d'inspection. Vous en aurez besoin pour référencer le modèle lorsque vous exécuterez une tâche, créerez un déclencheur de tâche, etc. Vous pouvez utiliser des lettres, des chiffres et des traits d'union. Si vous le souhaitez, vous pouvez également saisir un nom à afficher plus convivial, ainsi qu'une description pour mieux mémoriser le rôle du modèle.

Dans le champ Emplacement des ressources, sélectionnez la région dans laquelle les données à inspecter sont stockées. Le modèle d'inspection que vous créez est également stocké dans cette région. Si vous souhaitez pouvoir utiliser le nouveau modèle d'inspection dans n'importe quelle région, sélectionnez Global (any region) (Monde (n'importe quelle région)).

Configurer la détection

Vous configurez ensuite les éléments que la protection des données sensibles doit détecter dans votre contenu en choisissant un infoType et d'autres options.

Les détecteurs d'infoType trouvent des données sensibles d'un certain type. Par exemple, le détecteur d'infoType US_SOCIAL_SECURITY_NUMBER de la protection des données sensibles trouve les numéros de sécurité sociale américains. Outre les détecteurs d'infoTypes intégrés, vous pouvez créer vos propres détecteurs d'infoTypes personnalisés.

Dans la section InfoTypes, choisissez le détecteur d'infoType qui correspond au type de données que vous souhaitez analyser. Nous vous recommandons de ne pas laisser cette section vide. La protection des données sensibles analyse alors vos données avec un ensemble d'infoTypes par défaut, qui peut inclure des infoTypes dont vous n'avez pas besoin. Vous trouverez plus d'informations sur chaque détecteur dans la documentation de référence sur les détecteurs d'infoType.

Pour en savoir plus sur la gestion des infoTypes intégrés et personnalisés dans cette section, consultez Gérer les infoTypes via la console Google Cloud.

Ensembles de règles d'inspection

Les ensembles de règles d'inspection vous permettent de personnaliser à la fois les détecteurs d'infoTypes intégrés et personnalisés à l'aide de règles de contexte. Les deux types de règles d'inspection sont les suivants :

Les règles d'exclusion, qui permettent d'exclure des résultats faux ou indésirables
Les règles relatives aux mots clés, qui permettent d'identifier des résultats supplémentaires

Pour ajouter un ensemble de règles, spécifiez d'abord un ou plusieurs détecteurs d'infoType intégrés ou personnalisés dans la section InfoTypes. Il s'agit des détecteurs d'infoTypes que vos règles vont modifier. Ensuite, procédez comme suit :

Cliquez dans le champ Choisir des infoTypes. L'infoType ou les infoTypes que vous avez spécifiés précédemment s'affichent sous le champ dans un menu, comme illustré ci-dessous:

Capture d'écran de la configuration des règles d'inspection de l'interface utilisateur DLP.

Choisissez un infoType dans le menu, puis cliquez sur Ajouter une règle. Un menu s'affiche avec les deux options Règle relative aux mots clés et Règle d'exclusion.

Pour les règles relatives aux mots clés, sélectionnez Règles relatives aux mots clés. Ensuite, procédez comme suit :

Dans le champ Mot clé, saisissez une expression régulière que la protection des données sensibles doit rechercher.
Dans le menu Proximité du mot clé, indiquez si le mot clé que vous avez saisi doit être trouvé avant ou après l'infoType choisi.
Dans Distance des mots clés depuis l'infoType, saisissez le nombre approximatif de caractères entre le mot clé et l'infoType choisi.
Dans Ajustement du niveau de confiance, choisissez d'attribuer aux correspondances un niveau de probabilité fixe, ou d'augmenter ou de diminuer le niveau de probabilité par défaut d'une certaine valeur.

Pour les règles d'exclusion, sélectionnez Règles d'exclusion. Ensuite, procédez comme suit :

Dans le champ Exclure, saisissez une expression régulière que la protection des données sensibles doit rechercher.
Dans le menu Type de correspondance, sélectionnez l'une des options suivantes:

Correspondance exacte: le résultat doit correspondre entièrement à l'expression régulière.
Correspondance partielle: une sous-chaîne du résultat peut correspondre à l'expression régulière.
Correspondance inverse: le résultat ne correspond pas à l'expression régulière.

Vous pouvez ajouter des règles et des ensembles de règles d'exclusion ou de mots clés pour affiner davantage les résultats de votre analyse.

Seuil de confiance

Chaque fois que la protection des données sensibles détecte une correspondance potentielle pour des données sensibles, elle lui attribue une valeur de probabilité sur une échelle allant de "Très peu probable" à "Très probable". Lorsque vous définissez une valeur de probabilité ici, vous demandez à Sensitive Data Protection de ne faire correspondre que les données qui correspondent à cette valeur de probabilité ou plus.

La valeur par défaut "Possible" est suffisante dans la plupart des cas. Si vous obtenez régulièrement des correspondances trop larges lorsque vous utilisez ce modèle, déplacez le curseur vers le haut. Si vous obtenez trop peu de correspondances, déplacez le curseur vers le bas.

Lorsque vous avez terminé, cliquez sur Créer pour générer le modèle. La page d'informations récapitulatives du modèle apparaît.

Pour revenir à la page principale de la protection des données sensibles, cliquez sur la flèche Retour de la console Google Cloud.

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez la page Bibliothèques clientes de 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.


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

public class InspectTemplateCreate
{
    public static InspectTemplate Create(
        string projectId,
        string templateId,
        string displayName,
        string description,
        Likelihood likelihood,
        int maxFindings,
        bool includeQuote)
    {
        var client = DlpServiceClient.Create();

        var request = new CreateInspectTemplateRequest
        {
            Parent = new LocationName(projectId, "global").ToString(),
            InspectTemplate = new InspectTemplate
            {
                DisplayName = displayName,
                Description = description,
                InspectConfig = new InspectConfig
                {
                    MinLikelihood = likelihood,
                    Limits = new InspectConfig.Types.FindingLimits
                    {
                        MaxFindingsPerRequest = maxFindings
                    },
                    IncludeQuote = includeQuote
                },
            },
            TemplateId = templateId
        };

        var response = client.CreateInspectTemplate(request);

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

        return response;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

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

// createInspectTemplate creates a template with the given configuration.
func createInspectTemplate(w io.Writer, projectID string, templateID, displayName, description string, infoTypeNames []string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"
	// displayName := "My Template"
	// description := "My template description"
	// infoTypeNames := []string{"US_SOCIAL_SECURITY_NUMBER"}

	ctx := context.Background()

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

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

	// Create a configured request.
	req := &dlppb.CreateInspectTemplateRequest{
		Parent:     fmt.Sprintf("projects/%s/locations/global", projectID),
		TemplateId: templateID,
		InspectTemplate: &dlppb.InspectTemplate{
			DisplayName: displayName,
			Description: description,
			InspectConfig: &dlppb.InspectConfig{
				InfoTypes:     infoTypes,
				MinLikelihood: dlppb.Likelihood_POSSIBLE,
				Limits: &dlppb.InspectConfig_FindingLimits{
					MaxFindingsPerRequest: 10,
				},
			},
		},
	}
	// Send the request.
	resp, err := client.CreateInspectTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateInspectTemplate: %w", err)
	}
	// Print the result.
	fmt.Fprintf(w, "Successfully created inspect template: %v", resp.GetName())
	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CreateInspectTemplateRequest;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class TemplatesCreate {

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

  // Creates a template to persist configuration information
  public static void createInspectTemplate(String projectId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpServiceClient = DlpServiceClient.create()) {
      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      List<InfoType> infoTypes =
          Stream.of("PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());

      // Construct the inspection configuration for the template
      InspectConfig inspectConfig = InspectConfig.newBuilder().addAllInfoTypes(infoTypes).build();

      // Optionally set a display name and a description for the template
      String displayName = "Inspection Config Template";
      String description = "Save configuration for future inspection jobs";

      // Build the template
      InspectTemplate inspectTemplate =
          InspectTemplate.newBuilder()
              .setInspectConfig(inspectConfig)
              .setDisplayName(displayName)
              .setDescription(description)
              .build();

      // Create the request to be sent by the client
      CreateInspectTemplateRequest createInspectTemplateRequest =
          CreateInspectTemplateRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectTemplate(inspectTemplate)
              .build();

      // Send the request to the API and process the response
      InspectTemplate response =
          dlpServiceClient.createInspectTemplate(createInspectTemplateRequest);
      System.out.printf("Template created: %s", response.getName());
    }
  }
}

Node.js

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

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

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

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

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

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

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

// Whether to include the matching string
// const includeQuote = true;

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

// (Optional) The human-readable name to give the template
// const displayName = 'My template';

async function createInspectTemplate() {
  // Construct the inspection configuration for the template
  const inspectConfig = {
    infoTypes: infoTypes,
    minLikelihood: minLikelihood,
    includeQuote: includeQuote,
    limits: {
      maxFindingsPerRequest: maxFindings,
    },
  };

  // Construct template-creation request
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectTemplate: {
      inspectConfig: inspectConfig,
      displayName: displayName,
    },
    templateId: templateId,
  };

  const [response] = await dlp.createInspectTemplate(request);
  const templateName = response.name;
  console.log(`Successfully created template ${templateName}.`);
}
createInspectTemplate();

PHP

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

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CreateInspectTemplateRequest;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits;
use Google\Cloud\Dlp\V2\InspectTemplate;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Create a new DLP inspection configuration template.
 *
 * @param string $callingProjectId project ID to run the API call under
 * @param string $templateId       name of the template to be created
 * @param string $displayName      (Optional) The human-readable name to give the template
 * @param string $description      (Optional) A description for the trigger to be created
 * @param int    $maxFindings      (Optional) The maximum number of findings to report per request (0 = server maximum)
 */
function create_inspect_template(
    string $callingProjectId,
    string $templateId,
    string $displayName = '',
    string $description = '',
    int $maxFindings = 0
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

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

    // Whether to include the matching string in the response
    $includeQuote = true;

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

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

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

    // Construct inspection template
    $inspectTemplate = (new InspectTemplate())
        ->setInspectConfig($inspectConfig)
        ->setDisplayName($displayName)
        ->setDescription($description);

    // Run request
    $parent = "projects/$callingProjectId/locations/global";
    $createInspectTemplateRequest = (new CreateInspectTemplateRequest())
        ->setParent($parent)
        ->setInspectTemplate($inspectTemplate)
        ->setTemplateId($templateId);
    $template = $dlp->createInspectTemplate($createInspectTemplateRequest);

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

Python

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

from typing import List
from typing import Optional

import google.cloud.dlp


def create_inspect_template(
    project: str,
    info_types: List[str],
    template_id: Optional[str] = None,
    display_name: Optional[str] = None,
    min_likelihood: Optional[int] = None,
    max_findings: Optional[int] = None,
    include_quote: Optional[bool] = None,
) -> None:
    """Creates a Data Loss Prevention API inspect template.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        info_types: A list of strings representing info types to look for.
            A full list of info type categories can be fetched from the API.
        template_id: The id of the template. If omitted, an id will be randomly
            generated.
        display_name: The optional display name of the template.
        min_likelihood: A string representing the minimum likelihood threshold
            that constitutes a match. One of: 'LIKELIHOOD_UNSPECIFIED',
            'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE', 'LIKELY', 'VERY_LIKELY'.
        max_findings: The maximum number of findings to report; 0 = no maximum.
        include_quote: Boolean for whether to display a quote of the detected
            information in the results.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

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

    inspect_template = {
        "inspect_config": inspect_config,
        "display_name": display_name,
    }

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

    # Call the API.
    response = dlp.create_inspect_template(
        request={
            "parent": parent,
            "inspect_template": inspect_template,
            "template_id": template_id,
        }
    )

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

REST

Un modèle d'inspection est une configuration d'inspection réutilisable qui comprend des métadonnées. En termes d'API, l'objet InspectTemplate est de facto un objet InspectConfig qui inclut quelques champs de métadonnées supplémentaires, tels qu'un nom à afficher et une description. Par conséquent, pour créer un modèle d'inspection, vous devez effectuer les étapes de base suivantes :

Commencez avec un objet InspectConfig.
Appelez la méthode create de la ressource projects.inspectTemplates ou organizations.inspectTemplates (ou envoyez-lui une requête POST), en incluant dans la requête un objet InspectTemplate contenant un nom à afficher, une description et l'objet InspectConfig.

Le modèle InspectTemplate renvoyé est utilisable immédiatement. Vous pouvez faire référence à ce modèle dans d'autres appels ou d'autres tâches en spécifiant son nom (name). Vous pouvez répertorier les modèles existants en appelant la méthode *.inspectTemplates.list. Pour afficher un modèle spécifique, appelez la méthode *.inspectTemplates.get. Notez que vous pouvez créer au maximum 1 000 modèles.

Si vous avez déjà effectué une inspection de texte, d'images ou de contenus structurés afin d'identifier des contenus sensibles à l'aide de la protection des données sensibles, vous avez déjà créé un objet InspectConfig. Une étape supplémentaire permet de transformer un objet de ce type en objet InspectTemplate.

Le code JSON suivant est un exemple de ce que vous pouvez envoyer à la méthode projects.inspectTemplates.create. Ce code JSON crée un modèle avec le nom à afficher et la description indiqués, puis recherche les correspondances sur les infoTypes PHONE_NUMBER et US_TOLLFREE_PHONE_NUMBER. Les résultats renvoyés incluront jusqu'à 100 correspondances dont la probabilité est au moins égale à POSSIBLE, ainsi qu'un extrait de contexte pour chacune d'entre d'elles.

Entrée JSON :

POST https://dlp.googleapis.com/v2/projects/[PROJECT_ID]/inspectTemplates?key={YOUR_API_KEY}

{
  "inspectTemplate":{
    "displayName":"Phone number inspection",
    "description":"Scans for phone numbers",
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"PHONE_NUMBER"
        },
        {
          "name":"US_TOLLFREE_PHONE_NUMBER"
        }
      ],
      "minLikelihood":"POSSIBLE",
      "limits":{
        "maxFindingsPerRequest":100
      },
      "includeQuote":true
    }
  }
}

Sortie JSON :

La réponse JSON ressemblera à ceci :

{
  "name":"projects/[PROJECT_ID]/inspectTemplates/[JOB_ID]",
  "displayName":"Phone number inspection",
  "description":"Scans for phone numbers",
  "createTime":"2018-11-30T07:26:28.164136Z",
  "updateTime":"2018-11-30T07:26:28.164136Z",
  "inspectConfig":{
    "infoTypes":[
      {
        "name":"PHONE_NUMBER"
      },
      {
        "name":"US_TOLLFREE_PHONE_NUMBER"
      }
    ],
    "minLikelihood":"POSSIBLE",
    "limits":{
      "maxFindingsPerRequest":100
    },
    "includeQuote":true
  }
}

Pour tester rapidement ce code, utilisez APIs Explorer, intégré ci-dessous. Pour en savoir plus sur l'utilisation du format JSON pour envoyer des requêtes à l'API DLP, consultez le guide de démarrage rapide JSON.

Utiliser des modèles d'inspection

Après avoir créé un modèle d'inspection, vous pouvez l'utiliser lors de la création d'une tâche d'inspection ou d'un déclencheur de tâche. Chaque fois que vous mettez à jour ce modèle, la mise à jour s'applique également dans n'importe quel déclencheur de tâche qui l'utilise. Pour en savoir plus et obtenir des exemples de code, consultez les pages suivantes :

Console

Pour commencer rapidement à utiliser votre nouveau modèle, suivez les instructions fournies dans le guide de démarrage rapide : Créer un modèle d'inspection Sensitive Data Protection en appliquant la modification suivante :

Dans la section Configurer la détection > Modèles, cliquez dans le champ Nom du modèle et sélectionnez le modèle que vous venez de créer.

Pour une explication plus détaillée sur l'analyse de contenu, consultez la page Créer et planifier des tâches d'inspection de la protection des données sensibles, en prêtant une attention particulière à la section Configurer la détection.

REST

Vous pouvez utiliser l'identifiant du modèle que vous avez spécifié lors de sa création partout où les modèles de type inspectTemplateName sont acceptés, par exemple :

projects.content.inspect : recherche des données potentiellement sensibles dans le contenu en utilisant le modèle comme configuration.
projects.content.deidentify : recherche et anonymise les données potentiellement sensibles dans le contenu en utilisant le modèle comme configuration. Sachez que cette méthode utilise à la fois un modèle d'inspection et un modèle d'anonymisation.
projects.dlpJobs.create dans l'objet InspectJobConfig : crée une tâche d'inspection qui utilise le modèle comme configuration.

Répertorier les modèles d'inspection

Pour répertorier tous les modèles d'inspection qui ont été créés dans le projet ou l'organisation en cours :

Console

Dans la console Google Cloud, accédez à la page Configuration de la protection des données sensibles.

Accéder à la page "Configuration"
Sélectionnez le projet contenant les modèles d'inspection.
Cliquez sur l'onglet Modèles.

La console affiche une liste de tous les modèles d'inspection du projet en cours.

C#

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


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

public class InspectTemplateList
{
    public static PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> List(string projectId)
    {
        var client = DlpServiceClient.Create();

        var response = client.ListInspectTemplates(
            new ListInspectTemplatesRequest
            {
                Parent = new LocationName(projectId, "global").ToString(),
            }
        );

        // Uncomment to list templates
        //PrintTemplates(response);

        return response;
    }

    public static void PrintTemplates(PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> response)
    {
        foreach (var template in response)
        {
            Console.WriteLine($"Template {template.Name}:");
            Console.WriteLine($"\tDisplay Name: {template.DisplayName}");
            Console.WriteLine($"\tDescription: {template.Description}");
            Console.WriteLine($"\tCreated: {template.CreateTime}");
            Console.WriteLine($"\tUpdated: {template.UpdateTime}");
            Console.WriteLine("Configuration:");
            Console.WriteLine($"\tMin Likelihood: {template.InspectConfig?.MinLikelihood}");
            Console.WriteLine($"\tInclude quotes: {template.InspectConfig?.IncludeQuote}");
            Console.WriteLine($"\tMax findings per request: {template.InspectConfig?.Limits.MaxFindingsPerRequest}");
        }
    }
}

Go

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

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

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

// listInspectTemplates lists the inspect templates in the project.
func listInspectTemplates(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()

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

	// Create a configured request.
	req := &dlppb.ListInspectTemplatesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

	// Send the request and iterate over the results.
	it := client.ListInspectTemplates(ctx, req)
	for {
		t, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %w", err)
		}
		fmt.Fprintf(w, "Inspect template %v\n", t.GetName())
		c, err := ptypes.Timestamp(t.GetCreateTime())
		if err != nil {
			return fmt.Errorf("CreateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Created: %v\n", c.Format(time.RFC1123))
		u, err := ptypes.Timestamp(t.GetUpdateTime())
		if err != nil {
			return fmt.Errorf("UpdateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Updated: %v\n", u.Format(time.RFC1123))
		fmt.Fprintf(w, "  Display Name: %q\n", t.GetDisplayName())
		fmt.Fprintf(w, "  Description: %q\n", t.GetDescription())
	}

	return nil
}

Java

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


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.cloud.dlp.v2.DlpServiceClient.ListInspectTemplatesPagedResponse;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.ListInspectTemplatesRequest;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

class TemplatesList {

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

  // Lists all templates associated with a given project
  public static void listInspectTemplates(String projectId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpServiceClient = DlpServiceClient.create()) {

      // Create the request to be sent by the client
      ListInspectTemplatesRequest request =
          ListInspectTemplatesRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setPageSize(1)
              .build();

      // Send the request
      ListInspectTemplatesPagedResponse response = dlpServiceClient.listInspectTemplates(request);

      // Parse through and process the response
      System.out.println("Templates found:");
      for (InspectTemplate template : response.getPage().getResponse().getInspectTemplatesList()) {
        System.out.printf("Template name: %s\n", template.getName());
        if (template.getDisplayName() != null) {
          System.out.printf("\tDisplay name: %s \n", template.getDisplayName());
          System.out.printf("\tCreate time: %s \n", template.getCreateTime());
          System.out.printf("\tUpdate time: %s \n", template.getUpdateTime());

          // print inspection config
          InspectConfig inspectConfig = template.getInspectConfig();
          for (InfoType infoType : inspectConfig.getInfoTypesList()) {
            System.out.printf("\tInfoType: %s\n", infoType.getName());
          }
          System.out.printf("\tMin likelihood: %s\n", inspectConfig.getMinLikelihood());
          System.out.printf("\tLimits: %s\n", inspectConfig.getLimits().getMaxFindingsPerRequest());
        }
      }
    }
  }
}

Node.js

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

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

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

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

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

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

  // Run template-deletion request
  const [templates] = await dlp.listInspectTemplates(request);

  templates.forEach(template => {
    console.log(`Template ${template.name}`);
    if (template.displayName) {
      console.log(`  Display name: ${template.displayName}`);
    }

    console.log(`  Created: ${formatDate(template.createTime)}`);
    console.log(`  Updated: ${formatDate(template.updateTime)}`);

    const inspectConfig = template.inspectConfig;
    const infoTypes = inspectConfig.infoTypes.map(x => x.name);
    console.log('  InfoTypes:', infoTypes.join(' '));
    console.log('  Minimum likelihood:', inspectConfig.minLikelihood);
    console.log('  Include quotes:', inspectConfig.includeQuote);

    const limits = inspectConfig.limits;
    console.log('  Max findings per request:', limits.maxFindingsPerRequest);
  });
}

listInspectTemplates();

PHP

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

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

/**
 * List DLP inspection configuration templates.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 */
function list_inspect_templates(string $callingProjectId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

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

    // Run request
    $listInspectTemplatesRequest = (new ListInspectTemplatesRequest())
        ->setParent($parent);
    $response = $dlp->listInspectTemplates($listInspectTemplatesRequest);

    // Print results
    $templates = $response->iterateAllElements();

    foreach ($templates as $template) {
        printf('Template %s' . PHP_EOL, $template->getName());
        printf('  Created: %s' . PHP_EOL, $template->getCreateTime()->getSeconds());
        printf('  Updated: %s' . PHP_EOL, $template->getUpdateTime()->getSeconds());
        printf('  Display Name: %s' . PHP_EOL, $template->getDisplayName());
        printf('  Description: %s' . PHP_EOL, $template->getDescription());

        $inspectConfig = $template->getInspectConfig();
        if ($inspectConfig === null) {
            print('  No inspect config.' . PHP_EOL);
        } else {
            printf('  Minimum likelihood: %s' . PHP_EOL, $inspectConfig->getMinLikelihood());
            printf('  Include quotes: %s' . PHP_EOL, $inspectConfig->getIncludeQuote());
            $limits = $inspectConfig->getLimits();
            printf('  Max findings per request: %s' . PHP_EOL, $limits->getMaxFindingsPerRequest());
        }
    }
}

Python

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

import google.cloud.dlp


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

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

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

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

    for template in response:
        print(f"Template {template.name}:")
        if template.display_name:
            print(f"  Display Name: {template.display_name}")
        print(f"  Created: {template.create_time}")
        print(f"  Updated: {template.update_time}")

        config = template.inspect_config
        print(
            "  InfoTypes: {}".format(", ".join([it.name for it in config.info_types]))
        )
        print(f"  Minimum likelihood: {config.min_likelihood}")
        print(f"  Include quotes: {config.include_quote}")
        print(
            "  Max findings per request: {}".format(
                config.limits.max_findings_per_request
            )
        )

REST

Utilisez l'une des méthodes *.*.list :

Copier un modèle d'inspection dans la région `global`

Dans la console Google Cloud, accédez à la page Configuration de la protection des données sensibles.

Accéder à la page "Configuration"
Dans la barre d'outils, cliquez sur le sélecteur de projet, puis sélectionnez le projet contenant le modèle d'inspection que vous souhaitez utiliser.
Cliquez sur l'onglet Modèles, puis sur le sous-onglet Inspecter.
Cliquez sur l'ID du modèle que vous souhaitez utiliser.
Sur la page Détails du modèle d'inspection, cliquez sur Copier.
Sur la page Créer un modèle, dans la liste Emplacement des ressources, sélectionnez Global (n'importe quelle région).
Cliquez sur Créer.

Le modèle est copié dans la région global.

Copier un modèle d'inspection dans un autre projet

Dans la console Google Cloud, accédez à la page Configuration de la protection des données sensibles.

Accéder à la page "Configuration"
Dans la barre d'outils, cliquez sur le sélecteur de projet, puis sélectionnez le projet contenant le modèle d'inspection que vous souhaitez utiliser.
Cliquez sur l'onglet Modèles, puis sur le sous-onglet Inspecter.
Cliquez sur l'ID du modèle que vous souhaitez utiliser.
Sur la page Détails du modèle d'inspection, cliquez sur Copier.
Sélectionnez le projet dans lequel vous souhaitez copier le modèle d'inspection.

La page Créer un modèle se recharge dans le projet que vous avez sélectionné.
Cliquez sur Créer.

Le modèle est créé dans le projet que vous avez sélectionné.

Supprimer des modèles d'inspection

Pour supprimer un modèle d'inspection :

Console

Dans la console Google Cloud, accédez à la page Configuration de la protection des données sensibles.

Accéder à la page "Configuration"
Sélectionnez le projet contenant le modèle d'inspection que vous souhaitez supprimer.
Cliquez sur l'onglet Modèles. La console affiche une liste de tous les modèles du projet en cours.
Dans la colonne Actions associée au modèle que vous souhaitez supprimer, cliquez sur le menu Autres actions (représenté par trois points disposés verticalement) , puis cliquez sur Delete (Supprimer).

Sinon, dans la liste des modèles, cliquez sur le nom du modèle que vous souhaitez supprimer. Sur la page d'informations du modèle, cliquez sur Supprimer.

C#

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


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

public class InspectTemplateDelete
{
    public static object Delete(string projectId, string templateName)
    {
        var client = DlpServiceClient.Create();

        var request = new DeleteInspectTemplateRequest
        {
            Name = templateName
        };

        client.DeleteInspectTemplate(request);
        Console.WriteLine($"Successfully deleted template {templateName}.");

        return templateName;
    }
}

Go

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

import (
	"context"
	"fmt"
	"io"

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

// deleteInspectTemplate deletes the given template.
func deleteInspectTemplate(w io.Writer, templateID string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"

	ctx := context.Background()

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

	req := &dlppb.DeleteInspectTemplateRequest{
		Name: templateID,
	}

	if err := client.DeleteInspectTemplate(ctx, req); err != nil {
		return fmt.Errorf("DeleteInspectTemplate: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted inspect template %v", templateID)
	return nil
}

Java

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


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

class TemplatesDelete {

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

  // Delete an existing template
  public static void deleteInspectTemplate(String projectId, String templateId) throws IOException {
    // Construct the template name to be deleted
    String templateName = String.format("projects/%s/inspectTemplates/%s", projectId, templateId);

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpServiceClient = DlpServiceClient.create()) {

      // Create delete template request to be sent by the client
      DeleteInspectTemplateRequest request =
          DeleteInspectTemplateRequest.newBuilder().setName(templateName).build();

      // Send the request with the client
      dlpServiceClient.deleteInspectTemplate(request);
      System.out.printf("Deleted template: %s\n", templateName);
    }
  }
}

Node.js

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

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

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

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

// The name of the template to delete
// Parent project ID is automatically extracted from this parameter
// const templateName = 'projects/YOUR_PROJECT_ID/inspectTemplates/#####'
async function deleteInspectTemplate() {
  // Construct template-deletion request
  const request = {
    name: templateName,
  };

  // Run template-deletion request
  await dlp.deleteInspectTemplate(request);
  console.log(`Successfully deleted template ${templateName}.`);
}

deleteInspectTemplate();

PHP

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

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

/**
 * Delete a DLP inspection configuration template.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 * @param string $templateId        The name of the template to delete
 */
function delete_inspect_template(
    string $callingProjectId,
    string $templateId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Run template deletion request
    $templateName = "projects/$callingProjectId/locations/global/inspectTemplates/$templateId";
    $deleteInspectTemplateRequest = (new DeleteInspectTemplateRequest())
        ->setName($templateName);
    $dlp->deleteInspectTemplate($deleteInspectTemplateRequest);

    // Print results
    printf('Successfully deleted template %s' . PHP_EOL, $templateName);
}

Python

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

import google.cloud.dlp


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

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

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

    # Combine the template id with the parent id.
    template_resource = f"{parent}/inspectTemplates/{template_id}"

    # Call the API.
    dlp.delete_inspect_template(request={"name": template_resource})

    print(f"Template {template_resource} successfully deleted.")

REST

Utilisez l'une des méthodes *.*.delete :

Avec chaque méthode *.*.delete, vous devez inclure le nom de ressource du modèle qui doit être supprimé.

Créer des modèles d'inspection Sensitive Data Protection

À propos des modèles

Créer un modèle d'inspection

Console

Définir le modèle

Configurer la détection

Ensembles de règles d'inspection

Seuil de confiance

C#

Go

Java

Node.js

PHP

Python

REST

Utiliser des modèles d'inspection

Console

REST

Répertorier les modèles d'inspection

Console

C#

Go

Java

Node.js

PHP

Python

REST

Copier un modèle d'inspection dans la région global

Copier un modèle d'inspection dans un autre projet

Supprimer des modèles d'inspection

Console

C#

Go

Java

Node.js

PHP

Python

REST

Copier un modèle d'inspection dans la région `global`