Eingebaute InfoType-Detektoren auflisten

InfoTypes sind Arten sensibler Daten. Cloud Data Loss Prevention (DLP) unterstützt sowohl eingebundene als auch benutzerdefinierte infoTypes. Sie können alle eingebundenen infoTypes in der infoTypes-Referenz ansehen oder mit der Cloud DLP API programmatisch auflisten.

Die Methode infoTypes.list listet alle eingebundenen infoTypes auf, die derzeit in Cloud DLP unterstützt werden. Jeder infoType enthält die folgenden Informationen:

  • Die infoType-ID (ID), dies ist der interne Name des infoType.
  • Den Anzeigenamen des infoType, dies ist ein für Menschen lesbarer infoType-Name.
  • Die Angabe, ob der infoType von Inspektionen oder Risikoanalysen unterstützt wird.

Codebeispiele

So listen Sie alle eingebundenen infoType-Detektoren auf:

Console

  1. Öffnen Sie in der Cloud Console Cloud DLP.

    Zur Cloud DLP-UI

  2. Klicken Sie auf den Tab Konfiguration und dann auf InfoTypes.

  3. Eine Tabelle mit allen eingebundenen infoType-Detektoren wird angezeigt.

Protokoll

JSON-Eingabe:

GET https://dlp.googleapis.com/v2/infoTypes?key={YOUR_API_KEY}

Wenn die vorherige Anfrage an den angegebenen Endpunkt gesendet wird, wird eine Liste aller vordefinierten Detektoren im folgenden Format zurückgegeben. Dabei gilt:

  • [INFOTYPE-NAME] steht für den Namen des infoType-Detektors.
  • [INFOTYPE-DISPLAY-NAME] steht für den Anzeigenamen des Detektors.
  • "supportedBy" ist auf "INSPECT", "RISK_ANALYSIS" oder beides festgelegt, je nachdem, ob der Detektor von Inspektionen oder Risikoanalysen unterstützt wird.
  • [INFOTYPE-DESCRIPTION] steht für die Beschreibung des Detektors.

JSON-Ausgabe:

{
  "infoTypes":[
    {
      "name":"[INFOTYPE-NAME]",
      "displayName":"[INFOTYPE-DISPLAY-NAME]",
      "supportedBy":[
        "INSPECT"
      ],
      "description":"[INFOTYPE-DESCRIPTION]"
    },
    ...
  ]
}

Java


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.InfoTypeDescription;
import com.google.privacy.dlp.v2.ListInfoTypesRequest;
import com.google.privacy.dlp.v2.ListInfoTypesResponse;
import java.io.IOException;

public class InfoTypesList {

  public static void main(String[] args) throws IOException {
    listInfoTypes();
  }

  // Lists the types of sensitive information the DLP API supports.
  public static void listInfoTypes() 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 dlpClient = DlpServiceClient.create()) {

      // Construct the request to be sent by the client
      ListInfoTypesRequest listInfoTypesRequest =
          ListInfoTypesRequest.newBuilder()
              // Only return infoTypes supported by certain parts of the API.
              // Supported filters are "supported_by=INSPECT" and "supported_by=RISK_ANALYSIS"
              // Defaults to "supported_by=INSPECT"
              .setFilter("supported_by=INSPECT")
              // BCP-47 language code for localized infoType friendly names.
              // Defaults to "en_US"
              .setLanguageCode("en-US")
              .build();

      // Use the client to send the API request.
      ListInfoTypesResponse response = dlpClient.listInfoTypes(listInfoTypesRequest);

      // Parse the response and process the results
      System.out.println("Infotypes found:");
      for (InfoTypeDescription infoTypeDescription : response.getInfoTypesList()) {
        System.out.println("Name : " + infoTypeDescription.getName());
        System.out.println("Display name : " + infoTypeDescription.getDisplayName());
      }
    }
  }
}

Node.js

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

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

// The BCP-47 language code to use, e.g. 'en-US'
// const languageCode = 'en-US';

// The filter to use
// const filter = 'supported_by=INSPECT'

const [response] = await dlp.listInfoTypes({
  languageCode: languageCode,
  filter: filter,
});
const infoTypes = response.infoTypes;
console.log('Info types:');
infoTypes.forEach(infoType => {
  console.log(`\t${infoType.name} (${infoType.displayName})`);
});

Python

def list_info_types(language_code=None, result_filter=None):
    """List types of sensitive information within a category.
    Args:
        language_code: The BCP-47 language code to use, e.g. 'en-US'.
        filter: An optional filter to only return info types supported by
                certain parts of the API. Defaults to "supported_by=INSPECT".
    Returns:
        None; the response from the API is printed to the terminal.
    """
    # Import the client library
    import google.cloud.dlp

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

    # Make the API call.
    response = dlp.list_info_types(language_code, result_filter)

    # Print the results to the console.
    print("Info types:")
    for info_type in response.info_types:
        print(
            u"{name}: {display_name}".format(
                name=info_type.name, display_name=info_type.display_name
            )
        )

Go

import (
	"context"
	"fmt"
	"io"

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

// infoTypes returns the info types in the given language and matching the given filter.
func infoTypes(w io.Writer, languageCode, filter string) error {
	// languageCode := "en-US"
	// filter := "supported_by=INSPECT"
	ctx := context.Background()
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %v", err)
	}

	req := &dlppb.ListInfoTypesRequest{
		LanguageCode: languageCode,
		Filter:       filter,
	}
	resp, err := client.ListInfoTypes(ctx, req)
	if err != nil {
		return fmt.Errorf("ListInfoTypes: %v", err)
	}
	for _, it := range resp.GetInfoTypes() {
		fmt.Fprintln(w, it.GetName())
	}
	return nil
}

PHP

/**
 * Lists all Info Types for the Data Loss Prevention (DLP) API.
 */
use Google\Cloud\Dlp\V2\DlpServiceClient;

/** Uncomment and populate these variables in your code */
// $filter = ''; // (Optional) filter to use, empty for ''.
// $languageCode = ''; // (Optional) language code, empty for 'en-US'.

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

// Run request
$response = $dlp->listInfoTypes([
    'languageCode' => $languageCode,
    'filter' => $filter
]);

// Print the results
print('Info Types:' . PHP_EOL);
foreach ($response->getInfoTypes() as $infoType) {
    printf(
        '  %s (%s)' . PHP_EOL,
        $infoType->getDisplayName(),
        $infoType->getName()
    );
}

C#


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

public class InfoTypesList
{
    public static ListInfoTypesResponse ListInfoTypes(string languageCode, string filter)
    {
        var dlp = DlpServiceClient.Create();
        var response = dlp.ListInfoTypes(
            new ListInfoTypesRequest
            {
                LanguageCode = languageCode,
                Filter = filter
            });

        // Uncomment to print infotypes
        // Console.WriteLine("Info Types:");
        // foreach (var InfoType in response.InfoTypes)
        // {
        //     Console.WriteLine($"\t{InfoType.Name} ({InfoType.DisplayName})");
        // }

        return response;
    }
}

APIs Explorer

Sie können infoType-Detektoren mit APIs Explorer auflisten:

  1. Rufen Sie auf der API-Referenzseite für infoTypes.list den APIs Explorer auf, klicken Sie dazu auf diese Schaltfläche:

    APIs Explorer öffnen

  2. Deaktivieren Sie Google OAuth 2.0.

  3. Klicken Sie auf Ausführen.

APIs Explorer sendet eine Anfrage an Cloud DLP, die ein JSON-Objekt mit allen unterstützten infoType-Detektoren zurücksendet.