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

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 de l'autre, la méthode utilisée dans la mise en œuvre de vos requêtes pour supprimer l'identification de ces éléments. Les modèles constituent une solution robuste pour réutiliser des configurations. Ils garantissent en outre une plus grande cohérence pour les utilisateurs et pour les ensembles de données.

La protection des données sensibles accepte deux types de modèles:

  • Modèles de suppression de l'identification : modèles permettant d'enregistrer les informations de configuration relatives aux tâches de suppression de l'identification, y compris les transformations d'enregistrements (ensembles de données structurés) et d'infoTypes.
  • Modèles d'inspection : modèles permettant de conserver les informations de configuration relatives aux tâches d'analyse d'inspection, y compris les détecteurs prédéfinis ou personnalisés qui doivent être utilisés. Pour en savoir plus sur les modèles d'inspection, consultez la section Créer des modèles d'inspection 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.

Vous trouverez ci-dessous la procédure à suivre pour créer des modèles de suppression de l'identification à utiliser avec la protection des données sensibles.

Créer un modèle de suppression de l'identification

Console

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

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

Les sections suivantes expliquent comment remplir la page Créer un modèle.

Définir le modèle

Dans la section Définir le modèle, remplissez les champs comme suit:

  1. Pour le type de modèle, sélectionnez Supprimer l'identification (supprimer les données sensibles).

  2. Dans Type de transformation des données, sélectionnez le type de transformation à appliquer:

    • InfoType. La protection des données sensibles n'applique chaque transformation qu'à la valeur identifiée comme l'infoType spécifique. Ce type de transformation est utile pour le texte non structuré.

    • Enregistrer. La protection des données sensibles tient compte du format structuré des données lorsqu'elle applique une transformation. Ce type de transformation est utile pour les données tabulaires.

    • Image. La protection des données sensibles masque tout le texte détecté dans une image ou uniquement le texte correspondant à un infoType spécifique.

  3. Dans le champ ID du modèle, saisissez un identifiant unique pour le modèle.

  4. Dans le champ Display name (Nom à afficher), saisissez un nom pour le modèle.

  5. Dans le champ Description, décrivez le modèle.

  6. Pour Emplacement de la ressource, sélectionnez Global (Monde) ou l'emplacement des données que vous souhaitez anonymiser.

  7. Cliquez sur Continuer.

Configurer la suppression de l'identification

La sélection des champs qui s'affichent dans Configurer l'anonymisation dépend du type de transformation de données que vous avez choisi.

InfoType

Si vous avez sélectionné InfoType comme type de transformation des données, procédez comme suit:

  1. Dans le champ Transformation, sélectionnez une méthode de transformation à appliquer aux résultats.

    D'autres champs s'affichent en fonction de votre sélection. Renseignez les champs si nécessaire. Pour en savoir plus, consultez la documentation de référence sur les transformations.

  2. Dans la section InfoTypes to transform (InfoTypes à transformer), indiquez si vous souhaitez appliquer la transformation à tous les infoTypes détectés définis dans votre configuration d'inspection.

    Si vous sélectionnez Spécifier des infoTypes, sélectionnez les infoTypes auxquels vous souhaitez appliquer la méthode de transformation.

  3. Si vous souhaitez ajouter des règles de transformation pour des infoTypes qui ne sont pas couverts par votre règle de transformation, cliquez sur Ajouter une règle de transformation. Renseignez ensuite les champs si nécessaire. Répétez cette étape jusqu'à ce que vous ayez configuré une règle de transformation pour tous les infoTypes que vous souhaitez transformer.

  4. Cliquez sur Créer.

Enregistrer

Si vous avez sélectionné Enregistrer comme type de transformation des données, procédez comme suit:

  1. Pour Champs ou colonnes à transformer, saisissez le nom de la colonne de la table contenant les données que vous souhaitez transformer. Appuyez ensuite sur ENTER. Répétez cette étape pour chaque colonne contenant des données que vous souhaitez transformer.

  2. Spécifiez le type de transformation:

    • Correspondance par infoType La protection des données sensibles traite chaque cellule comme du texte non structuré et n'applique la transformation qu'aux infoTypes qu'elle trouve dans la cellule. La protection des données sensibles ne transforme aucune donnée entourant un infoType.

      Si vous sélectionnez cette option, procédez comme suit:

      1. Cliquez sur Ajouter une transformation. Dans le champ Transformation, sélectionnez une méthode de transformation à appliquer aux résultats.

      2. Indiquez si vous souhaitez appliquer la transformation à tous les infoTypes détectés définis dans votre configuration d'inspection.

        Si vous sélectionnez Spécifier des infoTypes, sélectionnez les infoTypes auxquels vous souhaitez appliquer la règle de transformation.

      Si vous souhaitez attribuer certaines règles de transformation à certains infoTypes, vous pouvez ajouter d'autres transformations si nécessaire.

    • Transformation de champ primitif La protection des données sensibles transforme toujours l'intégralité de la cellule selon une méthode de transformation que vous choisissez. Cette option est utile si vous souhaitez transformer des colonnes entières de données, que les cellules de ces colonnes aient détecté des infoTypes ou non.

      Si vous sélectionnez cette option, dans le champ Transformation, sélectionnez une méthode de transformation à appliquer aux colonnes que vous avez spécifiées.

    Dans les deux cas, d'autres champs s'affichent en fonction de la méthode de transformation sélectionnée. Remplissez les champs au besoin. Pour en savoir plus, consultez la documentation de référence sur les transformations.

  3. Cliquez sur Créer.

