Crea plantillas de desidentificación de Sensitive Data Protection

Puedes usar plantillas para crear y conservar información de configuración para usar con la Protección de datos sensibles. Las plantillas son útiles para la separación de la configuración como, por ejemplo, qué analizas y cómo lo desidentificas de la implementación de tus solicitudes. Las plantillas proporcionan una manera sólida de volver a usar las opciones de configuración y habilitan la coherencia entre usuarios y conjuntos de datos.

Sensitive Data Protection admite dos tipos de plantillas:

  • Plantillas de desidentificación: plantillas para guardar la información de configuración en trabajos de desidentificación, que incluyen transformaciones de Infotipo y registro (conjunto de datos estructurados).
  • Plantilla de inspección: plantillas para conservar la información de configuración en trabajos de análisis de inspección, que incluyen qué detectores personalizados o predefinidos usar. Para obtener más información sobre las plantillas de inspección, consulta Cómo crear plantillas de inspección de Protección de datos sensibles.

Para obtener información conceptual sobre las plantillas en Sensitive Data Protection, consulta Plantillas.

En el resto de este tema, se muestra cómo crear plantillas de desidentificación para usar con Sensitive Data Protection.

Crea una plantilla de desidentificación

Console

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

Ir a Crear plantilla

En las siguientes secciones, se describe cómo completar la página Create template.

Define una plantilla

En la sección Define template, completa los campos de la siguiente manera:

  1. En Tipo de plantilla, selecciona Desidentificar (quitar datos sensibles).

  2. En Tipo de transformación de datos, selecciona el tipo de transformación que se aplicará:

    • InfoType. Sensitive Data Protection aplica cada transformación solo al valor que se identificó como el infotipo específico. Este tipo de transformación es útil para el texto no estructurado.

    • Registro. Sensitive Data Protection considera el formato estructurado de los datos cuando aplica una transformación. Este tipo de transformación es útil para los datos tabulares.

    • Image. La protección de datos sensibles oculta todo el texto detectado en una imagen o solo el texto que coincide con un Infotipo específico.

  3. En ID de plantilla, ingresa un identificador único para la plantilla.

  4. En Nombre visible (Display name), ingresa un nombre para la plantilla.

  5. En Descripción, describe la plantilla.

  6. En Ubicación del recurso, selecciona Global o la ubicación de los datos que deseas desidentificar.

  7. Haga clic en Continuar.

Configura la desidentificación

La selección de campos que aparecen en Configurar desidentificación se basa en el tipo de transformación de datos que elegiste.

Infotipo

Si seleccionaste InfoType como el tipo de transformación de datos, haz lo siguiente:

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

    Aparecerán más campos según tu selección. Completa los campos según sea necesario. Para obtener más información, consulta Referencia de transformación.

  2. En la sección InfoTypes to transform, especifica si deseas aplicar la transformación a todos los infotipos detectados que se definen en la configuración de inspección.

    Si seleccionas Especificar Infotipos, selecciona los infotipos a los que deseas aplicar el método de transformación.

  3. Si deseas agregar reglas de transformación para los infoTypes que no están cubiertos por tu regla de transformación, haz clic en Agregar regla de transformación. Luego, completa los campos según sea necesario. Repite este paso hasta que hayas configurado una regla de transformación para todos los infotipos que deseas transformar.

  4. Haz clic en Crear.

Registro

