Daten aus externen Quellen mit Hybridjobs prüfen

In diesem Thema wird beschrieben, wie Sie mithilfe von Hybridjobs und Hybridjob-Triggern externe Daten auf sensible 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 Hybridjobs und Hybridjob-Trigger

Mit Hybridjobs und Hybridjob-Triggern können Sie den Umfang des Schutzes, den der Schutz sensibler Daten bietet, über einfache Anfragen zur Inhaltsprüfung und Google Cloud Storage-Repository-Scans hinaus erweitern. Mit Hybridjobs und Hybridjob-Triggern können Sie Daten aus praktisch jeder Quelle, einschließlich Quellen außerhalb von Google Cloud, direkt in Sensitive Data Protection streamen, um dann Sensitive Data Protection die Daten auf vertrauliche Informationen prüfen zu lassen. Der Schutz sensibler Daten speichert und aggregiert die Scanergebnisse automatisch zur weiteren Analyse.

Vergleich von Hybridjobs und Hybridjob-Triggern

Wenn Sie Hybridjobs erstellen, werden sie ausgeführt, bis Sie sie beenden. Sie akzeptieren alle eingehenden Daten, solange sie ordnungsgemäß weitergeleitet und formatiert sind.

Hybridjob-Trigger funktionieren ähnlich wie Hybridjobs, aber Sie müssen einen Job innerhalb eines Hybridjob-Triggers nicht explizit beenden. Mit dem Schutz sensibler Daten werden Jobs innerhalb von Hybrid-Job-Triggern am Ende jedes Tages automatisch angehalten.

Außerdem können Sie mit einem Hybridjob-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, dann den aktiven Job anhalten, seine Konfiguration ändern, einen neuen Job innerhalb dieses Triggers starten und dann weiterhin Daten an denselben Trigger senden.

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

Begriffsdefinition

In diesem Thema werden die folgenden Begriffe verwendet:

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

  • Hybridjob: Ein Prüfjob, der so konfiguriert ist, dass Daten aus praktisch jeder Quelle gescannt werden.

  • Hybrid-Job-Trigger: Ein Job-Trigger, der so konfiguriert ist, dass Daten aus praktisch jeder Quelle gescannt werden.

  • hybridInspect-Anfrage: Eine Anfrage, die die externen Daten enthält, die Sie prüfen möchten. Wenn Sie diese Anfrage senden, geben Sie den Hybridjob oder 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 Hybrid-Prüfprozess besteht aus drei Schritten.

  1. Wählen Sie die Daten aus, die an den Schutz sensibler Daten gesendet werden sollen.

    Die Daten können von innerhalb oder außerhalb von Google Cloud stammen. Sie können beispielsweise ein benutzerdefiniertes Skript oder eine benutzerdefinierte Anwendung so konfigurieren, dass Daten an den Schutz sensibler Daten gesendet werden, um Daten während der Übertragung, über einen anderen Clouddienst, ein lokales Daten-Repository oder praktisch jede andere Datenquelle zu prüfen.

  2. Richten Sie einen Hybridjob oder Hybridjob-Trigger in Sensitive Data Protection von Grund auf neu ein oder verwenden Sie eine Inspektionsvorlage.

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

    Wenn Sie den Hybridjob oder den Hybridjob-Trigger 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 die Veröffentlichung von Benachrichtigungen in Pub/Sub, Cloud Monitoring oder E-Mails.

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

    Eine hybridInspect-Anfrage enthält die zu scannenden Daten. Fügen Sie der Anfrage Metadaten hinzu (auch als Labels und Tabellenkennzeichnungen bezeichnet), die den Inhalt beschreiben und es dem Schutz sensibler Daten ermöglichen, die Informationen zu identifizieren, die Sie erfassen möchten. Wenn Sie beispielsweise verwandte Daten über mehrere Anfragen hinweg scannen (z. B. Zeilen in derselben Datenbanktabelle), können Sie in diesen Anfragen dieselben Metadaten verwenden. Anschließend können Sie die Ergebnisse für diese Datenbanktabelle erfassen, zusammenfassen und analysieren.

Während der Hybridjob ausgeführt und geprüft wird, stehen Inspektionsergebnisse zur Verfügung, sobald der Dienst zum Schutz sensibler Daten sie generiert hat. Aktionen wie Pub/Sub-Benachrichtigungen erfolgen dagegen erst, wenn die Anwendung den Hybridjob beendet.

