Cloud Data Loss Prevention (Cloud DLP) ora fa parte di Sensitive Data Protection. Il nome dell'API rimane invariato: API Cloud Data Loss Prevention (API DLP). Per informazioni sui servizi che compongono Sensitive Data Protection, consulta la panoramica di Sensitive Data Protection.

Questa pagina è stata tradotta dall'API Cloud Translation.

Ispezionare i dati da origini esterne utilizzando i job ibridi

Questo argomento descrive come utilizzare i job ibridi e gli trigger di job ibridi per verificare la presenza di informazioni sensibili nei dati esterni. Per scoprire di più sui job ibridi e sugli trigger di job ibridi, inclusi esempi di ambienti ibridi, consulta Job ibridi e trigger di job ibridi.

Introduzione ai job ibridi e agli trigger di job ibridi

I job ibridi e gli attivatori dei job ibridi ti consentono di ampliare l'ambito della protezione offerta da Sensitive Data Protection oltre le semplici richieste di ispezione dei contenuti e la scansione del repository dello spazio di archiviazione Google Cloud. Utilizzando i job ibridi e gli attivatori dei job ibridi, puoi eseguire lo streaming dei dati da quasi qualsiasi origine, anche esterna a Google Cloud, direttamente in Sensitive Data Protection e consentire a Sensitive Data Protection di verificare la presenza di informazioni sensibili. Sensitive Data Protection salva e aggrega automaticamente i risultati della scansione per ulteriori analisi.

Confronto tra job ibridi e trigger di job ibridi

Quando crei job ibridi, questi vengono eseguiti finché non li interrompi. Accettano tutti i dati in arrivo a condizione che siano instradati e formattati correttamente.

Gli attivatori di job ibridi funzionano in modo simile ai job ibridi, ma non è necessario interrompere esplicitamente un job all'interno di un attivatore di job ibrido. La funzionalità Protezione dei dati sensibili interrompe automaticamente i job all'interno degli trigger di job ibridi alla fine di ogni giorno.

Inoltre, con un attivatore di job ibrida, puoi interrompere e avviare nuovi job all'interno dell'attivatore senza dover riconfigurare le richieste hybridInspect. Ad esempio, puoi inviare dati a un attivatore di job ibrida, quindi interrompere il job attivo, modificarne la configurazione, avviare un nuovo job all'interno dell'attivatore e continuare a inviare dati allo stesso attivatore.

Per ulteriori indicazioni su quale opzione è adatta al tuo caso d'uso, consulta Scenari di ispezione ibrida tipici in questa pagina.

Definizione dei termini

Questo argomento utilizza i seguenti termini:

Dati esterni: dati archiviati al di fuori di Google Cloud o dati che la Protezione dei dati sensibili non supporta in modo nativo.
Job ibrido: un job di ispezione configurato per eseguire la scansione dei dati da praticamente qualsiasi origine.
Trigger di job ibrido: un trigger di job configurato per eseguire la scansione dei dati da praticamente qualsiasi origine.
Richiesta hybridInspect: una richiesta contenente i dati esterni che vuoi esaminare. Quando invii questa richiesta, specifica il job ibrido o l'attivatore del job ibrido a cui inviare la richiesta.

Per informazioni generali su job e trigger di job, consulta Job e trigger di job.

Procedura di ispezione ibrida

La procedura di ispezione ibrida prevede tre passaggi.

Scegli i dati che vuoi inviare a Sensitive Data Protection.

I dati possono provenire dall'interno o dall'esterno di Google Cloud. Ad esempio, puoi configurare uno script o un'applicazione personalizzata per inviare dati a Sensitive Data Protection, in modo da ispezionarli in tempo reale, da un altro servizio cloud, da un repository di dati on-premise o da qualsiasi altra fonte di dati.
Configura un job ibrido o un trigger di job ibrido in Sensitive Data Protection da zero o utilizzando un modello di ispezione.

Dopo aver configurato un job o un trigger di job ibrido, Sensitive Data Protection ascolta attivamente i dati che gli vengono inviati. Quando lo script o l'applicazione personalizzata invia dati a questo trigger o job ibrido, i dati vengono controllati e i risultati archiviati in base alla configurazione.

Quando configuri il job ibrido o l'attivatore di job ibrido, puoi specificare dove salvare o pubblicare i risultati. Le opzioni includono il salvataggio in BigQuery e la pubblicazione di notifiche su Pub/Sub, Cloud Monitoring o email.
Invia una richiesta hybridInspect al job ibrido o all'attivatore di job ibrido.

