Cloud DLP-Clientbibliotheken

Auf dieser Seite werden die ersten Schritte mit den Cloud-Clientbibliotheken für die Cloud Data Loss Prevention API beschrieben. Weitere Informationen zu den Clientbibliotheken für Cloud APIs einschließlich der Clientbibliotheken für ältere Google APIs finden Sie unter Erläuterung zu Clientbibliotheken.

Die auf dieser Seite erwähnten Cloud DLP-Clientbibliotheken werden von Compute Engine, der flexiblen App Engine-Umgebung, Google Kubernetes Engine und Cloud-Funktionen unterstützt. Die Cloud DLP-Clientbibliothek für Java wird auf Java 8 in der App Engine-Standardumgebung unterstützt.

Wenn Sie in der App Engine-Standardumgebung mit Java 7, Go, PHP oder Python arbeiten möchten, verwenden Sie die REST-Schnittstelle, um auf Cloud DLP zuzugreifen.

Clientbibliothek installieren

C#

Weitere Informationen finden Sie unter .NET-Entwicklungsumgebung einrichten.

Öffnen Sie zum Erstellen und Ausführen eines Beispiels die Lösungsdatei (Dlp.sln) mit Visual Studio 2015 oder höher und erstellen Sie das Beispiel.

Weitere Informationen finden Sie in der README-Datei.

Go

Weitere Informationen finden Sie unter Go-Entwicklungsumgebung einrichten.

go get -u github.com/GoogleCloudPlatform/golang-samples/dlp

Java

Weitere Informationen finden Sie unter Java-Entwicklungsumgebung einrichten.

Wenn Sie Maven verwenden, fügen Sie der Datei pom.xml Folgendes hinzu:

<dependency>
    <groupId>com.google.cloud</groupId>
    <artifactId>google-cloud-dlp</artifactId>
    <version></version>
</dependency>

Wenn Sie Gradle verwenden, fügen Sie den Abhängigkeiten Folgendes hinzu:

compile group: 'com.google.cloud', name: 'google-cloud-dlp', version: ''

Node.js

Weitere Informationen finden Sie unter Node.js-Entwicklungsumgebung einrichten.

npm install --save @google-cloud/dlp

PHP

Weitere Informationen finden Sie unter PHP auf Google Cloud verwenden.

composer require google/cloud-dlp

Python

Weitere Informationen finden Sie unter Python-Entwicklungsumgebung einrichten.

  1. Installieren Sie pip und virtualenv, sofern noch nicht vorhanden. Anweisungen dazu finden Sie im Einrichtungsleitfaden für die Python-Entwicklungsumgebung für Google Cloud.
  2. Klonen oder laden Sie die Google Cloud Python-Dokumentbeispiele auf GitHub herunter.
  3. Erstellen Sie eine virtualenv. Die Beispiele sind kompatibel mit Python 2.7.x, 3.4 und höher.
    $ virtualenv env
    $ source env/bin/activate
  4. Installieren Sie aus dem dlp-Verzeichnis im geklonten oder entpackten Verzeichnis der Google Cloud Python-Dokumentbeispiele die Abhängigkeiten, die zum Ausführen der Beispiele erforderlich sind.
    $ pip install -r requirements.txt

Ruby

Weitere Informationen finden Sie unter Ruby-Entwicklungsumgebung einrichten.

gem install google-api-client

Authentifizierung einrichten

Wenn Sie die Clientbibliothek ausführen möchten, müssen Sie zuerst die Authentifizierung einrichten. Hierzu erstellen Sie ein Dienstkonto und legen eine Umgebungsvariable fest. Zum Einrichten der Authentifizierung führen Sie die folgenden Schritte aus. Weitere Möglichkeiten zur Authentifizierung finden Sie in der Dokumentation zur GCP-Authentifizierung.

Cloud Console

  1. Wechseln Sie in der Cloud Console zur Seite Dienstkontoschlüssel erstellen.

    Zur Seite "Dienstkontoschlüssel erstellen"
  2. Wählen Sie aus der Liste Dienstkonto die Option Neues Dienstkonto aus.
  3. Geben Sie im Feld Dienstkontoname einen Namen ein.
  4. Wählen Sie in der Liste Rolle die Option Projekt > Inhaber aus.

    Hinweis: Über das Feld Rolle wird Ihr Dienstkonto für den Zugriff auf Ressourcen autorisiert. Sie können dieses Feld später in der Cloud Console aufrufen und ändern. Wenn Sie eine Produktionsanwendung entwickeln, müssen Sie detailliertere Berechtigungen als Projekt > Inhaber angeben. Weitere Informationen finden Sie unter Dienstkonten Rollen zuweisen.
  5. Klicken Sie auf Erstellen. Eine JSON-Datei mit Ihrem Schlüssel wird auf Ihren Computer heruntergeladen.

