Inspecter les données provenant de sources externes à l'aide de jobs hybrides

Cet article explique comment utiliser des tâches hybrides et des déclencheurs de tâches hybrides pour inspecter des données externes afin d'identifier des informations sensibles. Pour en savoir plus sur les tâches hybrides et les déclencheurs de tâches hybrides, y compris des exemples d'environnements hybrides, consultez la page Tâches hybrides et déclencheurs de tâches hybrides.

Présentation des tâches hybrides et des déclencheurs de tâches hybrides

Les tâches hybrides et les déclencheurs de tâches hybrides vous permettent d'élargir le champ d'application de la protection des données sensibles au-delà des requêtes d'inspection de contenu simples et de l'analyse du dépôt Google Cloud Storage. À l'aide de tâches hybrides et de déclencheurs de tâches hybrides, vous pouvez diffuser des données depuis pratiquement n'importe quelle source, y compris en dehors de Google Cloud, directement vers la protection des données sensibles, et laisser la protection des données sensibles inspecter les données à la recherche d'informations sensibles. La protection des données sensibles enregistre et agrège automatiquement les résultats pour une analyse plus approfondie.

Comparaison des tâches hybrides et des déclencheurs de tâches hybrides

Lorsque vous créez des tâches hybrides, elles s'exécutent jusqu'à ce que vous les arrêtiez. Ils acceptent toutes les données entrantes pour autant qu'elles soient correctement acheminées et formatées.

Les déclencheurs de tâches hybrides fonctionnent de manière semblable aux tâches hybrides, mais vous n'avez pas besoin d'arrêter explicitement une tâche dans un déclencheur de tâche hybride. La protection des données sensibles arrête automatiquement les tâches dans les déclencheurs de tâches hybrides à la fin de chaque journée.

En outre, avec un déclencheur de tâche hybride, vous pouvez arrêter et démarrer de nouvelles tâches dans le déclencheur sans avoir à reconfigurer vos requêtes hybridInspect. Par exemple, vous pouvez envoyer des données à un déclencheur de tâche hybride, puis arrêter la tâche active, modifier sa configuration, démarrer une nouvelle tâche au sein de ce déclencheur, puis continuer à envoyer des données au même déclencheur.

Pour savoir quelle option convient à votre cas d'utilisation, consultez la section Scénarios d'inspection hybride classiques sur cette page.

Définition des termes

Cette rubrique utilise les termes suivants:

  • Données externes: données stockées en dehors de Google Cloud ou données non compatibles avec la protection des données sensibles de manière native.

  • Tâche hybride: tâche d'inspection configurée pour analyser les données provenant de pratiquement n'importe quelle source.

  • Déclencheur de tâche hybride: déclencheur de tâche configuré pour analyser les données à partir de pratiquement n'importe quelle source.

  • Requête hybridInspect: requête contenant les données externes que vous souhaitez inspecter. Lorsque vous envoyez cette requête, vous spécifiez la tâche hybride ou le déclencheur de tâche hybride auquel elle est envoyée.

Pour obtenir des informations générales sur les tâches et les déclencheurs de tâche, consultez la page Tâches et déclencheurs de tâche.

Processus d'inspection hybride

Le processus d'inspection hybride comporte trois étapes.

  1. Sélectionnez les données que vous souhaitez envoyer à la protection des données sensibles.

    Les données peuvent provenir de Google Cloud ou d'une source extérieure à Google Cloud. Par exemple, vous pouvez configurer un script ou une application personnalisés pour envoyer des données au service de protection des données sensibles, ce qui vous permet d'inspecter les données en cours de transfert, depuis un autre service cloud, un dépôt de données sur site ou pratiquement toute autre source de données.

  2. Configurez une tâche hybride ou un déclencheur de tâche hybride dans la protection des données sensibles à partir de zéro ou à l'aide d'un modèle d'inspection.

    Une fois que vous avez configuré une tâche hybride ou un déclencheur de tâche hybride, la protection des données sensibles écoute activement les données qui lui sont envoyées. Lorsque votre script ou votre application personnalisés envoie des données à cette tâche hybride ou à ce déclencheur de tâche hybride, les données sont inspectées et leurs résultats sont stockés en fonction de la configuration.

    Lorsque vous configurez la tâche hybride ou le déclencheur de tâche hybride, vous pouvez spécifier l'emplacement où vous souhaitez enregistrer ou publier les résultats. Les options incluent l'enregistrement dans BigQuery et la publication des notifications dans Pub/Sub, Cloud Monitoring ou par e-mail.

  3. Envoyez une requête hybridInspect à la tâche hybride ou au déclencheur de tâche hybride.

    Une requête hybridInspect contient les données à analyser. Dans la requête, incluez des métadonnées (également appelées étiquettes et identifiants de table) qui décrivent le contenu et permettent à la protection des données sensibles d'identifier les informations que vous souhaitez suivre. Par exemple, si vous analysez des données associées dans plusieurs requêtes (telles que des lignes dans la même table de base de données), vous pouvez utiliser les mêmes métadonnées dans ces requêtes associées. Vous pouvez ensuite collecter, compter et analyser les résultats de cette table de base de données.

Lorsque la tâche hybride exécute et inspecte les requêtes, les résultats d'inspection sont disponibles lorsque la protection des données sensibles les génère. En revanche, les actions, telles que les notifications Pub/Sub, ne se produisent pas tant que votre application n'a pas terminé la tâche hybride.

Schéma illustrant le processus d'inspection de tâches hybride

Points à prendre en compte

Lorsque vous travaillez avec des tâches hybrides et des déclencheurs de tâches, tenez compte des points suivants:

  • Les tâches hybrides et les déclencheurs de tâches hybrides ne sont pas compatibles avec le filtrage et l'échantillonnage.
  • Les tâches et les déclencheurs de tâches ne sont pas soumis aux objectifs de niveau de service (SLO), mais vous pouvez prendre certaines mesures pour réduire la latence. Pour en savoir plus, consultez la section Latence des tâches.

Avant de commencer

Avant de configurer et d'utiliser des tâches hybrides ou des déclencheurs de tâches hybrides, assurez-vous d'avoir effectué les opérations suivantes:

Créer un projet, et activer la facturation et la protection des données sensibles

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the Sensitive Data Protection API.

    Enable the API

