Daten aus externen Quellen mit Hybridjobs prüfen

In diesem Thema wird beschrieben, wie Sie mit Hybridjobs und Hybridjob-Triggern externe Daten auf vertrauliche Informationen prüfen. Weitere Informationen zu Hybridjobs und Hybridjob-Triggern, einschließlich Beispielen für Hybridumgebungen, finden Sie unter Hybridjobs und Hybridjob-Trigger.

Einführung in hybride Jobs und Trigger für hybride Jobs

Mit Hybridjobs und Hybridjob-Triggern können Sie den Schutz sensibler Daten erweitern, der über einfache Anfragen zur Inhaltsprüfung und das Scannen von Google Cloud Storage-Repositories hinausgeht. Mit Hybridjobs und Hybridjob-Triggern können Sie Daten aus praktisch jeder Quelle – auch außerhalb von Google Cloud – direkt zum Schutz sensibler Daten streamen und den Schutz sensibler Daten die Daten auf vertrauliche Informationen prüfen lassen. Der Schutz sensibler Daten speichert und aggregiert die Scanergebnisse automatisch zur weiteren Analyse.

Hybridjobs und Trigger für hybride Jobs im Vergleich

Hybridjobs werden ausgeführt, bis Sie sie beenden. Sie akzeptieren alle eingehenden Daten, solange die Daten richtig geleitet und formatiert werden.

Hybridjob-Trigger funktionieren ähnlich wie Hybridjobs, Sie müssen einen Job innerhalb eines Hybridjob-Triggers jedoch nicht explizit beenden. Der Schutz sensibler Daten beendet Jobs in Hybridjob-Triggern automatisch am Ende jedes Tages.

Darüber hinaus können Sie mit einem hybriden Job-Trigger neue Jobs innerhalb des Triggers beenden und starten, ohne Ihre hybridInspect-Anfragen neu konfigurieren zu müssen. Sie können beispielsweise Daten an einen Hybridjob-Trigger senden und dann den aktiven Job anhalten, seine Konfiguration ändern, einen neuen Job innerhalb dieses Triggers starten und dann weiter Daten an denselben Trigger senden.

Weitere Informationen dazu, welche Option für Ihren Anwendungsfall geeignet ist, finden Sie auf dieser Seite unter Typische Szenarien für Hybridprüfungen.

Begriffsdefinitionen

In diesem Thema werden die folgenden Begriffe verwendet:

  • Externe Daten: Daten, die außerhalb von Google Cloud gespeichert sind oder die vom Schutz sensibler Daten nicht nativ unterstützt werden.

  • Hybridjob: Ein Inspektionsjob, der zum Scannen von Daten aus praktisch jeder Quelle konfiguriert ist.

  • Hybridjob-Trigger: Ein Job-Trigger, der so konfiguriert ist, dass er Daten aus praktisch jeder Quelle scannt.

  • hybridInspect-Anfrage: Eine Anfrage, die die externen Daten enthält, die Sie prüfen möchten. Beim Senden dieser Anfrage geben Sie den Hybridjob oder den Hybridjob-Trigger an, an den die Anfrage gesendet werden soll.

Allgemeine Informationen zu Jobs und Job-Triggern finden Sie unter Jobs und Job-Trigger.

Hybrider Prüfprozess

