Cloud Data Loss Prevention (Cloud DLP) ahora forma parte de Protección de Datos Sensibles. El nombre de la API sigue siendo el mismo: API Cloud Data Loss Prevention (API DLP). Para obtener información sobre los servicios que componen Protección de Datos Sensibles, consulta el artículo Información general sobre Protección de Datos Sensibles.

Esta página se ha traducido con Cloud Translation API.

Crear plantillas de desidentificación de Protección de Datos Sensibles

Puedes usar plantillas para crear y conservar información de configuración que se pueda usar con Protección de Datos Sensibles. Las plantillas son útiles para desacoplar la configuración (por ejemplo, qué inspeccionar y cómo desidentificarlo) de la implementación de tus solicitudes. Las plantillas ofrecen una forma eficaz de reutilizar la configuración y permiten mantener la coherencia entre usuarios y conjuntos de datos.

Protección de Datos Sensibles admite dos tipos de plantillas:

Plantillas de desidentificación: plantillas para guardar información de configuración de trabajos de desidentificación, incluidas las transformaciones de infoType y de registro (conjunto de datos estructurado).
Plantillas de inspección: plantillas para conservar la información de configuración de los trabajos de análisis de inspección, incluidos los detectores predefinidos o personalizados que se van a usar. Para obtener más información sobre las plantillas de inspección, consulta el artículo Crear plantillas de inspección de Protección de Datos Sensibles.

Para obtener información conceptual sobre las plantillas de Protección de Datos Sensibles, consulte Plantillas.

En el resto de este tema se explica cómo crear plantillas de desidentificación para usarlas con Protección de Datos Sensibles.

Crear una plantilla de desidentificación

Consola

En la Google Cloud consola, ve a la página Crear plantilla.

Ir a Crear plantilla

En las siguientes secciones se describe cómo rellenar la página Crear plantilla.

Definir la plantilla

En la sección Definir plantilla, rellena los campos de la siguiente manera:

En Tipo de plantilla, selecciona Desidentificar (eliminar datos sensibles).
En Tipo de transformación de datos, seleccione el tipo de transformación que quiera aplicar:
- InfoType. Protección de Datos Sensibles aplica cada transformación solo al valor que se ha identificado como el infoType específico. Este tipo de transformación es útil para el texto no estructurado.
- Registro. Protección de Datos Sensibles tiene en cuenta el formato estructurado de los datos cuando aplica una transformación. Este tipo de transformación es útil para datos tabulares.
- Imagen Protección de Datos Sensibles oculta todo el texto detectado en una imagen o solo el texto que coincide con un infoType específico.
En Template ID (ID de plantilla), introduce un identificador único para la plantilla.
En Nombre visible, escriba el nombre de la plantilla.
En Descripción, describe la plantilla.
En Ubicación del recurso, selecciona Global o la ubicación de los datos que quieras anonimizar.
Haz clic en Continuar.

Configurar la desidentificación

Los campos que aparecen en Configurar desidentificación se basan en el tipo de transformación de datos que elijas.

InfoType

Si has seleccionado InfoType como tipo de transformación de datos, haz lo siguiente:

En el campo Transformación, seleccione un método de transformación para aplicarlo a los resultados.

Aparecerán más campos en función de lo que selecciones. Rellena los campos según sea necesario. Para obtener más información, consulta la referencia de transformación.
En la sección InfoTypes que transformar, especifica si quieres aplicar la transformación a todos los infoTypes detectados que se definan en tu configuración de inspección.

Si seleccionas Especificar infoTypes, elige los infoTypes a los que quieras aplicar el método de transformación.
Si quiere añadir reglas de transformación para infoTypes que no estén cubiertos por su regla de transformación, haga clic en Añadir regla de transformación. A continuación, rellena los campos según sea necesario. Repite este paso hasta que hayas configurado una regla de transformación para todos los infoTypes que quieras transformar.
Haz clic en Crear.

Grabar

Si has seleccionado Registro como tipo de transformación de datos, haz lo siguiente:

En Campos o columnas que transformar, escriba el nombre de la columna de la tabla que contiene los datos que quiere transformar. A continuación, pulsa ENTER. Repite este paso con cada columna que contenga datos que quieras transformar.
Especifica el tipo de transformación:
- Coincidencia en infoType. Protección de Datos Sensibles trata cada celda como texto no estructurado y aplica la transformación solo a los infoTypes que encuentra en la celda. Protección de Datos Sensibles no transforma ningún dato que rodee a un infoType.
  
  Si selecciona esta opción, haga lo siguiente:
  1. Haz clic en Añadir transformación. En el campo Transformación, seleccione un método de transformación para aplicarlo a los resultados.
  2. Especifique si quiere aplicar la transformación a todos los infoTypes detectados que estén definidos en su configuración de inspección.
    
    Si seleccionas Especificar infoTypes, elige los infoTypes a los que quieras aplicar la regla de transformación.
  Si quieres asignar determinadas reglas de transformación a determinados infoTypes, puedes añadir más transformaciones según sea necesario.