Configurer la source de données

Avant que la protection des données sensibles puisse inspecter vos données, vous devez les envoyer au service de protection des données sensibles. Quelle que soit la méthode utilisée pour configurer la tâche hybride ou le déclencheur de tâche hybride, vous devez configurer votre source externe pour qu'elle envoie des données à l'API DLP.

Pour en savoir plus sur le format requis pour les requêtes d'inspection hybride, consultez la section Mise en forme hybride des éléments de contenu. Pour en savoir plus sur les types de métadonnées que vous pouvez inclure avec les données de votre requête, consultez la section Types de métadonnées que vous pouvez fournir.

Créer un déclencheur de tâche hybride ou hybride

Pour permettre à la protection des données sensibles d'inspecter les données que vous lui envoyez, vous devez d'abord configurer une tâche hybride ou un déclencheur de tâche hybride. Pour en savoir plus sur la méthode à créer, consultez la section Scénarios d'inspection hybride classiques sur cette page.

Console

Dans la console Google Cloud, accédez à la page Créer une tâche ou un déclencheur de tâche:

Accéder à la page "Créer une tâche ou un déclencheur de tâche"

Les sections suivantes décrivent comment remplir les sections de la page Créer une tâche ou un déclencheur de tâche qui concernent les opérations d'inspection hybride.

Choisir les données d'entrée

Dans cette section, vous spécifiez les données d'entrée que la protection des données sensibles doit inspecter.

  1. Facultatif: Dans le champ Nom, attribuez un nom à la tâche en saisissant une valeur dans le champ ID de la tâche. Si vous laissez ce champ vide, la protection des données sensibles génère automatiquement un identifiant.
  2. Facultatif: Dans le menu Emplacement de la ressource, choisissez la région dans laquelle vous souhaitez stocker la tâche hybride ou le déclencheur de tâche hybride. Pour en savoir plus, consultez la section Spécifier des emplacements de traitement.

  3. Dans le champ Type de stockage, sélectionnez Hybride.

  4. Facultatif: Dans le champ Description, décrivez la tâche hybride ou le déclencheur de tâche hybride que vous créez. Par exemple, vous pouvez inclure des informations sur la source des données à inspecter.

  5. Facultatif: Sous Étiquettes obligatoires, cliquez sur Ajouter une étiquette, puis saisissez une étiquette que vous souhaitez exiger des requêtes hybridInspect. Une requête hybridInspect qui ne spécifie pas ce libellé n'est pas traitée par cette tâche hybride ou ce déclencheur de tâche hybride. Vous pouvez ajouter jusqu'à 10 étiquettes obligatoires. Pour en savoir plus, consultez la section Exiger des étiquettes pour les requêtes hybridInspect sur cette page.

  6. (Facultatif) Sous Libellés facultatifs, saisissez les paires clé/valeur que vous souhaitez associer aux résultats de toutes les requêtes hybridInspect envoyées à cette tâche ou à ce déclencheur de tâche. Vous pouvez ajouter jusqu'à 10 libellés facultatifs. Pour en savoir plus, consultez Libellés facultatifs.

  7. Facultatif: Sous Options de données tabulaires, saisissez le nom de champ de la colonne de clé primaire si vous prévoyez d'envoyer des données tabulaires dans vos requêtes hybridInspect. Pour en savoir plus, consultez la section Options de données tabulaires.

  8. Cliquez sur Continuer.

Configurer la détection

Dans cette section, vous spécifiez les types de données sensibles pour lesquelles la protection des données sensibles inspectera les données d'entrée. Vous disposez des options suivantes :

  • Modèle: si vous avez déjà créé un modèle dans le projet actuel et que vous souhaitez l'utiliser pour définir les paramètres de détection de la protection des données sensibles, cliquez sur le champ Nom du modèle, puis sélectionnez le modèle dans la liste qui s'affiche.
  • InfoTypes: la protection des données sensibles sélectionne les infoTypes intégrés les plus courants à détecter. Pour modifier les infoTypes ou choisir un infoType personnalisé à utiliser, cliquez sur Gérer les infoTypes. Vous pouvez également affiner les critères de détection dans les sections Ensembles de règles d'inspection et Seuil de confiance. Pour en savoir plus, consultez la section Configurer la détection.

Après avoir configuré les paramètres de détection, cliquez sur Continuer.

Ajouter des actions

Cette section vous permet de spécifier où enregistrer les résultats de chaque analyse d'inspection et si vous souhaitez être averti par e-mail ou par un message de notification Pub/Sub chaque fois qu'une analyse est terminée. Si vous n'enregistrez pas les résultats dans BigQuery, les résultats de l'analyse ne contiennent que des statistiques sur le nombre et les infoTypes des résultats.

  • Enregistrement dans BigQuery: chaque fois qu'une analyse est exécutée, la protection des données sensibles enregistre les résultats dans la table BigQuery que vous spécifiez ici. Si vous ne spécifiez pas d'ID de table, BigQuery attribue un nom par défaut à une nouvelle table lors de la première exécution de l'analyse. Si vous spécifiez une table existante, la protection des données sensibles y ajoute les résultats d'analyse.

  • Publier dans Pub/Sub : lorsque la tâche est terminée, un message Pub/Sub est envoyé.

  • Notifier par e-mail : lorsque la tâche est terminée, un e-mail est envoyé.

  • Publier sur Cloud Monitoring : lorsque la tâche est terminée, ses résultats sont publiés dans Monitoring.

Après avoir sélectionné des actions, cliquez sur Continuer.

Planification

Cette section vous permet de spécifier si vous devez créer une tâche unique qui s'exécute immédiatement ou un déclencheur de tâche qui s'exécute chaque fois que la protection des données sensibles reçoit des données correctement acheminées et mises en forme.

Effectuez l'une des opérations suivantes :

  • Pour exécuter immédiatement la tâche hybride, sélectionnez Aucun (exécuter la tâche ponctuelle immédiatement après sa création).

  • Pour configurer la tâche de sorte que les données reçues de la source la déclenchent, choisissez Créer un déclencheur pour exécuter la tâche selon une programmation régulière.

    Une tâche hybride déclenche des appels d'API agrégés, ce qui vous permet de voir les résultats et les tendances au fil du temps.

