Einen großen benutzerdefinierten Wörterbuchdetektor erstellen

In diesem Thema wird beschrieben, wie Sie große benutzerdefinierte Wörterbücher erstellen und neu erstellen. Außerdem werden verschiedene Fehlerszenarien behandelt.

Wann sollte ein großes benutzerdefiniertes Wörterbuch statt einem normalen benutzerdefinierten Wörterbuch ausgewählt werden?

Reguläre benutzerdefinierte Wörterbuchdetektoren sind ausreichend, wenn Sie Zehntausende von vertraulichen Wörtern oder Wortgruppen haben, nach denen Sie Ihren Inhalt durchsuchen möchten. Wenn Sie mehr Begriffe haben oder sich Ihre Begriffsliste häufig ändert, sollten Sie ein großes benutzerdefiniertes Wörterbuch erstellen, das mehrere zehn Millionen Begriffe unterstützen kann.

Hinweis: Die genauen Nutzungslimits für Wörterbücher finden Sie unter Nutzungslimits.

Unterschiede zwischen großen benutzerdefinierten Wörterbüchern und anderen benutzerdefinierten infoTypes

Große benutzerdefinierte Wörterbücher unterscheiden sich von anderen benutzerdefinierten infoTypes dadurch, dass jedes große benutzerdefinierte Wörterbuch zwei Komponenten hat:

• Eine Liste von Wortgruppen, die Sie erstellen und definieren. Die Liste wird entweder als Textdatei in Cloud Storage oder als Spalte in einer BigQuery-Tabelle gespeichert.
• Die Wörterbuchdateien, die der Schutz sensibler Daten generiert und in Cloud Storage speichert. Wörterbuchdateien bestehen aus einer Kopie Ihrer Begriffsliste sowie Bloomfiltern, die beim Suchen und Abgleichen helfen.

Warnung: Ändern Sie benutzerdefinierte Wörterbuchdateien keinesfalls direkt in Cloud Storage. Dadurch wird das Wörterbuch ungültig und unbrauchbar.

Großes benutzerdefiniertes Wörterbuch erstellen

In diesem Abschnitt wird beschrieben, wie Sie ein großes benutzerdefiniertes Wörterbuch erstellen, bearbeiten und neu erstellen.

Begriffsliste erstellen

Erstellen Sie eine Liste mit allen Wörtern und Wortgruppen, nach denen der neue infoType-Detektor suchen soll. Führen Sie einen der folgenden Schritte aus:

• Platzieren Sie eine Textdatei, in der jedes Wort bzw. jede Wortgruppe in einer eigenen Zeile steht, in einem Cloud Storage-Bucket.
• Legen Sie eine Spalte einer BigQuery-Tabelle als Container für die Wörter und Wortgruppen fest. Weisen Sie jedem Eintrag eine eigene Zeile in der Spalte zu. Sie können eine vorhandene BigQuery-Tabelle verwenden, solange sich alle Wörterbuchwörter und -wortgruppen in einer einzigen Spalte befinden.

Es kann vorkommen, dass eine Begriffsliste zusammengestellt wird, die für den Schutz sensibler Daten zu lang ist. Wenn Sie eine Fehlermeldung erhalten, lesen Sie den Abschnitt Fehlerbehebung weiter unten in diesem Thema.

Gespeicherten infoType erstellen

Nachdem Sie Ihre Begriffsliste erstellt haben, verwenden Sie den Schutz sensibler Daten, um ein Wörterbuch zu erstellen:

Console

1. Erstellen Sie in einem Cloud Storage-Bucket einen neuen Ordner, in dem der Schutz sensibler Daten das generierte Wörterbuch speichert.

   Beim Schutz sensibler Daten werden Ordner mit den Wörterbuchdateien an dem von Ihnen angegebenen Speicherort erstellt.

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

   Zur Seite „infoType erstellen“

3. Wählen Sie unter Typ die Option Großes benutzerdefiniertes Wörterbuch aus.

4. Geben Sie als infoType-ID eine Kennung für den gespeicherten infoType ein.

   Sie verwenden diese ID beim Konfigurieren Ihrer Inspektions- und De-Identifikationsjobs. Sie können Buchstaben, Ziffern, Bindestriche und Unterstriche enthalten.

5. Geben Sie unter infoType-Anzeigename einen Namen für den gespeicherten infoType ein.

   Sie können im Namen Leerzeichen und Satzzeichen verwenden.

6. Geben Sie unter Beschreibung eine Beschreibung dessen ein, was Ihr gespeicherter infoType erkennt.

7. Wählen Sie unter Speichertyp den Standort der Begriffsliste aus:

   • BigQuery: Geben Sie die Projekt-ID, die Dataset-ID und die Tabellen-ID ein. Geben Sie im Feld Feldname die Spalten-ID ein. Sie können höchstens eine Spalte aus der Tabelle festlegen.
   • Google Cloud Storage: Geben Sie den Pfad zur Datei ein.

8. Geben Sie unter Ausgabe-Bucket oder -Ordner den Cloud Storage-Speicherort des in Schritt 1 erstellten Ordners ein.

   Hinweis : Legen Sie keine Dateien in den Ordnern ab, die beim Erstellen des Wörterbuchs durch den Schutz sensibler Daten erstellt werden. Wenn der Schutz sensibler Daten Wörterbuchdateien erstellt oder neu erstellt, werden alle anderen Dateien gelöscht, die in den von ihm erstellten Ordnern gespeichert sind. Alle Ordner, die sich auf derselben Ebene befinden wie die Ordner, die vom Schutz sensibler Daten erstellt werden, werden beibehalten.

9. Klicken Sie auf Erstellen.

Eine Zusammenfassung des gespeicherten infoType wird angezeigt. Wenn das Wörterbuch generiert wurde und der neue gespeicherte infoType einsatzbereit ist, wird als Status des infoTypes Bereit angezeigt.

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

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

public class CreateStoredInfoTypes
{
    public static StoredInfoType Create(
        string projectId,
        string outputPath,
        string storedInfoTypeId)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the stored infotype config by specifying the public table and
        // cloud storage output path.
        var storedInfoTypeConfig = new StoredInfoTypeConfig
        {
            DisplayName = "Github Usernames",
            Description = "Dictionary of Github usernames used in commits.",
            LargeCustomDictionary = new LargeCustomDictionaryConfig
            {
                BigQueryField = new BigQueryField
                {
                    Table = new BigQueryTable
                    {
                        DatasetId = "samples",
                        ProjectId = "bigquery-public-data",
                        TableId = "github_nested"
                    },
                    Field = new FieldId
                    {
                        Name = "actor"
                    }
                },
                OutputPath = new CloudStoragePath
                {
                    Path = outputPath
                }
            },
        };

        // Construct the request.
        var request = new CreateStoredInfoTypeRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            Config = storedInfoTypeConfig,
            StoredInfoTypeId = storedInfoTypeId
        };

        // Call the API.
        StoredInfoType response = dlp.CreateStoredInfoType(request);

        // Inspect the response.
        Console.WriteLine($"Created the stored infotype at path: {response.Name}");

        return response;
    }
}