Der Prozess der Hybridprüfung umfasst drei Schritte.

  1. Wählen Sie die Daten aus, die Sie an den Schutz sensibler Daten senden möchten.

    Die Daten können von innerhalb oder außerhalb von Google Cloud stammen. Sie können beispielsweise ein benutzerdefiniertes Skript oder eine Anwendung so konfigurieren, dass Daten an den Schutz sensibler Daten gesendet werden, sodass Sie Daten während der Übertragung, aus einem anderen Cloud-Dienst, einem lokalen Daten-Repository oder praktisch jeder anderen Datenquelle untersuchen können.

  2. Richten Sie einen Hybridjob oder Hybridjob-Trigger im Schutz sensibler Daten neu ein oder verwenden Sie eine Inspektionsvorlage.

    Nachdem Sie einen Hybridjob- oder Hybridjob-Trigger eingerichtet haben, wartet der Schutz sensibler Daten aktiv auf an ihn gesendete Daten. Wenn Ihr benutzerdefiniertes Skript oder Ihre benutzerdefinierte Anwendung Daten an diesen Hybridjob oder Hybridjob-Trigger sendet, werden die Daten geprüft und die Ergebnisse gemäß der Konfiguration gespeichert.

    Wenn Sie den Trigger für Hybridjobs oder hybride Jobs einrichten, können Sie angeben, wo Sie die Ergebnisse speichern oder veröffentlichen möchten. Zu den Optionen gehören das Speichern in BigQuery und das Veröffentlichen von Benachrichtigungen in Pub/Sub, Cloud Monitoring oder E-Mail.

  3. Senden Sie eine hybridInspect-Anfrage an den Hybridjob- oder Hybridjob-Trigger.

    Eine hybridInspect-Anfrage enthält die Daten, die gescannt werden sollen. Die Anfrage fügen Sie Metadaten (auch als Labels und Tabellenkennzeichnungen bezeichnet) hinzu, die den Inhalt beschreiben und durch den der Schutz sensibler Daten die Informationen identifizieren lässt, die Sie verfolgen möchten. Wenn Sie beispielsweise verwandte Daten über mehrere Anfragen hinweg scannen (z. B. Zeilen in derselben Datenbanktabelle), können Sie dieselben Metadaten in diesen verwandten Anfragen verwenden. Anschließend können Sie die Ergebnisse für diese Datenbanktabelle sammeln, zählen und analysieren.

Während der Hybridjob ausgeführt und Anfragen geprüft wird, sind die Prüfergebnisse verfügbar, wenn der Schutz sensibler Daten sie generiert. Im Gegensatz dazu werden Aktionen wie Pub/Sub-Benachrichtigungen erst ausgeführt, wenn Ihre Anwendung den Hybridjob beendet hat.

Diagramm zur Darstellung des Hybridjob-Prüfprozesses

Hinweise

Berücksichtigen Sie bei der Arbeit mit Hybridjobs und Job-Triggern die folgenden Punkte:

  • Hybridjobs und hybride Jobtrigger unterstützen Filterung und Stichprobenerhebung nicht.
  • Jobs und Job-Trigger unterliegen nicht den Service Level Objectives (SLO), Sie können jedoch die Latenz reduzieren. Weitere Informationen finden Sie unter Joblatenz.

Hinweise

Führen Sie Folgendes aus, bevor Sie Hybridjobs oder Hybridjob-Trigger einrichten und verwenden:

Erstellen Sie ein neues Projekt, aktivieren Sie die Abrechnung und aktivieren Sie den Schutz sensibler Daten

  1. Melden Sie sich bei Ihrem Google Cloud-Konto an. Wenn Sie mit Google Cloud noch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

  2. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  3. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  4. Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.

    Zur Projektauswahl

  5. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  6. Sensitive Data Protection API aktivieren.

    Aktivieren Sie die API

Datenquelle konfigurieren

Bevor der Schutz sensibler Daten Ihre Daten prüfen kann, müssen Sie sie an den Schutz sensibler Daten senden. Unabhängig davon, welche Methode Sie zum Konfigurieren des Hybridjobs oder des Hybridjob-Triggers verwenden, müssen Sie die externe Quelle so einrichten, dass Daten an die DLP API gesendet werden.

Informationen zum erforderlichen Format für Hybridprüfungsanfragen finden Sie unter Formatierung von Elementen für hybride Inhalte. Informationen zu den Arten von Metadaten, die Sie mit den Daten in Ihrer Anfrage angeben können, finden Sie unter Arten von Metadaten, die Sie zur Verfügung stellen können.

Hybridjob oder hybriden Job-Trigger erstellen

Damit der Schutz sensibler Daten die an ihn gesendeten Daten prüfen kann, müssen Sie zuerst einen Hybridjob oder Hybridjob-Trigger einrichten. Informationen dazu, welches Sie erstellen sollten, finden Sie auf dieser Seite unter Typische Szenarien für Hybridprüfungen.

Console

Rufen Sie in der Google Cloud Console die Seite Job oder Job-Trigger erstellen auf:

Zur Seite „Job oder Job-Trigger erstellen“

In den folgenden Abschnitten wird beschrieben, wie Sie die Bereiche der Seite Job oder Job-Trigger erstellen ausfüllen, die für Hybridinspektionsvorgänge relevant sind.

Eingabedaten auswählen

