Como criar modelos dedesidentificação de proteção de dados confidenciais

É possível usar modelos para criar e manter informações de configuração com o objetivo de usá-las com a Proteção de dados sensíveis. Os modelos são úteis para desacoplar a configuração. Por exemplo, o que você inspeciona e como desidentifica esse item da implementação de suas solicitações. Os modelos fornecem uma maneira robusta de reutilizar a configuração e ter consistência entre usuários e conjuntos de dados.

A Proteção de Dados Sensíveis é compatível com dois tipos de modelos:

  • Modelos de desidentificação: salvam as informações de configuração para jobs de desidentificação, incluindo transformações de InfoType e de registro (conjunto de dados estruturados).
  • Modelos de inspeção: mantêm informações de configuração para jobs de verificação de inspeção, incluindo quais detectores predefinidos ou personalizados serão usados. Para mais informações sobre modelos de inspeção, consulte Como criar modelos de inspeção da Proteção de dados sensíveis.

Para informações conceituais sobre modelos na Proteção de dados sensíveis, consulte Modelos.

O restante deste tópico mostra como criar modelos de desidentificação para uso com a Proteção de Dados Sensíveis.

Criar modelo de desidentificação

Console

No console do Google Cloud , acesse a página Criar modelo.

Acesse "Criar modelo".

As seções a seguir descrevem como preencher a página Criar modelo.

Definir modelo

Na seção Definir modelo, preencha os campos da seguinte maneira:

  1. Em Tipo de modelo, selecione Desidentificar (remover dados sensíveis).

  2. Em Tipo de transformação de dados, selecione o tipo de transformação a ser aplicada:

    • InfoType. A Proteção de dados sensíveis aplica cada transformação apenas ao valor identificado como o infoType específico. Esse tipo de transformação é útil para texto não estruturado.

    • Gravar. A Proteção de Dados Sensíveis considera o formato estruturado dos dados ao aplicar uma transformação. Esse tipo de transformação é útil para dados tabulares.

    • Image. A Proteção de dados sensíveis edita todo o texto detectado em uma imagem ou apenas o texto que corresponde a um infoType específico.

  3. Em ID do modelo, insira um identificador exclusivo para o modelo.

  4. Em Nome de exibição, insira um nome para o modelo.

  5. Em Descrição, descreva o modelo.

  6. Em Local do recurso, selecione Global ou o local dos dados que você quer desidentificar.

  7. Clique em Continuar.

Configurar desidentificação

A seleção de campos que aparecem em Configurar desidentificação se baseia no tipo de transformação de dados escolhido.

InfoType

Se você selecionou InfoType como o tipo de transformação de dados, faça o seguinte:

  1. No campo Transformação, selecione um método para aplicar aos resultados.

    Mais campos vão aparecer de acordo com sua seleção. Preencha os campos conforme necessário. Para mais informações, consulte Referência de transformação.

  2. Na seção InfoTypes para transformar, especifique se você quer aplicar a transformação a todos os infoTypes detectados definidos na configuração de inspeção.

    Se você selecionar Especificar infoTypes, escolha os infoTypes a que quer aplicar o método de transformação.

  3. Se quiser adicionar regras de transformação para infoTypes que não são cobertos pela sua regra, clique em Adicionar regra de transformação. Em seguida, preencha os campos conforme necessário. Repita essa etapa até configurar uma regra de transformação para todos os infoTypes que você quer transformar.

  4. Clique em Criar.

Gravar

Se você selecionou Registro como o tipo de transformação de dados, faça o seguinte:

  1. Em Campos ou colunas a serem transformados, digite o nome da coluna da tabela que contém os dados que você quer transformar. Em seguida, pressione ENTER. Repita essa etapa para cada coluna com dados que você quer transformar.

  2. Especifique o tipo de transformação:

    • Correspondência no infoType. A Proteção de dados sensíveis trata cada célula como texto não estruturado e aplica a transformação apenas aos infoTypes encontrados na célula. A proteção de dados sensíveis não transforma nenhum dado ao redor de um infoType.

      Se você selecionar essa opção, faça o seguinte:

      1. Clique em Adicionar transformação. No campo Transformação, selecione um método de transformação para aplicar às descobertas.

      2. Especifique se você quer aplicar a transformação a todos os infoTypes detectados definidos na configuração de inspeção.

        Se você selecionar Especificar infoTypes, escolha os infoTypes a que quer aplicar a regra de transformação.

      Se quiser atribuir determinadas regras de transformação a determinados infoTypes, adicione mais transformações conforme necessário.

    • Transformação de campo primitiva. A proteção de dados sensíveis sempre transforma toda a célula de acordo com um método de transformação escolhido por você. Essa opção é útil se você quiser transformar colunas inteiras de dados, independente de as células nessas colunas terem infoTypes detectados.

      Se você selecionar essa opção, no campo Transformação, escolha um método de transformação para aplicar às colunas especificadas.

    Em ambos os casos, mais campos aparecem de acordo com o método de transformação selecionado. Preencha os campos conforme necessário. Para mais informações, consulte Referência de transformação.

  3. Clique em Criar.

