Cloud Data Loss Prevention (Cloud DLP) ist jetzt Teil des Schutzes sensibler Daten. Der Name der API bleibt unverändert: Cloud Data Loss Prevention API (DLP API). Informationen zu den Diensten, die zum Schutz sensibler Daten gehören, finden Sie unter Schutz sensibler Daten.

Diese Seite wurde von der Cloud Translation API übersetzt.

De-Identifikationsvorlagen für Sensitive Data Protection erstellen

Sie können Vorlagen verwenden, um Konfigurationsinformationen für den Schutz sensibler Daten zu erstellen und beizubehalten. Vorlagen bieten sich an, wenn Sie Konfigurationsinformationen entkoppeln möchten, z. B. was Sie überprüfen und wie Sie dessen Identifizierung bei der Implementierung Ihrer Anfragen aufheben. Mit Vorlagen können Sie umfangreiche Rollouts von DLP API-Funktionen zuverlässig verwalten.

Sensitive Data Protection unterstützt zwei Arten von Vorlagen:

De-Identifikationsvorlagen: Vorlagen zum Speichern von Konfigurationsinformationen für De-Identifikationsjobs, einschließlich Transformationen von infoTypes und strukturierten Datasets.
Inspektionsvorlagen: Vorlagen zum Speichern von Konfigurationsinformationen für Inspektionsscanjobs, einschließlich der zu verwendenden vordefinierten oder benutzerdefinierten Detektoren. Weitere Informationen zu Inspektionsvorlagen finden Sie unter Inspektionsvorlagen für den Schutz sensibler Daten erstellen.

Konzeptionelle Informationen zu Vorlagen im Rahmen des Schutzes sensibler Daten finden Sie unter Vorlagen.

Im verbleibenden Teil dieses Themas erfahren Sie, wie Sie De-Identifikationsvorlagen für die Verwendung mit dem Sensitive Data Protection-Tool erstellen.

De-Identifikationsvorlagen erstellen

Console

Rufen Sie in der Google Cloud Console die Seite Vorlage erstellen auf.

Zur Seite „Vorlage erstellen“

In den folgenden Abschnitten wird beschrieben, wie Sie die Seite Vorlage erstellen ausfüllen.

Vorlage definieren

Füllen Sie im Bereich Vorlage definieren die Felder wie unten beschrieben aus:

Wählen Sie unter Vorlagentyp die Option De-identifizieren (sensible Daten entfernen) aus.
Wählen Sie unter Datentransformationstyp die gewünschte Transformation aus:
- InfoType übereinstimmen. Beim Schutz sensibler Daten wird jede Transformation nur auf den Wert angewendet, der als spezifischer infoType gekennzeichnet wurde. Dieser Transformationstyp eignet sich für unstrukturierten Text.
- Aufzeichnen Bei der Anwendung einer Transformation wird das strukturierte Format der Daten berücksichtigt. Dieser Transformationstyp eignet sich für tabellarische Daten.
- Image. Mit dem Schutz sensibler Daten wird der gesamte erkannte Text in einem Bild oder nur der Text entfernt, der einem bestimmten infoType entspricht.
Geben Sie unter Template ID eine eindeutige Kennung für die Vorlage ein.
Geben Sie unter Anzeigename einen Namen für die Vorlage ein.
Geben Sie unter Beschreibung eine Beschreibung der Vorlage ein.
Wählen Sie unter Ressourcenspeicherort die Option Global oder den Speicherort der Daten aus, die Sie deidentifizieren möchten.
Klicken Sie auf Weiter.

De-identifikation konfigurieren

Die Auswahl der Felder, die unter De-Identifikation konfigurieren angezeigt werden, hängt vom ausgewählten Datentransformationstyp ab.

infoType

Wenn Sie InfoType als Datentransformationstyp ausgewählt haben, gehen Sie so vor:

Wählen Sie im Feld Transformation eine Transformationsmethode aus, die auf die Ergebnisse angewendet werden soll.

Je nach Auswahl werden weitere Felder angezeigt. Füllen Sie die Felder nach Bedarf aus. Weitere Informationen finden Sie in der Transformationsreferenz.
Geben Sie im Abschnitt InfoTypes for the Transformation (InfoTypes für die Transformation) an, ob die Transformation auf alle erkannten InfoTypes angewendet werden soll, die in Ihrer Prüfkonfiguration definiert sind.

