Spécifier des emplacements de traitement

Avec la possibilité de spécifier une région dans laquelle effectuer vos opérations Sensitive Data Protection, vous pouvez contrôler l'emplacement de traitement de vos données potentiellement sensibles. Cet article explique le concept d'emplacement de traitement Sensitive Data Protection et indique comment spécifier une région.

Pour obtenir la liste des régions et emplacements multirégionaux compatibles, consultez la page Emplacements Sensitive Data Protection.

À propos des régions et des emplacements multirégionaux

Une région est un emplacement géographique spécifique, par exemple l'ouest des États-Unis ou l'Asie du Nord. Un emplacement multirégional (ou simplement multirégional) est une vaste zone géographique, telle que l'Union européenne, qui comprend au moins deux régions géographiques.

Considérations au sujet des zones

Un bon emplacement permet d'équilibrer les coûts de latence, de disponibilité et de bande passante.

  • Optez pour une zone régionale afin d'optimiser la latence et la bande passante réseau.

  • Optez pour un emplacement multirégional lorsque vous souhaitez traiter des données provenant de l'extérieur du réseau Google et répartis sur des zones géographiques vastes, ou lorsque vous souhaitez bénéficier de la plus grande disponibilité offerte par la redondance entre les régions.

  • En règle générale, vous devez traiter vos données dans un emplacement pratique ou regroupant la majorité des utilisateurs de vos données.

  • Si votre organisation est tenue de conserver les données en transit dans un emplacement spécifié, n'utilisez que les régions ou les emplacements multirégionaux qui acceptent les points de terminaison régionaux. Dans ce cas, vous devez utiliser l'API Cloud Data Loss Prevention, car les points de terminaison régionaux pour Sensitive Data Protection ne sont pas disponibles pour une utilisation avec la Google Cloud console.

Spécifiez une région.

La façon dont vous spécifiez la région de traitement dépend du type de point de terminaison auquel vous envoyez la requête : le point de terminaison mondial ou un point de terminaison régional. Le type de point de terminaison que vous choisissez dépend de si vous êtes tenu de conserver les données en transit dans une région spécifiée. Pour en savoir plus, consultez Points de terminaison mondiaux et régionaux pour Sensitive Data Protection.

Spécifier une région dans une requête adressée au point de terminaison mondial

Console

Choisissez une région lors de la configuration de votre opération Sensitive Data Protection.

Par exemple, lorsque vous créez un déclencheur de tâche, choisissez un emplacement dans le menu Resource location (Emplacement de la ressource), comme illustré ci-dessous :

Si l'emplacement de traitement n'est pas un problème, utilisez la région Global et Google sélectionne l'emplacement où le traitement doit avoir lieu. La région Global est définie par défaut.

REST

Insérez les informations de la région dans l'URL du point de terminaison de la requête. Si l'emplacement de traitement n'est pas un problème, utilisez la région global et Google sélectionne l'emplacement où le traitement doit avoir lieu. Notez que toutes les ressources créées par une requête spécifiant la région global sont stockées dans la région global.

Voici quelques exemples de requêtes adressées au point de terminaison mondial.

Utiliser la région mondiale

Les deux requêtes suivantes ont le même effet. Ne pas inclure une région revient à spécifier 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

Utiliser une région spécifique

Pour spécifier une région pour le traitement, dans l'URL de la ressource, insérez locations/ puis le nom de la région.

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

Spécifier une région dans une requête adressée à un point de terminaison régional

Console

Pour Sensitive Data Protection, les points de terminaison régionaux ne sont pas disponibles pour une utilisation avec la Google Cloud console.

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez la page Bibliothèques clientes Sensitive Data Protection.

Pour vous authentifier auprès de Sensitive Data Protection, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez la page Bibliothèques clientes Sensitive Data Protection.

Pour vous authentifier auprès de Sensitive Data Protection, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

Pour savoir comment installer et utiliser la bibliothèque cliente pour Sensitive Data Protection, consultez la page Bibliothèques clientes Sensitive Data Protection.

Pour vous authentifier auprès de Sensitive Data Protection, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement 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

L'exemple suivant envoie une requête content.inspect à un point de terminaison régional. Toutes les données jointes à cette requête restent dans la région spécifiée pendant le transit, l'utilisation et au repos.

Avant d'utiliser les données de requête, effectuez les remplacements suivants :

  • REGION : région où un point de terminaison régional pour Sensitive Data Protection est disponible (par exemple, us-west2). Pour obtenir la liste complète des régions, consultez la page Emplacements Sensitive Data Protection.
  • PROJECT_ID: ID de votre Google Cloud projet. Les ID de projet sont des chaînes alphanumériques, telles que example-project.

Méthode HTTP et URL : 

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

Corps JSON de la requête : 

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

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "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"
      }
    ]
  }
}

Considérations au sujet de la colocation

Lorsque vous analysez un dépôt de stockage tel que Cloud Storage ou BigQuery, vous devez spécifier le même emplacement dans votre requête Sensitive Data Protection que celui du dépôt que vous analysez. Par exemple, si l'ensemble de données BigQuery se trouve dans l'emplacement multirégional Union européenne, spécifiez l'emplacement multirégional Union européenne (europe) lors de la configuration de la tâche Sensitive Data Protection.

Si vous ne colocalisez pas votre requête Sensitive Data Protection avec le dépôt de stockage que vous analysez, le traitement de votre requête peut être divisé entre l'emplacement des données et l'emplacement spécifié dans la requête.

Étape suivante