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 (DLP). Pour en savoir plus sur les services qui constituent Sensitive Data Protection, consultez la section Présentation de Sensitive Data Protection.

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 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 Sensitive Data Protection au-delà des demandes d'inspection de contenu simples et de l'analyse du dépôt de stockageGoogle Cloud . 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. Sensitive Data Protection enregistre et agrège automatiquement les résultats d'analyse pour une analyse plus approfondie.

Comparaison entre les tâches hybrides et les 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. Sensitive Data Protection arrête automatiquement les jobs dans les déclencheurs de jobs 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âches hybrides, 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 correspond le mieux à 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 que la protection des données sensibles ne prend pas en charge de manière native.
Job hybride : job d'inspection configuré 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 provenant 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 l'envoyer.

Pour obtenir des informations générales sur les jobs et les déclencheurs de jobs, consultez Jobs et déclencheurs de jobs.

Processus d'inspection hybride

Le processus d'inspection hybride comprend 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 à la protection des données sensibles, 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 en utilisant un modèle d'inspection.

Une fois que vous avez configuré une tâche ou un déclencheur de tâche 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 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 connexes. Vous pouvez ensuite collecter, comptabiliser et analyser les résultats pour 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 Sensitive Data Protection les génère. En revanche, les actions, comme les notifications Pub/Sub, ne se produisent qu'une fois que votre application a terminé 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 jobs et les déclencheurs de job ne sont pas soumis à des objectifs de niveau de service (SLO), mais vous pouvez prendre des mesures pour réduire la latence. Pour en savoir plus, consultez Latence des jobs.

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 à Sensitive Data Protection 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 demandes d'inspection hybrides, consultez 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 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 à Sensitive Data Protection 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 Scénarios d'inspection hybride typiques sur cette page.

Console

Dans la console Google Cloud , accédez à la page Créer un job ou un déclencheur de jobs :

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 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 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 Emplacement de la ressource, sélectionnez la région dans laquelle vous souhaitez stocker le job hybride ou le déclencheur de job hybride. Pour en savoir plus, consultez Spécifier des emplacements de traitement.
Dans le champ Type de stockage, sélectionnez Hybride.
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.
Facultatif : Pour les 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 pour les requêtes hybridInspect sur cette page.
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 à ce job ou à ce déclencheur de job. Vous pouvez ajouter jusqu'à 10 libellés facultatifs. Pour en savoir plus, consultez 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 Options de données tabulaires.
Cliquez sur Continuer.

Configurer la détection

Dans cette section, vous allez spécifier les types de données sensibles que Sensitive Data Protection 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 Sensitive Data Protection, 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 pour la détection. 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, 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, Sensitive Data Protection 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, Sensitive Data Protection 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ème de configuration ou d'autorisation avec le sujet Pub/Sub, la protection des données sensibles tente 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 des 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 Sensitive Data Protection.

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 le job de sorte à ce qu'il soit déclenché par la réception de données en provenance de la source, sélectionnez Créer un déclencheur pour exécuter le job 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 Comparaison des jobs hybrides et des déclencheurs de jobs hybrides.

Récapitulatif

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

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

Sensitive Data Protection 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 hybridInspectrequête à 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 un job hybride, vous 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, vous devez appeler la méthode projects.locations.jobTriggers.create.

L'objet DlpJobs ou JobTrigger que vous créez doit comporter les 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 job.

Les actions publishSummaryToCscc et publishFindingsToCloudDataCatalog ne sont pas compatibles avec cette opération. Pour en savoir plus sur les actions, consultez Actions.
Spécifiez les éléments à analyser et la façon de les analyser 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 les 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 à Sensitive Data Protection pour créer une tâche hybride ou un déclencheur de tâche hybride. Ces exemples de tâches hybrides et de déclencheurs de tâches hybrides sont configurés pour effectuer les opérations suivantes :

Traitez toute demande hybridInspect si elle porte le libellé appointment-bookings-comments.
Analysez le contenu de la requête hybridInspect pour trouver 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 de la colonne booking_id (clé primaire) qui se trouve sur la même ligne que la cellule où les données sensibles ont été trouvées. Sensitive Data Protection associe cet identifiant au résultat pour que vous puissiez le relier à la ligne spécifique dont il provient.
Envoyez un e-mail lorsque le job s'arrête. L'e-mail est envoyé aux propriétaires de projets IAM et aux contacts essentiels techniques.
Envoyez 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 un job hybride.