In diesem Abschnitt geben Sie die Eingabedaten an, die geprüft werden sollen.

  1. Optional: Geben Sie unter Name einen Namen in das Feld Job-ID ein. Wenn Sie dieses Feld leer lassen, generiert der Schutz sensibler Daten automatisch eine Kennung.
  2. Optional: Wählen Sie im Menü Ressourcenstandort die Region aus, in der Sie den Hybridjob oder den Hybridjob-Trigger speichern möchten. Weitere Informationen finden Sie unter Verarbeitungsstandorte angeben.

  3. Wählen Sie als Speichertyp die Option Hybrid aus.

  4. Optional: Beschreiben Sie unter Beschreibung den Hybridjob oder Hybridjob-Trigger, den Sie erstellen. Sie können beispielsweise Informationen über die Quelle der zu prüfenden Daten angeben.

  5. Optional: Klicken Sie unter Erforderliche Labels auf Label hinzufügen und geben Sie ein Label ein, das Sie aus hybridInspect-Anfragen benötigen. Eine hybridInspect-Anfrage, in der dieses Label nicht angegeben ist, wird von diesem Hybridjob- oder Hybridjob-Trigger nicht verarbeitet. Sie können bis zu zehn erforderliche Labels hinzufügen. Weitere Informationen finden Sie auf dieser Seite unter Labels von hybridInspect-Anfragen anfordern.

  6. Optional: Geben Sie unter Optionale Labels beliebige Schlüssel/Wert-Paare ein, die an die Ergebnisse aller hybridInspect-Anfragen angehängt werden sollen, die an diesen Job oder Job-Trigger gesendet werden. Sie können bis zu zehn optionale Labels hinzufügen. Weitere Informationen finden Sie unter Optionale Labels.

  7. Optional: Geben Sie unter Tabellarische Datenoptionen den Feldnamen der Primärschlüsselspalte ein, wenn Sie in Ihren hybridInspect-Anfragen tabellarische Daten senden möchten. Weitere Informationen finden Sie unter Optionen für tabellarische Daten.

  8. Klicken Sie auf Weiter.

Erkennung konfigurieren

In diesem Abschnitt geben Sie die Typen sensibler Daten an, auf die der Schutz sensibler Daten die Eingabedaten prüft. Sie haben folgende Optionen:

  • Vorlage: Wenn Sie im aktuellen Projekt bereits eine Vorlage erstellt haben, die Sie zum Definieren der Erkennungsparameter für den Schutz sensibler Daten verwenden möchten, klicken Sie auf das Feld Vorlagenname und wählen Sie dann die Vorlage aus der angezeigten Liste aus.
  • InfoTypes: Beim Schutz sensibler Daten werden die gängigsten integrierten infoTypes zur Erkennung ausgewählt. Klicken Sie auf infoTypes verwalten, um die infoTypes zu ändern oder einen benutzerdefinierten infoType auszuwählen. Sie können die Erkennungskriterien auch in den Abschnitten Inspektionsregelsätze und Konfidenzschwellenwert optimieren. Weitere Informationen finden Sie unter Erkennung konfigurieren.

Klicken Sie nach dem Konfigurieren der Erkennungsparameter auf Weiter.

Aktionen hinzufügen

In diesem Abschnitt geben Sie an, wo die Ergebnisse aus jedem Prüfungsscan gespeichert werden sollen und ob Sie per E-Mail oder Pub/Sub-Benachrichtigung benachrichtigt werden möchten, wenn ein Scan abgeschlossen ist. Wenn Sie Ergebnisse nicht in BigQuery speichern, enthalten die Scanergebnisse nur Statistiken über die Anzahl und infoTypes der Ergebnisse.

  • In BigQuery speichern: Bei jedem Scan speichert der Schutz sensibler Daten die Scanergebnisse in der BigQuery-Tabelle, die Sie hier angeben. Wenn Sie keine Tabellen-ID angeben, weist BigQuery einer neuen Tabelle einen Standardnamen zu, wenn der Scan zum ersten Mal ausgeführt wird. Wenn Sie eine vorhandene Tabelle angeben, fügt der Schutz sensibler Daten Scanergebnisse an diese Tabelle an.

  • In Pub/Sub veröffentlichen: Wenn ein Job abgeschlossen ist, wird eine Pub/Sub-Nachricht ausgegeben.

  • Per E-Mail benachrichtigen: Wenn ein Job abgeschlossen ist, wird eine E-Mail-Nachricht gesendet.

  • In Cloud Monitoring veröffentlichen: Wenn ein Job abgeschlossen ist, werden die Ergebnisse in Monitoring veröffentlicht.