Go

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

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

// createStoredInfoType creates a custom stored info type based on your input data.
func createStoredInfoType(w io.Writer, projectID, outputPath string) error {
	// projectId := "my-project-id"
	// outputPath := "gs://" + "your-bucket-name" + "path/to/directory"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Specify the name you want to give the dictionary.
	displayName := "Github Usernames"

	// Specify a description of the dictionary.
	description := "Dictionary of GitHub usernames used in commits"

	// Specify the path to the location in a Cloud Storage
	// bucket to store the created dictionary.
	cloudStoragePath := &dlppb.CloudStoragePath{
		Path: outputPath,
	}

	// Specify your term list is stored in BigQuery.
	bigQueryField := &dlppb.BigQueryField{
		Table: &dlppb.BigQueryTable{
			ProjectId: "bigquery-public-data",
			DatasetId: "samples",
			TableId:   "github_nested",
		},
		Field: &dlppb.FieldId{
			Name: "actor",
		},
	}

	// Specify the configuration of the large custom dictionary.
	largeCustomDictionaryConfig := &dlppb.LargeCustomDictionaryConfig{
		OutputPath: cloudStoragePath,
		Source: &dlppb.LargeCustomDictionaryConfig_BigQueryField{
			BigQueryField: bigQueryField,
		},
	}

	// Specify the configuration for stored infoType.
	storedInfoTypeConfig := &dlppb.StoredInfoTypeConfig{
		DisplayName: displayName,
		Description: description,
		Type: &dlppb.StoredInfoTypeConfig_LargeCustomDictionary{
			LargeCustomDictionary: largeCustomDictionaryConfig,
		},
	}

	// Combine configurations into a request for the service.
	req := &dlppb.CreateStoredInfoTypeRequest{
		Parent:           fmt.Sprintf("projects/%s/locations/global", projectID),
		Config:           storedInfoTypeConfig,
		StoredInfoTypeId: "github-usernames",
	}

	// Send the request and receive response from the service.
	resp, err := client.CreateStoredInfoType(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "output: %v", resp.Name)
	return nil

}

Java

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.BigQueryField;
import com.google.privacy.dlp.v2.BigQueryTable;
import com.google.privacy.dlp.v2.CloudStoragePath;
import com.google.privacy.dlp.v2.CreateStoredInfoTypeRequest;
import com.google.privacy.dlp.v2.FieldId;
import com.google.privacy.dlp.v2.LargeCustomDictionaryConfig;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.StoredInfoType;
import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
import java.io.IOException;

public class CreateStoredInfoType {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.

    //The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The path to the location in a GCS bucket to store the created dictionary.
    String outputPath = "gs://" + "your-bucket-name" + "path/to/directory";
    createStoredInfoType(projectId, outputPath);
  }

  // Creates a custom stored info type that contains GitHub usernames used in commits.
  public static void createStoredInfoType(String projectId, String outputPath)
      throws IOException {
    try (DlpServiceClient dlp = DlpServiceClient.create()) {

      // Optionally set a display name and a description.
      String displayName = "GitHub usernames";
      String description = "Dictionary of GitHub usernames used in commits";

      // The output path where the custom dictionary containing the GitHub usernames will be stored.
      CloudStoragePath cloudStoragePath =
          CloudStoragePath.newBuilder()
              .setPath(outputPath)
              .build();

      // The reference to the table containing the GitHub usernames.
      BigQueryTable table = BigQueryTable.newBuilder()
              .setProjectId("bigquery-public-data")
              .setDatasetId("samples")
              .setTableId("github_nested")
              .build();

      // The reference to the BigQuery field that contains the GitHub usernames.
      BigQueryField bigQueryField = BigQueryField.newBuilder()
              .setTable(table)
              .setField(FieldId.newBuilder().setName("actor").build())
              .build();

      LargeCustomDictionaryConfig largeCustomDictionaryConfig =
          LargeCustomDictionaryConfig.newBuilder()
              .setOutputPath(cloudStoragePath)
              .setBigQueryField(bigQueryField)
              .build();

      StoredInfoTypeConfig storedInfoTypeConfig = StoredInfoTypeConfig.newBuilder()
              .setDisplayName(displayName)
              .setDescription(description)
              .setLargeCustomDictionary(largeCustomDictionaryConfig)
              .build();

      // Combine configurations into a request for the service.
      CreateStoredInfoTypeRequest createStoredInfoType = CreateStoredInfoTypeRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setConfig(storedInfoTypeConfig)
              .setStoredInfoTypeId("github-usernames")
              .build();

      // Send the request and receive response from the service.
      StoredInfoType response = dlp.createStoredInfoType(createStoredInfoType);

      // Print the results.
      System.out.println("Created Stored InfoType: " + response.getName());
    }
  }
}

Node.js

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

// Import the required libraries
const dlp = require('@google-cloud/dlp');

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

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The identifier for the stored infoType
// const infoTypeId = 'github-usernames';

// The path to the location in a Cloud Storage bucket to store the created dictionary
// const outputPath = 'cloud-bucket-path';

// The project ID the table is stored under
// This may or (for public datasets) may not equal the calling project ID
// const dataProjectId = 'my-project';

// The ID of the dataset to inspect, e.g. 'my_dataset'
// const datasetId = 'my_dataset';

// The ID of the table to inspect, e.g. 'my_table'
// const tableId = 'my_table';

// Field ID to be used for constructing dictionary
// const fieldName = 'field_name';

async function createStoredInfoType() {
  // The name you want to give the dictionary.
  const displayName = 'GitHub usernames';
  // A description of the dictionary.
  const description = 'Dictionary of GitHub usernames used in commits';

  // Specify configuration for the large custom dictionary
  const largeCustomDictionaryConfig = {
    outputPath: {
      path: outputPath,
    },
    bigQueryField: {
      table: {
        datasetId: datasetId,
        projectId: dataProjectId,
        tableId: tableId,
      },
      field: {
        name: fieldName,
      },
    },
  };

  // Stored infoType configuration that uses large custom dictionary.
  const storedInfoTypeConfig = {
    displayName: displayName,
    description: description,
    largeCustomDictionary: largeCustomDictionaryConfig,
  };

  // Construct the job creation request to be sent by the client.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    config: storedInfoTypeConfig,
    storedInfoTypeId: infoTypeId,
  };

  // Send the job creation request and process the response.
  const [response] = await dlpClient.createStoredInfoType(request);

  // Print results
  console.log(`InfoType stored successfully: ${response.name}`);
}
await createStoredInfoType();

PHP

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

use Google\Cloud\Dlp\V2\BigQueryField;
use Google\Cloud\Dlp\V2\BigQueryTable;
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStoragePath;
use Google\Cloud\Dlp\V2\FieldId;
use Google\Cloud\Dlp\V2\LargeCustomDictionaryConfig;
use Google\Cloud\Dlp\V2\StoredInfoTypeConfig;

/**
 * Create a stored infoType.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $outputgcsPath     The path to the location in a Cloud Storage bucket to store the created dictionary.
 * @param string $storedInfoTypeId  The name of the custom stored info type.
 * @param string $displayName       The human-readable name to give the stored infoType.
 * @param string $description       A description for the stored infoType to be created.
 */