Diagramm zur Darstellung des Hybridjob-Prüfprozesses

Hinweise

Beachten Sie bei der Arbeit mit Hybridjobs und Job-Triggern Folgendes:

  • Für Hybridjobs und Hybridjob-Trigger werden keine Filter und Stichproben unterstützt.
  • Jobs und Jobtrigger unterliegen keinen Service Level Objectives (SLOs). Es gibt jedoch Maßnahmen, mit denen Sie die Latenz reduzieren können. Weitere Informationen finden Sie unter Joblatenz.

Hinweise

Führen Sie vor dem Einrichten und Verwenden von Hybridjobs oder Hybridjob-Triggern folgende Schritte aus:

Neues Projekt erstellen, Abrechnung aktivieren und Schutz sensibler Daten aktivieren

  1. 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.

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

    Go to project selector

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

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

    Go to project selector

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

  6. Enable the Sensitive Data Protection API.

    Enable the API

Datenquelle konfigurieren

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

Informationen zum erforderlichen Format für Hybrid-Prüfungsanfragen finden Sie unter Formatierung von Hybrid-Inhaltselementen. Weitere Informationen zu den Arten von Metadaten, die Sie in die Daten einer Anfrage aufnehmen können, finden Sie unter Arten von Metadaten, die Sie bereitstellen können.

Hybridjob oder Hybridjob-Trigger erstellen

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

Console

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

Zur Seite „Job oder Job-Trigger erstellen“

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

Eingabedaten auswählen

In diesem Abschnitt geben Sie die Eingabedaten an, die vom Schutz sensibler Daten geprüft werden sollen.

  1. Optional: Geben Sie unter Name einen Namen für den Job ein, indem Sie einen Wert in das Feld Job-ID eingeben. Wenn Sie dieses Feld leer lassen, generiert Sensitive Data Protection automatisch eine Kennzeichnung.
  2. Optional: Wählen Sie im Menü Ressourcenstandort die Region aus, in der Sie den Hybridjob oder Hybridjob-Trigger speichern möchten. Weitere Informationen finden Sie unter Verarbeitungsstandorte angeben.

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

  4. Optional: Geben Sie unter Beschreibung eine Beschreibung für den Hybridjob oder Hybridjob-Trigger ein, den Sie erstellen. Sie können beispielsweise Informationen zur 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 für hybridInspect-Anfragen erforderlich sein soll. Eine hybridInspect-Anfrage, in der dieses Label nicht angegeben ist, wird von diesem Hybridjob oder Hybridjob-Trigger nicht verarbeitet. Sie können bis zu 10 erforderliche Labels hinzufügen. Weitere Informationen finden Sie auf dieser Seite unter Labels für hybridInspect-Anfragen anfordern.

  6. Optional: Geben Sie unter Optionale Labels beliebige Schlüssel/Wert-Paare ein, die Sie den Ergebnissen aller hybridInspect-Anfragen an diesen Job oder Jobtrigger anhängen möchten. Sie können bis zu 10 optionale Labels hinzufügen. Weitere Informationen finden Sie unter Optionale Labels.

  7. Optional: Geben Sie unter Tabular Data Options (Optionen für tabellarische Daten) 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, für die der Schutz sensibler Daten die Eingabedaten prüfen soll. Sie haben folgende Optionen:

  • Vorlage: Wenn Sie im aktuellen Projekt bereits eine Vorlage erstellt haben, die Sie zum Definieren der Parameter 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: Der Schutz sensibler Daten wählt die am häufigsten integrierten infoTypes aus, die erkannt werden sollen. Klicken Sie auf Infotypen verwalten, um die Infotypen zu ändern oder einen benutzerdefinierten Infotyp auszuwählen, der verwendet werden soll. Sie können die Erkennungskriterien auch in den Abschnitten Inspektionsregelsätze und Konfidenzschwellenwert optimieren. Weitere Informationen finden Sie unter Erkennung konfigurieren.

Klicken Sie nach der Konfiguration 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 die Ergebnisse nicht in BigQuery speichern, enthalten die Scanergebnisse nur Statistiken zur Anzahl und zu den infoTypes der Ergebnisse.

  • In BigQuery speichern: Bei jeder Ausführung eines Scans speichert der Schutz sensibler Daten Scanergebnisse in der hier angegebenen BigQuery-Tabelle. 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, hängt der Schutz sensibler Daten Scanergebnisse an diese 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.

