Automatisation de la classification des données importées sur Cloud Storage

Ce tutoriel explique comment implémenter un système de classification et de mise en quarantaine automatique des données à l'aide de Cloud Storage et d'autres produits Google Cloud Platform (GCP). Le tutoriel suppose que vous connaissez bien GCP et la programmation shell de base.

Dans toutes les entreprises, les délégués à la protection des données, comme vous, font face à une quantité de données de plus en plus importante, qui doivent être protégées et traitées correctement. La mise en quarantaine et la classification de ces données peuvent être compliquées et chronophages, en particulier lorsqu'elles portent sur des centaines ou des milliers de fichiers par jour.

Que diriez-vous si vous pouviez prendre chaque fichier, l'importer à un emplacement de la zone de quarantaine, le faire classer automatiquement et le déplacer à l'emplacement approprié en fonction du résultat de la classification ? Ce tutoriel explique comment mettre en œuvre un tel système à l'aide de Cloud Functions, de Cloud Storage et de Cloud Data Loss Prevention (DLP).

Objectifs

  • Créer des buckets Cloud Storage dans le pipeline de zone de quarantaine et de classification.
  • Créer un sujet Cloud Pub/Sub et un abonnement pour vous avertir lorsque le traitement du fichier est terminé.
  • Créer une fonction Cloud Functions simple qui appelle l'API DLP lors de l'importation de fichiers.
  • Importer des exemples de fichiers dans le bucket de la zone de quarantaine pour appeler la fonction Cloud Functions. La fonction utilise l'API DLP pour inspecter et classifier les fichiers avant de les déplacer dans le bucket approprié.

Coûts

Ce tutoriel utilise des composants GCP facturables, y compris :

  • Cloud Storage
  • Cloud Functions
  • Cloud Data Loss Prevention

Vous pouvez utiliser le Simulateur de coût pour générer une estimation du coût en fonction de votre utilisation prévue.

Avant de commencer

  1. Connectez-vous à votre compte Google.

    Si vous n'en possédez pas déjà un, vous devez en créer un.

  2. Sélectionnez ou créez un projet Google Cloud Platform.

    Accéder à la page "Gérer les ressources"

  3. Assurez-vous que la facturation est activée pour votre projet Google Cloud Platform.

    Découvrir comment activer la facturation

  4. Activez Cloud Functions, Cloud Storage, and Cloud Data Loss Preventionles API requises.

    Activer les API.

Accorder des autorisations aux comptes de service

Votre première étape consiste à accorder des autorisations à deux comptes de service : le compte de service Cloud Functions et le compte de service Cloud DLP.

Accorder des autorisations au compte de service par défaut App Engine

  1. Dans la console GCP, ouvrez la page "IAM et administration" et sélectionnez le projet que vous avez créé :

    Accéder à la page "IAM et administration"

  2. Recherchez le compte de service App Engine. Ce compte a le format [PROJECT_ID]@appspot.gserviceaccount.com. Remplacez [PROJECT_ID] par l'ID de votre projet :

  3. Sélectionnez l'icône de modification modifier en regard du compte de service.

  4. Ajoutez les rôles suivants :

    • Projet > Propriétaire
    • Cloud DLP > Administrateur DLP
    • Service Management > Agent de service Cloud DLP
  5. Cliquez sur Enregistrer.

Accorder des autorisations au compte de service DLP

  1. Dans la console GCP, ouvrez la page IAM et administration et sélectionnez le projet que vous avez créé :

    Accéder à la page "IAM et administration"

  2. Recherchez le compte de service Agent de service Cloud DLP. Ce compte a le format suivant : service-[PROJECT_NUMBER]@dlp-api.iam.gserviceaccount.com. Remplacez [PROJECT_NUMBER] par votre numéro de projet.

  3. Sélectionnez l'icône de modification modifier en regard du compte de service.

  4. Ajoutez le rôle Projet > Lecteur, puis cliquez sur Enregistrer.

Créer le pipeline de zone de quarantaine et de classification

Cette section décrit comment créer le pipeline de zone de quarantaine et de classification présenté dans le diagramme suivant.

Workflow de zone de quarantaine et de classification