Wenn Sie InfoTypes angeben auswählen, wählen Sie die InfoTypes aus, auf die die Transformationsmethode angewendet werden soll.
Wenn Sie Transformationsregeln für Infotypen hinzufügen möchten, die nicht von Ihrer Transformationsregel abgedeckt sind, klicken Sie auf Transformationsregel hinzufügen. Füllen Sie dann die Felder nach Bedarf aus. Wiederholen Sie diesen Schritt, bis Sie eine Transformationsregel für alle Infotypen konfiguriert haben, die Sie transformieren möchten.
Klicken Sie auf Erstellen.

Aufnehmen

Wenn Sie Aufzeichnen als Datentransformationstyp ausgewählt haben, gehen Sie so vor:

Geben Sie unter Feld(er) oder Spalte(n) zum Transformieren den Namen der Tabellenspalte ein, die die Daten enthält, die Sie transformieren möchten. Drücken Sie dann auf ENTER. Wiederholen Sie diesen Schritt für jede Spalte mit Daten, die Sie transformieren möchten.
Geben Sie den Transformationstyp an:
- Übereinstimmung mit infoType Sensitive Data Protection behandelt jede Zelle als unstrukturierten Text und wendet die Transformation nur auf die Infotypen an, die in der Zelle gefunden werden. Beim Schutz sensibler Daten werden keine Daten in Bezug auf einen infoType transformiert.
  
  Wenn Sie diese Option auswählen, gehen Sie so vor:
  1. Klicken Sie auf Transformation hinzufügen. Wählen Sie im Feld Transformation eine Transformationsmethode aus, die auf die Ergebnisse angewendet werden soll.
  2. Geben Sie an, ob die Transformation auf alle erkannten infoTypes angewendet werden soll, die in Ihrer Prüfkonfiguration definiert sind.
    
    Wenn Sie InfoTypes angeben auswählen, wählen Sie die InfoTypes aus, auf die die Transformationsregel angewendet werden soll.
  Wenn Sie bestimmten infoTypes bestimmte Transformationsregeln zuweisen möchten, können Sie bei Bedarf weitere Transformationen hinzufügen.
- Primitive Feldtransformation. Bei der Funktion „Schutz sensibler Daten“ wird immer die gesamte Zelle gemäß einer von Ihnen ausgewählten Transformationsmethode transformiert. Diese Option ist nützlich, wenn Sie ganze Datenspalten transformieren möchten, unabhängig davon, ob in den Zellen dieser Spalten Infotypen erkannt wurden.
  
  Wenn Sie diese Option auswählen, wählen Sie im Feld Transformation eine Transformationsmethode aus, die auf die von Ihnen angegebenen Spalten angewendet werden soll.
In beiden Fällen werden je nach ausgewählter Transformationsmethode weitere Felder angezeigt. Füllen Sie die Felder nach Bedarf aus. Weitere Informationen finden Sie in der Transformationsreferenz.
Klicken Sie auf Erstellen.

Bild

Wenn Sie Bild als Datentransformationstyp ausgewählt haben, gehen Sie so vor:

Optional: Wenn Sie die Farbe des Felds ändern möchten, das den entfernten Text abdeckt, klicken Sie auf das schwarze Feld im Feld Farbe für entfernten Text und wählen Sie eine andere Farbe aus.
Geben Sie im Abschnitt InfoTypes to transform (InfoTypes, die transformiert werden sollen) an, was entfernt werden soll: der gesamte erkannte Text, alle in der Inspektionskonfiguration definierten infoTypes oder nur bestimmte infoTypes.

Wenn Sie InfoTypes angeben auswählen, wählen Sie die InfoTypes aus, auf die die Transformationsregel angewendet werden soll.
Wenn Sie Transformationsregeln für Infotypen hinzufügen möchten, die nicht von Ihrer Transformationsregel abgedeckt sind, klicken Sie auf Transformationsregel hinzufügen. Füllen Sie dann die Felder nach Bedarf aus. Wiederholen Sie diesen Schritt, bis Sie eine Transformationsregel für alle Infotypen konfiguriert haben, die Sie transformieren möchten.
Klicken Sie auf Erstellen.

