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

Cette page a été traduite par l'API Cloud Translation.

Inspecter les données provenant de sources externes à l'aide de tâches hybrides

Cette rubrique explique comment utiliser des tâches hybrides et des déclencheurs de tâches hybrides pour inspecter des données externes à la recherche d'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 fournie par la protection des données sensibles au-delà des demandes d'inspection de contenu simples et de l'analyse du dépôt Google Cloud Storage. Les tâches hybrides et les déclencheurs de tâches hybrides vous permettent de diffuser des données en flux continu depuis presque n'importe quelle source (y compris en dehors de Google Cloud) directement dans Sensitive Data Protection de manière à laisser Sensitive Data Protection inspecter les données à la recherche d'informations sensibles. La protection des données sensibles enregistre et agrége automatiquement les résultats de l'analyse pour une analyse ultérieure.

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. Elles acceptent toutes les données entrantes tant qu'elles sont correctement acheminées et formatées.

Les déclencheurs de tâches hybrides fonctionnent de la même manière que les 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.

De plus, 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 dans 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 typiques sur cette page.

Définition des termes

Cet article utilise les termes suivants:

Données externes: données stockées en dehors de Google Cloud ou données non compatibles nativement avec la protection des données sensibles.
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 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 à laquelle l'envoyer.

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

Processus d'inspection hybride

Le processus d'inspection hybride comporte trois étapes.

Choisissez 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 une application ou un script personnalisé pour envoyer des données à Sensitive Data Protection, ce qui vous permet d'inspecter des données en cours de transfert depuis un autre service cloud, un dépôt de données sur site ou presque n'importe quelle autre source de données.
Configurez une tâche hybride ou un déclencheur de tâche hybride dans Sensitive Data Protection, en partant de zéro ou à l'aide d'un modèle d'inspection.