Les chiffres dans ce pipeline correspondent aux étapes suivantes :

  1. Vous importez des fichiers dans Cloud Storage.
  2. Vous appelez une fonction Cloud Functions.
  3. Cloud DLP inspecte et classifie les données.
  4. Le fichier est déplacé vers le bucket approprié.

Créer des buckets Cloud Storage

En suivant les instructions décrites dans les Consignes relatives aux noms des buckets et des objets, créez trois buckets nommés de manière unique que vous utiliserez tout au long de ce tutoriel :

  • Bucket 1 : remplacez [YOUR_QUARANTINE_BUCKET] par un nom unique.
  • Bucket 2 : remplacez [YOUR_SENSITIVE_DATA_BUCKET] par un nom unique.
  • Bucket 3 : remplacez [YOUR_NON_SENSITIVE_DATA_BUCKET] par un nom unique.

Console

  1. Dans la console GCP, ouvrez le navigateur Cloud Storage :

    Accéder au navigateur Cloud Storage

  2. Cliquez sur Créer un bucket.

  3. Dans la zone de texte Nom du Bucket, saisissez le nom que vous avez sélectionné pour [YOUR_QUARANTINE_BUCKET], puis cliquez sur Créer.

  4. Répétez cette procédure pour les buckets [YOUR_SENSITIVE_DATA_BUCKET] et [YOUR_NON_SENSITIVE_DATA_BUCKET].

gcloud

  1. Ouvrez Cloud Shell :

    Accéder à Cloud Shell

  2. Créez trois compartiments à l'aide des commandes suivantes :

    gsutil mb gs://[YOUR_QUARANTINE_BUCKET]
    gsutil mb gs://[YOUR_SENSITIVE_DATA_BUCKET]
    gsutil mb gs://[YOUR_NON_SENSITIVE_DATA_BUCKET]
    

Créer un sujet et un abonnement Cloud Pub/Sub

Console

  1. Ouvrez la page Sujets Cloud Pub/Sub :

    Accéder aux sujets Cloud Pub/Sub

  2. Cliquez sur Créer un sujet.

  3. Dans la zone de texte qui contient une entrée au format PROJECTS/[YOUR_PROJECT_NAME]/TOPICS/, ajoutez le nom du sujet, comme ceci :

    PROJECTS/[YOUR_PROJECT_NAME]/TOPICS/[PUB/SUB_TOPIC]
  4. Cliquez sur Créer.

  5. Sélectionnez le sujet que vous venez de créer, cliquez sur les trois points (…) qui suivent le nom du sujet, puis sélectionnez Nouvel abonnement.

  6. Dans la zone de texte qui contient une entrée au format PROJECTS/[YOUR_PROJECT_NAME]/TOPICS/[PUB/SUB_TOPIC], ajoutez le nom de l'abonnement, comme ceci :

    PROJECTS/[YOUR_PROJECT_NAME]/TOPICS/[PUB/SUB_TOPIC]/[PUB/SUB_SUBSCRIPTION]
  7. Cliquez sur Créer.

gcloud

  1. Ouvrez Cloud Shell :

    Accéder à Cloud Shell

  2. Créez un sujet en remplaçant [PUB/SUB_TOPIC] par le nom de votre choix :

    gcloud pubsub topics create [PUB/SUB_TOPIC]
  3. Créez un abonnement, en remplaçant [PUB/SUB_SUBSCRIPTION] par le nom de votre choix :

    gcloud pubsub subscriptions create [PUB/SUB_SUBSCRIPTION] --topic [PUB/SUB_TOPIC]

Créer les fonctions Cloud Functions

Cette section explique le déploiement du script Python contenant les deux fonctions Cloud Functions suivantes :

  • Une fonction appelée lorsqu'un objet est importé sur Cloud Storage.
  • Une fonction appelée lorsqu'un message est reçu dans la file d'attente Cloud Pub/Sub.

Créer la première fonction

