Criar modelos de inspeção da proteção de dados confidenciais

Este tópico descreve detalhadamente como criar um novo modelo de inspeção. Para ver um procedimento rápido sobre como criar um novo modelo de inspeção através da Google Cloud consola, consulte o Início rápido: criar um modelo de inspeção de proteção de dados confidenciais.

Acerca dos modelos

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 separar as informações de configuração, como o que inspeciona e como o desidentifica, da implementação dos seus pedidos. Os modelos oferecem uma forma de reutilizar a configuração e garantir a consistência entre utilizadores e conjuntos de dados. Além disso, sempre que atualiza um modelo, este é atualizado para qualquer acionador de tarefa que o use.

A proteção de dados confidenciais suporta modelos de inspeção, que são abordados neste tópico, e modelos de desidentificação, que são abordados no artigo Criar modelos de desidentificação da proteção de dados confidenciais.

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

Crie um novo modelo de inspeção

Importante: O código nesta página requer que configure primeiro um cliente da proteção de dados confidenciais. Para mais informações sobre a instalação e a criação de um cliente da Proteção de dados confidenciais, consulte Bibliotecas de cliente da Proteção de dados confidenciais. (O envio de JSON para pontos finais REST de proteção de dados confidenciais não requer uma biblioteca de cliente.)

Consola

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

Aceda a Criar modelo

A página Criar modelo contém as seguintes secções:

• Defina o modelo
• Configure a deteção

Defina o modelo

Em Definir modelo, introduza um identificador para o modelo de inspeção. É assim que vai referir-se ao modelo quando executar uma tarefa, criar um acionador de tarefas, etc. Pode usar letras, números e hífenes. Se quiser, também pode introduzir um nome a apresentar mais intuitivo, bem como uma descrição para se lembrar melhor da função do modelo.

No campo Localização do recurso, selecione a região onde os dados a inspecionar estão armazenados. O modelo de inspeção que criar também é armazenado nesta região. Se quiser poder usar o novo modelo de inspeção em qualquer região, selecione Global (qualquer região).

Configure a deteção

Em seguida, configura o que a Proteção de dados confidenciais deteta no seu conteúdo escolhendo um infoType e outras opções.

Os detetores de InfoType encontram dados confidenciais de um determinado tipo. Por exemplo, o detetor infoType de US_SOCIAL_SECURITY_NUMBERproteção de dados confidenciais encontra números de segurança social dos EUA. Além dos detetores de infoType incorporados, pode criar os seus próprios detetores de infoType personalizados.

Na secção InfoTypes, escolha o detetor InfoType que corresponde a um tipo de dados para o qual quer procurar. Não recomendamos que deixe esta secção em branco. Se o fizer, a proteção de dados confidenciais analisa os seus dados com um conjunto predefinido de infoTypes, que podem incluir infoTypes de que não precisa. Pode encontrar mais informações sobre cada detetor na referência do detetor de InfoType.

Para mais informações sobre como gerir infoTypes incorporados e personalizados nesta secção, consulte o artigo Faça a gestão de infoTypes através da Google Cloud consola.

Conjuntos de regras de inspeção

Limite de confiança

Sempre que a proteção de dados confidenciais deteta uma potencial correspondência de dados confidenciais, atribui-lhe um valor de probabilidade numa escala de "Muito improvável" a "Muito provável". Quando define um valor de probabilidade aqui, está a dar instruções ao Sensitive Data Protection para que só encontre correspondências em dados que correspondam a esse valor de probabilidade ou superior.

O valor predefinido de "Possível" é suficiente para a maioria dos fins. Se receber frequentemente correspondências demasiado amplas, mova o controlo de deslize para cima. Se tiver poucos resultados, mova o controlo de deslize para baixo.

Quando terminar, clique em Criar para criar o modelo. É apresentada a página de informações de resumo do modelo.

Para voltar à página principal de proteção de dados confidenciais, clique na seta Anterior na consola. Google Cloud

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;