- Transformación de campos primitivos. Protección de Datos Sensibles siempre transforma toda la celda según el método de transformación que elijas. Esta opción es útil si quiere transformar columnas enteras de datos, independientemente de si las celdas de esas columnas tienen infoTypes detectados.
  
  Si selecciona esta opción, en el campo Transformación, elija un método de transformación para aplicarlo a las columnas que haya especificado.
En ambos casos, aparecerán más campos según el método de transformación que hayas seleccionado. Rellena los campos según sea necesario. Para obtener más información, consulta la referencia de transformación.
Haz clic en Crear.

Imagen

Si has seleccionado Imagen como tipo de transformación de datos, haz lo siguiente:

Opcional: Para cambiar el color del recuadro que cubre el texto censurado, haz clic en el recuadro negro del campo Color de la censura y elige otro color.
En la sección InfoTypes to transform (InfoTypes que se van a transformar), especifica qué quieres ocultar: todo el texto detectado, todos los infoTypes definidos en tu configuración de inspección o solo infoTypes específicos.

Si selecciona Especificar infoTypes, elija los infoTypes a los que quiera aplicar la regla de transformación.
Si quiere añadir reglas de transformación para infoTypes que no estén cubiertos por su regla de transformación, haga clic en Añadir regla de transformación. A continuación, rellena los campos según sea necesario. Repite este paso hasta que hayas configurado una regla de transformación para todos los infoTypes que quieras transformar.
Haz clic en Crear.

Protocolo

Es importante tener en cuenta que una plantilla de desidentificación es simplemente una configuración de desidentificación reutilizable más algunos metadatos. En términos de API, el objeto DeidentifyTemplate es, en realidad, un objeto DeidentifyConfig que incluye algunos campos de metadatos más, como un nombre visible y una descripción. Por lo tanto, para crear una plantilla de desidentificación, los pasos básicos son los siguientes:

Empieza con un objeto DeidentifyConfig.
Llama o envía por POST al método create del recurso projects.deidentifyTemplates e incluye en tu solicitud un objeto DeidentifyTemplate que contenga un nombre visible, una descripción y el objeto DeidentifyConfig.

El DeidentifyTemplate devuelto se podrá usar inmediatamente. Puedes hacer referencia a ella en otras llamadas o trabajos por su name. Puedes enumerar las plantillas que ya tengas llamando al método *.deidentifyTemplates.list. Para ver una plantilla específica, llama al método *.deidentifyTemplates.get. Ten en cuenta que el límite de plantillas que puedes crear es de 1000.

Si ya tienes experiencia en anonimizar datos sensibles de texto, imágenes o contenido estructurado con Protección de Datos Sensibles, ya habrás creado un objeto DeidentifyConfig. Con un paso más, se convierte en un objeto DeidentifyTemplate.

Ejemplo de REST

El siguiente JSON es un ejemplo de lo que podrías enviar al método projects.deidentifyTemplates.create. Este JSON crea una plantilla con el nombre visible y la descripción proporcionados, y busca coincidencias en los infoTypes EMAIL_ADDRESS y GENERIC_ID. Cuando encuentre contenido que coincida con esos infoTypes, enmascarará los tres primeros caracteres con un asterisco (*).

Método HTTP y URL

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

Sustituye PROJECT_ID por el ID del proyecto.

Entrada JSON

{
  "deidentifyTemplate":{
    "displayName":"Email and id masker",
    "description":"De-identifies emails and ids with a series of asterisks.",
    "deidentifyConfig":{
      "infoTypeTransformations":{
        "transformations":[
          {
            "infoTypes":[
              {
                "name":"GENERIC_ID"
              }
            ],
            "primitiveTransformation":{
              "replaceWithInfoTypeConfig":{

              }
            }
          },
          {
            "infoTypes":[
              {
                "name":"EMAIL_ADDRESS"
              }
            ],
            "primitiveTransformation":{
              "characterMaskConfig":{
                "charactersToIgnore":[
                  {
                    "charactersToSkip":"@"
                  }
                ],
                "maskingCharacter":"*"
              }
            }
          }
        ]
      }
    }
  }
}