Una richiesta hybridInspect contiene i dati da scansionare. Nella richiesta, includere i metadati (chiamati anche etichette e identificatori di tabelle) che descrivono i contenuti e consentono a Sensitive Data Protection di identificare le informazioni che vuoi monitorare. Ad esempio, se stai eseguendo la scansione di dati correlati in più richieste (ad esempio righe nella stessa tabella di database), puoi utilizzare gli stessi metadati in queste richieste correlate. Puoi quindi raccogliere, sommare e analizzare i risultati per la tabella del database.

Quando il job ibrido viene eseguito e ispeziona le richieste, i risultati dell'ispezione sono disponibili quando Sensitive Data Protection li genera. Al contrario, le azioni, come le notifiche Pub/Sub, non si verificano finché l'applicazione non termina il job ibrido.

Diagramma che mostra la procedura di ispezione dei job ibridi

Considerazioni

Quando utilizzi job ibridi e trigger di job, tieni presente i seguenti punti:

I job ibridi e gli trigger di job ibridi non supportano il filtraggio e il campionamento.
I job e gli attivatori dei job non sono soggetti agli obiettivi del livello di servizio (SLO), ma esistono passaggi che puoi seguire per ridurre la latenza. Per ulteriori informazioni, consulta Latenza del job.

Prima di iniziare

Prima di configurare e utilizzare job ibride o attivatori di job ibride, assicurati di aver eseguito quanto segue:

Crea un nuovo progetto, abilita la fatturazione e Sensitive Data Protection

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

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

Go to project selector

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

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

Go to project selector

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

Enable the Sensitive Data Protection API.
Enable the API

Configurare l'origine dati

Prima che Sensitive Data Protection possa ispezionare i tuoi dati, devi inviarli a Sensitive Data Protection. Indipendentemente dal metodo utilizzato per configurare il job ibrido o l'attivatore del job ibrido, devi configurare l'origine esterna per inviare dati all'API DLP.

Per informazioni sul formato richiesto per le richieste di ispezione ibrida, consulta Formattazione degli elementi di contenuti ibridi. Per informazioni sui tipi di metadati che puoi includere con i dati nella richiesta, consulta Tipi di metadati che puoi fornire.

Creare un job ibrido o un trigger di job ibrido

Per consentire a Sensitive Data Protection di ispezionare i dati che le invii, devi prima configurare un job ibrido o un trigger di job ibrido. Per informazioni su quale creare, consulta Scenari di ispezione ibrida tipici in questa pagina.

Console

Nella console Google Cloud, vai alla pagina Crea job o trigger job:

Vai a Crea job o trigger di job

Le sezioni seguenti descrivono come compilare le sezioni della pagina Crea job o trigger di job pertinenti alle operazioni di ispezione ibrida.

Scegli dati di input

In questa sezione specifichi i dati di input da esaminare con Sensitive Data Protection.

(Facoltativo) In Nome, assegna un nome al job inserendo un valore nel campo ID job. Se lasci vuoto questo campo, Sensitive Data Protection genererà automaticamente un identificatore.
(Facoltativo) Nel menu Posizione della risorsa, scegli la regione in cui vuoi archiviare il job ibrida o l'attivatore del job ibrida. Per ulteriori informazioni, consulta Specificare le località di elaborazione.
In Tipo di archiviazione, seleziona Ibrida.
(Facoltativo) In Descrizione, descrivi il job ibrido o l'attivatore del job ibrido che stai creando. Ad esempio, puoi includere informazioni sull'origine dei dati da ispezionare.
(Facoltativo) Per Etichette obbligatorie, fai clic su Aggiungi etichetta e inserisci un'etichetta che vuoi richiedere dalle richieste hybridInspect. Una richiesta hybridInspect che non specifica questa etichetta non viene elaborata da questo jobibrido o dall'attivatore del jobibrido. Puoi aggiungere fino a 10 etichette obbligatorie. Per ulteriori informazioni, consulta la sezione Richiedi etichette dalle richieste hybridInspect in questa pagina.
(Facoltativo) Per Etichette facoltative, inserisci eventuali coppie chiave-valore da associare ai risultati di tutte le richieste hybridInspect inviate a questo job o all'attivatore del job. Puoi aggiungere fino a 10 etichette facoltative. Per saperne di più, consulta Etichette facoltative.
(Facoltativo) Per le opzioni relative ai dati tabulari, inserisci il nome del campo della colonna della chiave primaria se prevedi di inviare dati tabulari nelle richieste hybridInspect. Per ulteriori informazioni, consulta Opzioni per i dati tabulari.
Fai clic su Continua.