Imagem

Se você selecionou Imagem como o tipo de transformação de dados, faça o seguinte:

  1. Opcional: para mudar a cor da caixa que cobre o texto censurado, clique na caixa preta no campo Cor da censura e escolha uma cor diferente.

  2. Na seção InfoTypes para transformar, especifique o que você quer encobrir: todo o texto detectado, todos os infoTypes definidos na configuração de inspeção ou apenas infoTypes específicos.

    Se você selecionar Especificar infoTypes, escolha os infoTypes a que quer aplicar a regra de transformação.

  3. Se quiser adicionar regras de transformação para infoTypes que não são cobertos pela sua regra, clique em Adicionar regra de transformação. Em seguida, preencha os campos conforme necessário. Repita essa etapa até configurar uma regra de transformação para todos os infoTypes que você quer transformar.

  4. Clique em Criar.

Protocolo

Vale observar que um modelo de desidentificação é simplesmente uma configuração de desidentificação reutilizável com alguns metadados. Em termos de API, o objeto DeidentifyTemplate é efetivamente um objeto DeidentifyConfig que inclui mais alguns campos de metadados, como um nome de exibição e uma descrição. Portanto, para criar um novo modelo de desidentificação, siga estas etapas:

  1. Comece com um objeto DeidentifyConfig.
  2. Faça a chamada ou execute o comando POST do método create do recurso projects.deidentifyTemplates, DeidentifyTemplate, incluindo na solicitação um objeto DeidentifyConfig que contém um nome de exibição, uma descrição e esse objeto .

O DeidentifyTemplate retornado será usado imediatamente. É possível referir-se a ele em outras chamadas ou jobs pelo name. É possível listar os modelos existentes chamando o método *.deidentifyTemplates.list. Para ver um modelo específico, chame o método *.deidentifyTemplates.get. Observe que o limite para o número de modelos que podem ser criados é 1.000.

Se você já teve alguma experiência com a desidentificação de dados confidenciais de texto, imagens ou conteúdo estruturado usando a proteção de dados sensíveis, já criou um objeto DeidentifyConfig. Mais uma etapa o transforma em um objeto DeidentifyTemplate.

Exemplo de REST

O seguinte JSON é um exemplo do que é possível enviar ao método projects.deidentifyTemplates.create. Esse JSON cria um novo modelo com o nome de exibição e a descrição fornecidos e verifica correspondências nos InfoTypes EMAIL_ADDRESS e GENERIC_ID. Quando ele encontrar conteúdo correspondente a esses InfoTypes, ele mascarará os três primeiros caracteres com um asterisco (*):

Método HTTP e URL

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

Substitua PROJECT_ID pelo ID do projeto.

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":"*"
              }
            }
          }
        ]
      }
    }
  }
}

Saída 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 testar isso rapidamente, use o APIs Explorer incorporado abaixo. Para informações gerais sobre como usar JSON para enviar solicitações à API DLP, consulte o guia de início rápido do JSON.

Como usar modelos de desidentificação

Depois de criar um novo modelo, é possível usar o respectivo identificador name em qualquer lugar que deidentifyTemplateName é aceito, como:

  • projects.content.deidentify: desidentifica dados potencialmente confidenciais no conteúdo usando a própria configuração como modelo. Saiba que esse método pode usar um modelo de inspeção ou de desidentificação.

Como listar modelos de desidentificação

Para listar todos os modelos de desidentificação criados, use um dos métodos *.*.list:

Esta seção demonstra como usar a Proteção de dados sensíveis para listar modelos de inspeção. O processo é igual ao usado para listar os modelos de desidentificação.

C#

Para saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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
            )
        )

Como excluir modelos de desidentificação

Para excluir um modelo de desidentificação específico, use um dos métodos *.*.delete:

Com cada método *.*.delete, inclua o nome do recurso do modelo a ser excluído.

C#

Para saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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 saber como instalar e usar a biblioteca de cliente da Proteção de dados sensíveis, consulte Bibliotecas de cliente da Proteção de dados sensíveis.

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento 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.")