Pour en savoir plus, consultez la section Comparaison des tâches hybrides et des déclencheurs de tâches hybrides.

Récapitulatif

Vous pouvez ici consulter un résumé JSON de l'analyse. Veillez à noter le nom du déclencheur de tâche hybride ou hybride. Vous avez besoin de ces informations lorsque vous envoyez des données à la protection des données sensibles pour inspection.

Après avoir vérifié le résumé JSON, cliquez sur Créer.

La protection des données sensibles lance immédiatement la tâche hybride ou le déclencheur de tâche hybride. Une analyse d'inspection est lancée lorsque vous envoyez une requête hybridInspect à cette tâche hybride ou à ce déclencheur de tâche hybride.

API

Une tâche est représentée dans l'API DLP par la ressource DlpJobs. Pour créer une tâche hybride, vous devez appeler la méthode projects.locations.dlpJobs.create.

Un déclencheur de tâche est représenté dans l'API DLP par la ressource JobTrigger. Pour créer un déclencheur de tâche hybride, appelez la méthode projects.locations.jobTriggers.create.

L'objet DlpJobs ou JobTrigger que vous créez doit comporter les paramètres suivants:

  1. Dans le champ inspectJob, définissez un objet InspectJobConfig.
  2. Dans le champ storageConfig de l'objet InspectJobConfig, définissez un objet StorageConfig.
  3. Dans le champ hybridOptions de l'objet StorageConfig, définissez un objet HybridOptions. Cet objet contient des métadonnées sur les données que vous souhaitez inspecter.

  4. Dans le champ actions de l'objet InspectJobConfig, ajoutez toutes les actions (Action) que la protection des données sensibles doit effectuer à la fin de chaque tâche.

    Les actions publishSummaryToCscc et publishFindingsToCloudDataCatalog ne sont pas compatibles avec cette opération. Pour en savoir plus sur les actions, consultez la section Actions.

  5. Spécifiez les éléments à analyser et comment effectuer l'une des opérations suivantes, ou les deux:

    • Définissez le champ inspectTemplateName sur le nom complet de la ressource d'un modèle d'inspection que vous souhaitez utiliser, s'il est disponible.

    • Définissez le champ inspectConfig.

    Si vous définissez à la fois des champs inspectTemplateName et inspectConfig, leurs paramètres sont combinés.

À propos des exemples JSON

Les onglets suivants contiennent des exemples JSON que vous pouvez envoyer au service de protection des données sensibles pour créer une tâche hybride ou un déclencheur de tâche hybride. Ces exemples de déclencheurs de tâches hybrides et hybrides sont configurés pour effectuer les opérations suivantes:

  • Traitez toute requête hybridInspect si elle porte le libellé appointment-bookings-comments.
  • Analysez le contenu de la requête hybridInspect pour obtenir des adresses e-mail.
  • Associez le libellé "env": "prod" aux résultats.
  • Pour les données tabulaires, récupérez la valeur de la cellule dans la colonne booking_id (clé primaire) qui se trouve sur la même ligne que la cellule dans laquelle les données sensibles ont été trouvées. La protection des données sensibles associe cet identifiant au résultat afin que vous puissiez tracer ce résultat jusqu'à la ligne spécifique dont il provient.
  • Envoyer un e-mail lorsque la tâche s'arrête. L'e-mail est envoyé aux propriétaires de projets IAM et aux contacts essentiels techniques.
  • Envoie les résultats à Cloud Monitoring lorsque le job est arrêté.

Pour afficher les exemples JSON, consultez les onglets suivants.

Emploi hybride

Cet onglet contient un exemple JSON que vous pouvez utiliser pour créer une tâche hybride.

Pour créer une tâche hybride, envoyez une requête POST au point de terminaison ci-dessous.

Méthode et URL HTTP

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs

Remplacez les éléments suivants :

  • PROJECT_ID: ID du projet dans lequel vous souhaitez stocker la tâche hybride.
  • REGION: région géographique dans laquelle vous souhaitez stocker la tâche hybride.

Entrée JSON

{
  "jobId": "postgresql-table-comments",
  "inspectJob": {
    "actions": [
      {
        "jobNotificationEmails": {}
      },
      {
        "publishToStackdriver": {}
      }
    ],
    "inspectConfig": {
      "infoTypes": [
        {
          "name": "EMAIL_ADDRESS"
        }
      ],
      "minLikelihood": "POSSIBLE",
      "includeQuote": true
    },
    "storageConfig": {
      "hybridOptions": {
        "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
        "requiredFindingLabelKeys": [
          "appointment-bookings-comments"
        ],
        "labels": {
          "env": "prod"
        },
        "tableOptions": {
          "identifyingFields": [
            {
              "name": "booking_id"
            }
          ]
        }
      }
    }
  }
}

Sortie JSON

{
"name": "projects/PROJECT_ID/locations/REGION/dlpJobs/i-postgresql-table-comments",
"type": "INSPECT_JOB",
"state": "ACTIVE",
"inspectDetails": {
  "requestedOptions": {
    "snapshotInspectTemplate": {},
    "jobConfig": {
      "storageConfig": {
        "hybridOptions": {
          "description": "Hybrid job for data from the comments field of a table that contains customer appointment bookings",
          "requiredFindingLabelKeys": [
            "appointment-bookings-comments"
          ],
          "labels": {
            "env": "prod"
          },
          "tableOptions": {
            "identifyingFields": [
              {
                "name": "booking_id"
              }
            ]
          }
        }
      },
      "inspectConfig": {
        "infoTypes": [
          {
            "name": "EMAIL_ADDRESS"
          }
        ],
        "minLikelihood": "POSSIBLE",
        "limits": {},
        "includeQuote": true
      },
      "actions": [
        {
          "jobNotificationEmails": {}
        },
        {
          "publishToStackdriver": {}
        }
      ]
    }
  },
  "result": {
    "hybridStats": {}
  }
},
"createTime": "JOB_CREATION_DATETIME",
"startTime": "JOB_START_DATETIME"
}

La protection des données sensibles crée la tâche hybride et génère un ID de tâche. Dans cet exemple, l'ID de la tâche est i-postgresql-table-comments. Notez l'ID de la tâche. Vous en aurez besoin dans votre requête hybridInspect.