Pour créer un job 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 le job 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 un job hybride, vous devez appeler explicitement la méthode projects.locations.dlpJobs.finish. L'API DLP n'arrête pas automatiquement les jobs 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 job hybride.

Pour créer un déclencheur de job 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 job hybride.
REGION : région géographique dans laquelle vous souhaitez stocker le déclencheur de job 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. Le résultat 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 ou un déclencheur de jobs hybride, vous pouvez utiliser APIs Explorer sur les pages de référence de l'API suivantes, respectivement :

Dans le champ Paramètres de la 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 dans APIs Explorer, crée un job hybride ou un déclencheur de job 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 rapide 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 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 un 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é au job hybride, précédé de i-.

Pour rechercher l'ID du job, dans Protection des données sensibles, cliquez sur Inspection > Jobs d'inspection.
TRIGGER_NAME : nom que vous avez donné au déclencheur de job hybride.

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

Exiger des libellés pour les demandes `hybridInspect`

Si vous souhaitez contrôler les requêtes hybridInspect qui peuvent ê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 les libellés requis seront rejetées.

Pour définir un libellé 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 requis.

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é 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 le libellé requis dans votre requête hybridInspect, vous recevrez une erreur semblable à celle-ci :

{
  "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 job 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\ActivateJobTriggerRequest;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\GetDlpJobRequest;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;
use Google\Cloud\Dlp\V2\HybridInspectJobTriggerRequest;
use Google\Cloud\Dlp\V2\ListDlpJobsRequest;

/**
 * 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 {
        $activateJobTriggerRequest = (new ActivateJobTriggerRequest())
            ->setName($name);
        $triggerJob = $dlp->activateJobTrigger($activateJobTriggerRequest);
    } catch (ApiException $e) {
        $listDlpJobsRequest = (new ListDlpJobsRequest())
            ->setParent($parent)
            ->setFilter('trigger_name=' . $name);
        $result = $dlp->listDlpJobs($listDlpJobsRequest);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }
    $hybridInspectJobTriggerRequest = (new HybridInspectJobTriggerRequest())
        ->setName($name)
        ->setHybridItem($hybridItem);

    $dlp->hybridInspectJobTrigger($hybridInspectJobTriggerRequest);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $getDlpJobRequest = (new GetDlpJobRequest())
            ->setName($triggerJob->getName());
        $job = $dlp->getDlpJob($getDlpJobRequest);
        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 typiques

Les sections suivantes décrivent les utilisations types 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 un job hybride à l'aide de la console ou de l'API DLP.Google Cloud
Envoyez des données au job en appelant projects.locations.dlpJobs.hybridInspect. Si vous souhaitez examiner d'autres données, répétez cette étape autant de fois que nécessaire.
Après avoir envoyé les données à inspecter, 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 Sensitive Data Protection.

Créez un déclencheur de tâche hybride à l'aide de la console ou de l'API DLP.Google Cloud
Activez le déclencheur de job 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 examiner 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 job est actif, Sensitive Data Protection effectue les actions que vous avez spécifiées lorsque vous avez créé votre déclencheur de job hybride à la fin de chaque journée.

Analyser les données qui entrent dans une base de données

Analysez les données qui entrent dans une base de données tout en contrôlant la façon dont elles sont partitionnées. Chaque job d'un déclencheur de job est une partition unique.

Créez un déclencheur de tâche hybride à l'aide de la console ou de l'API DLP.Google Cloud
Activez le déclencheur de job en appelant la méthode projects.locations.jobTriggers.activate.

Le système renvoie l'ID d'un seul job. Vous en aurez besoin à l'étape suivante.
Envoyez des données au job 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 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 au job, 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 un autre job pour la partition suivante, réactivez le déclencheur de job, puis envoyez les données au job résultant.

Surveiller le trafic provenant d'un proxy

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

Créez un déclencheur de tâche hybride à l'aide de la console ou de l'API DLP.Google Cloud
Activez le déclencheur de job 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 examiner d'autres données, répétez cette étape autant de fois que nécessaire.

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

Étapes suivantes

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 Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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

Comparaison entre les tâches hybrides et les 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 pour les demandes hybridInspect

Exemple de code : créer un déclencheur de job hybride et lui envoyer des données

C#

Go

Java

Node.js

PHP

Python

Scénarios d'inspection hybride typiques

Effectuer une analyse ponctuelle

Configurer la surveillance continue

Analyser les données qui entrent dans une base de données

Surveiller le trafic provenant d'un proxy

Étapes suivantes

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

Exiger des libellés pour les demandes `hybridInspect`