Cloud Data Loss Prevention (Cloud DLP) fait désormais partie de la protection des données sensibles. Le nom de l'API reste le même: API Cloud Data Loss Prevention (API DLP). Pour en savoir plus sur les services qui composent la protection des données sensibles, consultez Présentation de la protection des données sensibles.

Anonymiser les données BigQuery au moment de la requête

Ce tutoriel explique comment anonymiser des données lorsque vous interrogez des tables de BigQuery à l'aide de fonctions distantes et de la protection des données sensibles. Cette approche est utile pour nettoyer les résultats de requêtes en temps réel afin de minimiser l'accès aux données qui ne sont pas nécessaires à l'analyse.

Ce tutoriel explique comment chiffrer et déchiffrer des données en transit. Pour en savoir plus sur l'utilisation de la protection des données sensibles pour chiffrer les données au repos, consultez la page Anonymiser les données sensibles dans le stockage.

Ce tutoriel est destiné à un public dont les responsabilités incluent la sécurité, le traitement ou l'analyse des données. Ce guide suppose que vous maîtrisez le traitement et la confidentialité des données. Vous n'avez pas besoin d'être un expert. Dans ce guide, nous partons également du principe que vous savez exécuter des scripts Cloud Shell et SQL de base.

Ce tutoriel utilise des fonctions basées sur SQL, BigQuery, des fonctions à distance, Cloud Run et la protection des données sensibles.

Des techniques d'anonymisation, telles que le chiffrement, obscurcissent les identifiants sensibles bruts dans vos données. Ces techniques vous permettent de préserver l'utilité de vos données à des fins de jointure ou d'analyse, tout en réduisant les risques liés à leur traitement.

Les entreprises peuvent avoir des règles ou des exigences réglementaires pour ne stocker que des données anonymisées dans leur entrepôt de données cloud. En outre, ils peuvent avoir besoin de restaurer efficacement l'identification des données anonymisées pour générer des rapports.

Pour réduire les risques liés au traitement d'importants volumes de données sensibles, vous pouvez utiliser un pipeline de transformation de données automatisé pour créer des ensembles de données anonymisés. Vous pouvez utiliser ce tutoriel pour remplacer ce pipeline par une requête SQL destinée uniquement à la restauration de l'identification, ou aux deux. Ce tutoriel vous aide à effectuer à la fois une opération d'anonymisation et de restauration de l'identification à l'aide d'un service central hébergé sur Cloud Run. Vous pouvez utiliser ce service central dans l'ensemble de l'organisation sans avoir à configurer ni à gérer de cluster Dataflow.

La protection des données sensibles peut classer les ensembles de données en inspectant les données à la recherche d'informations sensibles. La protection des données sensibles dispose de plus de 150 classificateurs intégrés, appelés infoTypes. L'utilisation de l'API Cloud Data Loss Prevention pour anonymiser des données nécessite des pipelines de données et des applications. Ce tutoriel vise à aider vos analystes de données, ingénieurs ou scientifiques à obtenir le même résultat via les fonctions SQL.

À la fin de ce tutoriel, vous serez en mesure d'écrire une requête semblable à la suivante. Les données sensibles seront anonymisées dans le résultat de la requête.

SELECT
    pii_column,
    fns.dlp_freetext_encrypt(pii_column) AS dlp_encrypted,
    fns.dlp_freetext_decrypt(fns.dlp_freetext_encrypt(pii_column)) AS dlp_decrypted
FROM
    UNNEST(
    [
        'My name is John Doe. My email is john.doe@example.com']) AS pii_column

Le résultat ressemble à ce qui suit :

Ligne	`pii_column`	`dlp_encrypted`	`dlp_decrypted`
`1`	`My name is John Doe. My email is john.doe@example.com`	`My name is John Doe. My email is BQ_TRF_EMAIL(40):AQy6lGvwKR+AiiRqJpEr+nBzZUzOcjXkXamUugU=`	`My name is John Doe. My email is john.doe@example.com`