Si seleccionaste Registrar como el tipo de transformación de datos, haz lo siguiente:

  1. En Campos o columnas para transformar, escribe el nombre de la columna de la tabla que contiene los datos que deseas transformar. Luego, presiona ENTER. Repite este paso para cada columna que contenga datos que quieras transformar.

  2. Especifica el tipo de transformación:

    • Coincidencia en el Infotipo. Sensitive Data Protection trata cada celda como texto no estructurado y aplica la transformación solo a los infoTypes que encuentra en la celda. La Protección de datos sensibles no transforma ningún dato que rodea un Infotipo.

      Si seleccionas esta opción, haz lo siguiente:

      1. Haz clic en Agregar transformación. En el campo Transformación, selecciona un método de transformación para aplicarlo a los resultados.

      2. Especifica si deseas aplicar la transformación a todos los infotipos detectados que se definen en la configuración de inspección.

        Si seleccionas Especificar infotipos, selecciona los infotipos a los que deseas aplicar la regla de transformación.

      Si deseas asignar ciertas reglas de transformación a ciertos infotipos, puedes agregar más transformaciones según sea necesario.

    • Transformación de campos primitivos. Sensitive Data Protection siempre transforma toda la celda según un método de transformación que tú elijas. Esta opción es útil si deseas transformar columnas completas de datos, independientemente de si las celdas de esas columnas detectaron infoTypes.

      Si seleccionas esta opción, en el campo Transformación, selecciona un método de transformación para aplicarlo a las columnas que especificaste.

    En ambos casos, aparecen más campos según el método de transformación que hayas seleccionado. Completa los campos según sea necesario. Para obtener más información, consulta Referencia de transformación.

  3. Haz clic en Crear.

Imagen

Si seleccionaste Image como el tipo de transformación de datos, haz lo siguiente:

  1. Opcional: Para cambiar el color del cuadro que cubre el texto oculto, haz clic en el cuadro negro del campo Color de ocultación y elige un color diferente.

  2. En la sección Infotipos para transformar, especifica lo que deseas ocultar: todo el texto detectado, todos los infotipos definidos en la configuración de inspección o solo infotipos específicos.

    Si seleccionas Especificar infotipos, selecciona los infotipos a los que deseas aplicar la regla de transformación.

  3. Si deseas agregar reglas de transformación para los infoTypes que no se incluyen en tu regla de transformación, haz clic en Agregar regla de transformación. Luego, completa los campos según sea necesario. Repite este paso hasta que configures una regla de transformación para todos los infotipos que deseas transformar.

  4. Haz clic en Crear.

Protocolo

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

  1. Comienza con un objeto DeidentifyConfig.
  2. Llama o PUBLICA el método create del recurso projects.deidentifyTemplates y, además, incluye en tu solicitud un objeto DeidentifyTemplate que contenga un nombre visible, una descripción y ese objeto DeidentifyConfig.

La DeidentifyTemplate que se muestra se podrá usar de inmediato. Puedes hacer referencia a ella en otras llamadas o trabajos por su name. Puedes enumerar las plantillas existentes 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 para la cantidad de plantillas que creas es 1,000.

Si ya tienes experiencia en la desidentificación de datos sensibles de imágenes de texto o contenido estructurado con Sensitive Data Protection, ya creaste un objeto DeidentifyConfig. Un paso adicional lo 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 nueva con el nombre visible y la descripción dados, y busca coincidencias en los Infotipos EMAIL_ADDRESS y GENERIC_ID. Cuando encuentre contenido que coincida con esos Infotipos, enmascarará los primeros tres caracteres con un asterisco (*).

Método HTTP y URL

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

Reemplaza PROJECT_ID por el ID del proyecto.

Entrada de 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 de 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 probar esto rápidamente, puedes usar el Explorador de API que se incorpora a continuación. Si quieres obtener información general sobre el uso de JSON para enviar solicitudes a la API de DLP, consulta la guía de inicio rápido de JSON.

Usa plantillas de desidentificación

Una vez que creaste una plantilla nueva, puedes usar su identificador name en cualquier lugar que se acepte deidentifyTemplateName, como los siguientes:

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

Haz una lista de las plantillas de desidentificación

Para hacer una lista de todas las plantillas de desidentificación que se crearon, usa uno de los métodos *.*.list:

En esta sección, se muestra cómo usar Sensitive Data Protection para enumerar plantillas de inspección. El proceso es igual al que se realiza para hacer una lista de las plantillas de desidentificación.

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

// 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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
            )
        )

Borra las plantillas de desidentificación

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

Con cada método *.*.delete, incluyes el nombre del recurso de la plantilla que se borrará.

C#

Para obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 


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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

// 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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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 obtener información sobre cómo instalar y usar la biblioteca cliente de Protección de datos sensibles, consulta las Bibliotecas cliente de Protección de datos sensibles.

Para autenticarte en la Protección de datos sensibles, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

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.")