Console

  1. Ouvrez la page Présentation de Cloud Functions :

    Accéder à la page "Présentation" de Cloud Functions

  2. Sélectionnez le projet pour lequel vous avez activé Cloud Functions.

  3. Cliquez sur Créer une fonction.

  4. Dans la zone Nom, remplacez le nom par défaut par create_DLP_job.

  5. Dans le champ Déclencheur, sélectionnez Cloud Storage.

  6. Dans le champ Bucket, cliquez sur Parcourir, sélectionnez le bucket de votre zone de quarantaine en le sélectionnant dans la liste déroulante, puis cliquez sur Sélectionner.

  7. Sous Environnement d'exécution, sélectionnez Python 3.7.

  8. Sous Code source, sélectionnez Éditeur intégré.

  9. Collez le code suivant dans la zone main.py en remplaçant le texte existant :

    """ Copyright 2018, Google, Inc.
    
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
    
      http://www.apache.org/licenses/LICENSE-2.0
    
    Unless  required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
    
    Authors: Yuhan Guo, Zhaoyuan Sun, Fengyi Huang, Weimu Song.
    Date:    October 2018
    
    """
    
    from google.cloud import dlp
    from google.cloud import storage
    from google.cloud import pubsub
    import os
    
    # ----------------------------
    #  User-configurable Constants
    
    PROJECT_ID = '[PROJECT_ID_HOSTING_STAGING_BUCKET]'
    """The bucket the to-be-scanned files are uploaded to."""
    STAGING_BUCKET = '[YOUR_QUARANTINE_BUCKET]'
    """The bucket to move "sensitive" files to."""
    SENSITIVE_BUCKET = '[YOUR_SENSITIVE_DATA_BUCKET]'
    """The bucket to move "non sensitive" files to."""
    NONSENSITIVE_BUCKET = '[YOUR_NON_SENSITIVE_DATA_BUCKET]'
    """ Pub/Sub topic to notify once the  DLP job completes."""
    PUB_SUB_TOPIC = '[PUB/SUB_TOPIC]'
    """The minimum_likelihood (Enum) required before returning a match"""
    """For more info visit: https://cloud.google.com/dlp/docs/likelihood"""
    MIN_LIKELIHOOD = 'POSSIBLE'
    """The maximum number of findings to report (0 = server maximum)"""
    MAX_FINDINGS = 0
    """The infoTypes of information to match"""
    """For more info visit: https://cloud.google.com/dlp/docs/concepts-infotypes"""
    INFO_TYPES = [
        'FIRST_NAME', 'PHONE_NUMBER', 'EMAIL_ADDRESS', 'US_SOCIAL_SECURITY_NUMBER'
    ]
    
    # End of User-configurable Constants
    # ----------------------------------
    
    # Initialize the Google Cloud client libraries
    dlp = dlp.DlpServiceClient()
    storage_client = storage.Client()
    publisher = pubsub.PublisherClient()
    subscriber = pubsub.SubscriberClient()
    
    def create_DLP_job(data, done):
      """This function is triggered by new files uploaded to the designated Cloud Storage quarantine/staging bucket.
    
           It creates a dlp job for the uploaded file.
        Arg:
           data: The Cloud Storage Event
        Returns:
            None. Debug information is printed to the log.
        """
      # Get the targeted file in the quarantine bucket
      file_name = data['name']
      print('Function triggered for file [{}]'.format(file_name))
    
      # Prepare info_types by converting the list of strings (INFO_TYPES) into a list of dictionaries
      info_types = [{'name': info_type} for info_type in INFO_TYPES]
    
      # Convert the project id into a full resource id.
      parent = dlp.project_path(PROJECT_ID)
    
      # Construct the configuration dictionary.
      inspect_job = {
          'inspect_config': {
              'info_types': info_types,
              'min_likelihood': MIN_LIKELIHOOD,
              'limits': {
                  'max_findings_per_request': MAX_FINDINGS
              },
          },
          'storage_config': {
              'cloud_storage_options': {
                  'file_set': {
                      'url':
                          'gs://{bucket_name}/{file_name}'.format(
                              bucket_name=STAGING_BUCKET, file_name=file_name)
                  }
              }
          },
          'actions': [{
              'pub_sub': {
                  'topic':
                      'projects/{project_id}/topics/{topic_id}'.format(
                          project_id=PROJECT_ID, topic_id=PUB_SUB_TOPIC)
              }
          }]
      }
    
      # Create the DLP job and let the DLP api processes it.
      try:
        dlp.create_dlp_job(parent, inspect_job)
        print('Job created by create_DLP_job')
      except Exception as e:
        print(e)
    
    def resolve_DLP(data, context):
      """This function listens to the pub/sub notification from function above.
    
        As soon as it gets pub/sub notification, it picks up results from the
        DLP job and moves the file to sensitive bucket or nonsensitive bucket
        accordingly.
        Args:
            data: The Cloud Pub/Sub event
    
        Returns:
            None. Debug information is printed to the log.
        """
      # Get the targeted DLP job name that is created by the create_DLP_job function
      job_name = data['attributes']['DlpJobName']
      print('Received pub/sub notification from DLP job: {}'.format(job_name))
    
      # Get the DLP job details by the job_name
      job = dlp.get_dlp_job(job_name)
      print('Job Name:{name}\nStatus:{status}'.format(
          name=job.name, status=job.state))
    
      # Fetching Filename in Cloud Storage from the original dlpJob config.
      # See defintion of "JSON Output' in Limiting Cloud Storage Scans':
      # https://cloud.google.com/dlp/docs/inspecting-storage
    
      file_path = (
          job.inspect_details.requested_options.job_config.storage_config
          .cloud_storage_options.file_set.url)
      file_name = os.path.basename(file_path)
    
      info_type_stats = job.inspect_details.result.info_type_stats
      source_bucket = storage_client.get_bucket(STAGING_BUCKET)
      source_blob = source_bucket.blob(file_name)
      if (len(info_type_stats) > 0):
        # Found at least one sensitive data
        for stat in info_type_stats:
          print('Found {stat_cnt} instances of {stat_type_name}.'.format(
              stat_cnt=stat.count, stat_type_name=stat.info_type.name))
        print('Moving item to sensitive bucket')
        destination_bucket = storage_client.get_bucket(SENSITIVE_BUCKET)
        source_bucket.copy_blob(source_blob, destination_bucket,
                                file_name)  # copy the item to the sensitive bucket
        source_blob.delete()  # delete item from the quarantine bucket
    
      else:
        # No sensitive data found
        print('Moving item to non-sensitive bucket')
        destination_bucket = storage_client.get_bucket(NONSENSITIVE_BUCKET)
        source_bucket.copy_blob(
            source_blob, destination_bucket,
            file_name)  # copy the item to the non-sensitive bucket
        source_blob.delete()  # delete item from the quarantine bucket
      print('{} Finished'.format(file_name))
    
  10. Modifiez les lignes suivantes dans le code que vous avez collé dans la zone main.py, en remplaçant les variables par l'ID de votre projet, les buckets correspondants, ainsi que les noms de sujet et d'abonnement Cloud Pub/Sub que vous avez créés précédemment.

    [YOUR_QUARANTINE_BUCKET]
    [YOUR_SENSITIVE_DATA_BUCKET]
    [YOUR_NON_SENSITIVE_DATA_BUCKET]
    [PROJECT_ID_HOSTING_STAGING_BUCKET]
    [PUB/SUB_TOPIC]
    
  11. Dans la zone de texte Fonction à exécuter, remplacez hello_gcs par create_DLP_job.

  12. Collez le code suivant dans la zone de texte requirements.txt, en remplaçant le texte existant :

    google-cloud-dlp
    google-cloud-pubsub
    google-cloud-storage
    
    
  13. Cliquez sur Enregistrer.

    Une coche verte à côté de la fonction indique un déploiement réussi.

    déploiement réussi