Nachdem Sie Aktionen ausgewählt haben, klicken Sie auf Weiter.

Zeitplan

In diesem Abschnitt geben Sie an, ob ein einzelner Job erstellt werden soll, der sofort ausgeführt wird, oder einen Job-Trigger, der jedes Mal ausgeführt wird, wenn ordnungsgemäß weitergeleitete und formatierte Daten vom Schutz sensibler Daten empfangen werden.

Führen Sie einen der folgenden Schritte aus:

  • Wählen Sie Keiner (einmaligen Job sofort bei der Erstellung ausführen) aus, um den Hybridjob sofort auszuführen.

  • Wenn Sie den Job so konfigurieren möchten, dass von der Quelle empfangene Daten den Job auslösen, wählen Sie Trigger zum Ausführen des Jobs nach einem regelmäßigen Zeitplan erstellen aus.

    Hybridjobs lösen zusammengefasste API-Aufrufe aus, sodass Sie Ergebnisse und Trends im Zeitverlauf sehen können.

Weitere Informationen finden Sie unter Vergleich von Hybridjobs und Hybridjob-Triggern.

Überprüfen

Eine JSON-Zusammenfassung des Scans finden Sie hier. Notieren Sie sich den Namen des Hybrid-OB- oder Hybrid-Job-Triggers. Sie benötigen diese Informationen, wenn Sie Daten zur Prüfung an den Schutz sensibler Daten senden.

Prüfen Sie die JSON-Zusammenfassung und klicken Sie dann auf Erstellen.

Der Schutz sensibler Daten startet den Hybridjob oder den Hybridjob-Trigger sofort. Ein Inspektionsscan wird gestartet, wenn Sie eine hybridInspect-Anfrage an diesen Hybridjob- oder Hybridjob-Trigger senden.

API

Ein Job wird in der DLP API durch die Ressource DlpJobs dargestellt. Wenn Sie einen Hybridjob erstellen möchten, rufen Sie die Methode projects.locations.dlpJobs.create auf.

Ein Job-Trigger wird in der DLP API durch die Ressource JobTrigger dargestellt. Rufen Sie die Methode projects.locations.jobTriggers.create auf, um einen Hybrid-Job-Trigger zu erstellen.

Das erstellte DlpJobs- oder JobTrigger-Objekt muss die folgenden Einstellungen haben:

  1. Legen Sie im Feld inspectJob ein InspectJobConfig-Objekt fest.
  2. Legen Sie im InspectJobConfig-Objekt im Feld storageConfig ein StorageConfig-Objekt fest.
  3. Legen Sie im StorageConfig-Objekt im Feld hybridOptions ein HybridOptions-Objekt fest. Dieses Objekt enthält Metadaten zu den Daten, die Sie prüfen möchten.

  4. Fügen Sie im InspectJobConfig-Objekt im Feld actions alle Aktionen (Action) hinzu, die am Ende jedes Jobs ausgeführt werden sollen.

    Die Aktionen publishSummaryToCscc und publishFindingsToCloudDataCatalog werden für diesen Vorgang nicht unterstützt. Weitere Informationen zu Aktionen finden Sie unter Aktionen.

  5. Geben Sie an, wonach und wie gescannt werden soll. Führen Sie dazu einen oder beide der folgenden Schritte aus:

    • Geben Sie für das Feld inspectTemplateName den vollständigen Ressourcennamen einer Inspektionsvorlage an, die Sie verwenden möchten (falls verfügbar).

    • Legen Sie das Feld inspectConfig fest.

    Wenn Sie die Felder inspectTemplateName und inspectConfig festlegen, werden ihre Einstellungen kombiniert.

JSON-Beispiele