Salida JSON

    {
      "name":"projects/PROJECT_ID/deidentifyTemplates/JOB-ID",
      "displayName":"Email and id masker",
      "description":"De-identifies emails and ids with a series of asterisks.",
      "createTime":"2018-11-30T07:17:59.536022Z",
      "updateTime":"2018-11-30T07:17:59.536022Z",
      "deidentifyConfig":{
        "infoTypeTransformations":{
          "transformations":[
            {
              "infoTypes":[
                {
                  "name":"GENERIC_ID"
                }
              ],
              "primitiveTransformation":{
                "replaceWithInfoTypeConfig":{

                }
              }
            },
            {
              "infoTypes":[
                {
                  "name":"EMAIL_ADDRESS"
                }
              ],
              "primitiveTransformation":{
                "characterMaskConfig":{
                  "maskingCharacter":"*",
                  "charactersToIgnore":[
                    {
                      "charactersToSkip":"@"
                    }
                  ]
                }
              }
            }
          ]
        }
      }
    }

Para probarlo rápidamente, puedes usar el Explorador de APIs que se incluye más abajo. Para obtener información general sobre cómo usar JSON para enviar solicitudes a la API DLP, consulta la guía de inicio rápido de JSON.

Usar plantillas de desidentificación

Una vez que hayas creado una plantilla, podrás usar su identificador name en cualquier lugar donde se acepte deidentifyTemplateName, como:

projects.content.deidentify: Desidentifica datos potencialmente sensibles en el contenido mediante la plantilla como configuración. Ten en cuenta que este método puede usar una plantilla de inspección o una plantilla de desidentificación.

Consultar una lista de plantillas de desidentificación

Para obtener una lista de todas las plantillas de desidentificación que se han creado, utilice uno de los siguientes métodos:*.*.list

projects.deidentifyTemplates.list

En esta sección se muestra cómo usar Protección de Datos Sensibles para enumerar plantillas de inspección. El proceso es idéntico al de las plantillas de desidentificación de fichas.

C#

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

Para autenticarte en Protección de Datos Sensibles, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.


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

public class InspectTemplateList
{
    public static PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> List(string projectId)
    {
        var client = DlpServiceClient.Create();

        var response = client.ListInspectTemplates(
            new ListInspectTemplatesRequest
            {
                Parent = new LocationName(projectId, "global").ToString(),
            }
        );

        // Uncomment to list templates
        //PrintTemplates(response);

        return response;
    }

    public static void PrintTemplates(PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> response)
    {
        foreach (var template in response)
        {
            Console.WriteLine($"Template {template.Name}:");
            Console.WriteLine($"\tDisplay Name: {template.DisplayName}");
            Console.WriteLine($"\tDescription: {template.Description}");
            Console.WriteLine($"\tCreated: {template.CreateTime}");
            Console.WriteLine($"\tUpdated: {template.UpdateTime}");
            Console.WriteLine("Configuration:");
            Console.WriteLine($"\tMin Likelihood: {template.InspectConfig?.MinLikelihood}");
            Console.WriteLine($"\tInclude quotes: {template.InspectConfig?.IncludeQuote}");
            Console.WriteLine($"\tMax findings per request: {template.InspectConfig?.Limits.MaxFindingsPerRequest}");
        }
    }
}

Go

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

import (
	"context"
	"fmt"
	"io"
	"time"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"github.com/golang/protobuf/ptypes"
	"google.golang.org/api/iterator"
)

