O Cloud Data Loss Prevention (Cloud DLP) faz agora parte da Proteção de dados confidenciais. O nome da API permanece o mesmo: Cloud Data Loss Prevention API (API DLP). Para informações sobre os serviços que compõem a proteção de dados confidenciais, consulte o artigo Vista geral da proteção de dados confidenciais.

Esta página foi traduzida pela API Cloud Translation.

Criar modelos de desidentificação da Proteção de dados confidenciais

Pode usar modelos para criar e manter informações de configuração para usar com a proteção de dados confidenciais. Os modelos são úteis para desassociar a configuração, como o que inspeciona e como o desidentifica da implementação dos seus pedidos. Os modelos oferecem uma forma robusta de reutilizar a configuração e permitir a consistência entre utilizadores e conjuntos de dados.

A proteção de dados confidenciais suporta dois tipos de modelos:

Modelos de desidentificação: modelos para guardar informações de configuração para tarefas de desidentificação, incluindo transformações de infoType e de registos (conjunto de dados estruturados).
Modelos de inspeção: modelos para manter informações de configuração para tarefas de análise de inspeção, incluindo que detetores predefinidos ou personalizados usar. Para mais informações sobre modelos de inspeção, consulte o artigo Criar modelos de inspeção de proteção de dados confidenciais.

Para ver informações conceptuais sobre os modelos na proteção de dados confidenciais, consulte o artigo Modelos.

O resto deste tópico mostra como criar modelos de desidentificação para utilização com a proteção de dados confidenciais.

Crie um modelo de anulação da identificação

Consola

Na Google Cloud consola, aceda à página Criar modelo.

Aceda a Criar modelo

As secções seguintes descrevem como preencher a página Criar modelo.

Defina o modelo

Na secção Definir modelo, preencha os campos da seguinte forma:

Para Tipo de modelo, selecione Desidentificar (remover dados confidenciais).
Em Tipo de transformação de dados, selecione o tipo de transformação a aplicar:
- InfoType. A proteção de dados confidenciais aplica cada transformação apenas ao valor que foi identificado como o infoType específico. Este tipo de transformação é útil para texto não estruturado.
- Registar. A proteção de dados confidenciais considera o formato estruturado dos dados quando aplica uma transformação. Este tipo de transformação é útil para dados tabulares.
- Imagem. A proteção de dados confidenciais oculta todo o texto detetado numa imagem ou apenas o texto que corresponde a um infoType específico.
Para o ID do modelo, introduza um identificador exclusivo para o modelo.
Em Nome a apresentar, introduza um nome para o modelo.
Em Descrição, descreva o modelo.
Para Localização do recurso, selecione Global ou a localização dos dados que quer desidentificar.
Clique em Continuar.

Configure a desidentificação

A seleção dos campos apresentados em Configurar a desidentificação baseia-se no tipo de transformação de dados escolhido.

InfoType

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

No campo Transformação, selecione um método de transformação a aplicar aos resultados.

São apresentados mais campos de acordo com a sua seleção. Preencha os campos conforme necessário. Para mais informações, consulte o artigo Referência de transformação.
Na secção Tipos de informações a transformar, especifique se quer aplicar a transformação a todos os tipos de informações detetados que estão definidos na sua configuração de inspeção.

Se selecionar Especificar infoTypes, selecione os infoTypes aos quais quer aplicar o método de transformação.
Se quiser adicionar regras de transformação para infoTypes que não estejam abrangidos pela regra de transformação, clique em Adicionar regra de transformação. Em seguida, preencha os campos conforme necessário. Repita este passo até configurar uma regra de transformação para todos os infoTypes que quer transformar.
Clique em Criar.

Grave

Se selecionou Registo como o tipo de transformação de dados, faça o seguinte:

Para Campos ou colunas a transformar, escreva o nome da coluna da tabela que contém os dados que quer transformar. Em seguida, prima ENTER. Repita este passo para cada coluna que contenha dados que quer transformar.
Especifique o tipo de transformação:
- Faça a correspondência com base no infoType. A proteção de dados confidenciais trata cada célula como texto não estruturado e aplica a transformação apenas aos infoTypes que encontra na célula. A Proteção de dados confidenciais não transforma quaisquer dados em torno de um infoType.
  
  Se selecionar esta opção, faça o seguinte:
  1. Clique em Adicionar transformação. No campo Transformação, selecione um método de transformação a aplicar às descobertas.
  2. Especifique se quer aplicar a transformação a todos os infoTypes detetados que estão definidos na sua configuração de inspeção.
    
    Se selecionar Especificar infoTypes, selecione os infoTypes aos quais quer aplicar a regra de transformação.
  Se quiser atribuir determinadas regras de transformação a determinados infoTypes, pode adicionar mais transformações conforme necessário.