Die folgenden Tabs enthalten JSON-Beispiele, die Sie an den Schutz sensibler Daten senden können, um einen Hybridjob oder einen Hybridjob-Trigger zu erstellen. Diese Beispiele für Hybridjobs und hybride Jobtrigger sind so konfiguriert:

  • Verarbeiten Sie alle hybridInspect-Anfragen, wenn die Anfrage das Label appointment-bookings-comments hat.
  • Scannen Sie den Inhalt der hybridInspect-Anfrage nach E-Mail-Adressen.
  • Hängen Sie das Label "env": "prod" an Ergebnisse an.
  • Rufen Sie bei tabellarischen Daten den Wert der Zelle in der Spalte booking_id (Primärschlüssel) ab, die sich in derselben Zeile wie die Zelle befindet, in der die sensiblen Daten gefunden wurden. Der Schutz sensibler Daten verknüpft diese Kennung mit dem Ergebnis, sodass Sie das Ergebnis bis zur spezifischen Zeile zurückverfolgen können, aus der es stammt.
  • Senden Sie eine E-Mail, wenn der Job beendet wird. Die E-Mail wird an IAM-Projektinhaber und wichtige Kontakte gesendet.
  • Senden Sie die Ergebnisse an Cloud Monitoring, wenn der Job angehalten wird.

Die JSON-Beispiele finden Sie auf den folgenden Tabs.

Hybrider Job

Dieser Tab enthält ein JSON-Beispiel, mit dem Sie einen Hybridjob erstellen können.

Senden Sie eine POST-Anfrage an den folgenden Endpunkt, um einen Hybridjob zu erstellen.

HTTP-Methode und URL

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: die ID des Projekts, in dem Sie den Hybridjob speichern möchten.
  • REGION: Die geografische Region, in der der Hybridjob gespeichert werden soll.

JSON-Eingabe

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

JSON-Ausgabe

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

Beim Schutz sensibler Daten wird der Hybridjob erstellt und eine Job-ID generiert. In diesem Beispiel lautet die Job-ID i-postgresql-table-comments. Notieren Sie sich die Job-ID. Sie wird in deiner hybridInspect-Anfrage benötigt.

Zum Beenden eines Hybridjobs müssen Sie die Methode projects.locations.dlpJobs.finish explizit aufrufen. Die DLP API beendet Hybridjobs nicht automatisch. Im Gegensatz dazu beendet die DLP API Jobs in Hybridjob-Triggern automatisch am Ende jedes Tages.

Hybridjob-Trigger

Dieser Tab enthält ein JSON-Beispiel, mit dem Sie einen Hybridjob-Trigger erstellen können.

Senden Sie eine POST-Anfrage an den folgenden Endpunkt, um einen Hybridjob-Trigger zu erstellen.

HTTP-Methode und URL

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: die ID des Projekts, in dem Sie den Hybridjob-Trigger speichern möchten.
  • REGION: Die geografische Region, in der Sie den Hybridjob-Trigger speichern möchten.

JSON-Eingabe

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

JSON-Ausgabe

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

Der Schutz sensibler Daten erstellt den Hybridjob-Trigger. Die Ausgabe enthält den Namen des Hybridjob-Triggers. In diesem Beispiel ist das postgresql-table-comments. Notieren Sie sich den Namen. Sie benötigen ihn in Ihrer hybridInspect-Anfrage.

Anders als bei Hybridjobs beendet die DLP API Jobs innerhalb von Hybridjob-Triggern automatisch am Ende jedes Tages. Daher müssen Sie die Methode projects.locations.dlpJobs.finish nicht explizit aufrufen.

Beim Erstellen eines hybriden Job- oder Hybrid-Job-Triggers können Sie APIs Explorer auf den folgenden API-Referenzseiten verwenden:

Geben Sie im Feld Anfrageparameter den Wert projects/PROJECT_ID/locations/REGION ein. Fügen Sie dann im Feld Request body (Anfragetext) die Beispiel-JSON-Datei für das Objekt ein, das Sie erstellen möchten.

Bei einer erfolgreichen Anfrage, die selbst im APIs Explorer erstellt wurde, wird ein Hybridjob oder Hybridjob-Trigger erstellt.

Allgemeine Informationen zum Einsatz von JSON für das Senden von Anfragen an die DLP API finden Sie im JSON-Schnellstart.

Daten an Hybridjob- oder Hybridjob-Trigger senden

Zum Prüfen von Daten müssen Sie eine hybridInspect-Anfrage im richtigen Format an einen Hybridjob oder einen Hybridjob-Trigger senden.

Formatierung von Hybrid-Inhaltselementen