Pour arrêter une tâche hybride, vous devez appeler la méthode projects.locations.dlpJobs.finish explicitement. L'API DLP n'arrête pas automatiquement les tâches hybrides. En revanche, l'API DLP arrête automatiquement les tâches dans les déclencheurs de tâches hybrides à la fin de chaque journée.

Déclencheur de tâche hybride

Cet onglet contient un exemple JSON que vous pouvez utiliser pour créer un déclencheur de tâche hybride.

Pour créer un déclencheur de tâche hybride, envoyez une requête POST au point de terminaison suivant.

Méthode et URL HTTP

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers

Remplacez les éléments suivants :

  • PROJECT_ID: ID du projet dans lequel vous souhaitez stocker le déclencheur de tâche hybride.
  • REGION: région géographique dans laquelle vous souhaitez stocker le déclencheur de tâche hybride.

Entrée JSON

{
    "triggerId": "postgresql-table-comments",
    "jobTrigger": {
      "triggers": [
        {
          "manual": {}
        }
      ],
      "inspectJob": {
        "actions": [
          {
            "jobNotificationEmails": {}
          },
          {
            "publishToStackdriver": {}
          }
        ],
        "inspectConfig": {
          "infoTypes": [
              {
                "name": "EMAIL_ADDRESS"
              }
          ],
          "minLikelihood": "POSSIBLE",
          "limits": {},
          "includeQuote": true
        },
        "storageConfig": {
          "hybridOptions": {
            "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
            "requiredFindingLabelKeys": [
                "appointment-bookings-comments"
              ],
            "labels": {
              "env": "prod"
            },
            "tableOptions": {
              "identifyingFields": [
                {
                  "name": "booking_id"
                }
              ]
            }
          }
        }
      }
    }
  }

Sortie JSON

{
"name": "projects/PROJECT_ID/locations/REGION/jobTriggers/postgresql-table-comments",
"inspectJob": {
  "storageConfig": {
    "hybridOptions": {
      "description": "Hybrid job trigger for data from the comments field of a table that contains customer appointment bookings",
      "requiredFindingLabelKeys": [
        "appointment-bookings-comments"
      ],
      "labels": {
        "env": "prod"
      },
      "tableOptions": {
        "identifyingFields": [
          {
            "name": "booking_id"
          }
        ]
      }
    }
  },
  "inspectConfig": {
    "infoTypes": [
      {
        "name": "EMAIL_ADDRESS"
      }
    ],
    "minLikelihood": "POSSIBLE",
    "limits": {},
    "includeQuote": true
  },
  "actions": [
    {
      "jobNotificationEmails": {}
    },
    {
      "publishToStackdriver": {}
    }
  ]
},
"triggers": [
  {
    "manual": {}
  }
],
"createTime": ""JOB_CREATION_DATETIME",
"updateTime": "TRIGGER_UPDATE_DATETIME",
"status": "HEALTHY"
}

La protection des données sensibles crée le déclencheur de tâche hybride. La sortie contient le nom du déclencheur de tâche hybride. Dans cet exemple, il s'agit de postgresql-table-comments. Notez le nom. Vous en aurez besoin dans votre requête hybridInspect.

Contrairement aux tâches hybrides, l'API DLP arrête automatiquement les tâches dans les déclencheurs de tâches hybrides à la fin de chaque journée. Ainsi, vous n'avez pas besoin d'appeler explicitement la méthode projects.locations.dlpJobs.finish.

Lorsque vous créez une tâche hybride ou un déclencheur de tâche hybride, vous pouvez utiliser APIs Explorer sur les pages de référence de l'API suivantes, respectivement:

Dans le champ Paramètres de requête, saisissez projects/PROJECT_ID/locations/REGION. Ensuite, dans le champ Request body (Corps de la requête), collez l'exemple JSON correspondant à l'objet que vous essayez de créer.

Une requête réussie, même créée dans APIs Explorer, crée une tâche hybride ou un déclencheur de tâche hybride.

Des informations générales sur l'utilisation du format JSON pour envoyer des requêtes à l'API DLP sont disponibles dans le guide de démarrage JSON.

Envoyer des données à la tâche hybride ou au déclencheur de tâche hybride

Pour inspecter des données, vous devez envoyer une requête hybridInspect, au format correct, à un déclencheur de tâche hybride ou à un déclencheur de tâche hybride.

Mise en forme hybride des éléments de contenu

Voici un exemple simple de requête hybridInspect envoyée à la protection des données sensibles pour traitement par une tâche hybride ou un déclencheur de tâche hybride. Notez la structure de l'objet JSON, y compris le champ hybridItem, qui contient les champs suivants:

  • item: contient le contenu réel à inspecter.
  • findingDetails: contient les métadonnées à associer au contenu.
{
  "hybridItem": {
    "item": {
      "value": "My email is test@example.org"
    },
    "findingDetails": {
      "containerDetails": {
        "fullPath": "10.0.0.2:logs1:app1",
        "relativePath": "app1",
        "rootPath": "10.0.0.2:logs1",
        "type": "logging_sys",
        "version": "1.2"
      },
      "labels": {
        "env": "prod",
        "appointment-bookings-comments": ""
      }
    }
  }
}

Pour obtenir des informations complètes sur le contenu des éléments d'inspection hybrides, consultez le contenu de référence de l'API pour l'objet HybridContentItem.

Points de terminaison d'inspection hybride

Pour que les données soient inspectées à l'aide d'une tâche hybride ou d'un déclencheur de tâche hybride, vous devez envoyer une requête hybridInspect au point de terminaison approprié.

Méthode HTTP et URL pour les tâches hybrides

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/dlpJobs/JOB_ID:hybridInspect

Pour plus d'informations sur ce point de terminaison, consultez la page de référence de l'API pour la méthode projects.locations.dlpJobs.hybridInspect.

Méthode HTTP et URL pour les déclencheurs de tâches hybrides

https://dlp.googleapis.com/v2/projects/PROJECT_ID/locations/REGION/jobTriggers/TRIGGER_NAME:hybridInspect

Pour plus d'informations sur ce point de terminaison, consultez la page de référence de l'API pour la méthode projects.locations.jobTriggers.hybridInspect.