gcloud

  1. Ouvrez une session Cloud Shell et clonez le dépôt GitHub contenant le code et les exemples de fichiers de données :

    Ouvrir dans Cloud Shell

  2. Remplacez les répertoires par le dossier dans lequel le dépôt a été cloné :

    cd gcs-dlp-classification-python/
  3. Modifiez les lignes suivantes du code que vous avez collé dans la zone main.py, en remplaçant les variables de bucket par les buckets correspondants que vous avez créés précédemment. Remplacez également le sujet Cloud Pub/Sub et les variables d'abonnement par les noms que vous avez choisis.

    [YOUR_QUARANTINE_BUCKET]
    [YOUR_SENSITIVE_DATA_BUCKET]
    [YOUR_NON_SENSITIVE_DATA_BUCKET]
    [PROJECT_ID_HOSTING_STAGING_BUCKET]
    [PUB/SUB_TOPIC]
    
  4. Déployez la fonction en remplaçant [YOUR_QUARANTINE_BUCKET] par votre nom de bucket :

    gcloud functions deploy create_DLP_job --runtime python37 \
        --trigger-resource [YOUR_QUARANTINE_BUCKET] \
        --trigger-event google.storage.object.finalize
    
  5. Confirmez que la fonction a bien été déployée :

    gcloud functions describe create_DLP_job

    Un déploiement réussi est indiqué par un état "ready" présenté comme ci-dessous :

    status:  READY
    timeout:  60s
    