- Transformação de campos primitivos. A proteção de dados confidenciais transforma sempre toda a célula de acordo com um método de transformação que escolher. Esta opção é útil se quiser transformar colunas inteiras de dados, independentemente de as células nessas colunas terem infoTypes detetados.
  
  Se selecionar esta opção, no campo Transformação, selecione um método de transformação a aplicar às colunas que especificou.
Em ambos os casos, são apresentados mais campos de acordo com o método de transformação selecionado. Preencha os campos conforme necessário. Para mais informações, consulte o artigo Referência de transformação.
Clique em Criar.

Imagem

Se 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 ocultado, clique na caixa preta no campo Cor da ocultação e escolha uma cor diferente.
Na secção InfoTypes a transformar, especifique o que quer ocultar: todo o texto detetado, todos os InfoTypes definidos na sua configuração de inspeção ou apenas InfoTypes específicos.

Se selecionar Especificar infoTypes, selecione os infoTypes aos quais quer aplicar a regra de transformação.
Se quiser adicionar regras de transformação para infoTypes que não estejam abrangidos pela regra de transformação, clique em Adicionar regra de transformação. Em seguida, preencha os campos conforme necessário. Repita este passo até configurar uma regra de transformação para todos os infoTypes que quer transformar.
Clique em Criar.

Protocolo

É útil ter em atenção que um modelo de anulação da identificação é simplesmente uma configuração de anulação da identificação reutilizável, além de alguns metadados. Em termos de API, o objeto DeidentifyTemplate é efetivamente um objeto DeidentifyConfig que inclui mais alguns campos de metadados, como um nome a apresentar e uma descrição. Por conseguinte, para criar um novo modelo de desidentificação, os passos básicos são:

Comece com um objeto DeidentifyConfig.
Chame ou POST o método create do recurso projects.deidentifyTemplates, incluindo no seu pedido um objeto DeidentifyTemplate que contenha um nome a apresentar, uma descrição e esse objeto DeidentifyConfig.

O DeidentifyTemplate devolvido fica imediatamente disponível para utilização. Pode fazer-lhe referência noutras chamadas ou tarefas através do respetivo name. Pode listar os modelos existentes chamando o método *.deidentifyTemplates.list. Para ver um modelo específico, chame o método *.deidentifyTemplates.get. Tenha em atenção que o limite para o número de modelos que pode criar é 1000.

Se já tiver alguma experiência na desidentificação de dados confidenciais de texto, imagens ou conteúdo estruturado através da proteção de dados confidenciais, já criou um objeto DeidentifyConfig. Um passo adicional transforma-o num DeidentifyTemplate objeto.

Exemplo de REST

O JSON seguinte é um exemplo do que pode enviar para o método projects.deidentifyTemplates.create. Este JSON cria um novo modelo com o nome a apresentar e a descrição indicados, e procura correspondências nos infoTypes EMAIL_ADDRESS e GENERIC_ID. Quando encontra conteúdo que corresponde a esses infoTypes, oculta os três primeiros carateres 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 experimentar rapidamente esta funcionalidade, pode usar o Explorador de APIs incorporado abaixo. Para informações gerais sobre a utilização de JSON para enviar pedidos à API DLP, consulte o início rápido de JSON.

Usar modelos de desidentificação

Depois de criar um novo modelo, pode usar o respetivo identificador name em qualquer lugar onde o deidentifyTemplateName seja aceite, como:

projects.content.deidentify: Remove a identificação de dados potencialmente confidenciais no conteúdo através do modelo como configuração. Tenha em atenção que este método pode usar um modelo de inspeção ou um modelo de anulação da identificação.

Modelos de desidentificação de fichas

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

projects.deidentifyTemplates.list

Esta secção demonstra como usar a proteção de dados confidenciais para listar modelos de inspeção. O processo é idêntico ao dos modelos de desidentificação de fichas.

C#

Para saber como instalar e usar a biblioteca cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

Para se autenticar na Proteção de dados confidenciais, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure 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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.


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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

// 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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

import google.cloud.dlp


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

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

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

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

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

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

Eliminar modelos de desidentificação

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

projects.deidentifyTemplates.delete

Com cada método *.*.delete, inclui o nome do recurso do modelo a eliminar.

C#

Para saber como instalar e usar a biblioteca cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.


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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.


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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

// 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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

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 cliente para a Proteção de dados confidenciais, consulte o artigo Bibliotecas cliente da Proteção de dados confidenciais.

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

Criar modelos de desidentificação da Proteção de dados confidenciais Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Crie um modelo de anulação da identificação

Consola

Defina o modelo

Configure a desidentificação

InfoType

Grave

Imagem

Protocolo

Exemplo de REST

Usar modelos de desidentificação

Modelos de desidentificação de fichas

C#

Go

Java

Node.js

PHP

Python

Eliminar modelos de desidentificação

C#

Go

Java

Node.js

PHP

Python

Criar modelos de desidentificação da Proteção de dados confidenciais