Configura il rilevamento

In questa sezione specifichi i tipi di dati sensibili per i quali Sensitive Data Protection esaminerà i dati di input. Le opzioni disponibili sono:

Modello: se hai già creato un modello nel progetto corrente che vuoi utilizzare per definire i parametri di rilevamento di Sensitive Data Protection, fai clic sul campo Nome modello e poi scegli il modello dall'elenco visualizzato.
InfoTypes: Sensitive Data Protection seleziona gli infoType integrati più comuni da rilevare. Per modificare gli infoType o per scegliere un infoType personalizzato da utilizzare, fai clic su Gestisci infoType. Puoi anche perfezionare i criteri di rilevamento nelle sezioni Regole di ispezione e Soglia di confidenza. Per maggiori dettagli, vedi Configurare il rilevamento.

Dopo aver configurato i parametri di rilevamento, fai clic su Continua.

Aggiungi azioni

In questa sezione puoi specificare dove salvare i risultati di ogni scansione di ispezione e se ricevere una notifica via email o un messaggio di notifica Pub/Sub ogni volta che una scansione è completata. Se non salvi i risultati in BigQuery, i risultati della scansione conterranno solo le statistiche sul numero e sugli infoType dei risultati.

Salva in BigQuery: ogni volta che viene eseguita una scansione, Sensitive Data Protection salva i risultati della scansione nella tabella BigQuery specificata qui. Se non specifichi un ID tabella, BigQuery assegnerà un nome predefinito a una nuova tabella la prima volta che viene eseguita la scansione. Se specifichi una tabella esistente, Sensitive Data Protection vi aggiunge i risultati della scansione.
Pubblica in Pub/Sub: al termine di un job, verrà emesso un messaggio Pub/Sub.

Nota: se si verificano problemi di configurazione o autorizzazione con l'argomento Pub/Sub, la Protezione dei dati sensibili riprova a inviare la notifica Pub/Sub per un massimo di due settimane. Dopo due settimane, la notifica viene eliminata.
Invia una notifica via email: al termine di un job, verrà inviato un messaggio email.
Pubblica su Cloud Monitoring: al termine di un job, i relativi risultati verranno pubblicati in Monitoring.

Dopo aver scelto le azioni, fai clic su Continua.

Pianificazione

In questa sezione puoi specificare se creare un singolo job che viene eseguito immediatamente o un trigger di job che viene eseguito ogni volta che Sensitive Data Protection riceve dati formattati e instradati correttamente.

Esegui una di queste operazioni:

Per eseguire immediatamente il job ibrido, scegli Nessun (esegui il job solo per una volta immediatamente dopo la creazione).
Per configurare il job in modo che i dati ricevuti dall'origine lo attivino, scegli Crea un trigger per eseguire il job su base periodica.

Gli trigger di job ibridi aggregano le chiamate API, per consentirti di visualizzare risultati e tendenze nel tempo.

Per ulteriori informazioni, consulta Confronto tra job ibridi e trigger di job ibridi.

Rivedi

Puoi esaminare un riepilogo JSON della scansione qui. Assicurati di annotare il nome dell'oggetto o dell'attivatore di job ibrida. Queste informazioni sono necessarie per inviare i dati a Sensitive Data Protection per l'ispezione.

Dopo aver esaminato il riepilogo JSON, fai clic su Crea.

Sensitive Data Protection avvia immediatamente il job ibrido o l'trigger del job ibrido. Un'analisi di ispezione viene avviata quando invii una hybridInspect richiesta a questo job ibrido o a questo trigger di job ibrido.

API

Un job è rappresentato nell'API DLP dalla risorsa DlpJobs. Per creare un job ibrido, chiama il metodo projects.locations.dlpJobs.create.

Un attivatore di job è rappresentato nell'API DLP dalla risorsa JobTrigger. Per creare un attivatore di job ibrido, chiama il metodo projects.locations.jobTriggers.create.

L'oggetto DlpJobs o JobTrigger che crei deve avere le seguenti impostazioni:

Nel campo inspectJob, imposta un oggetto InspectJobConfig.
Nell'oggetto InspectJobConfig, nel campo storageConfig, imposta un oggetto StorageConfig.
Nell'oggetto StorageConfig, nel campo hybridOptions, imposta un oggetto HybridOptions. Questo oggetto contiene i metadati relativi ai dati che vuoi esaminare.
Nell'oggetto InspectJobConfig, nel campo actions, aggiungi eventuali azioni (Action) che vuoi che Sensitive Data Protection esegua al termine di ogni job.

Le azioni publishSummaryToCscc e publishFindingsToCloudDataCatalog non sono supportate per questa operazione. Per ulteriori informazioni sulle azioni, consulta Azioni.
Specifica cosa cercare e come eseguire la ricerca effettuando una o entrambe le seguenti operazioni:
- Imposta il campo inspectTemplateName sul nome completo della risorsa di un modello di ispezione che vuoi utilizzare, se disponibile.
- Imposta il campo inspectConfig.
Se imposti entrambi i campi inspectTemplateName e inspectConfig, le relative impostazioni vengono combinate.

Informazioni sugli esempi JSON

Le seguenti schede contengono esempi di JSON che puoi inviare a Sensitive Data Protection per creare un job ibrido o un trigger per job ibrido. Questi esempi di job ibridi e trigger di job ibridi sono configurati per eseguire le seguenti operazioni:

Elabora qualsiasi richiesta hybridInspect se ha l'etichetta appointment-bookings-comments.
Scansiona i contenuti della richiesta hybridInspect per trovare gli indirizzi email.
Attacca l'etichetta "env": "prod" ai risultati.
Per i dati tabulari, ottieni il valore della cella nella colonna booking_id (la chiave primaria) che si trova nella stessa riga della cella in cui sono stati trovati i dati sensibili. Sensitive Data Protection associa questo identificatore al rilevamento, in modo da poter risalire alla riga specifica da cui proviene.
Invia un'email quando il job si interrompe. L'email viene inviata ai proprietari del progetto IAM e ai Contatti fondamentali tecnici.
Invia i risultati a Cloud Monitoring quando il job viene interrotto.

Per visualizzare gli esempi JSON, consulta le seguenti schede.

Job ibrido

Questa scheda contiene un esempio JSON che puoi utilizzare per creare un job ibrido.

Per creare un job ibrido, invia una richiesta POST al seguente endpoint.

Metodo HTTP e URL

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

Sostituisci quanto segue:

PROJECT_ID: il ID del progetto dove vuoi archiviare il job ibrido.
REGION: la regione geografica in cui vuoi archiviare il job ibrido.

Input JSON

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

Output JSON

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

Sensitive Data Protection crea il job ibrido e genera un ID job. In questo esempio, l'ID job è i-postgresql-table-comments. Prendi nota dell'ID job. Ti servirà nella richiesta hybridInspect.

Per interrompere un job ibrido, devi chiamare esplicitamente il metodo projects.locations.dlpJobs.finish. L'API DLP non interrompe automaticamente i job ibridi. Al contrario, l'API DLP interrompe automaticamente i job all'interno degli attivatori dei job ibridi alla fine di ogni giorno.

Trigger job ibrido

Questa scheda contiene un esempio JSON che puoi utilizzare per creare un attivatore di job ibrido.

Per creare un trigger di job ibrida, invia una richiesta POST al seguente endpoint.

Metodo HTTP e URL

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

Sostituisci quanto segue:

PROJECT_ID: il ID del progetto dove vuoi archiviare l'attivatore dei job ibridi.
REGION: la regione geografica in cui vuoi archiviare l'attivatore dei job ibridi.

Input JSON

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

Output JSON

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

Sensitive Data Protection crea l'attivatore del job ibrido. L'output contiene il nome dell'attivatore del job ibrido. In questo esempio, è postgresql-table-comments. Prendi nota del nome. Ti servirà nella richiestahybridInspect.

A differenza dei job ibridi, l'API DLP interrompe automaticamente i job all'interno degli attivatori dei job ibridi alla fine di ogni giorno. Pertanto, non è necessario chiamare esplicitamente il metodo projects.locations.dlpJobs.finish.

Quando crei un job ibrido o un trigger di job ibrido, puoi utilizzare Explorer API rispettivamente nelle seguenti pagine di riferimento dell'API:

Nel campo Parametri di richiesta, inserisci projects/PROJECT_ID/locations/REGION. Quindi, nel campo Testo della richiesta, incolla il JSON di esempio per l'oggetto che stai tentando di creare.

Una richiesta andata a buon fine, anche se creata in Esplora API, genera un job ibrido o un attivatore di job ibrido.

Per informazioni generali sull'utilizzo di JSON per inviare richieste all'API DLP, consulta la guida introduttiva JSON.

Invia i dati al job ibrido o all'trigger di job ibrido

Per ispezionare i dati, devi inviare una richiesta hybridInspect, nel formato corretto, a un job ibrido o a un trigger di job ibrido.

Formattazione degli elementi di contenuti ibridi

Di seguito è riportato un semplice esempio di richiesta hybridInspect inviata a Sensitive Data Protection per l'elaborazione da parte di un job ibrido o di un trigger di job ibrido. Tieni presente la struttura dell'oggetto JSON, incluso il campo hybridItem, che contiene i seguenti campi:

item: contiene i contenuti effettivi da ispezionare.
findingDetails: contiene i metadati da associare ai contenuti.

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

Per informazioni complete sui contenuti degli elementi di ispezione ibrida, consulta i contenuti di riferimento dell'API per l'oggetto HybridContentItem.

Endpoint di ispezione ibrida

Affinché i dati vengano ispezionati utilizzando un job ibrido o un trigger di job ibrido, devi inviare una richiesta hybridInspect all'endpoint corretto.

Metodo HTTP e URL per i job ibridi

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

Per ulteriori informazioni su questo endpoint, consulta la pagina di riferimento dell'API per il metodo projects.locations.dlpJobs.hybridInspect.

Metodo HTTP e URL per gli attivatori dei job ibridi

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

Per ulteriori informazioni su questo endpoint, consulta la pagina di riferimento dell'API per il metodo projects.locations.jobTriggers.hybridInspect.

Sostituisci quanto segue:

PROJECT_ID: il tuo identificatore progetto.
REGION: la regione geografica in cui vuoi archiviare la richiesta hybridInspect. Questa regione deve essere uguale a quella del job ibrido.
JOB_ID: l'ID assegnato al job ibrido, con prefisso i-.

Per cercare l'ID job, in Protezione dei dati sensibili, fai clic su Ispezione > Ispeziona job.
TRIGGER_NAME: il nome che hai assegnato all'attivatore dei job ibridi.

Per cercare il nome dell'attivatore del job, in Sensitive Data Protection, fai clic su Ispezione > Trigger job.

Richiedere etichette dalle richieste `hybridInspect`

Se vuoi controllare quali hybridInspect richieste possono essere elaborate da un job ibrido o da un attivatore di job ibrido, puoi impostare le etichette obbligatorie. Eventuali hybridInspect richieste per il job ibrido o l'attivatore di job ibrido che non includono queste etichette obbligatorie vengono rifiutate.

Per impostare un'etichetta obbligatoria:

Quando crei il job ibrido o l'attivatore del job ibrido, imposta il requiredFindingLabelKeys su un elenco di etichette obbligatorie.

L'esempio seguente imposta appointment-bookings-comments come etichetta obbligatoria in un job ibrido o in un trigger di job ibrido.
```
"hybridOptions": {
  ...
  "requiredFindingLabelKeys": [
    "appointment-bookings-comments"
  ],
  "labels": {
    "env": "prod"
  },
  ...
}
```

Nella richiesta hybridInspect, nel campo labels, aggiungi ogni etichetta richiesta come chiave in una coppia chiave-valore. Il valore corrispondente può essere una stringa vuota.

L'esempio seguente imposta l'etichetta obbligatoria appointment-bookings-comments in una richiesta hybridInspect.

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

Se non includi l'etichetta richiesta nella richiesta hybridInspect, viene visualizzato un messaggio di errore simile al seguente:

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

Esempio di codice: crea un trigger di job ibrido e inviavi i dati

C#

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

Per autenticarti a Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.


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

Per scoprire come installare e utilizzare la libreria client per Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection.

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

Scenari di ispezione ibrida tipici

Le sezioni seguenti descrivono gli utilizzi tipici dell'ispezione ibrida e i relativi flussi di lavoro.

Eseguire una scansione una tantum

Esegui una scansione una tantum di un database esterno a Google Cloud nell'ambito di un controllo a campione trimestrale dei database.

