Como especificar locais de processamento

Com a capacidade de especificar uma região para executar as operações de Proteção de dados sensíveis, é possível controlar onde os dados potencialmente confidenciais são processados. Este documento explica o conceito de local de processamento da Proteção de dados sensíveis e mostra como especificar uma região.

Para conferir uma lista de regiões e multirregiões compatíveis, consulte Locais da Proteção de dados sensíveis.

Sobre regiões e multirregiões

Uma região é um lugar geográfico específico, como o oeste dos Estados Unidos ou o nordeste da Ásia. Um local multirregional (ou apenas multirregião) é uma grande área geográfica, como a União Europeia, que contém duas ou mais regiões geográficas.

Questões sobre o local

O local ideal é aquele em que você encontra um equilíbrio entre latência, disponibilidade e custos de largura de banda.

  • Use um local regional para ajudar a otimizar a latência e a largura de banda de rede.

  • Use um local multirregional quando quiser processar dados de fora da rede do Google e distribuídos em grandes áreas geográficas, ou quando quiser a maior disponibilidade proveniente da redundância entre regiões.

  • Geralmente, o recomendável é processar os dados em um local que seja conveniente ou que contenha a maioria dos usuários dos seus dados.

  • Se a sua organização precisar manter dados em trânsito em uma região especificada, use apenas as regiões que oferecem suporte a endpoints regionais (REP, na sigla em inglês). Nesse caso, é necessário usar a API Cloud Data Loss Prevention, porque os endpoints regionais da proteção de dados sensíveis não estão disponíveis para uso com o console do Google Cloud.

Especifique uma Região

A forma de especificar a região de processamento depende do tipo de endpoint para o qual você está enviando a solicitação: global ou regional. O tipo de endpoint escolhido depende se você precisa manter dados em trânsito em uma região especificada. Para mais informações, consulte Endpoints globais e regionais para a Proteção de dados sensíveis.

Especificar uma região em uma solicitação para o endpoint global

Console

Escolha uma região ao configurar a operação de proteção de dados sensíveis.

Por exemplo, ao criar um gatilho de jobs, escolha um local no menu Local do recurso, como mostrado aqui:

Se o local de processamento não for uma preocupação, use a região Global e o Google escolherá o local onde o processamento ocorrerá. Global é a escolha de região padrão.

REST

Insira as informações da região no URL do endpoint da solicitação. Se o local de processamento não for uma preocupação, use a região global e o Google escolherá o local onde o processamento ocorrerá. Observe que todos os recursos criados por uma solicitação que especifica a região global são armazenados na região global.

Confira a seguir alguns exemplos de solicitações para o endpoint global.

Como usar a região global

As duas solicitações a seguir têm o mesmo efeito. Não incluir uma região é o mesmo que especificar locations/global/.

POST https://www.googleapis.com/dlp/v2/projects/PROJECT_ID/locations/global/content:inspect
 
POST https://www.googleapis.com/dlp/v2/projects/PROJECT_ID/content:inspect

Usar uma região específica

Para especificar uma região para processamento no URL do recurso, insira locations/ e depois o nome da região.

POST https://www.googleapis.com/dlp/v2/projects/PROJECT_ID/locations/us-west2/content:inspect

Especificar uma região em uma solicitação para um endpoint regional

Console

Para a Proteção de dados sensíveis, os endpoints regionais não estão disponíveis para uso com o console do Google Cloud.

C#

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

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


using System;
using System.Collections.Generic;
using System.Linq;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;
using static Google.Cloud.Dlp.V2.InspectConfig.Types;

public class InspectStringRep
{
    public static InspectContentResponse Inspect(
        string projectId,
        string repLocation,
        string dataValue,
        string minLikelihood,
        int maxFindings,
        bool includeQuote,
        IEnumerable<InfoType> infoTypes,
        IEnumerable<CustomInfoType> customInfoTypes)
    {
        var inspectConfig = new InspectConfig
        {
            MinLikelihood = (Likelihood)Enum.Parse(typeof(Likelihood), minLikelihood, true),
            Limits = new FindingLimits
            {
                MaxFindingsPerRequest = maxFindings
            },
            IncludeQuote = includeQuote,
            InfoTypes = { infoTypes },
            CustomInfoTypes = { customInfoTypes }
        };
        var request = new InspectContentRequest
        {
            Parent = new LocationName(projectId, repLocation).ToString(),
            Item = new ContentItem
            {
                Value = dataValue
            },
            InspectConfig = inspectConfig
        };

        var dlp = new DlpServiceClientBuilder
        {
            Endpoint = $"dlp.{repLocation}.rep.googleapis.com"
        }.Build();

        var response = dlp.InspectContent(request);

        PrintResponse(includeQuote, response);

        return response;
    }

    private static void PrintResponse(bool includeQuote, InspectContentResponse response)
    {
        var findings = response.Result.Findings;
        if (findings.Any())
        {
            Console.WriteLine("Findings:");
            foreach (var finding in findings)
            {
                if (includeQuote)
                {
                    Console.WriteLine($"  Quote: {finding.Quote}");
                }
                Console.WriteLine($"  InfoType: {finding.InfoType}");
                Console.WriteLine($"  Likelihood: {finding.Likelihood}");
            }
        }
        else
        {
            Console.WriteLine("No findings.");
        }
    }
}

Go

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

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"google.golang.org/api/option"
)