Protokoll

Eine De-Identifikationsvorlage ist einfach eine wiederverwendbare De-Identifikationskonfiguration plus einiger Metadaten. Für die API ist das DeidentifyTemplate-Objekt im Grunde ein DeidentifyConfig-Objekt, das einige weitere Metadatenfelder enthält, z. B. einen Anzeigenamen und eine Beschreibung. Zum Erstellen einer neuen De-Identifikationsvorlage sind daher die folgenden grundlegenden Schritte nötig:

Beginnen Sie mit einem DeidentifyConfig-Objekt.
Rufen Sie die Methode create der Ressource projects.deidentifyTemplates auf oder verwenden Sie dazu eine POST-Anfrage. Schließen Sie dabei ein DeidentifyTemplate-Objekt in die Anfrage ein, das einen Anzeigenamen, eine Beschreibung und das betreffende DeidentifyConfig-Objekt enthält.

Die zurückgegebene DeidentifyTemplate kann sofort eingesetzt werden. Sie können sie in anderen Aufrufen oder Jobs mithilfe ihres Namens (name) referenzieren. Sie können die vorhandenen Vorlagen durch Aufrufen der Methode *.deidentifyTemplates.list auflisten. Wenn Sie eine bestimmte Vorlage einsehen möchten, rufen Sie die Methode *.deidentifyTemplates.get auf. Beachten Sie, dass Sie maximal 1000 Vorlagen erstellen können.

Wenn Sie sich bereits mit der De-Identifikation von vertraulichen Daten aus Texten, Bildern oder strukturierten Inhalten mit dem Schutz sensibler Daten befasst haben, dann haben Sie bereits ein DeidentifyConfig-Objekt erstellt. Mit einem zusätzlichen Schritt können Sie es in ein DeidentifyTemplate-Objekt verwandeln.

REST-Beispiel

Die folgende JSON-Eingabe ist ein Beispiel dafür, was Sie an die Methode projects.deidentifyTemplates.create senden können. Diese JSON-Eingabe erstellt eine neue Vorlage mit dem angegebenen Anzeigenamen und der angegebenen Beschreibung und sucht nach Übereinstimmungen bei den infoTypes EMAIL_ADDRESS und GENERIC_ID. Finden sich Inhalte, die mit diesen infoTypes übereinstimmen, werden die ersten drei Zeichen mit einem Sternchen (*) markiert.

HTTP-Methode und URL

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

Ersetzen Sie PROJECT_ID durch die Projekt-ID.

JSON-Eingabe

{
  "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":"*"
              }
            }
          }
        ]
      }
    }
  }
}

JSON-Ausgabe

    {
      "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":"@"
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }

Wenn Sie dies schnell ausprobieren möchten, können Sie den unten eingebetteten APIs Explorer verwenden. Allgemeine Informationen zum Einsatz von JSON für das Senden von Anfragen an die DLP API finden Sie in der JSON-Kurzanleitung.

De-Identifikationsvorlagen verwenden

Sobald Sie eine neue Vorlage erstellt haben, können Sie deren name-ID überall dort verwenden, wo deidentifyTemplateName akzeptiert wird. Zum Beispiel:

projects.content.deidentify: De-identifiziert potenziell vertrauliche Daten in Inhalten, wobei zur Konfiguration auf die Vorlage zurückgegriffen wird. Beachten Sie, dass diese Methode entweder eine Inspektionsvorlage oder eine De-Identifikationsvorlage verwenden kann.

De-Identifikationsvorlagen auflisten

Wenn Sie alle bisher erstellten De-Identifikationsvorlagen auflisten möchten, verwenden Sie eine der *.*.list-Methoden:

projects.deidentifyTemplates.list

In diesem Abschnitt wird gezeigt, wie Sie mit Sensitive Data Protection Inspektionsvorlagen auflisten. Der Prozess stimmt mit dem Prozess zum Auflisten von De-Identifikationsvorlagen überein.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

De-Identifikationsvorlagen löschen

Zum Löschen einer bestimmten De-Identifikationsvorlage können Sie eine der *.*.delete-Methoden verwenden:

projects.deidentifyTemplates.delete

Bei jeder *.*.delete-Methode geben Sie den Ressourcennamen der zu löschenden Vorlage an.

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

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