public class InspectTemplateCreate
{
    public static InspectTemplate Create(
        string projectId,
        string templateId,
        string displayName,
        string description,
        Likelihood likelihood,
        int maxFindings,
        bool includeQuote)
    {
        var client = DlpServiceClient.Create();

        var request = new CreateInspectTemplateRequest
        {
            Parent = new LocationName(projectId, "global").ToString(),
            InspectTemplate = new InspectTemplate
            {
                DisplayName = displayName,
                Description = description,
                InspectConfig = new InspectConfig
                {
                    MinLikelihood = likelihood,
                    Limits = new InspectConfig.Types.FindingLimits
                    {
                        MaxFindingsPerRequest = maxFindings
                    },
                    IncludeQuote = includeQuote
                },
            },
            TemplateId = templateId
        };

        var response = client.CreateInspectTemplate(request);

        Console.WriteLine($"Successfully created template {response.Name}.");

        return response;
    }
}

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.

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.

import (
	"context"
	"fmt"
	"io"

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

// createInspectTemplate creates a template with the given configuration.
func createInspectTemplate(w io.Writer, projectID string, templateID, displayName, description string, infoTypeNames []string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"
	// displayName := "My Template"
	// description := "My template description"
	// infoTypeNames := []string{"US_SOCIAL_SECURITY_NUMBER"}

	ctx := context.Background()

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

	// Convert the info type strings to a list of InfoTypes.
	var infoTypes []*dlppb.InfoType
	for _, it := range infoTypeNames {
		infoTypes = append(infoTypes, &dlppb.InfoType{Name: it})
	}

	// Create a configured request.
	req := &dlppb.CreateInspectTemplateRequest{
		Parent:     fmt.Sprintf("projects/%s/locations/global", projectID),
		TemplateId: templateID,
		InspectTemplate: &dlppb.InspectTemplate{
			DisplayName: displayName,
			Description: description,
			InspectConfig: &dlppb.InspectConfig{
				InfoTypes:     infoTypes,
				MinLikelihood: dlppb.Likelihood_POSSIBLE,
				Limits: &dlppb.InspectConfig_FindingLimits{
					MaxFindingsPerRequest: 10,
				},
			},
		},
	}
	// Send the request.
	resp, err := client.CreateInspectTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateInspectTemplate: %w", err)
	}
	// Print the result.
	fmt.Fprintf(w, "Successfully created inspect template: %v", resp.GetName())
	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.

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.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CreateInspectTemplateRequest;
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.LocationName;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class TemplatesCreate {

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

  // Creates a template to persist configuration information
  public static void createInspectTemplate(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()) {
      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      List<InfoType> infoTypes =
          Stream.of("PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());

      // Construct the inspection configuration for the template
      InspectConfig inspectConfig = InspectConfig.newBuilder().addAllInfoTypes(infoTypes).build();

      // Optionally set a display name and a description for the template
      String displayName = "Inspection Config Template";
      String description = "Save configuration for future inspection jobs";

      // Build the template
      InspectTemplate inspectTemplate =
          InspectTemplate.newBuilder()
              .setInspectConfig(inspectConfig)
              .setDisplayName(displayName)
              .setDescription(description)
              .build();

      // Create the request to be sent by the client
      CreateInspectTemplateRequest createInspectTemplateRequest =
          CreateInspectTemplateRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectTemplate(inspectTemplate)
              .build();

      // Send the request to the API and process the response
      InspectTemplate response =
          dlpServiceClient.createInspectTemplate(createInspectTemplateRequest);
      System.out.printf("Template created: %s", response.getName());
    }
  }
}

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.

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.

// 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 minimum likelihood required before returning a match
// const minLikelihood = 'LIKELIHOOD_UNSPECIFIED';

// The maximum number of findings to report per request (0 = server maximum)
// const maxFindings = 0;

// The infoTypes of information to match
// const infoTypes = [{ name: 'PHONE_NUMBER' }, { name: 'EMAIL_ADDRESS' }, { name: 'CREDIT_CARD_NUMBER' }];

// Whether to include the matching string
// const includeQuote = true;

// (Optional) The name of the template to be created.
// const templateId = 'my-template';

// (Optional) The human-readable name to give the template
// const displayName = 'My template';

async function createInspectTemplate() {
  // Construct the inspection configuration for the template
  const inspectConfig = {
    infoTypes: infoTypes,
    minLikelihood: minLikelihood,
    includeQuote: includeQuote,
    limits: {
      maxFindingsPerRequest: maxFindings,
    },
  };

  // Construct template-creation request
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectTemplate: {
      inspectConfig: inspectConfig,
      displayName: displayName,
    },
    templateId: templateId,
  };

  const [response] = await dlp.createInspectTemplate(request);
  const templateName = response.name;
  console.log(`Successfully created template ${templateName}.`);
}
createInspectTemplate();

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.

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.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CreateInspectTemplateRequest;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits;
use Google\Cloud\Dlp\V2\InspectTemplate;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Create a new DLP inspection configuration template.
 *
 * @param string $callingProjectId project ID to run the API call under
 * @param string $templateId       name of the template to be created
 * @param string $displayName      (Optional) The human-readable name to give the template
 * @param string $description      (Optional) A description for the trigger to be created
 * @param int    $maxFindings      (Optional) The maximum number of findings to report per request (0 = server maximum)
 */
