Como criar modelos de desidentificação do Cloud DLP

É possível usar modelos para criar e manter informações de configuração com o objetivo de usá-las com o Cloud Data Loss Prevention. 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.

O Cloud DLP é 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 do Cloud DLP.

Para informações conceituais sobre modelos no Cloud DLP, consulte Modelos.

O restante deste tópico mostra como criar modelos de desidentificação para uso com o Cloud DLP.

Criar modelo de desidentificação

Console

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

Acessar "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:

Em Tipo de modelo, selecione Desidentificar (remover dados confidenciais).
Em Tipo de transformação de dados, selecione o tipo de transformação a ser aplicado:
- InfoType. O Cloud DLP aplica cada transformação apenas ao valor que foi identificado como o infoType específico. Esse tipo de transformação é útil para textos não estruturados.
- Gravar. O Cloud DLP considera o formato estruturado dos dados quando aplica uma transformação. Esse tipo de transformação é útil para dados tabulares.
- Image. O Cloud DLP edita todo o texto detectado em uma imagem ou apenas o texto que corresponde a um infoType específico.
Em Código do modelo, insira um identificador exclusivo para o modelo.
Em Nome de exibição, insira um nome para o modelo.
Em Descrição, descreva o modelo.
Em Local do recurso, selecione Global ou o local dos dados que você quer desidentificar.
Clique em Continuar.

Configurar desidentificação

A seleção de campos que aparece em Configurar desidentificação tem como base o tipo de transformação de dados escolhido.

InfoType

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

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

Mais campos aparecerão de acordo com a seleção. Preencha os campos conforme necessário. Para mais informações, consulte Referência de transformação.
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, selecione os infoTypes aos quais quer aplicar o método de transformação.
Se você quiser adicionar regras de transformação para infoTypes que não são cobertos pela sua regra de transformação, 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.
Clique em Criar.

Record

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

Em Campos a serem transformados, digite o nome da coluna da tabela que contém os dados a serem transformados. Em seguida, pressione ENTER. Repita essa etapa para cada coluna que contém os dados que você quer transformar.
Especifique o tipo de transformação:
- Correspondência no infoType. O Cloud DLP trata cada célula como texto não estruturado e aplica a transformação apenas aos infoTypes que encontra na célula. O Cloud DLP não transforma os dados em torno 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, selecione os infoTypes aos quais quer aplicar a regra de transformação.
  Se você quiser atribuir certas regras de transformação a determinados infoTypes, adicione mais transformações conforme necessário.
- Transformação do campo primário. O Cloud DLP sempre transforma toda a célula de acordo com um método de transformação que você escolhe. Essa opção é útil se você quiser transformar colunas inteiras de dados, independentemente de as células nessas colunas terem detectado infoTypes.
  
  Se você selecionar essa opção, no campo Transformação, selecione um método de transformação a ser aplicado às colunas especificadas.
Nos dois 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.
Clique em Criar.

Image

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

Opcional: para alterar a cor da caixa que cobre o texto editado, clique na caixa preta no campo Cor de edição e escolha uma cor diferente.
Na seção InfoTypes para transformar, especifique o que você quer editar: todo o texto detectado, todos os infoTypes definidos na configuração de inspeção ou apenas infoTypes específicos.

Se você selecionar Especificar infoTypes, selecione os infoTypes aos quais quer aplicar a regra de transformação.
Se você quiser adicionar regras de transformação para infoTypes que não são cobertos pela sua regra de transformação, 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.
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:

Comece com um objeto DeidentifyConfig.
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 o Cloud DLP, você 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 e URL HTTP

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:

projects.deidentifyTemplates.list

Exemplos de código

A amostra de código a seguir demonstra em várias linguagens como usar o Cloud DLP para listar modelos de inspeção. O processo é igual ao usado para listar os modelos de desidentificação.

Java

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback


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 do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

// 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();

Python

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

import google.cloud.dlp  # noqa: E402, F811

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

Go

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

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
}

PHP

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

use Google\Cloud\Dlp\V2\DlpServiceClient;

/**
 * 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
    $response = $dlp->listInspectTemplates($parent);

    // 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());
        }
    }
}

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback


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}");
        }
    }
}

Como excluir modelos de desidentificação

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

projects.deidentifyTemplates.delete

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

Exemplos de código

A amostra de código a seguir demonstra em várias linguagens como usar o Cloud DLP para excluir um modelo de inspeção. O processo é igual ao usado para listar os modelos de desidentificação.

Java

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback


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 do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

// 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();

Python

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

import google.cloud.dlp  # noqa: E402, F811

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

Go

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

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
}

PHP

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback

use Google\Cloud\Dlp\V2\DlpServiceClient;

/**
 * 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";
    $dlp->deleteInspectTemplate($templateName);

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

C#

Para saber como instalar e usar a biblioteca de cliente do Cloud DLP, consulte Bibliotecas de cliente do Cloud DLP.

Para autenticar no Cloud DLP, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local.

Ver no GitHub Feedback


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;
    }
}