Klicken Sie nach der Auswahl der Aktionen auf Weiter.

Planen

In diesem Abschnitt geben Sie an, ob ein einzelner Job, der sofort ausgeführt wird, oder ein Job-Trigger erstellt wird, der jedes Mal ausgeführt wird, wenn ordnungsgemäß weitergeleitete und formatierte Daten von Sensitive Data Protection 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.

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

    Hybrid-Job-Trigger aggregieren API-Aufrufe, sodass Sie Ergebnisse und Trends im Laufe der Zeit erkennen 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 Hybridjobs oder Hybridjob-Triggers. Sie benötigen diese Informationen, wenn Sie Daten zur Prüfung an den Schutz sensibler Daten senden.

Klicken Sie nach der Überprüfung der JSON-Zusammenfassung auf Erstellen.

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

API

Jobs werden 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. Um einen Hybridjob-Trigger zu erstellen, rufen Sie die Methode projects.locations.jobTriggers.create auf.

Das von Ihnen 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 Objekt InspectJobConfig im Feld actions alle Aktionen (Action) hinzu, die der Schutz sensibler Daten am Ende jedes Jobs ausführen soll.

    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 gesucht werden soll. Gehen Sie dazu so vor:

    • Legen Sie für das Feld inspectTemplateName den vollständigen Ressourcennamen einer Inspektionsvorlage fest, die Sie verwenden möchten, sofern verfügbar.

    • Legen Sie das Feld inspectConfig fest.

    Wenn Sie sowohl das Feld inspectTemplateName als auch das Feld inspectConfig festlegen, werden die Einstellungen kombiniert.

JSON-Beispiele

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

  • Verarbeite alle hybridInspect-Anfragen, die das Label appointment-bookings-comments haben.
  • Prüfen Sie den Inhalt der hybridInspect-Anfrage auf E-Mail-Adressen.
  • Hängen Sie das Label "env": "prod" an die Ergebnisse an.
  • Rufen Sie für tabellarische Daten den Wert der Zelle in der Spalte booking_id (der Primärschlüssel) ab, die sich in derselben Zeile wie die Zelle befindet, in der die vertraulichen Daten gefunden wurden. Sensitive Data Protection ordnet diese Kennung dem Ergebnis zu, damit Sie es der entsprechenden Zeile zuordnen können.
  • E-Mail senden, wenn der Job beendet wird Die E-Mail wird an IAM-Projektinhaber und wichtige technische Kontakte gesendet.
  • Die Ergebnisse an Cloud Monitoring senden, wenn der Job angehalten wird.

Die JSON-Beispiele finden Sie auf den folgenden Tabs.

Hybride Stelle

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

Senden Sie zum Erstellen eines Hybridjobs eine POST-Anfrage an den folgenden Endpunkt.

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 Region, in der Sie den Hybridjob speichern möchten.

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

Der Dienst zum Schutz sensibler Daten erstellt den Hybridjob und generiert eine Job-ID. In diesem Beispiel lautet die Job-ID i-postgresql-table-comments. Notieren Sie sich die Job-ID. Sie benötigen sie in Ihrer hybridInspect-Anfrage.

Wenn Sie einen Hybridjob beenden möchten, müssen Sie die Methode projects.locations.dlpJobs.finish explizit aufrufen. Die DLP API beendet Hybridjobs nicht automatisch. Im Gegensatz dazu werden Jobs innerhalb von hybriden Job-Triggern mit der DLP API am Ende jedes Tages automatisch beendet.

Hybrid-Job-Trigger

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

Senden Sie zum Erstellen eines Hybridjob-Triggers eine POST-Anfrage an den folgenden Endpunkt.

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

Sensitive Data Protection erstellt den Hybrid-Job-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 werden Jobs innerhalb von Hybrid-Job-Triggern am Ende jedes Tages automatisch von der DLP API beendet. Sie müssen die Methode projects.locations.dlpJobs.finish also nicht explizit aufrufen.

Wenn Sie einen Hybridjob oder einen Hybridjob-Trigger erstellen, können Sie den 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.

Eine erfolgreiche Anfrage, auch wenn sie im APIs Explorer erstellt wurde, erzeugt einen Hybridjob oder einen Hybridjob-Trigger.

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

Daten an den Hybridjob oder Hybridjob-Trigger senden