// listInspectTemplates lists the inspect templates in the project.
func listInspectTemplates(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Create a configured request.
	req := &dlppb.ListInspectTemplatesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

	// Send the request and iterate over the results.
	it := client.ListInspectTemplates(ctx, req)
	for {
		t, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %w", err)
		}
		fmt.Fprintf(w, "Inspect template %v\n", t.GetName())
		c, err := ptypes.Timestamp(t.GetCreateTime())
		if err != nil {
			return fmt.Errorf("CreateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Created: %v\n", c.Format(time.RFC1123))
		u, err := ptypes.Timestamp(t.GetUpdateTime())
		if err != nil {
			return fmt.Errorf("UpdateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Updated: %v\n", u.Format(time.RFC1123))
		fmt.Fprintf(w, "  Display Name: %q\n", t.GetDisplayName())
		fmt.Fprintf(w, "  Description: %q\n", t.GetDescription())
	}

	return nil
}

Java

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.cloud.dlp.v2.DlpServiceClient.ListInspectTemplatesPagedResponse;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.ListInspectTemplatesRequest;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

class TemplatesList {

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

  // Lists all templates associated with a given project
  public static void listInspectTemplates(String projectId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpServiceClient = DlpServiceClient.create()) {

      // Create the request to be sent by the client
      ListInspectTemplatesRequest request =
          ListInspectTemplatesRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setPageSize(1)
              .build();

      // Send the request
      ListInspectTemplatesPagedResponse response = dlpServiceClient.listInspectTemplates(request);

      // Parse through and process the response
      System.out.println("Templates found:");
      for (InspectTemplate template : response.getPage().getResponse().getInspectTemplatesList()) {
        System.out.printf("Template name: %s\n", template.getName());
        if (template.getDisplayName() != null) {
          System.out.printf("\tDisplay name: %s \n", template.getDisplayName());
          System.out.printf("\tCreate time: %s \n", template.getCreateTime());
          System.out.printf("\tUpdate time: %s \n", template.getUpdateTime());

          // print inspection config
          InspectConfig inspectConfig = template.getInspectConfig();
          for (InfoType infoType : inspectConfig.getInfoTypesList()) {
            System.out.printf("\tInfoType: %s\n", infoType.getName());
          }
          System.out.printf("\tMin likelihood: %s\n", inspectConfig.getMinLikelihood());
          System.out.printf("\tLimits: %s\n", inspectConfig.getLimits().getMaxFindingsPerRequest());
        }
      }
    }
  }
}

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

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

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

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

// Helper function to pretty-print dates
const formatDate = date => {
  const msSinceEpoch = parseInt(date.seconds, 10) * 1000;
  return new Date(msSinceEpoch).toLocaleString('en-US');
};

async function listInspectTemplates() {
  // Construct template-listing request
  const request = {
    parent: `projects/${projectId}/locations/global`,
  };

  // Run template-deletion request
  const [templates] = await dlp.listInspectTemplates(request);

  templates.forEach(template => {
    console.log(`Template ${template.name}`);
    if (template.displayName) {
      console.log(`  Display name: ${template.displayName}`);
    }

    console.log(`  Created: ${formatDate(template.createTime)}`);
    console.log(`  Updated: ${formatDate(template.updateTime)}`);

    const inspectConfig = template.inspectConfig;
    const infoTypes = inspectConfig.infoTypes.map(x => x.name);
    console.log('  InfoTypes:', infoTypes.join(' '));
    console.log('  Minimum likelihood:', inspectConfig.minLikelihood);
    console.log('  Include quotes:', inspectConfig.includeQuote);

    const limits = inspectConfig.limits;
    console.log('  Max findings per request:', limits.maxFindingsPerRequest);
  });
}

listInspectTemplates();

PHP

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ListInspectTemplatesRequest;

/**
 * List DLP inspection configuration templates.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 */