Une fois la fonction Cloud Functions déployée, passez à la section suivante pour créer la deuxième fonction Cloud Functions.

Créer la deuxième fonction

Console

  1. Ouvrez la page Présentation de Cloud Functions :

    Accéder à la page "Présentation" de Cloud Functions

  2. Sélectionnez le projet pour lequel vous avez activé Cloud Functions.

  3. Cliquez sur Créer une fonction.

  4. Dans la zone Nom, remplacez le nom par défaut par resolve_DLP.

  5. Dans le champ Déclencheur, sélectionnez Cloud Pub/Sub.

  6. Dans le champ Sujet, saisissez [PUB/SUB_TOPIC].

  7. Sous Code source, sélectionnez Éditeur intégré.

  8. Sous Environnement d'exécution, sélectionnez Python 3.7.

  9. Collez le code suivant dans la zone main.py en remplaçant le texte existant :

    """ Copyright 2018, Google, Inc.
    
    Licensed under the Apache License, Version 2.0 (the "License");
    you may not use this file except in compliance with the License.
    You may obtain a copy of the License at
    
      http://www.apache.org/licenses/LICENSE-2.0
    
    Unless  required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
    
    Authors: Yuhan Guo, Zhaoyuan Sun, Fengyi Huang, Weimu Song.
    Date:    October 2018
    
    """
    
    from google.cloud import dlp
    from google.cloud import storage
    from google.cloud import pubsub
    import os
    
    # ----------------------------
    #  User-configurable Constants
    
    PROJECT_ID = '[PROJECT_ID_HOSTING_STAGING_BUCKET]'
    """The bucket the to-be-scanned files are uploaded to."""
    STAGING_BUCKET = '[YOUR_QUARANTINE_BUCKET]'
    """The bucket to move "sensitive" files to."""
    SENSITIVE_BUCKET = '[YOUR_SENSITIVE_DATA_BUCKET]'
    """The bucket to move "non sensitive" files to."""
    NONSENSITIVE_BUCKET = '[YOUR_NON_SENSITIVE_DATA_BUCKET]'
    """ Pub/Sub topic to notify once the  DLP job completes."""
    PUB_SUB_TOPIC = '[PUB/SUB_TOPIC]'
    """The minimum_likelihood (Enum) required before returning a match"""
    """For more info visit: https://cloud.google.com/dlp/docs/likelihood"""
    MIN_LIKELIHOOD = 'POSSIBLE'
    """The maximum number of findings to report (0 = server maximum)"""
    MAX_FINDINGS = 0
    """The infoTypes of information to match"""
    """For more info visit: https://cloud.google.com/dlp/docs/concepts-infotypes"""
    INFO_TYPES = [
        'FIRST_NAME', 'PHONE_NUMBER', 'EMAIL_ADDRESS', 'US_SOCIAL_SECURITY_NUMBER'
    ]
    
    # End of User-configurable Constants
    # ----------------------------------
    
    # Initialize the Google Cloud client libraries
    dlp = dlp.DlpServiceClient()
    storage_client = storage.Client()
    publisher = pubsub.PublisherClient()
    subscriber = pubsub.SubscriberClient()
    
    def create_DLP_job(data, done):
      """This function is triggered by new files uploaded to the designated Cloud Storage quarantine/staging bucket.
    
           It creates a dlp job for the uploaded file.
        Arg:
           data: The Cloud Storage Event
        Returns:
            None. Debug information is printed to the log.
        """
      # Get the targeted file in the quarantine bucket
      file_name = data['name']
      print('Function triggered for file [{}]'.format(file_name))
    
      # Prepare info_types by converting the list of strings (INFO_TYPES) into a list of dictionaries
      info_types = [{'name': info_type} for info_type in INFO_TYPES]
    
      # Convert the project id into a full resource id.
      parent = dlp.project_path(PROJECT_ID)
    
      # Construct the configuration dictionary.
      inspect_job = {
          'inspect_config': {
              'info_types': info_types,
              'min_likelihood': MIN_LIKELIHOOD,
              'limits': {
                  'max_findings_per_request': MAX_FINDINGS
              },
          },
          'storage_config': {
              'cloud_storage_options': {
                  'file_set': {
                      'url':
                          'gs://{bucket_name}/{file_name}'.format(
                              bucket_name=STAGING_BUCKET, file_name=file_name)
                  }
              }
          },
          'actions': [{
              'pub_sub': {
                  'topic':
                      'projects/{project_id}/topics/{topic_id}'.format(
                          project_id=PROJECT_ID, topic_id=PUB_SUB_TOPIC)
              }
          }]
      }
    
      # Create the DLP job and let the DLP api processes it.
      try:
        dlp.create_dlp_job(parent, inspect_job)
        print('Job created by create_DLP_job')
      except Exception as e:
        print(e)
    
    def resolve_DLP(data, context):
      """This function listens to the pub/sub notification from function above.
    
        As soon as it gets pub/sub notification, it picks up results from the
        DLP job and moves the file to sensitive bucket or nonsensitive bucket
        accordingly.
        Args:
            data: The Cloud Pub/Sub event
    
        Returns:
            None. Debug information is printed to the log.
        """
      # Get the targeted DLP job name that is created by the create_DLP_job function
      job_name = data['attributes']['DlpJobName']
      print('Received pub/sub notification from DLP job: {}'.format(job_name))
    
      # Get the DLP job details by the job_name
      job = dlp.get_dlp_job(job_name)
      print('Job Name:{name}\nStatus:{status}'.format(
          name=job.name, status=job.state))
    
      # Fetching Filename in Cloud Storage from the original dlpJob config.
      # See defintion of "JSON Output' in Limiting Cloud Storage Scans':
      # https://cloud.google.com/dlp/docs/inspecting-storage
    
      file_path = (
          job.inspect_details.requested_options.job_config.storage_config
          .cloud_storage_options.file_set.url)
      file_name = os.path.basename(file_path)
    
      info_type_stats = job.inspect_details.result.info_type_stats
      source_bucket = storage_client.get_bucket(STAGING_BUCKET)
      source_blob = source_bucket.blob(file_name)
      if (len(info_type_stats) > 0):
        # Found at least one sensitive data
        for stat in info_type_stats:
          print('Found {stat_cnt} instances of {stat_type_name}.'.format(
              stat_cnt=stat.count, stat_type_name=stat.info_type.name))
        print('Moving item to sensitive bucket')
        destination_bucket = storage_client.get_bucket(SENSITIVE_BUCKET)
        source_bucket.copy_blob(source_blob, destination_bucket,
                                file_name)  # copy the item to the sensitive bucket
        source_blob.delete()  # delete item from the quarantine bucket
    
      else:
        # No sensitive data found
        print('Moving item to non-sensitive bucket')
        destination_bucket = storage_client.get_bucket(NONSENSITIVE_BUCKET)
        source_bucket.copy_blob(
            source_blob, destination_bucket,
            file_name)  # copy the item to the non-sensitive bucket
        source_blob.delete()  # delete item from the quarantine bucket
      print('{} Finished'.format(file_name))
    
  10. Modifiez les lignes suivantes dans le code que vous avez collé dans la zone main.py, en remplaçant les variables par l'ID de votre projet, les buckets correspondants, ainsi que les noms de sujet et d'abonnement Cloud Pub/Sub que vous avez créés précédemment.

    [YOUR_QUARANTINE_BUCKET]
    [YOUR_SENSITIVE_DATA_BUCKET]
    [YOUR_NON_SENSITIVE_DATA_BUCKET]
    [PROJECT_ID_HOSTING_STAGING_BUCKET]
    [PUB/SUB_TOPIC]
    
  11. Dans la zone de texte Fonction à exécuter, remplacez helloPubSub par resolve_DLP.

  12. Collez le code suivant dans la zone de texte requirements.txt, en remplaçant le texte existant :

    google-cloud-dlp
    google-cloud-pubsub
    google-cloud-storage
    
    
  13. Cliquez sur Enregistrer.

    Une coche verte à côté de la fonction indique un déploiement réussi.

    déploiement réussi