Crea un job ibrido utilizzando la console Google Cloud o l'API DLP.
Invia i dati al job chiamando projects.locations.dlpJobs.hybridInspect. Se vuoi esaminare altri dati, ripeti questo passaggio tutte le volte necessarie.
Dopo aver inviato i dati per l'ispezione, chiama il metodo projects.locations.dlpJobs.finish.

Sensitive Data Protection esegue le azioni specificate nella richiestaprojects.locations.dlpJobs.create.

Configurare il monitoraggio continuo

Monitora tutti i nuovi contenuti aggiunti quotidianamente a un database che Sensitive Data Protection non supporta in modo nativo.

Crea un attivatore di job ibrida utilizzando la console Google Cloud o l'API DLP.
Attiva l'attivatore del job chiamando il metodo projects.locations.jobTriggers.activate.
Invia i dati all'attivatore del job chiamando projects.locations.jobTriggers.hybridInspect. Se vuoi esaminare altri dati, ripeti questo passaggio tutte le volte necessarie.

In questo caso, non è necessario chiamare il metodo projects.locations.dlpJobs.finish. Sensitive Data Protection partiziona automaticamente i dati che invii. Finché l'attivatore del job è attivo, al termine di ogni giorno Sensitive Data Protection esegue le azioni specificate quando hai creato l'attivatore del job ibrida.

Scansionare i dati in entrata in un database

Esegui la scansione dei dati in entrata in un database, controllando al contempo il modo in cui vengono suddivisi. Ogni job in un attivatore di job è una singola partizione.

Crea un attivatore di job ibrida utilizzando la console Google Cloud o l'API DLP.
Attiva l'attivatore del job chiamando il metodo projects.locations.jobTriggers.activate.

Il sistema restituisce l'ID di un singolo job. Ti servirà questo ID job nel passaggio successivo.
Invia i dati al job chiamando projects.locations.dlpJobs.hybridInspect.

In questo caso, invii i dati al job anziché all'attivatore del job. Questo approccio ti consente di controllare la modalità di partizione dei dati inviati per l'ispezione. Se vuoi aggiungere altri dati da ispezionare nella partizione corrente, ripeti questo passaggio.
Dopo aver inviato i dati al job, chiama il metodo projects.locations.dlpJobs.finish.

Sensitive Data Protection esegue le azioni specificate nella richiestaprojects.locations.jobTriggers.create.
Se vuoi creare un altro job per la partizione successiva, attiva di nuovo l'attivatore del job e poi invia i dati al job risultante.

Monitorare il traffico da un proxy

Monitora il traffico da un proxy installato tra due applicazioni personalizzate.

Crea un attivatore di job ibrida utilizzando la console Google Cloud o l'API DLP.
Attiva l'attivatore del job chiamando il metodo projects.locations.jobTriggers.activate.
Invia i dati all'attivatore del job chiamando projects.locations.jobTriggers.hybridInspect. Se vuoi esaminare altri dati, ripeti questo passaggio tutte le volte necessarie.

Puoi chiamare questa richiesta a tempo indeterminato per tutto il traffico di rete. Assicurati di includere i metadati in ogni richiesta.

Passaggi successivi

Scopri di più su come funzionano i job ibridi e gli trigger di job ibridi.

Ispezionare i dati da origini esterne utilizzando i job ibridi

Introduzione ai job ibridi e agli trigger di job ibridi

Confronto tra job ibridi e trigger di job ibridi

Definizione dei termini

Procedura di ispezione ibrida

Considerazioni

Prima di iniziare

Crea un nuovo progetto, abilita la fatturazione e Sensitive Data Protection

Configurare l'origine dati

Creare un job ibrido o un trigger di job ibrido

Console

Scegli dati di input

Configura il rilevamento

Aggiungi azioni

Pianificazione

Rivedi

API

Informazioni sugli esempi JSON

Job ibrido

Trigger job ibrido

Invia i dati al job ibrido o all'trigger di job ibrido

Formattazione degli elementi di contenuti ibridi

Endpoint di ispezione ibrida

Richiedere etichette dalle richieste hybridInspect

Esempio di codice: crea un trigger di job ibrido e inviavi i dati

C#

Go

Java

Node.js

PHP

Python

Scenari di ispezione ibrida tipici

Eseguire una scansione una tantum

Configurare il monitoraggio continuo

Scansionare i dati in entrata in un database

Monitorare il traffico da un proxy

Passaggi successivi

Richiedere etichette dalle richieste `hybridInspect`