function create_stored_infotype(
    string $callingProjectId,
    string $outputgcsPath,
    string $storedInfoTypeId,
    string $displayName,
    string $description
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // The reference to the table containing the GitHub usernames.
    // The reference to the BigQuery field that contains the GitHub usernames.
    // Note: we have used public data
    $bigQueryField = (new BigQueryField())
        ->setTable((new BigQueryTable())
            ->setDatasetId('samples')
            ->setProjectId('bigquery-public-data')
            ->setTableId('github_nested'))
        ->setField((new FieldId())
            ->setName('actor'));

    $largeCustomDictionaryConfig = (new LargeCustomDictionaryConfig())
        // The output path where the custom dictionary containing the GitHub usernames will be stored.
        ->setOutputPath((new CloudStoragePath())
            ->setPath($outputgcsPath))
        ->setBigQueryField($bigQueryField);

    // Configure the StoredInfoType we want the service to perform.
    $storedInfoTypeConfig = (new StoredInfoTypeConfig())
        ->setDisplayName($displayName)
        ->setDescription($description)
        ->setLargeCustomDictionary($largeCustomDictionaryConfig);

    // Send the stored infoType creation request and process the response.
    $parent = "projects/$callingProjectId/locations/global";
    $response = $dlp->createStoredInfoType($parent, $storedInfoTypeConfig, [
        'storedInfoTypeId' => $storedInfoTypeId
    ]);

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

Python

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import google.cloud.dlp

def create_stored_infotype(
    project: str,
    stored_info_type_id: str,
    output_bucket_name: str,
) -> None:
    """Uses the Data Loss Prevention API to create stored infoType.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        stored_info_type_id: The identifier for large custom dictionary.
        output_bucket_name: The name of the bucket in Google Cloud Storage
            that would store the created dictionary.
    """

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

    # Construct the stored infoType Configuration dictionary. This example creates
    # a stored infoType from a term list stored in a publicly available BigQuery
    # database (bigquery-public-data.samples.github_nested).
    # The database contains all GitHub usernames used in commits.
    stored_info_type_config = {
        "display_name": "GitHub usernames",
        "description": "Dictionary of GitHub usernames used in commits",
        "large_custom_dictionary": {
            "output_path": {"path": f"gs://{output_bucket_name}"},
            # We can either use bigquery field or gcs file as a term list input option.
            "big_query_field": {
                "table": {
                    "project_id": "bigquery-public-data",
                    "dataset_id": "samples",
                    "table_id": "github_nested",
                },
                "field": {"name": "actor"},
            },
        },
    }

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

    # Call the API.
    response = dlp.create_stored_info_type(
        request={
            "parent": parent,
            "config": stored_info_type_config,
            "stored_info_type_id": stored_info_type_id,
        }
    )

    # Print the result
    print(f"Created Stored InfoType: {response.name}")

REST

1. Erstellen Sie in einem Cloud Storage-Bucket einen neuen Ordner für das Wörterbuch. Beim Schutz sensibler Daten werden Ordner mit den Wörterbuchdateien an dem von Ihnen angegebenen Speicherort erstellt.
Hinweis : Legen Sie keine Dateien in den Ordnern ab, die beim Erstellen des Wörterbuchs durch den Schutz sensibler Daten erstellt werden. Beim Schutz sensibler Daten werden beim Erstellen oder Neuerstellen von Wörterbuchdateien alle anderen Dateien gelöscht, die in den von ihm erstellten Ordnern gespeichert sind. Alle Ordner, die sich auf derselben Ebene befinden wie die Ordner, die vom Schutz sensibler Daten erstellt werden, werden beibehalten.
2. Erstellen Sie das Wörterbuch mit der Methode storedInfoTypes.create. Die Methode create verwendet folgende Parameter:
   • Ein StoredInfoTypeConfig-Objekt, das die Konfiguration des gespeicherten infoType enthält. Sie umfasst Folgendes:
     • description: eine Beschreibung des Wörterbuchs.
     • displayName: der Name, den Sie dem Wörterbuch geben möchten.
     • LargeCustomDictionaryConfig: enthält die Konfiguration des großen benutzerdefinierten Wörterbuchs. Es enthält Folgendes:
       • BigQueryField: wird angegeben, wenn die Begriffsliste in BigQuery gespeichert ist. Enthält einen Verweis auf die Tabelle, in der Ihre Liste gespeichert ist, sowie das Feld, das die einzelnen Wörterbuchsätze enthält.
       • CloudStorageFileSet: wird angegeben, wenn die Begriffsliste in Cloud Storage gespeichert ist. Enthält die URL zum Quellspeicherort in Cloud Storage im folgenden Format: "gs://[PATH_TO_GS]". Platzhalter werden unterstützt.
       Hinweis : Sie können in LargeCustomDictionaryConfig entweder BigQueryField oder CloudStorageFileSet angeben, aber nicht beides.
       • outputPath: der Pfad zum Speicherort in einem Cloud Storage-Bucket, in dem das erstellte Wörterbuch gespeichert wird.
   • storedInfoTypeId: Die Kennung für den gespeicherten infoType. Mit dieser Kennung verweisen Sie auf den gespeicherten infoType, wenn Sie ihn neu erstellen, löschen oder in einem Inspektions- oder De-Identifikationsjob verwenden. Wenn Sie dieses Feld leer lassen, generiert das System eine Kennzeichnung für Sie.

Es folgt ein Beispiel für JSON-Code, der beim Senden an die Methode storedInfoTypes.create einen neuen gespeicherten infoType erstellt, insbesondere einen großen benutzerdefinierten Wörterbuchdetektor. In diesem Beispiel wird ein gespeicherter infoType aus einer Begriffsliste erstellt, die in einer öffentlich verfügbaren BigQuery-Datenbank (bigquery-public-data.samples.github_nested) gespeichert ist. Die Datenbank enthält alle GitHub-Nutzernamen, die in Commits verwendet werden. Der Ausgabepfad für das generierte Wörterbuch wird auf einen Cloud Storage-Bucket namens dlptesting festgelegt und der gespeicherte infoType heißt github-usernames.

JSON-Eingabe

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

{
  "config":{
    "displayName":"GitHub usernames",
    "description":"Dictionary of GitHub usernames used in commits",
    "largeCustomDictionary":{
      "outputPath":{
        "path":"gs://[PATH_TO_GS]"
      },
      "bigQueryField":{
        "table":{
          "datasetId":"samples",
          "projectId":"bigquery-public-data",
          "tableId":"github_nested"
        }
      }
    }
  },
  "storedInfoTypeId":"github-usernames"
}

Wörterbuch neu erstellen

Wenn Sie Ihr Wörterbuch aktualisieren möchten, aktualisieren Sie zuerst die Liste der Quellbegriffe und weisen Sie dann den Schutz sensibler Daten an, den gespeicherten infoType neu zu erstellen.

1. Aktualisieren Sie die vorhandene Liste der Quellbegriffe in Cloud Storage oder BigQuery.

   Fügen Sie die Begriffe oder Wortgruppen nach Bedarf hinzu, entfernen oder ändern Sie sie.

2. Erstellen Sie eine neue Version des gespeicherten infoType. Dazu „erstellen“ Sie ihn entweder mit der Google Cloud Console oder der Methode storedInfoTypes.patch.

   Bei der Neuerstellung wird eine neue Version des Wörterbuchs erstellt, die das alte Wörterbuch ersetzt.

Wenn Sie einen gespeicherten infoType in einer neuen Version neu erstellen, wird die alte Version gelöscht. Während der Schutz sensibler Daten den gespeicherten infoType aktualisiert, ist sein Status „Ausstehend“. Während dieser Zeit ist die alte Version des gespeicherten infoType noch vorhanden. Alle Scans, die Sie ausführen, während sich der gespeicherte infoType im Status „Ausstehend“ befindet, werden mit der alten Version des gespeicherten infoType ausgeführt.

So erstellen Sie den gespeicherten infoType neu:

Console

1. Aktualisieren und speichern Sie die Begriffsliste in Cloud Storage oder BigQuery.

2. Rufen Sie in der Google Cloud Console die Liste der gespeicherten infoTypes auf.

   Zu gespeicherten infoTypes

3. Klicken Sie auf die ID des gespeicherten infoType, den Sie aktualisieren möchten.

4. Klicken Sie auf der Seite infoType-Details auf Daten neu erstellen.

Der Schutz sensibler Daten erstellt den gespeicherten infoType mit den Änderungen, die Sie an der Liste der Quellbegriffe vorgenommen haben, neu. Sobald der Status des gespeicherten infoTypes „Bereit“ ist, können Sie ihn verwenden. Alle Vorlagen oder Job-Trigger, die den gespeicherten infoType verwenden, verwenden automatisch die neu erstellte Version.

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

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

public class UpdateStoredInfoTypes
{
    public static StoredInfoType Update(
        string gcsFileUri,
        string storedInfoTypePath,
        string outputPath)
    {
        // Instantiate the client.
        var dlp = DlpServiceClient.Create();

        // Construct the stored infotype config. Here, we will change the source from bigquery table to GCS file.
        var storedConfig = new StoredInfoTypeConfig
        {
            LargeCustomDictionary = new LargeCustomDictionaryConfig
            {
                CloudStorageFileSet = new CloudStorageFileSet
                {
                    Url = gcsFileUri
                },
                OutputPath = new CloudStoragePath
                {
                    Path = outputPath
                }
            }
        };

        // Construct the request using the stored config by specifying the update mask object
        // which represent the path of field to be updated.
        var request = new UpdateStoredInfoTypeRequest
        {
            Config = storedConfig,
            Name = storedInfoTypePath,
            UpdateMask = new FieldMask
            {
                Paths =
                {
                    "large_custom_dictionary.cloud_storage_file_set.url"
                }
            }
        };

        // Call the API.
        StoredInfoType response = dlp.UpdateStoredInfoType(request);

        // Inspect the result.
        Console.WriteLine(response);
        return response;
    }
}

Go

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateStoredInfoType uses the Data Loss Prevention API to update stored infoType
// detector by changing the source term list from one stored in Bigquery
// to one stored in Cloud Storage.
func updateStoredInfoType(w io.Writer, projectID, gcsUri, fileSetUrl, infoTypeId string) error {
	// projectId := "your-project-id"
	// gcsUri := "gs://" + "your-bucket-name" + "/path/to/your/file.txt"
	// fileSetUrl := "your-cloud-storage-file-set"
	// infoTypeId := "your-stored-info-type-id"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Set path in Cloud Storage.
	cloudStoragePath := &dlppb.CloudStoragePath{
		Path: gcsUri,
	}
	cloudStorageFileSet := &dlppb.CloudStorageFileSet{
		Url: fileSetUrl,
	}

	// Configuration for a custom dictionary created from a data source of any size
	largeCustomDictionaryConfig := &dlppb.LargeCustomDictionaryConfig{
		OutputPath: cloudStoragePath,
		Source: &dlppb.LargeCustomDictionaryConfig_CloudStorageFileSet{
			CloudStorageFileSet: cloudStorageFileSet,
		},
	}

	// Set configuration for stored infoTypes.
	storedInfoTypeConfig := &dlppb.StoredInfoTypeConfig{
		Type: &dlppb.StoredInfoTypeConfig_LargeCustomDictionary{
			LargeCustomDictionary: largeCustomDictionaryConfig,
		},
	}

	// Set mask to control which fields get updated.
	fieldMask := &fieldmaskpb.FieldMask{
		Paths: []string{"large_custom_dictionary.cloud_storage_file_set.url"},
	}
	// Construct the job creation request to be sent by the client.
	req := &dlppb.UpdateStoredInfoTypeRequest{
		Name:       fmt.Sprint("projects/" + projectID + "/storedInfoTypes/" + infoTypeId),
		Config:     storedInfoTypeConfig,
		UpdateMask: fieldMask,
	}

	// Use the client to send the API request.
	resp, err := client.UpdateStoredInfoType(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "output: %v", resp.Name)
	return nil
}

Java

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CloudStorageFileSet;
import com.google.privacy.dlp.v2.CloudStoragePath;
import com.google.privacy.dlp.v2.LargeCustomDictionaryConfig;
import com.google.privacy.dlp.v2.StoredInfoType;
import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
import com.google.privacy.dlp.v2.StoredInfoTypeName;
import com.google.privacy.dlp.v2.UpdateStoredInfoTypeRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateStoredInfoType {
  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The path to file in GCS bucket that holds a collection of words and phrases to be searched by
    // the new infoType detector.
    String filePath = "gs://" + "your-bucket-name" + "/path/to/your/file.txt";
    // The path to the location in a GCS bucket to store the created dictionary.
    String outputPath = "your-cloud-storage-file-set";
    // The name of the stored InfoType which is to be updated.
    String infoTypeId = "your-stored-info-type-id";
    updateStoredInfoType(projectId, filePath, outputPath, infoTypeId);
  }

  // Update the stored info type rebuilding the Custom dictionary.
  public static void updateStoredInfoType(
      String projectId, String filePath, String outputPath, String infoTypeId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlp = DlpServiceClient.create()) {
      // Set path in Cloud Storage.
      CloudStoragePath cloudStoragePath = CloudStoragePath.newBuilder().setPath(outputPath).build();
      CloudStorageFileSet cloudStorageFileSet =
          CloudStorageFileSet.newBuilder().setUrl(filePath).build();

      // Configuration for a custom dictionary created from a data source of any size
      LargeCustomDictionaryConfig largeCustomDictionaryConfig =
          LargeCustomDictionaryConfig.newBuilder()
              .setOutputPath(cloudStoragePath)
              .setCloudStorageFileSet(cloudStorageFileSet)
              .build();

      // Set configuration for stored infoTypes.
      StoredInfoTypeConfig storedInfoTypeConfig =
          StoredInfoTypeConfig.newBuilder()
              .setLargeCustomDictionary(largeCustomDictionaryConfig)
              .build();

      // Set mask to control which fields get updated.
      // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
      FieldMask fieldMask =
          FieldMask.newBuilder()
              .addPaths("large_custom_dictionary.cloud_storage_file_set.url")
              .build();

      // Construct the job creation request to be sent by the client.
      UpdateStoredInfoTypeRequest updateStoredInfoTypeRequest =
          UpdateStoredInfoTypeRequest.newBuilder()
              .setName(
                  StoredInfoTypeName.ofProjectStoredInfoTypeName(projectId, infoTypeId).toString())
              .setConfig(storedInfoTypeConfig)
              .setUpdateMask(fieldMask)
              .build();

      // Send the job creation request and process the response.
      StoredInfoType response = dlp.updateStoredInfoType(updateStoredInfoTypeRequest);

      // Print the results.
      System.out.println("Updated stored InfoType successfully: " + response.getName());
    }
  }
}