gcloud

  1. Ouvrez (ou rouvrez) une session Cloud Shell et clonez le dépôt GitHub contenant le code et les exemples de fichiers de données :

    Ouvrir dans Cloud Shell

  2. Remplacez les répertoires par le dossier contenant le code Python :

    cd gcs-dlp-classification-python
  3. Modifiez les lignes suivantes dans le code de la zone main.py, en remplaçant les variables de buckets suivantes par celles des buckets créés précédemment. Remplacez également le sujet Cloud Pub/Sub et les variables d'abonnement par les noms que vous avez choisis.

    [YOUR_QUARANTINE_BUCKET]
    [YOUR_SENSITIVE_DATA_BUCKET]
    [YOUR_NON_SENSITIVE_DATA_BUCKET]
    [PROJECT_ID_HOSTING_STAGING_BUCKET]
    [PUB/SUB_TOPIC]
    
  4. Déployez la fonction en remplaçant [PUB/SUB_TOPIC] par votre sujet Cloud Pub/Sub :

    gcloud functions deploy resolve_DLP --runtime python37 --trigger-topic [PUB/SUB_TOPIC]
  5. Confirmez que la fonction a bien été déployée :

    gcloud functions describe resolve_DLP

    Un déploiement réussi est indiqué par un état "ready" présenté comme ci-dessous :

    status:  READY
    timeout:  60s
    