Remplacez les éléments suivants :

  • PROJECT_ID: identifiant de votre projet.
  • REGION: région géographique dans laquelle vous souhaitez stocker la requête hybridInspect. Cette région doit être identique à celle du job hybride.

  • JOB_ID: ID que vous avez attribué à la tâche hybride, précédé de i-.

    Pour rechercher l'ID de tâche, dans Protection des données sensibles, cliquez sur Inspection> Tâches d'inspection.

  • TRIGGER_NAME: nom que vous avez donné au déclencheur de tâche hybride.

    Pour rechercher le nom du déclencheur de tâche, dans Protection des données sensibles, cliquez sur Inspection > Déclencheurs de tâche.

Exiger des étiquettes pour hybridInspect requêtes

Si vous souhaitez contrôler les requêtes hybridInspect pouvant être traitées par une tâche hybride ou un déclencheur de tâche hybride, vous pouvez définir les libellés requis. Toutes les requêtes hybridInspect pour cette tâche hybride ou ce déclencheur de tâche hybride qui n'incluent pas ces libellés obligatoires sont refusées.

Pour définir une étiquette obligatoire, procédez comme suit:

  1. Lors de la création de la tâche hybride ou du déclencheur de tâche hybride, définissez le champ requiredFindingLabelKeys sur la liste des étiquettes requises.

    L'exemple suivant définit appointment-bookings-comments comme libellé requis dans une tâche hybride ou un déclencheur de tâche hybride.

    "hybridOptions": {
  ...
  "requiredFindingLabelKeys": [
    "appointment-bookings-comments"
  ],
  "labels": {
    "env": "prod"
  },
  ...
}

  2. Dans le champ labels de la requête hybridInspect, ajoutez chaque libellé requis en tant que clé dans une paire clé/valeur. La valeur correspondante peut être une chaîne vide.

    L'exemple suivant définit le libellé requis, appointment-bookings-comments, dans une requête hybridInspect.

    {
  "hybridItem": {
    "item": {
      "value": "My email is test@example.org"
    },
    "findingDetails": {
      "containerDetails": {...},
      "labels": {
        "appointment-bookings-comments": ""
      }
    }
  }
}

Si vous n'incluez pas l'étiquette requise dans la requête hybridInspect, une erreur semblable à celle-ci s'affiche:

{
  "error": {
    "code": 400,
    "message": "Trigger required labels that were not included: [appointment-bookings-comments]",
    "status": "INVALID_ARGUMENT"
  }
}

Exemple de code: Créer un déclencheur de tâche hybride et lui envoyer des données

C#

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les 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 Google.Api.Gax.ResourceNames;
using Google.Api.Gax;
using Google.Cloud.Dlp.V2;
using Grpc.Core;

public class SendDataToTheHybridJobTrigger
{
    public static DlpJob SendToHybridJobTrigger(
       string projectId,
       string jobTriggerId,
       string text = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the hybrid finding details which will be used as metadata with the content.
        // Refer to this for more information: https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#google.privacy.dlp.v2.Container
        var findingDetails = new HybridFindingDetails
        {
            ContainerDetails = new Container
            {
                FullPath = "10.0.0.2:logs1:aap1",
                RelativePath = "app1",
                RootPath = "10.0.0.2:logs1",
                Type = "System Logs"
            }
        };

        // Construct the hybrid content item using the finding details and text to be inspected.
        var hybridContentItem = new HybridContentItem
        {
            Item = new ContentItem { Value = text ?? "My email is ariel@example.org and name is Ariel." },
            FindingDetails = findingDetails
        };

        var jobTriggerName = new JobTriggerName(projectId, jobTriggerId);

        // Construct the request to activate the Job Trigger.
        var activate = new ActivateJobTriggerRequest
        {
            JobTriggerName = jobTriggerName
        };

        DlpJob triggerJob = null;

        try
        {
            // Call the API to activate the trigger.
            triggerJob = dlp.ActivateJobTrigger(activate);
        }
        catch (RpcException)
        {
            ListDlpJobsRequest listJobsRequest = new ListDlpJobsRequest
            {
                ParentAsLocationName = new LocationName(projectId, "global"),
                Filter = $"trigger_name={jobTriggerName}"
            };

            PagedEnumerable<ListDlpJobsResponse, DlpJob> res = dlp.ListDlpJobs(listJobsRequest);
            foreach (DlpJob j in res)
            {
                triggerJob = j;
            }
        }

        // Construct the request using hybrid content item.
        var request = new HybridInspectJobTriggerRequest
        {
            HybridItem = hybridContentItem,
            JobTriggerName = jobTriggerName
        };

        // Call the API.
        HybridInspectResponse _ = dlp.HybridInspectJobTrigger(request);

        Console.WriteLine($"Hybrid job created successfully. Job name: {triggerJob.Name}");

        return triggerJob;
    }
}

Go

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les 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"
	"log"
	"time"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectDataToHybridJobTrigger uses the Data Loss Prevention API to inspect sensitive