Node.js

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

// Import the required libraries
const dlp = require('@google-cloud/dlp');

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

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The identifier for the stored infoType
// const infoTypeId = 'github-usernames';

// The path to the location in a Cloud Storage bucket to store the created dictionary
// const outputPath = 'cloud-bucket-path';

// Path of file containing term list
// const cloudStorageFileSet = 'gs://[PATH_TO_GS]';

async function updateStoredInfoType() {
  // Specify configuration of the large custom dictionary including cloudStorageFileSet and outputPath
  const largeCustomDictionaryConfig = {
    outputPath: {
      path: outputPath,
    },
    cloudStorageFileSet: {
      url: fileSetUrl,
    },
  };

  // Construct the job creation request to be sent by the client.
  const updateStoredInfoTypeRequest = {
    name: `projects/${projectId}/storedInfoTypes/${infoTypeId}`,
    config: {
      largeCustomDictionary: largeCustomDictionaryConfig,
    },
    updateMask: {
      paths: ['large_custom_dictionary.cloud_storage_file_set.url'],
    },
  };

  // Send the job creation request and process the response.
  const [response] = await dlpClient.updateStoredInfoType(
    updateStoredInfoTypeRequest
  );

  // Print the results.
  console.log(`InfoType updated successfully: ${JSON.stringify(response)}`);
}
await updateStoredInfoType();