Befehlszeile

Sie können die folgenden Befehle mithilfe des Cloud SDK auf Ihrem lokalen Computer oder in Cloud Shell ausführen.

  1. Erstellen Sie das Dienstkonto. Ersetzen Sie [NAME] mit einem Namen für das Dienstkonto.

    gcloud iam service-accounts create [NAME]
  2. Gewähren Sie dem Dienstkonto Berechtigungen. Geben Sie für [PROJECT_ID] Ihre Projekt-ID an.

    gcloud projects add-iam-policy-binding [PROJECT_ID] --member "serviceAccount:[NAME]@[PROJECT_ID].iam.gserviceaccount.com" --role "roles/owner"
    Hinweis: Über das Feld Rolle wird Ihr Dienstkonto für den Zugriff auf Ressourcen autorisiert. Sie können dieses Feld später in der Cloud Console ansehen und ändern. Wenn Sie eine Produktionsanwendung entwickeln, müssen Sie detailliertere Berechtigungen als Projekt > Inhaber festlegen. Weitere Informationen finden Sie unter Dienstkonten Rollen zuweisen.
  3. Erstellen Sie die Schlüsseldatei. Geben Sie für [FILE_NAME] einen Namen für die Schlüsseldatei an.

    gcloud iam service-accounts keys create [FILE_NAME].json --iam-account [NAME]@[PROJECT_ID].iam.gserviceaccount.com

Die Anmeldedaten zur Authentifizierung für Ihren Anwendungscode geben Sie durch Festlegung der Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS an. Geben Sie für [PATH] den Dateipfad der JSON-Datei an, die Ihren Dienstkontoschlüssel enthält. Diese Variable gilt nur für Ihre aktuelle Shell-Sitzung. Wenn Sie eine neue Sitzung öffnen, müssen Sie die Variable neu festlegen.

Linux oder macOS

export GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Beispiel:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/my-key.json"

Windows

Mit PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="[PATH]"

Beispiel:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\my-key.json"

Mit Eingabeaufforderung:

set GOOGLE_APPLICATION_CREDENTIALS=[PATH]

Clientbibliothek verwenden

Das folgende Beispiel zeigt die Verwendung der Clientbibliothek.

Go


// The quickstart program is an example of using the Data Loss Prevention API.
package main

import (
	"context"
	"fmt"
	"log"

	dlp "cloud.google.com/go/dlp/apiv2"
	dlppb "google.golang.org/genproto/googleapis/privacy/dlp/v2"
)

func main() {
	ctx := context.Background()

	projectID := "PROJECT_ID"

	// Creates a DLP client.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		log.Fatalf("error creating DLP client: %v", err)
	}

	// The string to inspect.
	input := "Robert Frost"

	// The minimum likelihood required before returning a match.
	minLikelihood := dlppb.Likelihood_POSSIBLE

	// The maximum number of findings to report (0 = server maximum).
	maxFindings := int32(0)

	// Whether to include the matching string.
	includeQuote := true

	// The infoTypes of information to match.
	infoTypes := []*dlppb.InfoType{
		{
			Name: "PERSON_NAME",
		},
		{
			Name: "US_STATE",
		},
	}

	// Construct item to inspect.
	item := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_Value{
			Value: input,
		},
	}

	// Construct request.
	req := &dlppb.InspectContentRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
		InspectConfig: &dlppb.InspectConfig{
			InfoTypes:     infoTypes,
			MinLikelihood: minLikelihood,
			Limits: &dlppb.InspectConfig_FindingLimits{
				MaxFindingsPerRequest: maxFindings,
			},
			IncludeQuote: includeQuote,
		},
		Item: item,
	}

	// Run request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		log.Fatal(err)
	}
	findings := resp.GetResult().GetFindings()
	if len(findings) == 0 {
		fmt.Println("No findings.")
	}
	fmt.Println("Findings:")
	for _, f := range findings {
		if includeQuote {
			fmt.Println("\tQuote: ", f.GetQuote())
		}
		fmt.Println("\tInfo type: ", f.GetInfoType().GetName())
		fmt.Println("\tLikelihood: ", f.GetLikelihood())
	}
}