Une fois que vous avez configuré une tâche ou un déclencheur hybride, Sensitive Data Protection écoute activement les données qui lui sont envoyées. Lorsque votre application ou votre script personnalisé envoie des données à cette tâche hybride ou à ce déclencheur de tâche hybride, les données sont inspectées et les 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 de notifications dans Pub/Sub, Cloud Monitoring ou par e-mail.
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 libellés 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 connexes sur plusieurs requêtes (telles que des lignes de 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, totaliser et analyser les résultats de cette table de base de données.

Au fur et à mesure que la tâche hybride s'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 que lorsque votre application met fin à la tâche hybride.

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

Remarques

Lorsque vous utilisez 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 des 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, activer la facturation et activer la protection des données sensibles

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

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

Go to project selector

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

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

Go to project selector

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

Enable the Sensitive Data Protection API.
Enable the API

Configurer la source de données

Vous devez envoyer les données à la protection des données sensibles pour qu'elles puissent être inspectées. 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 une tâche hybride ou un déclencheur de tâche 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 savoir lequel créer, consultez la section Scénarios d'inspection hybrides typiques 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 un job ou un déclencheur de job"

Les sections suivantes expliquent comment remplir les sections de la page Create job or job trigger (Créer une tâche ou un déclencheur de tâche) qui sont pertinentes pour les opérations d'inspection hybride.

Choisir les données d'entrée

Dans cette section, vous allez spécifier les données d'entrée que Sensitive Data Protection doit inspecter.

(Facultatif) Dans le champ Nom, attribuez un nom à la tâche en saisissant une valeur dans le champ ID de tâche. Si vous laissez ce champ vide, Sensitive Data Protection génère automatiquement un identifiant.
Facultatif: dans le menu Resource location (Emplacement de la ressource), choisissez la région dans laquelle vous souhaitez stocker la tâche ou le déclencheur de tâche hybride. Pour en savoir plus, consultez la section Spécifier des emplacements de traitement.
Dans le champ Storage type (Type de stockage), sélectionnez Hybrid (Hybride).
Facultatif: Dans 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.
Facultatif: Pour Libellés obligatoires, cliquez sur Ajouter un libellé, puis saisissez un libellé 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 ni par ce déclencheur de tâche hybride. Vous pouvez ajouter jusqu'à 10 étiquettes obligatoires. Pour en savoir plus, consultez la section Exiger des libellés à partir des requêtes hybridInspect sur cette page.
Facultatif: Sous Libellés facultatifs, saisissez toutes 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 la section Libellés facultatifs.
Facultatif: Dans Options de données tabulaires, saisissez le nom du 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 pour les données tabulaires.
Cliquez sur Continuer.

Configurer la détection

Dans cette section, vous allez spécifier les types de données sensibles que la protection des données sensibles doit rechercher dans 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 choisissez le modèle dans la liste qui apparaît.
InfoTypes: la protection des données sensibles sélectionne les infoTypes intégrés les plus courants à détecter. Pour modifier les infoTypes ou pour 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, ils ne contiennent que des statistiques sur le nombre et les infoTypes des résultats.

Enregistrer dans BigQuery: chaque fois qu'une analyse est exécutée, la protection des données sensibles enregistre les résultats d'analyse 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 le nom d'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é.

Remarque :En cas de problèmes de configuration ou d'autorisation avec le sujet Pub/Sub, la protection des données sensibles réessaie d'envoyer la notification Pub/Sub pendant deux semaines maximum. Au bout de deux semaines, la notification est supprimée.
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 choisi les actions, cliquez sur Continuer.

Planification

Cette section vous permet de spécifier si vous souhaitez 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 les données formatées et correctement acheminées sont reçues par la protection des données sensibles.

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 à ce qu'elle soit déclenchée par la réception de données en provenance de la source, sélectionnez Créer un déclencheur pour exécuter la tâche selon une programmation régulière.

Les déclencheurs de tâches hybrides regroupent les appels d'API, ce qui vous permet de voir les résultats de recherche 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 à bien noter le nom de l'objet hybride ou du déclencheur de tâche hybride. Vous aurez besoin de ces informations lorsque vous enverrez des données à la protection des données sensibles pour inspection.

Après avoir examiné le récapitulatif JSON, cliquez sur Créer.

La protection des données sensibles démarre 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, appelez 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 disposer des paramètres suivants:

Dans le champ inspectJob, définissez un objet InspectJobConfig.
Dans l'objet InspectJobConfig, dans le champ storageConfig, définissez un objet StorageConfig.
Dans l'objet StorageConfig, dans le champ hybridOptions, définissez un objet HybridOptions. Cet objet contient des métadonnées sur les données que vous souhaitez inspecter.
Dans l'objet InspectJobConfig, dans le champ actions, ajoutez les actions (Action) que vous souhaitez que la protection des données sensibles effectue à 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.
Spécifiez ce que vous recherchez et comment effectuer la recherche en effectuant 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, le cas échéant.
- Définissez le champ inspectConfig.
Si vous définissez à la fois les champs inspectTemplateName et inspectConfig, leurs paramètres sont combinés.

À propos des exemples JSON

Les onglets suivants contiennent des exemples de code JSON que vous pouvez envoyer à la protection des données sensibles pour créer une tâche hybride ou un déclencheur de tâche hybride. Ces exemples de tâche hybride et de déclencheur de tâche hybride 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 rechercher des adresses e-mail.
Associez l'étiquette "env": "prod" aux résultats.
Pour les données tabulaires, obtenez la valeur de la cellule de 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. Sensitive Data Protection associe cet identifiant à la découverte afin que vous puissiez la remonter à la ligne spécifique d'où elle 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.
Envoyer les résultats à Cloud Monitoring lorsque la tâche est arrêtée.

Pour afficher les exemples de code JSON, consultez les onglets suivants.

Emploi hybride

Cet onglet contient un exemple de fichier 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 suivant.

Méthode HTTP et URL

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 l'exécution hybride.
REGION: région géographique dans laquelle vous souhaitez stocker le job 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"
}

Sensitive Data Protection crée le job hybride et génère un ID de job. 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 explicitement la méthode projects.locations.dlpJobs.finish. 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 de code 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 HTTP et URL

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

Sensitive Data Protection crée le déclencheur de job hybride. La sortie contient le nom du déclencheur de tâche hybride. Dans cet exemple, il s'agit de postgresql-table-comments. Notez ce 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. Vous n'avez donc pas besoin d'appeler explicitement la méthode projects.locations.dlpJobs.finish.

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

Dans le champ Paramètres de requête, saisissez projects/PROJECT_ID/locations/REGION. Ensuite, dans le champ Corps de la requête, collez l'exemple de code JSON pour 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.

Pour en savoir plus sur l'utilisation du format JSON pour envoyer des requêtes à l'API DLP, consultez le guide de démarrage rapide JSON.

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

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

Mise en forme hybride des éléments de contenu