PHP

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStorageFileSet;
use Google\Cloud\Dlp\V2\CloudStoragePath;
use Google\Cloud\Dlp\V2\LargeCustomDictionaryConfig;
use Google\Cloud\Dlp\V2\StoredInfoTypeConfig;
use Google\Protobuf\FieldMask;

/**
 * Rebuild/Update the stored infoType.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $gcsPath           The path to file in GCS bucket that holds a collection of words and phrases to be searched by the new infoType detector.
 * @param string $outputgcsPath     The path to the location in a Cloud Storage bucket to store the created dictionary.
 * @param string $storedInfoTypeId  The name of the stored InfoType which is to be updated.
 *
 */
function update_stored_infotype(
    string $callingProjectId,
    string $gcsPath,
    string $outputgcsPath,
    string $storedInfoTypeId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Set path in Cloud Storage.
    $cloudStorageFileSet = (new CloudStorageFileSet())
        ->setUrl($gcsPath);

    // Configuration for a custom dictionary created from a data source of any size
    $largeCustomDictionaryConfig = (new LargeCustomDictionaryConfig())
        ->setOutputPath((new CloudStoragePath())
            ->setPath($outputgcsPath))
        ->setCloudStorageFileSet($cloudStorageFileSet);

    // Set configuration for stored infoTypes.
    $storedInfoTypeConfig = (new StoredInfoTypeConfig())
        ->setLargeCustomDictionary($largeCustomDictionaryConfig);

    // Send the stored infoType creation request and process the response.

    $name = "projects/$callingProjectId/locations/global/storedInfoTypes/" . $storedInfoTypeId;
    // Set mask to control which fields get updated.
    // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
    $fieldMask = (new FieldMask())
        ->setPaths([
            'large_custom_dictionary.cloud_storage_file_set.url'
        ]);

    // Run request
    $response = $dlp->updateStoredInfoType($name, [
        'config' => $storedInfoTypeConfig,
        'updateMask' => $fieldMask
    ]);

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

Python

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import google.cloud.dlp

def update_stored_infotype(
    project: str,
    stored_info_type_id: str,
    gcs_input_file_path: str,
    output_bucket_name: str,
) -> None:
    """Uses the Data Loss Prevention API to update stored infoType
    detector by changing the source term list from one stored in Bigquery
    to one stored in Cloud Storage.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        stored_info_type_id: The identifier of stored infoType which is to
            be updated.
        gcs_input_file_path: The url in the format <bucket>/<path_to_file>
            for the location of the source term list.
        output_bucket_name: The name of the bucket in Google Cloud Storage
            where large dictionary is stored.
    """

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

    # Construct the stored infoType configuration dictionary.
    stored_info_type_config = {
        "large_custom_dictionary": {
            "output_path": {"path": f"gs://{output_bucket_name}"},
            "cloud_storage_file_set": {"url": f"gs://{gcs_input_file_path}"},
        }
    }

    # Set mask to control which fields get updated. For more details, refer
    # https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
    # for constructing the field mask paths.
    field_mask = {"paths": ["large_custom_dictionary.cloud_storage_file_set.url"]}

    # Convert the stored infoType id into a full resource id.
    stored_info_type_name = (
        f"projects/{project}/locations/global/storedInfoTypes/{stored_info_type_id}"
    )

    # Call the API.
    response = dlp.update_stored_info_type(
        request={
            "name": stored_info_type_name,
            "config": stored_info_type_config,
            "update_mask": field_mask,
        }
    )

    # Print the result
    print(f"Updated stored infoType successfully: {response.name}")

REST

Begriffsliste aktualisieren

Wenn Sie nur die Liste der Begriffe im großen benutzerdefinierten Wörterbuch aktualisieren, benötigt Ihre storedInfoTypes.patch-Anfrage nur das Feld name. Geben Sie den vollständigen Ressourcennamen des gespeicherten infoTypes an, den Sie neu erstellen möchten.

Die folgenden Muster stellen gültige Einträge für das Feld name dar:

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

Ersetzen Sie STORED_INFOTYPE_ID durch die ID des gespeicherten infoTypes, den Sie neu erstellen möchten.

Wenn Sie die Kennzeichnung des gespeicherten infoTypes nicht kennen, rufen Sie die Methode storedInfoTypes.list auf, um eine Liste aller aktuell gespeicherten infoTypes anzusehen.

Hinweis: Gespeicherte infoTypes haben zwar keine Versionsnummern, aber jeder hat ein createTime-Feld, das bei jeder Neuerstellung aktualisiert wird. Rufen Sie mit der Methode storedInfoTypes.get Informationen zum gespeicherten infoType ab. Ermitteln Sie mit dem Feld createTime, wann er zuletzt neu erstellt wurde.

Beispiel

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

In diesem Fall ist kein Anfragetext erforderlich.

Liste der Quellbegriffe ändern

Sie können die Liste der Quellbegriffe für einen gespeicherten infoType von einer in BigQuery gespeicherten in eine in Cloud Storage gespeicherte Liste ändern. Verwenden Sie die Methode storedInfoTypes.patch, aber fügen Sie ein CloudStorageFileSet-Objekt in LargeCustomDictionaryConfig ein, in dem Sie zuvor ein BigQueryField-Objekt verwendet haben. Legen Sie dann den Parameter updateMask auf den gespeicherten, neu erstellten infoType-Parameter im Format FieldMask fest. Beispielsweise gibt die folgende JSON im Parameter updateMask an, dass die URL des Cloud Storage-Pfads aktualisiert wurde (large_custom_dictionary.cloud_storage_file_set.url):

Beispiel

PATCH https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes/github-usernames

{
  "config":{
    "largeCustomDictionary":{
      "cloudStorageFileSet":{
        "url":"gs://[BUCKET_NAME]/[PATH_TO_FILE]"
      }
    }
  },
  "updateMask":"large_custom_dictionary.cloud_storage_file_set.url"
}

Ebenso können Sie Ihre Begriffsliste von einer in einer BigQuery-Tabelle gespeicherten Begriffsliste auf eine in einem Cloud Storage-Bucket gespeicherte Begriffsliste umstellen.

Inhalte mit einem großen benutzerdefinierten Wörterbuchdetektor scannen

Das Scannen von Inhalten mit einem großen benutzerdefinierten Wörterbuchdetektor ähnelt dem Scannen von Inhalten mit einem anderen benutzerdefinierten infoType-Detektor.

Bei diesem Verfahren wird davon ausgegangen, dass Sie einen vorhandenen gespeicherten infoType haben. Weitere Informationen finden Sie auf dieser Seite unter Gespeicherten infoType erstellen.

Console

Sie können einen großen benutzerdefinierten Wörterbuchdetektor anwenden, wenn Sie Folgendes tun:

• Neuen Job erstellen
• Job-Trigger erstellen oder bearbeiten
• Vorlagen erstellen oder bearbeiten
• Datenprofilerstellung konfigurieren

Im Abschnitt Erkennung konfigurieren der Seite können Sie im Unterabschnitt infoTypes den großen benutzerdefinierten Wörterbuch-infoType angeben.

1. Klicken Sie auf infoTypes verwalten.
2. Klicken Sie im Bereich InfoTypes auf den Tab InfoTypes.
3. Klicken Sie auf Benutzerdefinierten infoType hinzufügen.

4. Führen Sie im Bereich Benutzerdefinierten infoType hinzufügen die folgenden Schritte aus:

   1. Wählen Sie für Typ die Option Gespeicherter infoType aus.
   2. Geben Sie als InfoType einen Namen für den benutzerdefinierten infoType ein. Sie können Buchstaben, Ziffern und Unterstriche verwenden.

   3. Wählen Sie unter Wahrscheinlichkeit die Standardwahrscheinlichkeit aus, die Sie allen Ergebnissen zuweisen möchten, die diesem benutzerdefinierten infoType entsprechen. Sie können die Wahrscheinlichkeit einzelner Ergebnisse mithilfe von Hotword-Regeln weiter optimieren.

      Wenn Sie keinen Standardwert angeben, wird die Standardwahrscheinlichkeitsstufe auf VERY_LIKELY festgelegt. Weitere Informationen finden Sie unter Übereinstimmungswahrscheinlichkeit.

   4. Wählen Sie unter Empfindlichkeit die Empfindlichkeitsstufe aus, die Sie allen Ergebnissen zuweisen möchten, die diesem benutzerdefinierten infoType entsprechen. Wenn Sie keinen Wert angeben, werden die Vertraulichkeitsstufen dieser Ergebnisse auf HIGH festgelegt.

      Empfindlichkeitswerte werden in Datenprofilen verwendet. Bei der Profilerstellung für Ihre Daten verwendet der Schutz sensibler Daten die Vertraulichkeitswerte der infoTypes, um die Vertraulichkeitsstufe zu berechnen.

   5. Wählen Sie unter Gespeicherter infoType-Name den gespeicherten infoType aus, auf dem der neue benutzerdefinierte infoType basieren soll.

   6. Klicken Sie auf Fertig, um den Bereich Benutzerdefinierten infoType hinzufügen zu schließen.

5. Optional: Bearbeiten Sie auf dem Tab Integriert Ihre Auswahl der integrierten infoTypes.

6. Klicken Sie auf Fertig, um den Bereich infoTypes zu schließen.

   Der benutzerdefinierte infoType wird der Liste der infoTypes hinzugefügt, nach denen der Schutz sensibler Daten sucht. Diese Auswahl ist jedoch erst endgültig, wenn Sie den Job, den Job-Trigger, die Vorlage oder die Scankonfiguration gespeichert haben.

7. Wenn Sie die Konfiguration erstellt oder bearbeitet haben, klicken Sie auf Speichern.

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

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

public class InspectDataWithStoredInfotypes
{
    public static InspectContentResponse Inspect(
        string projectId,
        string storedInfotypePath,
        string text,
        InfoType infoType = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the infotype if null.
        var infotype = infoType ?? new InfoType { Name = "GITHUB_LOGINS" };

        // Construct the inspect config using stored infotype.
        var inspectConfig = new InspectConfig
        {
            CustomInfoTypes =
            {
                new CustomInfoType
                {
                    InfoType = infotype,
                    StoredType = new StoredType { Name = storedInfotypePath }
                }
            },
            IncludeQuote = true
        };

        // Construct the request using inspect config.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            InspectConfig = inspectConfig,
            Item = new ContentItem { Value = text }
        };

        // Call the API.
        InspectContentResponse response = dlp.InspectContent(request);

        // Inspect the results.
        var findings = response.Result.Findings;
        Console.WriteLine($"Findings: {findings.Count}");
        foreach (var f in findings)
        {
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tInfo type: " + f.InfoType.Name);
            Console.WriteLine("\tLikelihood: " + f.Likelihood);
        }

        return response;
    }
}