Architecture

Le schéma suivant montre comment ce tutoriel utilise BigQuery comme entrepôt de données, la protection des données sensibles pour anonymiser et restaurer l'identification des données, et Cloud Run pour héberger les fonctions distantes.

Objectifs

Déployez un service Cloud Run qui fournit une fonctionnalité d'anonymisation de la protection des données sensibles.
Créer des fonctions à distance BigQuery qui utilisent des modèles d'anonymisation de la protection des données sensibles
Vérifier le chiffrement des données dans BigQuery à l'aide d'une requête SQL

Coûts

Dans ce document, vous utilisez les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé les tâches décrites dans ce document, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Pour en savoir plus, consultez la section Effectuer un nettoyage.

Avant de commencer

Install the Google Cloud CLI.
Configure the gcloud CLI to use your federated identity.

For more information, see Browser-based sign-in with the gcloud CLI.
To initialize the gcloud CLI, run the following command:
```
gcloud init
```
Create or select a Google Cloud project.

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.
- Create a Google Cloud project:
```
gcloud projects create PROJECT_ID
```
  Replace PROJECT_ID with a name for the Google Cloud project you are creating.
- Select the Google Cloud project that you created:
```
gcloud config set project PROJECT_ID
```
  Replace PROJECT_ID with your Google Cloud project name.
Make sure that billing is enabled for your Google Cloud project.

Enable the Artifact Registry, BigQuery, API BigQuery Connection, Cloud Build, API Cloud Data Loss Prevention, Cloud Key Management Service, Cloud Run, Container Registry, Identity and Access Management, Resource Manager, Secret Manager et Service Usage APIs:

gcloud services enable artifactregistry.googleapis.com bigquery.googleapis.com bigqueryconnection.googleapis.com cloudbuild.googleapis.com cloudkms.googleapis.com cloudresourcemanager.googleapis.com containerregistry.googleapis.com dlp.googleapis.com iam.googleapis.com run.googleapis.com secretmanager.googleapis.com serviceusage.googleapis.com

Préparer l'environnement

Dans Cloud Shell, clonez le dépôt source :

git clone https://github.com/GoogleCloudPlatform/bigquery-dlp-remote-function.git

Accédez au répertoire de ce tutoriel:
```
cd bigquery-dlp-remote-function/
```

Déployer les ressources à l'aide d'un script

Si vous souhaitez utiliser le script de déploiement sans le personnaliser, procédez comme suit. Si vous souhaitez personnaliser le déploiement, ignorez cette section et consultez plutôt la section Déployer une solution personnalisée manuellement.

Définissez les valeurs des champs PROJECT_ID et REGION:
```
# Project ID of the Google Cloud project
PROJECT_ID="PROJECT_ID"

# Google Cloud region to use for deployment of resources
# Refer to https://cloud.google.com/about/locations
REGION="REGION"
```
Remplacez les éléments suivants :
- PROJECT_ID: ID du projet pour ce tutoriel.
- REGION: région dans laquelle vous souhaitez stocker et traiter les données (par exemple, us-west1). Indiquez une région, et non une zone.
Facultatif: Si vous souhaitez utiliser un modèle d'inspection, définissez le champ DLP_INSPECT_TEMPLATE sur le nom complet de la ressource de ce modèle d'inspection. Le modèle d'inspection doit se trouver dans la même région que celle que vous avez définie dans le champ REGION.

Assurez-vous que le modèle d'inspection inclut tous les infoTypes utilisés dans le modèle d'anonymisation.

Si vous ignorez cette étape, la protection des données sensibles inspecte les données avec un ensemble de détecteurs d'infoTypes par défaut.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Remplacez DLP_INSPECT_TEMPLATE par le nom complet de la ressource de votre modèle d'inspection (par exemple, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID).

Authentifiez-vous à l'aide des identifiants par défaut de l'application:

gcloud auth application-default login && \
gcloud auth application-default set-quota-project "${PROJECT_ID}"