// information using Hybrid jobs trigger that scans payloads of data sent from
// virtually any source and stores findings in Google Cloud.
func inspectDataToHybridJobTrigger(w io.Writer, projectID, textToDeIdentify, jobTriggerName string) error {
	// projectId := "your-project-id"
	// jobTriggerName := "your-job-trigger-name"
	// textToDeIdentify := "My email is test@example.org"

	ctx := context.Background()

	// Initialize a client once and reuse it to send multiple requests. Clients
	// are safe to use across goroutines. When the client is no longer needed,
	// call the Close method to cleanup its resources.
	client, err := dlp.NewClient(ctx)
	if err != nil {
		return err
	}

	// Closing the client safely cleans up background resources.
	defer client.Close()

	// Specify the content to be inspected.
	contentItem := &dlppb.ContentItem{
		DataItem: &dlppb.ContentItem_Value{
			Value: textToDeIdentify,
		},
	}

	// Contains metadata to associate with the content.
	// Refer to https://cloud.google.com/dlp/docs/reference/rpc/google.privacy.dlp.v2#container for specifying the paths in container object.
	container := &dlppb.Container{
		Type:         "logging_sys",
		FullPath:     "10.0.0.2:logs1:app1",
		RelativePath: "app1",
		RootPath:     "10.0.0.2:logs1",
		Version:      "1.2",
	}

	// Set the required label.
	labels := map[string]string{
		"env":                           "prod",
		"appointment-bookings-comments": "",
	}

	hybridFindingDetails := &dlppb.HybridFindingDetails{
		ContainerDetails: container,
		Labels:           labels,
	}

	hybridContentItem := &dlppb.HybridContentItem{
		Item:           contentItem,
		FindingDetails: hybridFindingDetails,
	}

	// Activate the job trigger.
	activateJobreq := &dlppb.ActivateJobTriggerRequest{
		Name: jobTriggerName,
	}

	dlpJob, err := client.ActivateJobTrigger(ctx, activateJobreq)
	if err != nil {
		log.Printf("Error from return part %v", err)
		return err
	}
	// Build the hybrid inspect request.
	req := &dlppb.HybridInspectJobTriggerRequest{
		Name:       jobTriggerName,
		HybridItem: hybridContentItem,
	}

	// Send the hybrid inspect request.
	_, err = client.HybridInspectJobTrigger(ctx, req)
	if err != nil {
		return err
	}

	getDlpJobReq := &dlppb.GetDlpJobRequest{
		Name: dlpJob.Name,
	}

	var result *dlppb.DlpJob
	for i := 0; i < 5; i++ {
		// Get DLP job
		result, err = client.GetDlpJob(ctx, getDlpJobReq)
		if err != nil {
			fmt.Printf("Error getting DLP job: %v\n", err)
			return err
		}

		// Check if processed bytes is greater than 0
		if result.GetInspectDetails().GetResult().GetProcessedBytes() > 0 {
			break
		}

		// Wait for 5 seconds before checking again
		time.Sleep(5 * time.Second)
		i++
	}

	fmt.Fprintf(w, "Job Name: %v\n", result.Name)
	fmt.Fprintf(w, "Job State: %v\n", result.State)

	inspectionResult := result.GetInspectDetails().GetResult()
	fmt.Fprint(w, "Findings: \n")
	for _, v := range inspectionResult.GetInfoTypeStats() {
		fmt.Fprintf(w, "Infotype: %v\n", v.InfoType.Name)
		fmt.Fprintf(w, "Likelihood: %v\n", v.GetCount())
	}

	fmt.Fprint(w, "successfully inspected data using hybrid job trigger ")
	return nil
}

Java

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les 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.api.gax.rpc.InvalidArgumentException;
import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ActivateJobTriggerRequest;
import com.google.privacy.dlp.v2.Container;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.GetDlpJobRequest;
import com.google.privacy.dlp.v2.HybridContentItem;
import com.google.privacy.dlp.v2.HybridFindingDetails;
import com.google.privacy.dlp.v2.HybridInspectJobTriggerRequest;
import com.google.privacy.dlp.v2.InfoTypeStats;
import com.google.privacy.dlp.v2.InspectDataSourceDetails;
import com.google.privacy.dlp.v2.JobTriggerName;
import com.google.privacy.dlp.v2.ListDlpJobsRequest;

public class InspectDataToHybridJobTrigger {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    // The Google Cloud project id to use as a parent resource.
    String projectId = "your-project-id";
    // The job trigger id used to for processing a hybrid job trigger.
    String jobTriggerId = "your-job-trigger-id";
    // The string to de-identify.
    String textToDeIdentify = "My email is test@example.org and my name is Gary.";
    inspectDataToHybridJobTrigger(textToDeIdentify, projectId, jobTriggerId);
  }

  // Inspects data using a hybrid job trigger.
  // Hybrid jobs trigger allows to scan payloads of data sent from virtually any source for
  // sensitive information and then store the findings in Google Cloud.
  public static void inspectDataToHybridJobTrigger(
      String textToDeIdentify, String projectId, String jobTriggerId) throws Exception {
    // 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 dlpClient = DlpServiceClient.create()) {
      // Specify the content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToDeIdentify).build();

      // Contains metadata to associate with the content.
      // Refer to https://cloud.google.com/dlp/docs/reference/rest/v2/Container for specifying the
      // paths in container object.
      Container container =
          Container.newBuilder()
              .setFullPath("10.0.0.2:logs1:app1")
              .setRelativePath("app1")
              .setRootPath("10.0.0.2:logs1")
              .setType("logging_sys")
              .setVersion("1.2")
              .build();

      HybridFindingDetails hybridFindingDetails =
          HybridFindingDetails.newBuilder().setContainerDetails(container).build();

      HybridContentItem hybridContentItem =
          HybridContentItem.newBuilder()
              .setItem(contentItem)
              .setFindingDetails(hybridFindingDetails)
              .build();

      // Activate the job trigger.
      ActivateJobTriggerRequest activateJobTriggerRequest =
          ActivateJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .build();

      DlpJob dlpJob;

      try {
        dlpJob = dlpClient.activateJobTrigger(activateJobTriggerRequest);
      } catch (InvalidArgumentException e) {
        ListDlpJobsRequest request =
            ListDlpJobsRequest.newBuilder()
                .setParent(JobTriggerName.of(projectId, jobTriggerId).toString())
                .setFilter("trigger_name=" + JobTriggerName.of(projectId, jobTriggerId).toString())
                .build();

        // Retrieve the DLP jobs triggered by the job trigger
        DlpServiceClient.ListDlpJobsPagedResponse response = dlpClient.listDlpJobs(request);
        dlpJob = response.getPage().getResponse().getJobs(0);
      }

      // Build the hybrid inspect request.
      HybridInspectJobTriggerRequest request =
          HybridInspectJobTriggerRequest.newBuilder()
              .setName(JobTriggerName.of(projectId, jobTriggerId).toString())
              .setHybridItem(hybridContentItem)
              .build();

      // Send the hybrid inspect request.
      dlpClient.hybridInspectJobTrigger(request);

      // Build a request to get the completed job
      GetDlpJobRequest getDlpJobRequest =
          GetDlpJobRequest.newBuilder().setName(dlpJob.getName()).build();

      DlpJob result = null;

      do {
        result = dlpClient.getDlpJob(getDlpJobRequest);
        Thread.sleep(5000);
      } while (result.getInspectDetails().getResult().getProcessedBytes() <= 0);

      System.out.println("Job status: " + result.getState());
      System.out.println("Job name: " + result.getName());
      // Parse the response and process results.
      InspectDataSourceDetails.Result inspectionResult = result.getInspectDetails().getResult();
      System.out.println("Findings: ");
      for (InfoTypeStats infoTypeStat : inspectionResult.getInfoTypeStatsList()) {
        System.out.println("\tInfoType: " + infoTypeStat.getInfoType().getName());
        System.out.println("\tCount: " + infoTypeStat.getCount() + "\n");
      }
    }
  }
}