Go

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import (
	"context"
	"fmt"
	"io"

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

// inspectWithStoredInfotype inspects the given text using the specified stored infoType detector.
func inspectWithStoredInfotype(w io.Writer, projectID, infoTypeId, textToDeidentify string) error {
	// projectId := "your-project-id"
	// infoTypeId := "your-info-type-id"
	// textToDeidentify := "This commit was made by kewin2010"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Specify the content to be inspected.
	contentItem := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_Value{
			Value: textToDeidentify,
		},
	}

	// Specify the info type the inspection will look for.
	infoType := &dlppb.InfoType{
		Name: "GITHUB_LOGINS",
	}

	// Specify the stored info type the inspection will look for.
	storedType := &dlppb.StoredType{
		Name: infoTypeId,
	}

	customInfoType := &dlppb.CustomInfoType{
		InfoType: infoType,
		Type: &dlppb.CustomInfoType_StoredType{
			StoredType: storedType,
		},
	}

	// Specify how the content should be inspected.
	inspectConfig := &dlppb.InspectConfig{
		CustomInfoTypes: []*dlppb.CustomInfoType{
			customInfoType,
		},
		IncludeQuote: true,
	}

	// Construct the Inspect request to be sent by the client.
	req := &dlppb.InspectContentRequest{
		Parent:        fmt.Sprintf("projects/%s/locations/global", projectID),
		InspectConfig: inspectConfig,
		Item:          contentItem,
	}

	// Use the client to send the API request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return err
	}

	// Process the results.
	fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
	for _, f := range resp.Result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.CustomInfoType;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.ProjectStoredInfoTypeName;