Initialisez et exécutez le script Terraform pour créer toutes les ressources:
```
terraform init && \
terraform apply \
-var "project_id=${PROJECT_ID}" \
-var "region=${REGION}" \
-var "dlp_inspect_template_full_path=${DLP_INSPECT_TEMPLATE}"
```
Le système affiche toutes les actions que Terraform effectuera. Examinez les actions. Pour continuer, saisissez yes.
Vérifiez que les données peuvent être chiffrées et déchiffrées.

Déployer manuellement une solution personnalisée

Si vous souhaitez personnaliser le déploiement, procédez comme suit. Si vous souhaitez utiliser le script de déploiement fourni sans personnalisation ni procédure manuelle, consultez plutôt la section Déployer les ressources à l'aide d'un script.

Définir les variables d'environnement

Dans Cloud Shell, définissez les variables d'environnement suivantes:

PROJECT_ID="PROJECT_ID"
REGION="REGION"
CLOUD_RUN_SERVICE_NAME="CLOUD_RUN_SERVICE_NAME"
ARTIFACT_REGISTRY_NAME="ARTIFACT_DOCKER_REGISTRY_NAME"

Remplacez les éléments suivants :

PROJECT_ID: ID du projet pour ce tutoriel.
REGION: région dans laquelle vous souhaitez stocker et traiter les données (par exemple, us-west1). Indiquez une région, et non une zone.
CLOUD_RUN_SERVICE_NAME: nom du nouveau service Cloud Run. Saisissez jusqu'à 15 caractères.
ARTIFACT_REGISTRY_NAME: nom du nouvel Artifact Registry pour le stockage des images de conteneurs.

Créer un compte de service pour le service Cloud Run

Créez un compte de service :

RUNNER_SA_NAME="${CLOUD_RUN_SERVICE_NAME}-runner"
RUNNER_SA_EMAIL="${RUNNER_SA_NAME}@${PROJECT_ID}.iam.gserviceaccount.com"
gcloud iam service-accounts create "${RUNNER_SA_NAME}" \
    --project="${PROJECT_ID}" \
    --description "Runner for BigQuery remote function execution" \
    --display-name "${RUNNER_SA_NAME}"

Attribuez les rôles requis pour la protection des données sensibles.

Attribuez le rôle Lecteur DLP:

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${RUNNER_SA_EMAIL}" \
    --role='roles/dlp.reader'

Attribuez le rôle Utilisateur DLP:

gcloud projects add-iam-policy-binding "${PROJECT_ID}" \
    --member="serviceAccount:${RUNNER_SA_EMAIL}" \
    --role='roles/dlp.user'

Déployer le service Cloud Run

Pour déployer l'application, procédez comme suit:

Facultatif: Vous pouvez modifier les valeurs par défaut en modifiant les variables d'environnement ou en mettant à jour le fichier src/main/resources/aes.properties.

Créez un dépôt Artifact Registry pour stocker l'image de conteneur de la fonction:

gcloud artifacts repositories create "${ARTIFACT_REGISTRY_NAME}" \
--repository-format=docker \
--location="${REGION}" \
--description="Container images repository for BigQuery Functions" \
--project="${PROJECT_ID}"

Compilez l'application et déployez-la sur Cloud Run à l'aide de Cloud Build:

gcloud builds submit \
--project ${PROJECT_ID} \
--substitutions=_CONTAINER_IMAGE_NAME="${REGION}-docker.pkg.dev/${PROJECT_ID}/${ARTIFACT_REGISTRY_NAME}/${CLOUD_RUN_SERVICE_NAME}:latest" \
--machine-type=e2-highcpu-8 && \
gcloud beta run deploy ${CLOUD_RUN_SERVICE_NAME} \
--image="${REGION}-docker.pkg.dev/${PROJECT_ID}/${ARTIFACT_REGISTRY_NAME}/${CLOUD_RUN_SERVICE_NAME}:latest" \
--execution-environment=gen2 \
--platform=managed \
--region="${REGION}" \
--service-account="${RUNNER_SA_EMAIL}" \
--cpu=4 \
--memory=8Gi \
--no-allow-unauthenticated \
--project ${PROJECT_ID} \
--update-env-vars=PROJECT_ID=${PROJECT_ID}