Vous trouverez ci-dessous un exemple simple de requête hybridInspect envoyée à Sensitive Data Protection pour être traitée 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 jobs 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 de la tâche hybride.
JOB_ID: ID que vous avez attribué à la tâche hybride, précédé de i-.

Pour rechercher l'ID de la tâche, dans Protection des données sensibles, cliquez sur Inspection > Inspecter les tâches.
TRIGGER_NAME: nom que vous avez attribué 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 libellés dans les requêtes `hybridInspect`

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 des libellés obligatoires. 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 rejetées.

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

Lorsque vous créez la tâche hybride ou le déclencheur de tâche hybride, définissez le champ requiredFindingLabelKeys sur une liste de libellés obligatoires.

L'exemple suivant définit appointment-bookings-comments comme libellé obligatoire dans une tâche hybride ou un déclencheur de tâche hybride.
```
"hybridOptions": {
  ...
  "requiredFindingLabelKeys": [
    "appointment-bookings-comments"
  ],
  "labels": {
    "env": "prod"
  },
  ...
}
```

Dans la requête hybridInspect, dans le champ labels, ajoutez chaque libellé obligatoire 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 le libellé requis dans votre requête hybridInspect, vous recevez un message d'erreur semblable au suivant:

{
  "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 la page Bibliothèques clientes de 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 la page Bibliothèques clientes de la protection des données sensibles.

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 la page Bibliothèques clientes de la protection des données sensibles.


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 la page Bibliothèques clientes de la protection des données sensibles.

// 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 la page Bibliothèques clientes de la protection des données sensibles.


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 la page Bibliothèques clientes de la protection des données sensibles.

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 courants

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

Effectuer une analyse ponctuelle

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

Créez une tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.
Envoyez des données à la tâche en appelant projects.locations.dlpJobs.hybridInspect. Si vous souhaitez inspecter d'autres données, répétez cette étape autant de fois que nécessaire.
Après avoir envoyé des données à des fins d'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 la surveillance continue

Surveillez tous les nouveaux contenus ajoutés quotidiennement dans une base de données qui n'est pas compatible en mode natif avec la protection des données sensibles.

Créez un déclencheur de tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.
Activez le déclencheur de tâche en appelant la méthode projects.locations.jobTriggers.activate.
Envoyez des données au déclencheur de tâche en appelant projects.locations.jobTriggers.hybridInspect. Si vous souhaitez inspecter d'autres 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 jour, Sensitive Data Protection effectue les actions que vous avez spécifiées lorsque vous avez créé votre déclencheur de tâche hybride.

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

Analysez les données entrantes 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 correspond à une partition unique.

Créez un déclencheur de tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.
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.
Envoyez des données à la tâche en appelant projects.locations.dlpJobs.hybridInspect.

Dans ce cas, vous envoyez les données à la tâche plutôt qu'au déclencheur de tâche. Cette approche vous permet de contrôler la façon 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.
Après avoir envoyé des 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.
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 générée.

Surveiller le trafic à partir d'un proxy

Surveillez le trafic d'un proxy installé entre deux applications personnalisées.

Créez un déclencheur de tâche hybride à l'aide de la console Google Cloud ou de l'API DLP.
Activez le déclencheur de tâche en appelant la méthode projects.locations.jobTriggers.activate.
Envoyez des données au déclencheur de tâche en appelant projects.locations.jobTriggers.hybridInspect. Si vous souhaitez inspecter d'autres 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.

Étape suivante

Découvrez le fonctionnement des tâches hybrides et des déclencheurs de tâches hybrides.

Inspecter les données provenant de sources externes à l'aide de tâches hybrides

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

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

Définition des termes

Processus d'inspection hybride

Remarques

Avant de commencer

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

Configurer la source de données

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

Console

Choisir les données d'entrée

Configurer la détection

Ajouter des actions

Planification

Récapitulatif

API

À propos des exemples JSON

Emploi hybride

Déclencheur de tâche hybride

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

Mise en forme hybride des éléments de contenu

Points de terminaison d'inspection hybride

Exiger des libellés dans les requêtes hybridInspect

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

C#

Go

Java

Node.js

PHP

Python

Scénarios d'inspection hybride courants

Effectuer une analyse ponctuelle

Configurer la surveillance continue

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

Surveiller le trafic à partir d'un proxy

Étape suivante

Exiger des libellés dans les requêtes `hybridInspect`