Crea una lista de detectores de Infotipos incorporados

Los Infotipos son tipos de datos sensibles. Cloud Data Loss Prevention (DLP) admite activadores Infotipos integrados y personalizados. Puedes ver todos los Infotipos integrados en la referencia de Infotipos o puedes usar la API de Cloud DLP para enumerar todos los Infotipos integrados de manera programática.

Mediante el método infoTypes.list, se enumeran todos los Infotipos integrados compatibles con Cloud DLP. Cada Infotipo incluye la siguiente información:

  • El identificador (ID) del Infotipo, que es el nombre interno del Infotipo
  • El nombre visible del Infotipo, que es un nombre legible del Infotipo
  • Si el Infotipo es compatible con las operaciones de inspección o de análisis de riesgos

Ejemplos de código

Para enumerar todos los detectores de Infotipos incorporados, haz lo siguiente:

Console

  1. En Cloud Console, abre Cloud DLP.

    Ir a la IU de Cloud DLP

  2. Haz clic en la pestaña Configuración y, luego, en Infotipos.

  3. Aparecerá una tabla que contiene todos los detectores de Infotipos integrados.

Protocolo

Entrada de JSON:

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

La solicitud anterior, cuando se envía al extremo indicado, muestra una lista de todos los detectores predefinidos con el siguiente formato, en la que se representa lo siguiente:

  • [INFOTYPE-NAME] representa el nombre del detector de Infotipos.
  • [INFOTYPE-DISPLAY-NAME] representa el nombre visible del detector.
  • "supportedBy" se establece en "INSPECT", en "RISK_ANALYSIS" o en ambos, según si el detector es compatible con las operaciones de inspección o de análisis de riesgos.
  • [INFOTYPE-DESCRIPTION] representa la descripción del detector.

Salida de JSON:

{
  "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 {

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

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

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

    return 0;
}

Explorador de API

Puedes enumerar los detectores de Infotipos mediante el Explorador de API:

  1. Para ir al Explorador de API en la página de referencia de la API de infoTypes.list, haz clic en el siguiente botón:

    Abrir el Explorador de API

  2. Desmarca Google OAuth 2.0.

  3. Haz clic en Ejecutar.

El Explorador de API envía una solicitud a Cloud DLP, que devuelve un objeto JSON que contiene todos los detectores de Infotipos compatibles.