Wenn Sie Daten prüfen möchten, müssen Sie eine hybridInspect-Anfrage im richtigen Format an einen Hybridjob oder einen Hybridjob-Trigger senden.

Formatierung von Hybrid-Inhaltselementen

Im Folgenden finden Sie ein einfaches Beispiel für eine hybridInspect-Anfrage, die zur Verarbeitung durch einen Hybridjob oder Hybridjob-Trigger an Sensitive Data Protection gesendet wird. Beachten Sie die Struktur des JSON-Objekts, einschließlich des Felds hybridItem, das die folgenden Felder enthält:

  • item: Enthält den eigentlich zu prüfenden Inhalt.
  • 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 der 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 übereinstimmen.

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

    Wenn Sie die Job-ID suchen möchten, klicken Sie unter Schutz sensibler Daten auf Prüfung > Jobs prüfen.

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

    Wenn Sie den Namen des Jobtriggers ermitteln möchten, klicken Sie unter Schutz sensibler Daten auf Prüfung > Jobtrigger.

Labels für hybridInspect-Anfragen erforderlich machen

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

So legen Sie ein Pflichtlabel fest:

  1. Legen Sie beim Erstellen des Hybridjobs oder Hybridjob-Triggers im Feld requiredFindingLabelKeys 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 hinzu. 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 aufnehmen, 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: Hybridjob-Trigger erstellen und Daten an ihn 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection 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 die Standardanmeldedaten für Anwendungen ein, um sich bei Sensitive Data Protection 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 Hybridprüfungsszenarien

In den folgenden Abschnitten werden typische Anwendungsfälle für die hybride Prüfung und die entsprechenden Workflows beschrieben.

Einmal-Scan durchführen

Sie möchten einen einmaligen Scan einer Datenbank außerhalb von Google Cloud im Rahmen einer vierteljährlichen Prüfung von Datenbanken ausführen.

  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 prüfen möchten, wiederholen Sie diesen Schritt so oft wie nötig.

  3. Rufen Sie nach dem Senden der Daten zur Überprüfung die Methode projects.locations.dlpJobs.finish auf.

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

Kontinuierliches Monitoring konfigurieren

Alle neuen Inhalte überwachen, die täglich einer Datenbank hinzugefügt werden, die Sensitive Data Protection nicht nativ unterstützt

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

  2. Aktivieren Sie den Jobtrigger, indem Sie die Methode projects.locations.jobTriggers.activate aufrufen.

  3. Senden Sie Daten an den Job-Trigger, indem Sie projects.locations.jobTriggers.hybridInspect aufrufen. Wenn Sie weitere Daten prüfen 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. Mit Sensitive Data Protection werden die von Ihnen gesendeten Daten automatisch partitioniert. 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.

Daten scannen, die in eine Datenbank aufgenommen werden

Daten scannen, die in eine Datenbank eingehen, und dabei steuern, wie die Daten partitioniert werden. Jeder Job in einem Jobtrigger ist eine einzelne Partition.

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

  2. Aktivieren Sie den Jobtrigger, indem Sie die Methode projects.locations.jobTriggers.activate aufrufen.

    Das System gibt die Job-ID eines einzelnen Jobs 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. So können Sie festlegen, wie die Daten, die Sie zur Prüfung senden, partitioniert werden. Wenn Sie der aktuellen Partition weitere Daten zur Prüfung hinzufügen möchten, wiederholen Sie diesen Schritt.

  4. Rufen Sie nach dem Senden von Daten an den Job die Methode projects.locations.dlpJobs.finish auf.

    Der Schutz sensibler Daten führt die in Ihrer 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 Jobtrigger noch einmal und senden Sie die Daten an den resultierenden Job.

Traffic über einen Proxy überwachen

Traffic von einem Proxy überwachen, der zwischen zwei benutzerdefinierten Anwendungen installiert ist

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

  2. Aktivieren Sie den Jobtrigger, indem Sie die Methode projects.locations.jobTriggers.activate aufrufen.

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

    Sie können diese Anfrage unbegrenzt für den gesamten Netzwerkverkehr aufrufen. Fügen Sie jeder Anfrage Metadaten hinzu.

In diesem Fall müssen Sie die Methode projects.locations.dlpJobs.finish nicht aufrufen. Mit Sensitive Data Protection werden die von Ihnen gesendeten Daten automatisch partitioniert. 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