Node.js

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');

// Instantiates a client
const dlpClient = new DLP.DlpServiceClient();

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The string to de-identify
// const string = 'My email is test@example.org';

// Job Trigger ID
// const jobTriggerId = 'your-job-trigger-id';

async function inspectDataToHybridJobTrigger() {
  // Contains metadata to associate with the content.
  const container = {
    full_path: '10.0.0.2:logs1:app1',
    relative_path: 'app1',
    root_path: '10.0.0.2:logs1',
    type: 'logging_sys',
    version: '1.2',
  };

  const labels = {env: 'prod', 'appointment-bookings-comments': ''};

  // Build the hybrid content item.
  const hybridContentItem = {
    item: {value: string},
    findingDetails: {
      containerDetails: container,
      labels,
    },
  };
  let jobName;
  const fullTriggerName = `projects/${projectId}/jobTriggers/${jobTriggerId}`;
  // Activate the job trigger.
  try {
    const response = await dlpClient.activateJobTrigger({
      name: fullTriggerName,
    });
    jobName = response[0].name;
  } catch (err) {
    console.log(err);
    if (err.code === 3) {
      const response = await dlpClient.listDlpJobs({
        parent: fullTriggerName,
        filter: `trigger_name=${fullTriggerName}`,
      });
      jobName = response[0][0].name;
    }
    // Ignore error related to job trigger already active
    if (err.code !== 3) {
      console.log(err.message);
      return;
    }
  }
  // Build the hybrid inspect request.
  const request = {
    name: `projects/${projectId}/jobTriggers/${jobTriggerId}`,
    hybridItem: hybridContentItem,
  };
  // Send the hybrid inspect request.
  await dlpClient.hybridInspectJobTrigger(request);
  // Waiting for a maximum of 15 minutes for the job to get complete.
  let job;
  let numOfAttempts = 30;
  while (numOfAttempts > 0) {
    // Fetch DLP Job status
    [job] = await dlpClient.getDlpJob({name: jobName});

    if (job.state === 'FAILED') {
      console.log('Job Failed, Please check the configuration.');
      return;
    }
    // Check if the job has completed.
    if (job.inspectDetails.result.processedBytes > 0) {
      break;
    }
    // Sleep for a short duration before checking the job status again.
    await new Promise(resolve => {
      setTimeout(() => resolve(), 30000);
    });
    numOfAttempts -= 1;
  }
  // Finish the job once the inspection is complete.
  await dlpClient.finishDlpJob({name: jobName});

  // Print out the results.
  const infoTypeStats = job.inspectDetails.result.infoTypeStats;
  if (infoTypeStats.length > 0) {
    infoTypeStats.forEach(infoTypeStat => {
      console.log(
        `  Found ${infoTypeStat.count} instance(s) of infoType ${infoTypeStat.infoType.name}.`
      );
    });
  } else {
    console.log('No findings.');
  }
}
await inspectDataToHybridJobTrigger();

PHP

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 


use Google\ApiCore\ApiException;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;

/**
 * Inspect data hybrid job trigger.
 * Send data to the hybrid job or hybrid job trigger.
 *
 * @param string $callingProjectId  The Google Cloud project id to use as a parent resource.
 * @param string $string            The string to inspect (will be treated as text).
 */

function inspect_send_data_to_hybrid_job_trigger(
    // TODO(developer): Replace sample parameters before running the code.
    string $callingProjectId,
    string $jobTriggerId,
    string $string
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $content = (new ContentItem())
        ->setValue($string);

    $container = (new Container())
        ->setFullPath('10.0.0.2:logs1:app1')
        ->setRelativePath('app1')
        ->setRootPath('10.0.0.2:logs1')
        ->setType('logging_sys')
        ->setVersion('1.2');

    $findingDetails = (new HybridFindingDetails())
        ->setContainerDetails($container)
        ->setLabels([
            'env' => 'prod',
            'appointment-bookings-comments' => ''
        ]);

    $hybridItem = (new HybridContentItem())
        ->setItem($content)
        ->setFindingDetails($findingDetails);

    $parent = "projects/$callingProjectId/locations/global";
    $name = "projects/$callingProjectId/locations/global/jobTriggers/" . $jobTriggerId;

    $triggerJob = null;
    try {
        $triggerJob = $dlp->activateJobTrigger($name);
    } catch (ApiException $e) {
        $result = $dlp->listDlpJobs($parent, ['filter' => 'trigger_name=' . $name]);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }

    $dlp->hybridInspectJobTrigger($name, [
        'hybridItem' => $hybridItem,
    ]);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $job = $dlp->getDlpJob($triggerJob->getName());
        if ($job->getState() != JobState::RUNNING) {
            break;
        }
        $numOfAttempts--;
    } while ($numOfAttempts > 0);

    // Print finding counts.
    printf('Job %s status: %s' . PHP_EOL, $job->getName(), JobState::name($job->getState()));
    switch ($job->getState()) {
        case JobState::DONE:
            $infoTypeStats = $job->getInspectDetails()->getResult()->getInfoTypeStats();
            if (count($infoTypeStats) === 0) {
                printf('No findings.' . PHP_EOL);
            } else {
                foreach ($infoTypeStats as $infoTypeStat) {
                    printf(
                        '  Found %s instance(s) of infoType %s' . PHP_EOL,
                        $infoTypeStat->getCount(),
                        $infoTypeStat->getInfoType()->getName()
                    );
                }
            }
            break;
        case JobState::FAILED:
            printf('Job %s had errors:' . PHP_EOL, $job->getName());
            $errors = $job->getErrors();
            foreach ($errors as $error) {
                var_dump($error->getDetails());
            }
            break;
        case JobState::PENDING:
            printf('Job has not completed. Consider a longer timeout or an asynchronous execution model' . PHP_EOL);
            break;
        default:
            printf('Unexpected job state. Most likely, the job is either running or has not yet started.');
    }
}