Une fois la fonction Cloud Functions déployée, passez à la section suivante.

Importer des exemples de fichiers dans le bucket de zone de quarantaine

Le dépôt GitHub associé à cet article inclut des exemples de fichiers de données. Le dossier contient deux types de fichiers : les fichiers contenant des données non sensibles et ceux contenant des données sensibles. Les données sensibles sont classées comme contenant une ou plusieurs des valeurs INFO_TYPES suivantes :

US_SOCIAL_SECURITY_NUMBER
EMAIL_ADDRESS
PERSON_NAME
LOCATION
PHONE_NUMBER

Les types de données qui sont utilisés pour classer les exemples de fichiers sont définis dans les constantes INFO_TYPES du fichier main.py, qui est initialement défini sur [‘PHONE_NUMBER', ‘EMAIL_ADDRESS'].

  1. Si vous n'avez pas encore cloné le dépôt, ouvrez Cloud Shell et clonez le dépôt GitHub contenant le code et les exemples de fichiers de données :

    Ouvrir dans Cloud Shell

  2. Remplacez les dossiers par les exemples de fichiers de données :

    cd ~/dlp-cloud-functions-tutorials/sample_data/
  3. Copiez les exemples de fichiers de données dans le bucket de la zone de quarantaine à l'aide de la commande gsutil, en remplaçant [YOUR_QUARANTINE_BUCKET] par le nom de votre bucket de zone de quarantaine :

    gsutil -m  cp * gs://[YOUR_QUARANTINE_BUCKET]/

    Cloud DLP inspecte et classe chaque fichier importé dans le bucket de zone de quarantaine et le déplace dans le bucket cible approprié en fonction de sa classification.

  4. Dans la console Cloud Storage, ouvrez la page du navigateur de Cloud Storage :

    Accéder au navigateur Cloud Storage

  5. Sélectionnez l'un des buckets cibles que vous avez créés précédemment et consultez les fichiers importés. Consultez également les autres buckets que vous avez créés.

Nettoyer

Une fois que vous avez terminé ce tutoriel, vous pouvez procéder au nettoyage des ressources que vous avez créées sur GCP afin qu'elles ne soient plus comptabilisées dans votre quota et qu'elles ne vous soient plus facturées. Dans les sections suivantes, nous allons voir comment supprimer ou désactiver ces ressources.

Supprimer le projet

  1. Dans la console GCP, accédez à la page "Projets".

    Accéder à la page Projets

  2. Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Étapes suivantes

Cette page vous a-t-elle été utile ? Évaluez-la :

Envoyer des commentaires concernant…