import com.google.privacy.dlp.v2.StoredType;
import java.io.IOException;

public class InspectWithStoredInfotype {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    // The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The sample assumes that you have an existing stored infoType.
    // To create a stored InfoType refer:
    // https://cloud.google.com/dlp/docs/creating-stored-infotypes#create-storedinfotye
    String storedInfoTypeId = "your-info-type-id";
    // The string to de-identify.
    String textToInspect =
        "My phone number is [phone] and my email address is [e-mail].";
    inspectWithStoredInfotype(projectId, storedInfoTypeId, textToInspect);
  }

  //  Inspects the given text using the specified stored infoType detector.
  public static void inspectWithStoredInfotype(
      String projectId, String storedInfoTypeId, String textToInspect) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlp = DlpServiceClient.create()) {

      // Specify the content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToInspect).build();

      InfoType infoType = InfoType.newBuilder().setName("STORED_TYPE").build();

      // Reference to the existing StoredInfoType to inspect the data.
      StoredType storedType = StoredType.newBuilder()
              .setName(ProjectStoredInfoTypeName.of(projectId, storedInfoTypeId).toString())
              .build();

      CustomInfoType customInfoType =
          CustomInfoType.newBuilder().setInfoType(infoType).setStoredType(storedType).build();

      // Construct the configuration for the Inspect request.
      InspectConfig inspectConfig =
          InspectConfig.newBuilder()
              .addCustomInfoTypes(customInfoType)
              .setIncludeQuote(true)
              .build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest inspectContentRequest =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectConfig(inspectConfig)
              .setItem(contentItem)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(inspectContentRequest);

      // Parse the response and process results.
      System.out.println("Findings: " + "" + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfoType: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood() + "\n");
      }
    }
  }
}

Node.js

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

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

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

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

// The custom info-type id created and stored in the bucket.
// const infoTypeId = 'your-info-type-id';

// The string to inspect.
// const string = 'My phone number is [phone] and my email address is [e-mail].';

async function inspectWithStoredInfotype() {
  // Reference to the existing StoredInfoType to inspect the data.
  const customInfoType = {
    infoType: {
      name: 'GITHUB_LOGINS',
    },
    storedType: {
      name: infoTypeId,
    },
  };

  // Construct the configuration for the Inspect request.
  const inspectConfig = {
    customInfoTypes: [customInfoType],
    includeQuote: true,
  };

  // Construct the Inspect request to be sent by the client.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectConfig: inspectConfig,
    item: {
      value: string,
    },
  };
  // Run request
  const [response] = await dlp.inspectContent(request);

  // Print Findings
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log(`Findings: ${findings.length}\n`);
    findings.forEach(finding => {
      console.log(`InfoType: ${finding.infoType.name}`);
      console.log(`\tQuote: ${finding.quote}`);
      console.log(`\tLikelihood: ${finding.likelihood} \n`);
    });
  } else {
    console.log('No findings.');
  }
}
await inspectWithStoredInfotype();

PHP

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\CustomInfoType;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\StoredType;

/**
 * Inspect with stored infoType.
 * Scan content using a large custom dictionary detector.
 *
 * @param string $projectId             The Google Cloud Project ID to run the API call under.
 * @param string $storedInfoTypeName    The name of the stored infotype whose This value must be in the format
 * projects/projectName/(locations/locationId)/storedInfoTypes/storedInfoTypeName.
 * @param string $textToInspect         The string to inspect.
 */