La fin du résultat ressemble à ce qui suit:

ID: 403a276e-b0c6-41f3-aaed-f0ec9f9cedba
CREATE_TIME: 2023-02-04T01:52:15+00:00
DURATION: 1M59S
SOURCE: gs://PROJECT_ID_cloudbuild/source/1675475534.124241-9c43787f64e04cfd9e4a1979d3324fe0.tgz
IMAGES: gcr.io/PROJECT_ID/CLOUD_RUN_SERVICE_NAME (+1 more)
STATUS: SUCCESS
Deploying container to Cloud Run service [CLOUD_RUN_SERVICE_NAME] in project [PROJECT_ID] region [REGION]
OK Deploying new service... Done.
 OK Creating Revision... Revision deployment finished. Checking container heal
 th.
 OK Routing traffic...
Done.
Service [CLOUD_RUN_SERVICE_NAME] revision [CLOUD_RUN_SERVICE_NAME-00001-tat] has been deployed and is serving 100 percent of traffic.
Service URL: https://CLOUD_RUN_SERVICE_NAME-j2bpjx2xoq-uw.a.run.app

Récupérez l'URL Cloud Run et enregistrez-la dans vos variables d'environnement:

RUN_URL="$(gcloud run services describe ${CLOUD_RUN_SERVICE_NAME} --region \
    ${REGION} --project ${PROJECT_ID} --format="get(status.address.url)")"

Créer un modèle d'anonymisation pour la protection des données sensibles

Les modèles d'anonymisation pour la protection des données sensibles vous aident à enregistrer vos paramètres d'anonymisation afin de pouvoir les réutiliser pour plusieurs opérations et sources de données.

Cette étape utilise le fichier sample_dlp_deid_config.json, qui contient un exemple de modèle d'anonymisation.

Dans Cloud Shell, créez le modèle:

DEID_TEMPLATE=$(curl -X POST \
-H "Authorization: Bearer `gcloud auth print-access-token`" \
-H "Accept: application/json" \
-H "Content-Type: application/json" \
-H "X-Goog-User-Project: ${PROJECT_ID}" \
--data-binary "@sample_dlp_deid_config.json" \
"https://dlp.googleapis.com/v2/projects/${PROJECT_ID}/locations/${REGION}/deidentifyTemplates")

DEID_TEMPLATE_NAME="$(echo ${DEID_TEMPLATE} | jq -r '.name')"

Google vous recommande d'utiliser une clé encapsulée lorsque vous effectuez un chiffrement de protection des données sensibles sur des charges de travail sensibles réelles. À des fins de démonstration, ce tutoriel utilise une clé non encapsulée. Pour savoir comment créer une clé encapsulée et l'utiliser dans des requêtes d'anonymisation et de restauration de l'identification, consultez la page Anonymiser et restaurer l'identification des données sensibles.

Créer la connexion BigQuery à Cloud Run

Dans Cloud Shell, créez une connexion BigQuery pour accéder à Cloud Run:

bq mk --connection \
--display_name='External transform function connection' \
--connection_type=CLOUD_RESOURCE \
--project_id="${PROJECT_ID}" \
--location="${REGION}" \
ext-${CLOUD_RUN_SERVICE_NAME}

Recherchez et définissez le compte de service BigQuery utilisé pour la connexion:

CONNECTION_SA="$(bq --project_id ${PROJECT_ID} --format json show \
    --connection ${PROJECT_ID}.${REGION}.ext-${CLOUD_RUN_SERVICE_NAME} \
    | jq -r '.cloudResource.serviceAccountId')"

Attribuez le rôle Demandeur Cloud Run au compte de service:

gcloud projects add-iam-policy-binding ${PROJECT_ID} \
    --member="serviceAccount:${CONNECTION_SA}" \
    --role='roles/run.invoker'

Créer l'ensemble de données BigQuery pour les fonctions distantes

Définissez l'ensemble de données BigQuery pour les fonctions distantes:
```
BQ_FUNCTION_DATASET="fns"
```

Créez l'ensemble de données s'il n'existe pas déjà:

   bq mk --dataset \
       --project_id ${PROJECT_ID} \
       --location ${REGION} \
       ${BQ_FUNCTION_DATASET}

Créer les fonctions distantes de protection des données sensibles

Facultatif: Si vous souhaitez utiliser un modèle d'inspection, définissez la variable DLP_INSPECT_TEMPLATE sur le nom de ressource complet de ce modèle d'inspection. Le modèle d'inspection doit se trouver dans la même région que celle que vous avez définie dans la variable d'environnement REGION.

Assurez-vous que le modèle d'inspection inclut tous les infoTypes utilisés dans le modèle d'anonymisation.

Si vous ignorez cette étape, la protection des données sensibles inspecte les données avec un ensemble de détecteurs d'infoTypes par défaut.
```
DLP_INSPECT_TEMPLATE="DLP_INSPECT_TEMPLATE"
```
Remplacez DLP_INSPECT_TEMPLATE par le nom complet de la ressource de votre modèle d'inspection (par exemple, projects/PROJECT_ID/locations/REGION/inspectTemplates/TEMPLATE_ID).

Créez la fonction d'anonymisation pour la protection des données sensibles:

bq query --project_id ${PROJECT_ID} \
--use_legacy_sql=false \
"CREATE OR REPLACE FUNCTION ${BQ_FUNCTION_DATASET}.dlp_freetext_encrypt(v STRING)
RETURNS STRING
REMOTE WITH CONNECTION \`${PROJECT_ID}.${REGION}.ext-${CLOUD_RUN_SERVICE_NAME}\`
OPTIONS (endpoint = '${RUN_URL}', user_defined_context = [('mode', 'deidentify'),('algo','dlp'),('dlp-deid-template','${DEID_TEMPLATE_NAME}'),('dlp-inspect-template', '${DLP_INSPECT_TEMPLATE}')]);"

Créez la fonction de restauration de l'identification pour la protection des données sensibles:

bq query --project_id ${PROJECT_ID} \
--use_legacy_sql=false \
"CREATE OR REPLACE FUNCTION ${BQ_FUNCTION_DATASET}.dlp_freetext_decrypt(v STRING)
RETURNS STRING
REMOTE WITH CONNECTION \`${PROJECT_ID}.${REGION}.ext-${CLOUD_RUN_SERVICE_NAME}\`
OPTIONS (endpoint = '${RUN_URL}', user_defined_context = [('mode', 'reidentify'),('algo','dlp'),('dlp-deid-template','${DEID_TEMPLATE_NAME}'),('dlp-inspect-template', '${DLP_INSPECT_TEMPLATE}')]);"

Vérifier l'anonymisation et la restauration de l'identification

Pour vérifier si la solution anonymise et réidentifie les données, procédez comme suit:

Console

Dans la console Google Cloud, accédez à BigQuery.

Accéder à BigQuery

BigQuery s'ouvre dans le dernier projet auquel vous avez accédé.
Pour ouvrir un éditeur de requête, cliquez sur Saisir une nouvelle requête.

Saisissez la requête suivante :

SELECT
    pii_column,
    fns.dlp_freetext_encrypt(pii_column) AS dlp_encrypted,
    fns.dlp_freetext_decrypt(fns.dlp_freetext_encrypt(pii_column)) AS dlp_decrypted
FROM
    UNNEST(
    [
        'My name is John Doe. My email is john.doe@example.com',
        'Some non PII data',
        '650-253-0000',
        'some script with simple number 1234']) AS pii_column

Cliquez sur Exécuter.

bq

Définissez la variable d'environnement pour l'ensemble de données:
```
BQ_FUNCTION_DATASET="fns"
```

Exécutez la requête:

bq query --project_id ${PROJECT_ID} \
--use_legacy_sql=false \
"
SELECT
  pii_column,
  ${BQ_FUNCTION_DATASET}.dlp_freetext_encrypt(pii_column) AS dlp_encrypted,
${BQ_FUNCTION_DATASET}.dlp_freetext_decrypt(${BQ_FUNCTION_DATASET}.dlp_freetext_encrypt(pii_column)) AS dlp_decrypted
FROM
  UNNEST(
    [
      'My name is John Doe. My email is john.doe@example.com',
      'Some non PII data',
      '650-253-0000',
      'some script with simple number 1234']) AS pii_column"

Le résultat ressemble à ce qui suit :

Ligne	`pii_column`	`dlp_encrypted`	`dlp_decrypted`
`1`	`My name is John Doe. My email is john.doe@example.com`	`My name is John Doe. My email is BQ_TRF_EMAIL(40):AQy6lGvwKR+AiiRqJpEr+nBzZUzOcjXkXamUugU=`	`My name is John Doe. My email is john.doe@example.com`
`2`	`Some non PII data`	`Some non PII data`	`Some non PII data`
`3`	`650-253-0000`	`BQ_TRF_PH(40):AeKpGU5KBXaTyecCun7dv1hHht5w5Q2PTpvkRC4=`	`650-253-0000`
`4`	`some script with simple number 1234`	`some script with simple number 1234`	`some script with simple number 1234`

Points à prendre en compte

Lorsque vous adaptez ce tutoriel à vos besoins, tenez compte des points suivants:

L'anonymisation et la restauration de l'identification sont traitées via un service Cloud Run. Provisionnez le processeur et la mémoire de Cloud Run en fonction de vos besoins en calcul. Pour en savoir plus, consultez les sections Limites de processeur et Limites de mémoire de Cloud Run.
Lorsque vous utilisez la protection des données sensibles, tenez compte des limites d'utilisation et des recommandations pour le contrôle des coûts.
Pour vous aider à contrôler les coûts et la consommation totale de votre quota de protection des données sensibles, limitez à 10 000 le nombre d'articles que vous transmettez via la fonction distante de protection des données sensibles. La solution peut automatiquement regrouper les requêtes pour gérer correctement les limites de requêtes liées à la protection des données sensibles suivantes:
- Nombre maximal de valeurs de table: 50 000
- Taille maximale des requêtes par défaut: 0,5 Mo
Les résultats finaux et filtrés de la requête doivent être transmis à la fonction de protection des données sensibles plutôt qu'à la source.

Pour cette solution, chaque valeur de la colonne pii_column est un élément. Par exemple, My name is John Doe. My email is john.doe@example.com est un élément.
Assurez-vous que votre ensemble de données BigQuery, votre service Cloud Run et vos modèles de protection des données sensibles se trouvent dans la même région cloud.

Effectuer un nettoyage

Pour éviter que les ressources utilisées lors de ce tutoriel soient facturées sur votre compte Google Cloud, supprimez le projet contenant les ressources, ou conservez le projet et supprimez les ressources individuelles.

Attention : La suppression d'un projet entraîne les effets décrits ci-dessous :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour les tâches décrites dans ce document et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs architectures, tutoriels et guides de démarrage rapide, réutiliser des projets peut vous aider à ne pas dépasser les limites de quotas des projets.

Delete a Google Cloud project:

gcloud projects delete PROJECT_ID

Étapes suivantes

Apprenez-en plus sur les fonctions distantes BigQuery.
Découvrez comment anonymiser les données sensibles.
Parcourez un exemple qui montre comment créer une clé encapsulée, tokeniser du contenu et restaurer l'identification du contenu tokenisé.
Découvrez comment gérer l'anonymisation et la désidentification des informations personnelles dans les ensembles de données à grande échelle à l'aide de la protection des données sensibles.
Découvrez Cloud KMS.