function create_inspect_template(
    string $callingProjectId,
    string $templateId,
    string $displayName = '',
    string $description = '',
    int $maxFindings = 0
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // ----- Construct inspection config -----
    // The infoTypes of information to match
    $personNameInfoType = (new InfoType())
        ->setName('PERSON_NAME');
    $phoneNumberInfoType = (new InfoType())
        ->setName('PHONE_NUMBER');
    $infoTypes = [$personNameInfoType, $phoneNumberInfoType];

    // Whether to include the matching string in the response
    $includeQuote = true;

    // The minimum likelihood required before returning a match
    $minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED;

    // Specify finding limits
    $limits = (new FindingLimits())
        ->setMaxFindingsPerRequest($maxFindings);

    // Create the configuration object
    $inspectConfig = (new InspectConfig())
        ->setMinLikelihood($minLikelihood)
        ->setLimits($limits)
        ->setInfoTypes($infoTypes)
        ->setIncludeQuote($includeQuote);

    // Construct inspection template
    $inspectTemplate = (new InspectTemplate())
        ->setInspectConfig($inspectConfig)
        ->setDisplayName($displayName)
        ->setDescription($description);

    // Run request
    $parent = "projects/$callingProjectId/locations/global";
    $createInspectTemplateRequest = (new CreateInspectTemplateRequest())
        ->setParent($parent)
        ->setInspectTemplate($inspectTemplate)
        ->setTemplateId($templateId);
    $template = $dlp->createInspectTemplate($createInspectTemplateRequest);

    // Print results
    printf('Successfully created template %s' . PHP_EOL, $template->getName());
}

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.

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.

from typing import List
from typing import Optional

import google.cloud.dlp