function inspect_with_stored_infotype(
    string $projectId,
    string $storedInfoTypeName,
    string $textToInspect
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

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

    // Specify the content to be inspected.
    $item = (new ContentItem())
        ->setValue($textToInspect);

    // Reference to the existing StoredInfoType to inspect the data.
    $customInfoType = (new CustomInfoType())
        ->setInfoType((new InfoType())
            ->setName('STORED_TYPE'))
        ->setStoredType((new StoredType())
            ->setName($storedInfoTypeName));

    // Construct the configuration for the Inspect request.
    $inspectConfig = (new InspectConfig())
        ->setCustomInfoTypes([$customInfoType])
        ->setIncludeQuote(true);

    // Run request.
    $response = $dlp->inspectContent([
        'parent' => $parent,
        'inspectConfig' => $inspectConfig,
        'item' => $item
    ]);

    // Print the results.
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        printf('No findings.' . PHP_EOL);
    } else {
        printf('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            printf('  Quote: %s' . PHP_EOL, $finding->getQuote());
            printf('  Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
            printf('  Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
        }
    }
}

Python

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 Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

Auf GitHub ansehen Feedback

import google.cloud.dlp

def inspect_with_stored_infotype(
    project: str,
    stored_info_type_id: str,
    content_string: str,
) -> None:
    """Uses the Data Loss Prevention API to inspect/scan content using stored
    infoType.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        content_string: The string to inspect.
        stored_info_type_id: The identifier of stored infoType used to inspect.
    """

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

    # Convert stored infoType id into full resource id
    stored_type_name = f"projects/{project}/storedInfoTypes/{stored_info_type_id}"

    # Construct a custom info type dictionary using stored infoType.
    custom_info_types = [
        {
            "info_type": {"name": "STORED_TYPE"},
            "stored_type": {
                "name": stored_type_name,
            },
        }
    ]

    # Construct the inspection configuration dictionary.
    inspect_config = {
        "custom_info_types": custom_info_types,
        "include_quote": True,
    }

    # Construct the `item` to be inspected using stored infoType.
    item = {"value": content_string}

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

    # Call the API.
    response = dlp.inspect_content(
        request={
            "parent": parent,
            "inspect_config": inspect_config,
            "item": item,
        }
    )

    # Print out the results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")

REST

Wenn das folgende Beispiel an die Methode content.inspect gesendet wird, wird der angegebene Text mithilfe des angegebenen gespeicherten infoType-Detektors gescannt. Der Parameter infoType ist erforderlich, da alle benutzerdefinierten infoTypes einen Namen haben müssen, der nicht mit integrierten infoTypes oder anderen benutzerdefinierten infoTypes in Konflikt steht. Der Parameter storedType enthält den vollständigen Ressourcenpfad des gespeicherten infoType.

JSON-Eingabe

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/content:inspect

{
  "inspectConfig":{
    "customInfoTypes":[
      {
        "infoType":{
          "name":"GITHUB_LOGINS"
        },
        "storedType":{
          "name":"projects/PROJECT_ID/storedInfoTypes/github-logins"
        }
      }
    ]
  },
  "item":{
    "value":"The commit was made by githubuser."
  }
}

Fehler beheben

Wenn Sie beim Erstellen eines gespeicherten infoType aus einer in Cloud Storage gespeicherten Begriffsliste eine Fehlermeldung erhalten, gibt es folgende mögliche Ursachen:

• Sie haben eine Obergrenze für gespeicherte infoTypes erreicht. Je nach Problem gibt es verschiedene Umgehungen:
  • Wenn Sie die Obergrenze für eine einzelne Eingabedatei in Cloud Storage (200 MB) erreichen, versuchen Sie, die Datei in mehrere Dateien aufzuteilen. Sie können mehrere Dateien verwenden, um ein einzelnes benutzerdefiniertes Wörterbuch zu erstellen, solange die Gesamtgröße aller Dateien 1 GB nicht überschreitet.
  • Für BigQuery gelten nicht dieselben Limits wie für Cloud Storage. Ziehen Sie in Betracht, die Begriffe in eine BigQuery-Tabelle zu verschieben. Die maximale Größe einer benutzerdefinierten Wörterbuchspalte in BigQuery beträgt 1 GB und die maximale Anzahl von Zeilen 5.000.000.
  • Wenn Ihre Begriffslistendatei alle anwendbaren Limits für Quellbegriffslisten überschreitet, müssen Sie die Begriffslistendatei in mehrere Dateien aufteilen und für jede Datei ein Wörterbuch erstellen. Erstellen Sie dann für jedes Wörterbuch einen separaten Scanjob.
• Einer oder mehrere Ihrer Begriffe enthalten nicht mindestens einen Buchstaben oder eine Ziffer. Der Schutz sensibler Daten kann nicht nach Begriffen suchen, die ausschließlich aus Leerzeichen oder Symbolen bestehen. Mindestens ein Buchstabe oder eine Ziffer muss enthalten sein. Sehen Sie sich Ihre Begriffsliste an, prüfen Sie, ob solche Begriffe enthalten sind, und korrigieren oder löschen Sie sie dann.
• Ihre Begriffsliste enthält eine Wortgruppe mit zu vielen "Komponenten". Eine Komponente in diesem Kontext ist eine fortlaufende Sequenz, die nur Buchstaben, nur Ziffern oder nur Nicht-Buchstaben- und Nicht-Ziffern-Zeichen wie Leerzeichen oder Symbole enthält. Sehen Sie sich Ihre Begriffsliste an, prüfen Sie, ob solche Begriffe enthalten sind, und korrigieren oder löschen Sie sie dann.
• Der Dienst-Agent für den Schutz sensibler Daten hat keinen Zugriff auf die Wörterbuchquelldaten oder auf den Cloud Storage-Bucket zum Speichern von Wörterbuchdateien. Um dieses Problem zu beheben, weisen Sie dem Dienst-Agent für den Schutz sensibler Daten die Rollen „Storage-Administrator“ (roles/storage.admin) oder die Rollen „BigQuery-Dateninhaber“ (roles/bigquery.dataOwner) und „BigQuery-Jobnutzer“ (roles/bigquery.jobUser) zu.

API-Übersicht

Das Erstellen eines gespeicherten infoType ist erforderlich, wenn Sie einen großen benutzerdefinierten Wörterbuchdetektor erstellen.

Hinweis: Wenn Sie einen regulären benutzerdefinierten Wörterbuchdetektor oder einen regulären Ausdrucksdetektor erstellen, müssen Sie keinen gespeicherten infoType erstellen. Es ist einfacher, sie direkt im CustomInfoType-Objekt zu definieren.

Ein gespeicherter infoType wird im Schutz sensibler Daten durch das Objekt StoredInfoType dargestellt. Es besteht aus den folgenden verwandten Objekten:

• StoredInfoTypeVersion enthält das Datum und die Uhrzeit der Erstellung sowie die letzten fünf Fehlermeldungen, die beim Erstellen der aktuellen Version aufgetreten sind.

  • StoredInfoTypeConfig enthält die Konfiguration des gespeicherten infoType, einschließlich Name und Beschreibung. Bei einem großen benutzerdefinierten Wörterbuch muss type ein LargeCustomDictionaryConfig sein.

    • LargeCustomDictionaryConfig gibt die beiden folgenden Speicherorte an:
      • Den Speicherort Ihrer Wortgruppenliste in Cloud Storage oder BigQuery.
      • Den Speicherort der generierten Wörterbuchdateien in Cloud Storage.

  • StoredInfoTypeState enthält den Status der aktuellen Version und alle ausstehenden Versionen des gespeicherten infoType. Statusinformationen geben Aufschluss darüber, ob der gespeicherte infoType neu erstellt wird, einsatzbereit oder ungültig ist.

Details zum Wörterbuchabgleich

Im Folgenden finden Sie Informationen dazu, wie der Schutz sensibler Daten mit Wörtern und Wortgruppen im Wörterbuch übereinstimmt. Diese Punkte gelten sowohl für reguläre als auch für große benutzerdefinierte Wörterbücher:

• Bei Wörtern in Wörterbüchern wird nicht zwischen Groß- und Kleinschreibung unterschieden. Wenn Ihr Wörterbuch Abby enthält, wird es auf abby, ABBY, Abby usw. abgestimmt.
• Alle Zeichen, ob in Wörterbüchern oder zu scannenden Inhalten, die nicht zu den in der Unicode Basic Multilingual Plane enthaltenen Buchstaben und Ziffern zählen, werden beim Scannen auf Übereinstimmungen wie Leerzeichen behandelt. Wenn Ihr Wörterbuch nach Abby Abernathy sucht, findet es abby abernathy, Abby, Abernathy, Abby (ABERNATHY) und so weiter als Übereinstimmungen.
• Die Zeichen in direkter Nachbarschaft zu einer Übereinstimmung müssen von einem anderen Typ sein (Buchstaben oder Ziffern) als die benachbarten Zeichen innerhalb des Worts. Wenn Ihr Wörterbuch nach Abi sucht, werden die ersten drei Zeichen von Abi904, aber nicht von Abigail als Übereinstimmung erkannt.
• Wörterbuchwörter, die Zeichen in der Supplementary Multilingual Plane des Unicode-Standards enthalten, können unerwartete Ergebnisse liefern. Beispiele für solche Zeichen sind Chinesisch, Japanisch, Koreanisch und Emojis.

Zum Erstellen, Bearbeiten oder Löschen eines gespeicherten infoType verwenden Sie die folgenden Methoden:

• storedInfoTypes.create: erstellt einen neuen gespeicherten infoType mit der von Ihnen angegebenen StoredInfoTypeConfig.
• storedInfoTypes.patch: Erstellt den gespeicherten infoType mit einer neuen StoredInfoTypeConfig, die Sie angeben. Wenn keine angegeben ist, erstellt diese Methode eine neue Version des gespeicherten infoType mit dem vorhandenen StoredInfoTypeConfig.
• storedInfoTypes.get: ruft die StoredInfoTypeConfig und alle ausstehenden Versionen des angegebenen gespeicherten infoType ab.
• storedInfoTypes.list: listet alle aktuell gespeicherten infoTypes auf.
• storedInfoTypes.delete: löscht den angegebenen gespeicherten infoType.