Java


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ByteContentItem;
import com.google.privacy.dlp.v2.ContentItem;
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.InspectResult;
import com.google.privacy.dlp.v2.Likelihood;
import com.google.privacy.dlp.v2.LocationName;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class QuickStart {

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

  public static void quickstart(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()) {
      // Configure that content that will be inspected
      String text = "His name was Robert Frost";
      ByteContentItem byteContentItem =
          ByteContentItem.newBuilder()
              .setType(ByteContentItem.BytesType.TEXT_UTF8)
              .setData(ByteString.copyFromUtf8(text))
              .build();
      ContentItem contentItem = ContentItem.newBuilder().setByteItem(byteContentItem).build();

      // The types of information to match:
      // See: https://cloud.google.com/dlp/docs/infotypes-reference
      List<InfoType> infoTypes =
          Stream.of("PERSON_NAME", "US_STATE")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());

      // The minimum likelihood required before returning a match:
      // See: https://cloud.google.com/dlp/docs/likelihood
      Likelihood minLikelihood = Likelihood.POSSIBLE;

      // The maximum number of findings to report (0 = server maximum)
      InspectConfig.FindingLimits findingLimits =
          InspectConfig.FindingLimits.newBuilder().setMaxFindingsPerItem(0).build();

      // Specify the inspection configuration
      InspectConfig inspectConfig =
          InspectConfig.newBuilder()
              .addAllInfoTypes(infoTypes)
              .setMinLikelihood(minLikelihood)
              .setLimits(findingLimits)
              .setIncludeQuote(true)
              .build();

      // Create the request from previous configs
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectConfig(inspectConfig)
              .setItem(contentItem)
              .build();

      // Send the request to the service and receive the results
      InspectContentResponse response = dlpServiceClient.inspectContent(request);

      // Process the results
      System.out.println("Inspect of text complete: ");
      InspectResult result = response.getResult();
      if (result.getFindingsCount() < 0) {
        System.out.println("No findings.");
        return;
      }
      System.out.println("Findings: ");
      for (Finding finding : result.getFindingsList()) {
        System.out.println("\tQuote: " + finding.getQuote());
        System.out.println("\tInfo type: " + finding.getInfoType().getName());
        System.out.println("\tLikelihood: " + finding.getLikelihood());
      }
    }
  }
}

Node.js


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

// The string to inspect
const string = 'Robert Frost';

// The project ID to run the API call under
const projectId = process.env.GCLOUD_PROJECT;

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

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

// The infoTypes of information to match
const infoTypes = [{name: 'PERSON_NAME'}, {name: 'US_STATE'}];

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

// Construct item to inspect
const item = {value: string};

// Construct request
const request = {
  parent: `projects/${projectId}/locations/global`,
  inspectConfig: {
    infoTypes: infoTypes,
    minLikelihood: minLikelihood,
    limits: {
      maxFindingsPerRequest: maxFindings,
    },
    includeQuote: includeQuote,
  },
  item: item,
};

// Run request
const [response] = await dlp.inspectContent(request);
const findings = response.result.findings;
if (findings.length > 0) {
  console.log('Findings:');
  findings.forEach(finding => {
    if (includeQuote) {
      console.log(`\tQuote: ${finding.quote}`);
    }
    console.log(`\tInfo type: ${finding.infoType.name}`);
    console.log(`\tLikelihood: ${finding.likelihood}`);
  });
} else {
  console.log('No findings.');
}

PHP

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

// Instantiate a client.
$dlp = new DlpServiceClient();

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

// Set the string to inspect
$stringToInspect = 'Robert Frost';

// Only return results above a likelihood threshold, 0 for all
$minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED;

// Limit the number of findings, 0 for no limit
$maxFindings = 0;

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

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

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

$content = (new ContentItem())
    ->setValue($stringToInspect);

$parent = $dlp->projectName(getEnv('GOOGLE_PROJECT_ID'));

// Run request
$response = $dlp->inspectContent($parent, array(
    'inspectConfig' => $inspectConfig,
    'item' => $content
));

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

Python

# Import the client library
import google.cloud.dlp

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

# The string to inspect
content = "Robert Frost"

# Construct the item to inspect.
item = {"value": content}

# The info types to search for in the content. Required.
info_types = [{"name": "FIRST_NAME"}, {"name": "LAST_NAME"}]

# The minimum likelihood to constitute a match. Optional.
min_likelihood = "LIKELIHOOD_UNSPECIFIED"

# The maximum number of findings to report (0 = server maximum). Optional.
max_findings = 0

# Whether to include the matching string in the results. Optional.
include_quote = True

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

# Convert the project id into a full resource id.
parent = dlp_client.project_path(project_id)

# Call the API.
response = dlp_client.inspect_content(parent, inspect_config, item)

# Print out the results.
if response.result.findings:
    for finding in response.result.findings:
        try:
            print("Quote: {}".format(finding.quote))
        except AttributeError:
            pass
        print("Info type: {}".format(finding.info_type.name))
        # Convert likelihood value to string respresentation.
        likelihood = (
            google.cloud.dlp.types.Finding.DESCRIPTOR.fields_by_name[
                "likelihood"
            ]
            .enum_type.values_by_number[finding.likelihood]
            .name
        )
        print("Likelihood: {}".format(likelihood))
else:
    print("No findings.")

Weitere Ressourcen