Das folgende Beispiel zeigt ein einfaches Beispiel für eine hybridInspect-Anfrage, die zur Verarbeitung durch einen Hybridjob oder Hybridjob-Trigger an den Schutz sensibler Daten gesendet wird. Beachten Sie die Struktur des JSON-Objekts, einschließlich des Felds hybridItem, das die folgenden Felder enthält:

  • item: enthält den tatsächlichen Inhalt, der geprüft werden soll.
  • findingDetails: enthält Metadaten, die mit dem Inhalt verknüpft werden sollen.
{
  "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": ""
      }
    }
  }
}

Ausführliche Informationen zum Inhalt von Hybrid-Prüfungselementen finden Sie im API-Referenzinhalt für das Objekt HybridContentItem.

Endpunkte für Hybridprüfung

Damit Daten mit einem Hybridjob oder Hybridjob-Trigger geprüft werden können, müssen Sie eine hybridInspect-Anfrage an den richtigen Endpunkt senden.

HTTP-Methode und URL für Hybridjobs

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

Weitere Informationen zu diesem Endpunkt finden Sie auf der API-Referenzseite für die Methode projects.locations.dlpJobs.hybridInspect.

HTTP-Methode und URL für Hybridjob-Trigger

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

Weitere Informationen zu diesem Endpunkt finden Sie auf der API-Referenzseite für die Methode projects.locations.jobTriggers.hybridInspect.

Ersetzen Sie Folgendes:

  • PROJECT_ID: Ihre Projekt-ID.
  • REGION: Die geografische Region, in der Sie die hybridInspect-Anfrage speichern möchten. Diese Region muss mit der Region des Hybridjobs identisch sein.

  • JOB_ID: Die ID, die Sie dem Hybridjob mit dem Präfix i- gegeben haben.

    Rufen Sie die Job-ID ab, indem Sie unter Schutz sensibler Daten auf Inspektion > Jobs prüfen klicken.

  • TRIGGER_NAME: Der Name, den Sie dem Hybridjob-Trigger gegeben haben.

    Klicken Sie unter Schutz sensibler Daten auf Prüfung > Job-Trigger, um den Namen des Job-Triggers zu sehen.

Labels aus hybridInspect-Anfragen anfordern

Wenn Sie steuern möchten, welche hybridInspect-Anfragen von einem Hybridjob oder Hybridjob-Trigger verarbeitet werden können, können Sie die erforderlichen Labels festlegen. Alle hybridInspect-Anfragen für diesen Hybridjob oder Hybridjob-Trigger, die diese erforderlichen Labels nicht enthalten, werden abgelehnt.

So legen Sie ein erforderliches Label fest:

  1. Legen Sie beim Erstellen des Hybridjobs oder des Hybridjob-Triggers das Feld requiredFindingLabelKeys auf eine Liste der erforderlichen Labels fest.

    Im folgenden Beispiel wird appointment-bookings-comments als erforderliches Label in einem Hybridjob oder Hybridjob-Trigger festgelegt.

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

  2. Fügen Sie in der hybridInspect-Anfrage im Feld labels jedes erforderliche Label als Schlüssel in einem Schlüssel/Wert-Paar ein. Der entsprechende Wert kann ein leerer String sein.

    Im folgenden Beispiel wird das erforderliche Label appointment-bookings-comments in einer hybridInspect-Anfrage festgelegt.

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

Wenn Sie das erforderliche Label nicht in Ihre hybridInspect-Anfrage einfügen, erhalten Sie eine Fehlermeldung wie die folgende:

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

Codebeispiel: Hybrid-Job-Trigger erstellen und Daten an diesen senden

C#

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

// 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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 


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

Informationen zum Installieren und Verwenden der Clientbibliothek für den Schutz sensibler Daten finden Sie unter Clientbibliotheken für den Schutz sensibler Daten.

Richten Sie Standardanmeldedaten für Anwendungen ein, um sich beim Schutz sensibler Daten zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten. 

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.")

Typische Szenarien für Hybridprüfungen

In den folgenden Abschnitten werden typische Anwendungsbereiche für Hybridprüfungen und die entsprechenden Workflows beschrieben.

Einmaligen Scan durchführen