function list_inspect_templates(string $callingProjectId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

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

    // Run request
    $listInspectTemplatesRequest = (new ListInspectTemplatesRequest())
        ->setParent($parent);
    $response = $dlp->listInspectTemplates($listInspectTemplatesRequest);

    // Print results
    $templates = $response->iterateAllElements();

    foreach ($templates as $template) {
        printf('Template %s' . PHP_EOL, $template->getName());
        printf('  Created: %s' . PHP_EOL, $template->getCreateTime()->getSeconds());
        printf('  Updated: %s' . PHP_EOL, $template->getUpdateTime()->getSeconds());
        printf('  Display Name: %s' . PHP_EOL, $template->getDisplayName());
        printf('  Description: %s' . PHP_EOL, $template->getDescription());

        $inspectConfig = $template->getInspectConfig();
        if ($inspectConfig === null) {
            print('  No inspect config.' . PHP_EOL);
        } else {
            printf('  Minimum likelihood: %s' . PHP_EOL, $inspectConfig->getMinLikelihood());
            printf('  Include quotes: %s' . PHP_EOL, $inspectConfig->getIncludeQuote());
            $limits = $inspectConfig->getLimits();
            printf('  Max findings per request: %s' . PHP_EOL, $limits->getMaxFindingsPerRequest());
        }
    }
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

import google.cloud.dlp


def list_inspect_templates(project: str) -> None:
    """Lists all Data Loss Prevention API inspect templates.
    Args:
        project: The Google Cloud project id to use as a parent resource.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Call the API.
    response = dlp.list_inspect_templates(request={"parent": parent})

    for template in response:
        print(f"Template {template.name}:")
        if template.display_name:
            print(f"  Display Name: {template.display_name}")
        print(f"  Created: {template.create_time}")
        print(f"  Updated: {template.update_time}")

        config = template.inspect_config
        print(
            "  InfoTypes: {}".format(", ".join([it.name for it in config.info_types]))
        )
        print(f"  Minimum likelihood: {config.min_likelihood}")
        print(f"  Include quotes: {config.include_quote}")
        print(
            "  Max findings per request: {}".format(
                config.limits.max_findings_per_request
            )
        )

Eliminar plantillas de desidentificación

Para eliminar una plantilla de desidentificación específica, utilice uno de los *.*.delete métodos:

projects.deidentifyTemplates.delete

Con cada método *.*.delete, se incluye el nombre del recurso de la plantilla que se va a eliminar.

C#

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.


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

public class InspectTemplateDelete
{
    public static object Delete(string projectId, string templateName)
    {
        var client = DlpServiceClient.Create();

        var request = new DeleteInspectTemplateRequest
        {
            Name = templateName
        };

        client.DeleteInspectTemplate(request);
        Console.WriteLine($"Successfully deleted template {templateName}.");

        return templateName;
    }
}

Go

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

import (
	"context"
	"fmt"
	"io"

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

// deleteInspectTemplate deletes the given template.
func deleteInspectTemplate(w io.Writer, templateID string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	req := &dlppb.DeleteInspectTemplateRequest{
		Name: templateID,
	}

	if err := client.DeleteInspectTemplate(ctx, req); err != nil {
		return fmt.Errorf("DeleteInspectTemplate: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted inspect template %v", templateID)
	return nil
}

Java

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DeleteInspectTemplateRequest;
import java.io.IOException;

class TemplatesDelete {

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

  // Delete an existing template
  public static void deleteInspectTemplate(String projectId, String templateId) throws IOException {
    // Construct the template name to be deleted
    String templateName = String.format("projects/%s/inspectTemplates/%s", projectId, templateId);

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (DlpServiceClient dlpServiceClient = DlpServiceClient.create()) {

      // Create delete template request to be sent by the client
      DeleteInspectTemplateRequest request =
          DeleteInspectTemplateRequest.newBuilder().setName(templateName).build();

      // Send the request with the client
      dlpServiceClient.deleteInspectTemplate(request);
      System.out.printf("Deleted template: %s\n", templateName);
    }
  }
}

Node.js

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

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

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

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

// The name of the template to delete
// Parent project ID is automatically extracted from this parameter
// const templateName = 'projects/YOUR_PROJECT_ID/inspectTemplates/#####'
async function deleteInspectTemplate() {
  // Construct template-deletion request
  const request = {
    name: templateName,
  };

  // Run template-deletion request
  await dlp.deleteInspectTemplate(request);
  console.log(`Successfully deleted template ${templateName}.`);
}

deleteInspectTemplate();

PHP

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\DeleteInspectTemplateRequest;

/**
 * Delete a DLP inspection configuration template.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 * @param string $templateId        The name of the template to delete
 */
function delete_inspect_template(
    string $callingProjectId,
    string $templateId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Run template deletion request
    $templateName = "projects/$callingProjectId/locations/global/inspectTemplates/$templateId";
    $deleteInspectTemplateRequest = (new DeleteInspectTemplateRequest())
        ->setName($templateName);
    $dlp->deleteInspectTemplate($deleteInspectTemplateRequest);

    // Print results
    printf('Successfully deleted template %s' . PHP_EOL, $templateName);
}

Python

Para saber cómo instalar y usar la biblioteca de cliente de Protección de Datos Sensibles, consulta el artículo sobre las bibliotecas de cliente de Protección de Datos Sensibles.

import google.cloud.dlp


def delete_inspect_template(project: str, template_id: str) -> None:
    """Deletes a Data Loss Prevention API template.
    Args:
        project: The id of the Google Cloud project which owns the template.
        template_id: The id of the template to delete.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Combine the template id with the parent id.
    template_resource = f"{parent}/inspectTemplates/{template_id}"

    # Call the API.
    dlp.delete_inspect_template(request={"name": template_resource})

    print(f"Template {template_resource} successfully deleted.")

Crear plantillas de desidentificación de Protección de Datos Sensibles Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Crear una plantilla de desidentificación

Consola

Definir la plantilla

Configurar la desidentificación

InfoType

Grabar

Imagen

Protocolo

Ejemplo de REST

Usar plantillas de desidentificación

Consultar una lista de plantillas de desidentificación

C#

Go

Java

Node.js

PHP

Python

Eliminar plantillas de desidentificación

C#

Go

Java

Node.js

PHP

Python

Crear plantillas de desidentificación de Protección de Datos Sensibles