def create_inspect_template(
    project: str,
    info_types: List[str],
    template_id: Optional[str] = None,
    display_name: Optional[str] = None,
    min_likelihood: Optional[int] = None,
    max_findings: Optional[int] = None,
    include_quote: Optional[bool] = None,
) -> None:
    """Creates a Data Loss Prevention API inspect template.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        info_types: A list of strings representing info types to look for.
            A full list of info type categories can be fetched from the API.
        template_id: The id of the template. If omitted, an id will be randomly
            generated.
        display_name: The optional display name of the template.
        min_likelihood: A string representing the minimum likelihood threshold
            that constitutes a match. One of: 'LIKELIHOOD_UNSPECIFIED',
            'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE', 'LIKELY', 'VERY_LIKELY'.
        max_findings: The maximum number of findings to report; 0 = no maximum.
        include_quote: Boolean for whether to display a quote of the detected
            information in the results.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries (protos are also accepted).
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration dictionary. Keys which are None may
    # optionally be omitted entirely.
    inspect_config = {
        "info_types": info_types,
        "min_likelihood": min_likelihood,
        "include_quote": include_quote,
        "limits": {"max_findings_per_request": max_findings},
    }

    inspect_template = {
        "inspect_config": inspect_config,
        "display_name": display_name,
    }

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

    # Call the API.
    response = dlp.create_inspect_template(
        request={
            "parent": parent,
            "inspect_template": inspect_template,
            "template_id": template_id,
        }
    )

    print(f"Successfully created template {response.name}")

REST

Um modelo de inspeção é uma configuração de inspeção reutilizável, além de alguns metadados. Em termos de API, o objeto InspectTemplate é efetivamente um objeto InspectConfig que inclui mais alguns campos de metadados, como um nome a apresentar e uma descrição. Por conseguinte, para criar um novo modelo de inspeção, os passos básicos são:

1. Comece com um objeto InspectConfig.
2. Chame ou POST o método create do recurso projects.inspectTemplates ou organizations.inspectTemplates, incluindo na sua solicitação um objeto InspectTemplate que contenha um nome a apresentar, uma descrição e esse objeto InspectConfig.

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

Se já teve alguma experiência na inspeção de texto, imagens ou conteúdo estruturado para conteúdo confidencial através da proteção de dados confidenciais, já criou um objeto InspectConfig. Um passo adicional transforma-o num objeto InspectTemplate.

O JSON seguinte é um exemplo do que pode enviar para o método projects.inspectTemplates.create. Este JSON cria um novo modelo com o nome a apresentar e a descrição indicados, e procura correspondências nos infoTypes PHONE_NUMBER e US_TOLLFREE_PHONE_NUMBER. Inclui nas respetivas conclusões até 100 correspondências cuja probabilidade seja, pelo menos, POSSIBLE e inclui um fragmento de contexto para cada uma.

Entrada JSON:

POST https://dlp.googleapis.com/v2/projects/[PROJECT_ID]/inspectTemplates?key={YOUR_API_KEY}

{
  "inspectTemplate":{
    "displayName":"Phone number inspection",
    "description":"Scans for phone numbers",
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"PHONE_NUMBER"
        },
        {
          "name":"US_TOLLFREE_PHONE_NUMBER"
        }
      ],
      "minLikelihood":"POSSIBLE",
      "limits":{
        "maxFindingsPerRequest":100
      },
      "includeQuote":true
    }
  }
}

Saída JSON:

O JSON da resposta tem o seguinte aspeto:

{
  "name":"projects/[PROJECT_ID]/inspectTemplates/[JOB_ID]",
  "displayName":"Phone number inspection",
  "description":"Scans for phone numbers",
  "createTime":"2018-11-30T07:26:28.164136Z",
  "updateTime":"2018-11-30T07:26:28.164136Z",
  "inspectConfig":{
    "infoTypes":[
      {
        "name":"PHONE_NUMBER"
      },
      {
        "name":"US_TOLLFREE_PHONE_NUMBER"
      }
    ],
    "minLikelihood":"POSSIBLE",
    "limits":{
      "maxFindingsPerRequest":100
    },
    "includeQuote":true
  }
}

Nota: este modelo foi criado ao nível do projeto, mas também o pode criar ao nível da organização através do método organizations.inspectTemplates.create.

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.

Use modelos de inspeção

Depois de criar um novo modelo de inspeção, pode usá-lo quando criar uma nova tarefa de inspeção ou um acionador de tarefas. Sempre que atualiza esse modelo, este é atualizado em qualquer acionador de tarefa que o use. Para mais informações, incluindo exemplos de código, consulte:

• Inspeção do armazenamento e das bases de dados para verificar a existência de dados confidenciais
• Criar e agendar tarefas de inspeção da proteção de dados confidenciais

Consola

Para começar rapidamente a usar o novo modelo, siga as instruções fornecidas no artigo Início rápido: crie um modelo de inspeção da proteção de dados confidenciais com a seguinte alteração:

• Na secção Configurar deteção > Modelos, clique no campo Nome do modelo e selecione o modelo que acabou de criar.

Para obter um guia mais detalhado sobre como analisar o seu conteúdo, consulte o artigo Criar e agendar tarefas de inspeção da proteção de dados confidenciais, prestando especial atenção à secção "Configurar a deteção".

REST

Pode usar o identificador do modelo que especificou quando criou o modelo em qualquer lugar onde inspectTemplateName seja aceite, como:

• projects.content.inspect: Encontra dados potencialmente confidenciais no conteúdo através do modelo como configuração.
• projects.content.deidentify: Encontra e desidentifica dados potencialmente confidenciais no conteúdo através do modelo como configuração. Tenha em atenção que este método usa um modelo de inspeção e um modelo de desidentificação.
• projects.dlpJobs.create, no objeto InspectJobConfig: cria uma tarefa de inspeção que inclui o modelo como respetiva configuração.

Liste modelos de inspeção

Para listar todos os modelos de inspeção que foram criados no projeto atual ou na organização:

Consola

Nota: atualmente, não existe forma de ver os modelos ao nível da organização na consola.

1. Na Google Cloud consola, aceda à página Configuração da proteção de dados confidenciais.

   Aceda à configuração

2. Selecione o projeto que contém os modelos de inspeção.

3. Clique no separador Modelos.

A consola apresenta uma lista de todos os modelos de inspeção do projeto atual.

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.

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.

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.

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.

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.

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.

// 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.

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.

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.

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.

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

REST

Use um dos *.*.list métodos:

• organizations.inspectTemplates.list
• projects.inspectTemplates.list

Copie um modelo de inspeção para a região global

1. Na Google Cloud consola, aceda à página Sensitive Data Protection Configuração.

   Aceda à configuração

2. Na barra de ferramentas, clique no seletor de projetos e selecione o projeto que contém o modelo de inspeção que quer usar.

3. Clique no separador Modelos e, de seguida, no subseparador Inspecionar.

4. Clique no ID do modelo que quer usar.

5. Na página Detalhes do modelo de inspeção, clique em Copiar.

6. Na página Criar modelo, na lista Localização do recurso, selecione Global (qualquer região).

7. Clique em Criar.

O modelo é copiado para a região global.

Copie um modelo de inspeção para outro projeto

1. Na Google Cloud consola, aceda à página Sensitive Data Protection Configuração.

   Aceda à configuração

2. Na barra de ferramentas, clique no seletor de projetos e selecione o projeto que contém o modelo de inspeção que quer usar.

3. Clique no separador Modelos e, de seguida, no subseparador Inspecionar.

4. Clique no ID do modelo que quer usar.

5. Na página Detalhes do modelo de inspeção, clique em Copiar.

6. Selecione o projeto para o qual quer copiar o modelo de inspeção.

   A página Criar modelo é recarregada no projeto que selecionou.

7. Clique em Criar.

O modelo é criado no projeto que selecionou.

Elimine modelos de inspeção

Para eliminar um modelo de inspeção:

Consola

1. Na Google Cloud consola, aceda à página Configuração da proteção de dados confidenciais.

   Aceda à configuração

2. Selecione o projeto que contém o modelo de inspeção que quer eliminar.

3. Clique no separador Modelos. A consola apresenta uma lista de todos os modelos para o projeto atual.

4. Na coluna Ações do modelo que quer eliminar, clique no menu mais ações (apresentado como três pontos dispostos verticalmente) e, de seguida, clique em Eliminar.

Em alternativa, na lista de modelos, clique no nome do modelo que quer eliminar. Na página de detalhes do modelo, clique em 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.

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

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.

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.

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.

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.

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.

// 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.

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.

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.

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.

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

REST

Use um dos *.*.delete métodos:

• organizations.inspectTemplates.delete
• projects.inspectTemplates.delete

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