Image

Si vous avez sélectionné Image comme type de transformation des données, procédez comme suit:

  1. Facultatif: Pour modifier la couleur de la zone qui recouvre le texte masqué, cliquez sur la zone noire dans le champ Couleur de masquage, puis choisissez une autre couleur.

  2. Dans la section InfoTypes à transformer, spécifiez ce que vous souhaitez masquer : tout le texte détecté, tous les infoTypes définis dans votre configuration d'inspection ou uniquement des infoTypes spécifiques.

    Si vous sélectionnez Spécifier des infoTypes, sélectionnez les infoTypes auxquels vous souhaitez appliquer la règle de transformation.

  3. Si vous souhaitez ajouter des règles de transformation pour des infoTypes qui ne sont pas couverts par votre règle de transformation, cliquez sur Ajouter une règle de transformation. Renseignez ensuite les champs si nécessaire. Répétez cette étape jusqu'à ce que vous ayez configuré une règle de transformation pour tous les infoTypes que vous souhaitez transformer.

  4. Cliquez sur Créer.

Protocole

Il est utile de noter qu'un modèle de suppression de l'identification n'est ni plus ni moins qu'une configuration de suppression de l'identification réutilisable, à laquelle sont associées certaines métadonnées. En termes d'API, l'objet DeidentifyTemplate est effectivement un objet DeidentifyConfig 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 de suppression de l'identification, vous devez effectuer les étapes de base suivantes :

  1. Commencez avec un objet DeidentifyConfig.
  2. Appelez la méthode create de la ressource projects.deidentifyTemplates, en incluant dans la requête un objet DeidentifyTemplate contenant un nom à afficher, une description et l'objet DeidentifyConfig.

Le modèle DeidentifyTemplate 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 *.deidentifyTemplates.list. Pour afficher un modèle spécifique, appelez la méthode *.deidentifyTemplates.get. Notez que vous pouvez créer au maximum 1 000 modèles.

Si vous avez déjà effectué une opération d'anonymisation des données sensibles sur du texte, des images ou des contenus structurés à l'aide de la protection des données sensibles, vous avez déjà créé un objet DeidentifyConfig. Une étape supplémentaire permet de transformer un objet de ce type en objet DeidentifyTemplate.

Exemple REST

Le code JSON suivant est un exemple de ce que vous pouvez envoyer à la méthode projects.deidentifyTemplates.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 EMAIL_ADDRESS et GENERIC_ID. Lorsqu'il trouve du contenu correspondant à ces infoTypes, il masque les trois premiers caractères à l'aide d'astérisques (*).

Méthode HTTP et URL

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

Remplacez PROJECT_ID par l'ID du projet.

Entrée JSON

{
  "deidentifyTemplate":{
    "displayName":"Email and id masker",
    "description":"De-identifies emails and ids with a series of asterisks.",
    "deidentifyConfig":{
      "infoTypeTransformations":{
        "transformations":[
          {
            "infoTypes":[
              {
                "name":"GENERIC_ID"
              }
            ],
            "primitiveTransformation":{
              "replaceWithInfoTypeConfig":{

              }
            }
          },
          {
            "infoTypes":[
              {
                "name":"EMAIL_ADDRESS"
              }
            ],
            "primitiveTransformation":{
              "characterMaskConfig":{
                "charactersToIgnore":[
                  {
                    "charactersToSkip":"@"
                  }
                ],
                "maskingCharacter":"*"
              }
            }
          }
        ]
      }
    }
  }
}

Sortie JSON

    {
      "name":"projects/PROJECT_ID/deidentifyTemplates/JOB-ID",
      "displayName":"Email and id masker",
      "description":"De-identifies emails and ids with a series of asterisks.",
      "createTime":"2018-11-30T07:17:59.536022Z",
      "updateTime":"2018-11-30T07:17:59.536022Z",
      "deidentifyConfig":{
        "infoTypeTransformations":{
          "transformations":[
            {
              "infoTypes":[
                {
                  "name":"GENERIC_ID"
                }
              ],
              "primitiveTransformation":{
                "replaceWithInfoTypeConfig":{

                }
              }
            },
            {
              "infoTypes":[
                {
                  "name":"EMAIL_ADDRESS"
                }
              ],
              "primitiveTransformation":{
                "characterMaskConfig":{
                  "maskingCharacter":"*",
                  "charactersToIgnore":[
                    {
                      "charactersToSkip":"@"
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }

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 de suppression de l'identification

Une fois que vous avez créé un modèle, vous pouvez utiliser son identifiant name partout où les modèles de type deidentifyTemplateName sont acceptés, par exemple:

  • projects.content.deidentify : anonymise des données potentiellement sensibles dans des contenus en utilisant le modèle comme configuration. Sachez que cette méthode peut utiliser un modèle d'inspection ou un modèle de suppression de l'identification.

Répertorier les modèles de suppression de l'identification

Pour répertorier tous les modèles d'anonymisation qui ont été créés, utilisez l'une des méthodes *.*.list :

Cette section explique comment utiliser Sensitive Data Protection pour lister les modèles d'inspection. Le processus est identique à celui utilisé pour répertorier les modèles de suppression de l'identification.

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;
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.

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. 

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.

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. 


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.

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. 

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

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. 

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.

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. 

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

Supprimer des modèles de suppression de l'identification

Pour supprimer un modèle d'anonymisation spécifique, exécutez 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é.

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

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. 

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.

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. 


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.

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. 

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

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. 

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.

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. 

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