// inspectString inspects the a given string, and prints results.
func inspectStringRep(w io.Writer, projectID, repLocation, textToInspect string) error {
	// projectID := "my-project-id"
	// textToInspect := "My name is Gary and my email is gary@example.com"
	ctx := context.Background()

	// Assemble the regional endpoint url using provided rep location
	repEndpoint := fmt.Sprintf("dlp.%s.rep.googleapis.com:443", repLocation)

	// Initialize client.
	client, err := dlp.NewClient(ctx, option.WithEndpoint(repEndpoint))
	if err != nil {
		return err
	}
	defer client.Close() // Closing the client safely cleans up background resources.

	// Create and send the request.
	req := &dlppb.InspectContentRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, repLocation),
		Item: &dlppb.ContentItem{
			DataItem: &dlppb.ContentItem_Value{
				Value: textToInspect,
			},
		},
		InspectConfig: &dlppb.InspectConfig{
			InfoTypes: []*dlppb.InfoType{
				{Name: "PHONE_NUMBER"},
				{Name: "EMAIL_ADDRESS"},
				{Name: "CREDIT_CARD_NUMBER"},
			},
			IncludeQuote: true,
		},
	}
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return err
	}

	// Process the results.
	result := resp.Result
	fmt.Fprintf(w, "Findings: %d\n", len(result.Findings))
	for _, f := range result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

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

Para autenticar na Proteção de dados sensíveis, configure o Application Default Credentials. Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local. 


import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.cloud.dlp.v2.DlpServiceSettings;
import com.google.privacy.dlp.v2.ByteContentItem;
import com.google.privacy.dlp.v2.ByteContentItem.BytesType;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.protobuf.ByteString;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

public class InspectStringRep {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String repLocation = "regional-endpoint-location-to-use";
    String textToInspect = "My name is Gary and my email is gary@example.com";
    inspectString(projectId, repLocation, textToInspect);
  }

  // Inspects the provided text.
  public static void inspectString(String projectId, String repLocation, String textToInspect)
      throws IOException {
    // Assemble the regional endpoint url using provided rep location
    String repEndpoint = String.format("dlp.%s.rep.googleapis.com:443", repLocation);
    DlpServiceSettings settings = DlpServiceSettings.newBuilder()
        .setEndpoint(repEndpoint)
        .build();
    // 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 dlp = DlpServiceClient.create(settings)) {
      // Specify the type and content to be inspected.
      ByteContentItem byteItem =
          ByteContentItem.newBuilder()
              .setType(BytesType.TEXT_UTF8)
              .setData(ByteString.copyFromUtf8(textToInspect))
              .build();
      ContentItem item = ContentItem.newBuilder().setByteItem(byteItem).build();

      // Specify the type of info the inspection will look for.
      List<InfoType> infoTypes = new ArrayList<>();
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      for (String typeName : new String[] {"PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER"}) {
        infoTypes.add(InfoType.newBuilder().setName(typeName).build());
      }

      // Construct the configuration for the Inspect request.
      InspectConfig config =
          InspectConfig.newBuilder().addAllInfoTypes(infoTypes).setIncludeQuote(true).build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest request =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, repLocation).toString())
              .setItem(item)
              .setInspectConfig(config)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(request);

      // Parse the response and process results
      System.out.println("Findings: " + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfo type: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood());
      }
    }
  }
}

REST

O exemplo a seguir envia uma solicitação content.inspect para um endpoint regional. Todos os dados anexados a essa solicitação permanecem na região especificada durante o trânsito, o uso e o armazenamento.

Antes de usar os dados da solicitação abaixo, faça as substituições a seguir:

  • REP_REGION: uma região em que um endpoint regional (REP) para a Proteção de Dados Sensíveis está disponível, por exemplo, us-west2. Para uma lista completa de regiões, consulte Locais da Proteção de dados sensíveis.
  • PROJECT_ID: é seu ID do projeto no Google Cloud. Os IDs do projeto são strings alfanuméricas, como example-project.

Método HTTP e URL: 

POST https://dlp.REP_REGION.rep.googleapis.com/v2/projects/PROJECT_ID/locations/REP_REGION/content:inspect

Corpo JSON da solicitação:

{
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "CREDIT_CARD_NUMBER"
      }
    ]
  },
  "item": {
    "value": "hi, my ccn is 4111111111111111"
  }
}

Para enviar a solicitação, expanda uma destas opções:

Você receberá uma resposta JSON semelhante a esta:

{
  "result": {
    "findings": [
      {
        "infoType": {
          "name": "CREDIT_CARD_NUMBER",
          "sensitivityScore": {
            "score": "SENSITIVITY_HIGH"
          }
        },
        "likelihood": "LIKELY",
        "location": {
          "byteRange": {
            "start": "14",
            "end": "30"
          },
          "codepointRange": {
            "start": "14",
            "end": "30"
          }
        },
        "createTime": "2024-08-09T19:54:13.348Z",
        "findingId": "2024-08-09T19:54:13.352163Z4747901452516738787"
      }
    ]
  }
}

Considerações sobre a locação conjunta

Ao verificar um repositório de armazenamento, como o Cloud Storage ou o BigQuery, você precisa especificar o mesmo local na sua solicitação de proteção de dados sensíveis que o local do repositório que você está verificando. Por exemplo, se o conjunto de dados do BigQuery estiver no local multirregional da União Europeia, especifique a multirregião da União Europeia (europe) ao configurar o job de Proteção de Dados Sensíveis.

Se você não realizar um locação conjunta da solicitação de proteção de dados sensíveis com o repositório de armazenamento que você está verificando, o processamento da solicitação poderá ser dividido entre o local dos dados e o local especificado na solicitação.

A seguir