Python

Pour savoir comment installer et utiliser la bibliothèque cliente pour la protection des données sensibles, consultez Bibliothèques clientes pour la protection des données sensibles.

Pour vous authentifier auprès de la protection des données sensibles, configurez les Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local. 

import time

import google.cloud.dlp

def inspect_data_to_hybrid_job_trigger(
    project: str,
    trigger_id: str,
    content_string: str,
) -> None:
    """
    Uses the Data Loss Prevention API to inspect sensitive information
    using Hybrid jobs trigger that scans payloads of data sent from
    virtually any source and stores findings in Google Cloud.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        trigger_id: The job trigger identifier for hybrid job trigger.
        content_string: The string to inspect.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Construct the `item` to inspect.
    item = {"value": content_string}

    # Construct the container details that contains metadata to be
    # associated with the content. For more details, please refer to
    # https://cloud.google.com/dlp/docs/reference/rest/v2/Container
    container_details = {
        "full_path": "10.0.0.2:logs1:app1",
        "relative_path": "app1",
        "root_path": "10.0.0.2:logs1",
        "type_": "logging_sys",
        "version": "1.2",
    }

    # Construct hybrid inspection configuration.
    hybrid_config = {
        "item": item,
        "finding_details": {
            "container_details": container_details,
            "labels": {
                "env": "prod",
                "appointment-bookings-comments": "",
            },
        },
    }

    # Convert the trigger id into a full resource id.
    trigger_id = f"projects/{project}/jobTriggers/{trigger_id}"

    # Activate the job trigger.
    dlp_job = dlp.activate_job_trigger(request={"name": trigger_id})

    # Call the API.
    dlp.hybrid_inspect_job_trigger(
        request={
            "name": trigger_id,
            "hybrid_item": hybrid_config,
        }
    )

    # Get inspection job details.
    job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Wait for dlp job to get finished.
    while job.inspect_details.result.processed_bytes <= 0:
        time.sleep(5)
        job = dlp.get_dlp_job(request={"name": dlp_job.name})

    # Print the results.
    print(f"Job name: {dlp_job.name}")
    if job.inspect_details.result.info_type_stats:
        for finding in job.inspect_details.result.info_type_stats:
            print(f"Info type: {finding.info_type.name}; Count: {finding.count}")
    else:
        print("No findings.")

Scénarios d'inspection hybride typiques

Les sections suivantes décrivent des utilisations courantes de l'inspection hybride et les workflows correspondants.

Effectuer une analyse ponctuelle

Exécutez une analyse ponctuelle d'une base de données en dehors de Google Cloud dans le cadre d'une vérification trimestrielle des bases de données.

  1. Créez une tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.

  2. Envoyez des données à la tâche en appelant projects.locations.dlpJobs.hybridInspect. Si vous souhaitez inspecter davantage de données, répétez cette étape autant de fois que nécessaire.

  3. Après avoir envoyé les données pour inspection, appelez la méthode projects.locations.dlpJobs.finish.

    La protection des données sensibles effectue les actions spécifiées dans votre requête projects.locations.dlpJobs.create.

Configurer une surveillance continue

Surveiller tout nouveau contenu ajouté quotidiennement à une base de données non compatible avec la protection des données sensibles de manière native

  1. Créez un déclencheur de tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.

  2. Activez le déclencheur de tâche en appelant la méthode projects.locations.jobTriggers.activate.

  3. Envoyez des données au déclencheur de tâche en appelant projects.locations.jobTriggers.hybridInspect. Si vous souhaitez inspecter davantage de données, répétez cette étape autant de fois que nécessaire.

Dans ce cas, vous n'avez pas besoin d'appeler la méthode projects.locations.dlpJobs.finish. La protection des données sensibles partitionne automatiquement les données que vous envoyez. Tant que le déclencheur de tâche est actif, à la fin de chaque journée, la protection des données sensibles effectue les actions que vous avez spécifiées lors de la création de votre déclencheur de tâche hybride.

Analyser les données entrant dans une base de données

analyser les données arrivant dans une base de données, tout en contrôlant la manière dont elles sont partitionnées ; Chaque tâche d'un déclencheur de tâche est une partition unique.

  1. Créez un déclencheur de tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.

  2. Activez le déclencheur de tâche en appelant la méthode projects.locations.jobTriggers.activate.

    Le système renvoie l'ID d'une seule tâche. Vous en aurez besoin à l'étape suivante.

  3. Envoyez des données à la tâche en appelant projects.locations.dlpJobs.hybridInspect.

    Dans ce cas, vous envoyez les données à la tâche au lieu du déclencheur de tâche. Cette approche vous permet de contrôler la manière dont les données que vous envoyez pour inspection sont partitionnées. Si vous souhaitez ajouter d'autres données à inspecter dans la partition actuelle, répétez cette étape.

  4. Après avoir envoyé les données à la tâche, appelez la méthode projects.locations.dlpJobs.finish.

    La protection des données sensibles effectue les actions spécifiées dans votre requête projects.locations.jobTriggers.create.

  5. Si vous souhaitez créer une autre tâche pour la partition suivante, activez à nouveau le déclencheur de tâche, puis envoyez les données à la tâche obtenue.

Surveiller le trafic provenant d'un proxy

Surveiller le trafic provenant d'un proxy installé entre deux applications personnalisées

  1. Créez un déclencheur de tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.

  2. Activez le déclencheur de tâche en appelant la méthode projects.locations.jobTriggers.activate.

  3. Envoyez des données au déclencheur de tâche en appelant projects.locations.jobTriggers.hybridInspect. Si vous souhaitez inspecter davantage de données, répétez cette étape autant de fois que nécessaire.

    Vous pouvez appeler cette requête indéfiniment pour tout le trafic réseau. Veillez à inclure des métadonnées dans chaque requête.

Dans ce cas, vous n'avez pas besoin d'appeler la méthode projects.locations.dlpJobs.finish. La protection des données sensibles partitionne automatiquement les données que vous envoyez. Tant que le déclencheur de tâche est actif, à la fin de chaque journée, la protection des données sensibles effectue les actions que vous avez spécifiées lors de la création de votre déclencheur de tâche hybride.

Étapes suivantes