Utiliser un proxy compatible avec la protection contre la perte de données (Proxy DLP) pour interagir avec Cloud SQL

Ce tutoriel explique comment utiliser un proxy qui transmet les résultats d'une requête via Cloud DLP (Data Loss Prevention, DLP) afin que les résultats renvoyés soient tokenisés ou que leur identification soit supprimée. Ce proxy est une démonstration pour ce tutoriel et n'est pas destiné à la production.

Ce tutoriel est destiné aux administrateurs de base de données, aux professionnels de la sécurité et aux architectes cloud qui souhaitent utiliser Cloud DLP pour tokeniser et supprimer l'identification des données stockées dans Cloud SQL. Ce tutoriel suppose que vous maîtrisez Cloud Shell et Cloud SQL.

Toutes les entreprises stockent de plus en plus de données. Une grande partie de ces données est considérée comme sensible. Toutes les personnes qui accèdent à ces données stockées n'ont pas besoin de voir les données sensibles lors de l'exécution de requêtes sur la base de données.

Ce tutoriel explique comment autoriser vos utilisateurs à accéder à une base de données Cloud SQL contenant des données sensibles, mais en empêchant l'affichage de ces données sensibles lors de l'examen des résultats de requête.

Le schéma suivant illustre l'architecture de déploiement pour ce tutoriel.

Architecture de déploiement permettant aux utilisateurs d'accéder à la base de données Cloud SQL

Dans ce tutoriel, vous configurez un proxy DLP servant d'interface entre Cloud SQL et un client SQL simple.

Objectifs

Créez une base de données et remplissez un tableau avec des exemples de données sensibles.
Créez des modèles Cloud DLP.
Téléchargez les fichiers JAR du serveur proxy DLP et du client.
Configurez le proxy DLP pour qu'il se connecte à la base de données d'instance Cloud SQL pour qu'il utilise les modèles Cloud DLP.
Testez les fonctionnalités du proxy.

Coûts

Ce tutoriel utilise 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é ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Avant de commencer

Connectez-vous à votre compte Google.
Si vous n'en possédez pas déjà un, vous devez en créer un.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder à la page de sélection du projet

Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

Activez les API requises.
Activer les API

Créer une base de données Cloud SQL pour MySQL

Dans cette section, vous créez une instance Cloud SQL, une base de données Cloud SQL pour MySQL et ajoutez des exemples de données sensibles.

Dans Cloud Console, activez Cloud Shell.

Activer Cloud Shell