Führen Sie einen einmaligen Scan einer Datenbank außerhalb von Google Cloud im Rahmen einer vierteljährlichen Stichprobenprüfung von Datenbanken aus.

  1. Erstellen Sie einen Hybridjob mit der Google Cloud Console oder der DLP API.

  2. Senden Sie Daten an den Job, indem Sie projects.locations.dlpJobs.hybridInspect aufrufen. Wenn Sie weitere Daten untersuchen möchten, wiederholen Sie diesen Schritt so oft wie nötig.

  3. Nachdem Sie Daten zur Prüfung gesendet haben, rufen Sie die Methode projects.locations.dlpJobs.finish auf.

    Der Schutz sensibler Daten führt die in der projects.locations.dlpJobs.create-Anfrage angegebenen Aktionen aus.

Kontinuierliches Monitoring konfigurieren

Überwachen Sie alle neuen Inhalte, die täglich zu einer Datenbank hinzugefügt werden, die der Schutz sensibler Daten nativ nicht unterstützt.

  1. Erstellen Sie einen Hybridjob-Trigger mit der Google Cloud Console oder der DLP API.

  2. Aktivieren Sie den Job-Trigger durch Aufrufen der Methode projects.locations.jobTriggers.activate.

  3. Senden Sie Daten an den Job-Trigger, indem Sie projects.locations.jobTriggers.hybridInspect aufrufen. Wenn Sie weitere Daten untersuchen möchten, wiederholen Sie diesen Schritt so oft wie nötig.

In diesem Fall müssen Sie die Methode projects.locations.dlpJobs.finish nicht aufrufen. Der Schutz sensibler Daten partitioniert die von Ihnen gesendeten Daten automatisch. Solange der Job-Trigger aktiv ist, führt der Schutz sensibler Daten am Ende jedes Tages die Aktionen aus, die Sie beim Erstellen des Hybrid-Job-Triggers angegeben haben.

In eine Datenbank eingehende Daten scannen

Sie können Daten scannen, die in eine Datenbank eingehen, und gleichzeitig steuern, wie die Daten partitioniert werden. Jeder Job in einem Job-Trigger ist eine einzelne Partition.

  1. Erstellen Sie einen Hybridjob-Trigger mit der Google Cloud Console oder der DLP API.

  2. Aktivieren Sie den Job-Trigger durch Aufrufen der Methode projects.locations.jobTriggers.activate.

    Das System gibt die Job-ID eines einzelnen Auftrags zurück. Sie benötigen diese Job-ID im nächsten Schritt.

  3. Senden Sie Daten an den Job, indem Sie projects.locations.dlpJobs.hybridInspect aufrufen.

    In diesem Fall senden Sie die Daten an den Job und nicht an den Job-Trigger. Mit diesem Ansatz können Sie steuern, wie die Daten partitioniert werden, die Sie zur Prüfung senden. Wenn Sie der aktuellen Partition weitere Daten zur Prüfung hinzufügen möchten, wiederholen Sie diesen Schritt.

  4. Nachdem Sie Daten an den Job gesendet haben, rufen Sie die Methode projects.locations.dlpJobs.finish auf.

    Der Schutz sensibler Daten führt die in der projects.locations.jobTriggers.create-Anfrage angegebenen Aktionen aus.

  5. Wenn Sie einen weiteren Job für die nächste Partition erstellen möchten, aktivieren Sie den Job-Trigger noch einmal und senden Sie die Daten dann an den resultierenden Job.

Traffic von einem Proxy überwachen

Überwachen Sie den Traffic von einem Proxy, der zwischen zwei benutzerdefinierten Anwendungen installiert ist.

  1. Erstellen Sie einen Hybridjob-Trigger mit der Google Cloud Console oder der DLP API.

  2. Aktivieren Sie den Job-Trigger durch Aufrufen der Methode projects.locations.jobTriggers.activate.

  3. Senden Sie Daten an den Job-Trigger, indem Sie projects.locations.jobTriggers.hybridInspect aufrufen. Wenn Sie weitere Daten untersuchen möchten, wiederholen Sie diesen Schritt so oft wie nötig.

    Sie können diese Anfrage für den gesamten Netzwerkverkehr unbegrenzt aufrufen. In jeder Anfrage müssen Metadaten enthalten sein.

In diesem Fall müssen Sie die Methode projects.locations.dlpJobs.finish nicht aufrufen. Der Schutz sensibler Daten partitioniert die von Ihnen gesendeten Daten automatisch. Solange der Job-Trigger aktiv ist, führt der Schutz sensibler Daten am Ende jedes Tages die Aktionen aus, die Sie beim Erstellen des Hybrid-Job-Triggers angegeben haben.

Nächste Schritte