En bas de la fenêtre de Cloud Console, une session Cloud Shell démarre et affiche une invite de ligne de commande. Cloud Shell est un environnement shell dans lequel le SDK Cloud est déjà installé (y compris l'outil de ligne de commande gcloud), et dans lequel des valeurs sont déjà définies pour votre projet actuel. L'initialisation de la session peut prendre quelques secondes.
Copiez les fichiers nécessaires pour terminer le tutoriel à partir du bucket Cloud Storage public de Google dans un dossier appelé gcp-dlp-tutorial :
```
mkdir gcp-dlp-proxy-tutorial
gsutil cp  gs://solutions-public-assets/dlp-cloudsql-proxy/*.* gcp-dlp-proxy-tutorial
```
Définissez le projet Cloud :
```
gcloud config set project project-id
```
Remplacez l'élément suivant :
- project-id : ID de votre projet Cloud.
Remplacez les répertoires par le dossier dans lequel vous avez copié les fichiers du tutoriel :
```
cd  gcp-dlp-proxy-tutorial
```
Pour voir la liste des zones, exécutez la commande suivante :
```
gcloud compute zones list
```
Pour en savoir plus sur les zones, consultez la page Zones géographiques et régions.
Choisissez une zone pour créer l'instance Cloud SQL et exporter la zone en tant que variable d'environnement :
```
export ZONE=zone
```
Remplacez l'élément suivant :
- zone : zone de votre choix dans laquelle vous créez l'instance Cloud SQL.

Créez une instance Cloud SQL pour MySQL appelée dlp-test-instance :

gcloud sql instances create dlp-test-instance  --zone  $ZONE

L'instance est créée lorsque le résultat est semblable à celui-ci :

Creating Cloud SQL instance...done.
Created [https://www.googleapis.com/sql/v1beta4/projects/[PROJECT_ID]/instances/dlp-test-instance].
NAME               DATABASE_VERSION  LOCATION  TIER              PRIMARY_ADDRESS  PRIVATE_ADDRESS  STATUS
dlp-test-instance  MYSQL_5_7         [ZONE]    db-n1-standard-1  35.195.26.16     -                RUNNABLE

Définissez le mot de passe de l'utilisateur MySQL root@%.
```
gcloud sql users set-password root \
  --host=% --instance=dlp-test-instance \
  --password=password
```
Remplacez l'élément suivant :
- password : mot de passe sécurisé.
Le résultat suivant s'affiche :
```
Updating Cloud SQL user...done.
```

Créez une base de données dans votre instance appelée dlp-test-db :

gcloud sql databases create  dlp-test-db --instance dlp-test-instance

Le résultat ressemble à ce qui suit :

Creating Cloud SQL database...done.
Created database [dlp-test-db].
instance: dlp-test-instance
name: dlp-test-db
project: project-id

Créez un utilisateur de base de données appelé dlptester :
```
gcloud sql users create dlptester \
  --host=% --instance=dlp-test-instance --password=password-database
```
Remplacez l'élément suivant :
- password-database : substituez par un mot de passe sécurisé. Notez le mot de passe, car vous en aurez besoin dans la suite du tutoriel.
Le résultat suivant s'affiche :
```
Creating Cloud SQL user...done.
Created user [dlptester].
```
Connectez-vous à l'instance Cloud SQL for MySQL :
```
gcloud sql connect dlp-test-instance  --user=dlptester
```
Lorsque vous y êtes invité, saisissez password-database.
À l'invite MySQL, créez une table appelée TEST_DATA et remplissez-la avec quelques lignes d'exemples de données sensibles :
```
source create_test_data.sql
```

À l'invite MySQL, exécutez une requête pour indiquer que les données de test ont été chargées dans la table :

select * from TEST_DATA LIMIT 10;

Les résultats de la requête sont similaires à ceux-ci :

MySQL [dlp-test-db]> select * from TEST_DATA LIMIT 10;
+------+---------------------+--------------+-------------+--------+
| id   | email               | phone        | ssn         | metric |
+------+---------------------+--------------+-------------+--------+
|    1 | mallory@example.org | 858-222-0222 | 222-22-2222 |      5 |
|    2 | james@example.org   | 858-333-0333 | 333-33-3333 |      8 |
|    3 | mallory@example.org | 858-222-0222 | 222-22-2222 |      8 |
|    4 | maria@example.org   | 858-444-0444 | 444-44-4444 |      1 |
|    1 | mallory@example.org | 858-222-0222 | 222-22-2222 |      5 |
|    2 | james@example.org   | 858-333-0333 | 333-33-3333 |      8 |
|    3 | mallory@example.org | 858-222-0222 | 222-22-2222 |      8 |
|    4 | maria@example.org   | 858-444-0444 | 444-44-4444 |      1 |
+------+---------------------+--------------+-------------+--------+
8 rows in set (0.00 sec)

Quittez le client MySQL :
```
exit
```

Créer des modèles Cloud DLP

Dans cette section, vous allez créer deux modèles Cloud DLP. Un modèle d'inspection pour inspecter les données dans les tableaux TEST_DATA et identifier les données sensibles telles que définies par les InfoTypes. Le second modèle est un modèle de désidentification permettant de tokeniser les données sensibles définies par les InfoTypes.

Créer un modèle d'inspection

Dans Cloud Console, accédez à la page Cloud DLP.

Accéder à Cloud DLP
Cliquez sur Créer et sélectionnez Modèle.
Dans le champ ID du modèle, saisissez inspect-template-1.
Cliquez sur Continuer.
Définissez les InfoTypes sur EMAIL_ADDRESS, PHONE_NUMBER et US_SOCIAL_SECURITY_NUMBER.
Cliquez sur Créer.

Créer un modèle de suppression de l'identification

Dans cette section, vous créez un modèle de désidentification nommé de-identify-template-1, configuré pour remplacer les informations sensibles par une valeur de substitution générée par le hachage cryptographique. Pour en savoir plus, consultez la section cryptoHashConfig de la documentation Cloud DLP.

Accédez à l'outil APIs Explorer.
Dans le champ parent, remplacez [YOUR-PROJECT] par l'ID de votre projet Cloud.

Sélectionnez Exécuter. Lorsque vous y êtes invité, sélectionnez de nouveau Exécuter.

Vous obtenez une réponse 200 et un résultat semblable à celui-ci :

{
  "name": "projects/YOUR-PROJECT-ID/deidentifyTemplates/de-identify-template-1",
  "createTime": "2019-10-15T12:46:51.944253Z",
  "updateTime": "2019-10-15T12:46:51.944253Z",
  "deidentifyConfig": {
    "infoTypeTransformations": {
      "transformations": [
        {
          "infoTypes": [
            {
              "name": "PHONE_NUMBER"
            },
            {
              "name": "US_SOCIAL_SECURITY_NUMBER"
            },
            {
              "name": "EMAIL_ADDRESS"
            }
          ],
          "primitiveTransformation": {
            "cryptoDeterministicConfig": {
              "cryptoKey": {
                "transient": {
                  "name": "abc"
                }
              },
              "surrogateInfoType": {
                "name": "S1"
              }

Pour vérifier que votre modèle de désidentification a bien été enregistré, accédez à nouveau à l'outil APIs Explorer pour passer un appel afin de répertorier les modèles.
Dans le champ parent, saisissez projects/project-id.
Sélectionnez Exécuter. Lorsque vous y êtes invité, sélectionnez de nouveau Exécuter.

Le résultat est similaire au résultat suivant et inclut le modèle que vous avez créé :

Configurer et utiliser le proxy DLP

Dans cette section, vous configurez le proxy DLP, vous vous y connectez à l'aide du client et vérifiez que les résultats de la requête sont traités par Cloud DLP.

Dans Cloud Shell, remplacez le répertoire par celui contenant le dossier dans lequel vous avez copié les fichiers du tutoriel :
```
cd  ~/gcp-dlp-proxy-tutorial
```
Modifiez le fichier de configuration du serveur proxy DLP :
```
nano config.json
```
Modifiez les lignes suivantes en remplaçant les espaces réservés par les valeurs correspondant à votre configuration.
```
"db_instance": "project_id:region:instance_name",
"db_dbname": "dbase_name",
"projectID": "project_id",
"audit_template": "inspect_template",
 "deidentify_template": "deidentify_template",
```
Remplacez l'élément suivant :
- project_id : ID de votre projet Cloud.
- region : nom de la région correspondant à la zone dans laquelle votre instance Cloud SQL a été créée. Par exemple, si votre instance a été créée dans la zone us-central1-a, la région est us-central1..
- instance_name : nom de votre instance Cloud SQL, tel que dlp-test-instance.
- dbase_name : nom de votre base de données, tel que dlp-test-db.
- inspect_template : nom de votre modèle d'inspection, tel que inspect-template-1.
- inspect_template : nom de votre modèle de désidentification, tel que de-identify-template-1.
Pour démarrer le proxy DLP, exécutez le proxy en arrière-plan en dirigeant la sortie du terminal vers le fichier log.txt :
```
java -jar dlp-cloudsql-proxy-server.jar database_userpassword-databaselog.txt 2>&1 &
```
Remplacez l'élément suivant :
- database_user : nom d'utilisateur de l'utilisateur de la base de données.
- password-database : mot de passe de l'utilisateur de la base de données que vous avez précédemment créé.
Pour vérifier que le proxy DLP est en cours d'exécution, vérifiez que le processus est en cours d'exécution :
```
ps -ax | grep dlp-cloudsql-proxy-server.jar
```
Le processus exécutant le proxy DLP est affiché dans le résultat :
```
1233 pts/1    Sl     0:08 java -jar dlP-cloudsql-proxy-Server.jar dlptester XXXXXXXX
1266 pts/1    S+     0:00 grep --color=auto dlp-cloud sql-proxy-Server
```
Si vous ne voyez pas le processus en cours d'exécution, recherchez les messages d'erreur dans le fichier log.txt.

Remarque : La liste des processus affiche la commande complète utilisée pour démarrer le proxy DLP, y compris le nom d'utilisateur et le mot de passe. Cette approche n'est pas recommandée, car les noms d'utilisateur et les mots de passe ne doivent pas être facilement visibles. Vous pouvez utiliser le fichier Docker associé pour empêcher l'affichage de ces valeurs dans la liste des processus. Pour en savoir plus, consultez le fichier README que vous avez téléchargé lors du clonage du dépôt GitHub. Dans un environnement de production, suivez les bonnes pratiques pour protéger votre nom d'utilisateur et vos mots de passe contre l'exposition.
Démarrez le client simple fourni pour vous connecter au proxy DLP sur le port 5000 :
```
java -jar dlp-sql-proxy-client-0.1.0.jar 5000
```
Remarque : Si vous recevez un message d'erreur Failed to connect to the proxy server, attendez quelques secondes, puis réessayez, car le serveur proxy DLP est peut-être toujours en cours de démarrage.

À partir du client, exécutez une requête simple. Cette commande peut prendre quelques instants, car Cloud DLP doit traiter les données avant de vous les renvoyer.

select * from TEST_DATA LIMIT 10;

La sortie contient le numéro de téléphone, l'adresse e-mail et les valeurs SSN dans les résultats de la requête, remplacés par des valeurs de substitution hachées cryptographiquement. Comparez-les aux résultats renvoyés précédemment sans l'utilisation du proxy.

Connected to SQL Proxy
Enter query here (enter "quit" to disconnect):
select * from TEST_DATA LIMIT 10;
id: 1
phone: S1(40):AYnPXA6QcxlpOITeaZZM3+U/s7KtXyTqv5KAbB8=
metric: 5
email: S1(48):AS8hnzz6g1fGCabK2cbhPn5X7Qvc7FKmLTXnKF1iKF2nRjGQ
ssn: S1(40):AQ1jSCdIsctniCkCHNEbsc+kliJArHmM6bOJRg==

id: 2
phone: S1(40):AfiaKlOYHAzgWGtrkpvaCWUY1e2yvMaK7IQvM/M=
metric: 8
email: S1(48):ASF7UBFuZ/xUzXJjD1Ap745xcGmKpTjw+IwIBB/F/OX53w==
ssn: S1(40):AWYXh7U8PhNUZu+fXLuLFS0KCMmcM5uKH17rig==

id: 3
phone: S1(40):AYnPXA6QcxlpOITeaZZM3+U/s7KtXyTqv5KAbB8=
metric: 8
email: S1(48):AS8hnzz6g1fGCabK2cbhPn5X7Qvc7FKmLTXnKF1iKF2nRjGQ
ssn: S1(40):AQ1jSCdIsctniCkCHNEbsc+kliJArHmM6bOJRg==

id: 4
phone: S1(40):AXFnPkf620wIBXxW0uuBXSVERzRzvhdgbCdaYIw=
metric: 1
email: S1(48):AZgs1pfjEPLL6sDAcIZWuCZhC/saw/rQrujxAFy/O60uIA==
ssn: S1(40):AatdICHDpwCc19ELEjCS8zAmeSVvx/1KB5/S2Q==

End of query results

Quittez le client :
```
quit
```
Désactivez le serveur proxy DLP :
```
killall java
```

Écrivez le fichier log.txt sur le terminal pour afficher la sortie du proxy DLP :

cat  log.txt

Le résultat de la phase d'audit est affiché à la fin du fichier, correspondant aux trois InfoTypes que vous avez configurés précédemment :

RunCommand
DLP Result
DLP Findings:
        Quote:                          Info type: PHONE_NUMBER Likelihood: VERY_LIKELY
        Quote:                          Info type: EMAIL_ADDRESS        Likelihood: LIKELY
        Quote:                          Info type: US_SOCIAL_SECURITY_NUMBER    Likelihood: VERY_LIKELY
        Quote:                          Info type: PHONE_NUMBER Likelihood: VERY_LIKELY
        Quote:                          Info type: EMAIL_ADDRESS        Likelihood: LIKELY
        Quote:                          Info type: US_SOCIAL_SECURITY_NUMBER    Likelihood: VERY_LIKELY
        Quote:                          Info type: PHONE_NUMBER Likelihood: VERY_LIKELY
        Quote:                          Info type: EMAIL_ADDRESS        Likelihood: LIKELY
        Quote:                          Info type: US_SOCIAL_SECURITY_NUMBER    Likelihood: VERY_LIKELY
        Quote:                          Info type: PHONE_NUMBER Likelihood: VERY_LIKELY
        Quote:                          Info type: EMAIL_ADDRESS        Likelihood: LIKELY
        Quote:                          Info type: US_SOCIAL_SECURITY_NUMBER    Likelihood: VERY_LIKELY

Got DLP Result
Sensitive information found
write log: 1503994
Logged Main.Query: 1503994

Nettoyer

Le moyen le plus simple d'éviter la facturation consiste à supprimer le projet Cloud que vous avez créé pour le tutoriel. Vous pouvez également supprimer les différentes ressources.

Supprimer le projet

Dans Cloud Console, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étape suivante

Consultez la page sur l'exemple d'architecture pour utiliser un proxy DLP afin d'interroger une base de données contenant des données sensibles pour découvrir des exemples d'utilisation du proxy DLP dans votre architecture.
Testez d'autres fonctionnalités de Google Cloud. Découvrez nos tutoriels.