Ispeziona i dati da origini esterne utilizzando job ibridi

Questo argomento descrive come utilizzare i job ibridi e i trigger di job ibridi per ispezionare i dati esterni alla ricerca di informazioni sensibili. Per scoprire di più sui job ibridi e sui trigger di job ibridi, inclusi esempi di ambienti ibridi, consulta Job ibridi e trigger di job ibridi.

Introduzione ai job ibridi e ai trigger di job ibridi

I job ibridi e i trigger di job ibridi consentono di ampliare l'ambito di protezione offerto da Sensitive Data Protection oltre le semplici richieste di ispezione dei contenuti e la analisi dei repository di archiviazione di Google Cloud. Con i job ibridi e i trigger di job ibridi, puoi trasmettere il flusso di dati praticamente da qualsiasi origine, anche esterna a Google Cloud, direttamente a Sensitive Data Protection e consentire a Sensitive Data Protection di ispezionare i dati per individuare 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

I job ibridi creati vengono eseguiti finché non li interrompi. Accetta tutti i dati in entrata, purché vengano indirizzati e formattati correttamente.

I trigger di job ibridi funzionano in modo simile ai job ibridi, ma non è necessario arrestare esplicitamente un job all'interno di un trigger di job ibrido. Sensitive Data Protection interrompe automaticamente i job all'interno di trigger di job ibridi alla fine di ogni giornata.

Inoltre, con un trigger di job ibrido puoi arrestare e avviare nuovi job all'interno del trigger senza dover riconfigurare le richieste hybridInspect. Ad esempio, puoi inviare dati a un trigger di job ibrido, quindi arrestare il job attivo, modificarne la configurazione, avviare un nuovo job all'interno di quel trigger e continuare a inviare dati allo stesso trigger.

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

Definizione dei termini

In questo argomento vengono utilizzati i seguenti termini:

• Dati esterni: dati archiviati all'esterno di Google Cloud o dati che Sensitive Data Protection non supporta in modo nativo.

• Job ibrido: un job di ispezione configurato per eseguire la scansione dei dati praticamente da qualsiasi origine.

• Trigger di job ibrido: un trigger di job configurato per eseguire la scansione dei dati praticamente da qualsiasi origine.

• Richiesta hybridInspect: una richiesta contenente i dati esterni da esaminare. Quando invii questa richiesta, specifichi il trigger del job ibrido o del job ibrido a cui inviarla.

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

Processo di ispezione ibrido

La procedura di ispezione ibrida prevede tre passaggi.

1. 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 personalizzati per inviare dati a Sensitive Data Protection, in modo da ispezionare i dati in corso, da un altro servizio cloud, da un repository di dati on-premise o praticamente da qualsiasi altra origine dati.

2. Configura un job ibrido o un trigger di job ibrido in Sensitive Data Protection da scratch o utilizzando un modello di ispezione.

   Dopo aver configurato un trigger di job ibrido o ibrido, Sensitive Data Protection rimane in ascolto dei dati inviati. Quando lo script o l'applicazione personalizzati invia dati a questo trigger di job ibrido o ibrido, i dati vengono ispezionati e i relativi risultati vengono archiviati in base alla configurazione.

   Quando configuri il trigger di job ibrido o ibrido, puoi specificare dove vuoi salvare o pubblicare i risultati. Le opzioni includono il salvataggio in BigQuery e la pubblicazione delle notifiche in Pub/Sub, Cloud Monitoring o email.

3. Invia una richiesta hybridInspect al trigger di job ibrido o ibrido.

   Una richiesta hybridInspect contiene i dati da scansionare. Nella richiesta, includi i metadati (noti anche come etichette e identificatori di tabella) che descrivono i contenuti e consentono a Sensitive Data Protection di identificare le informazioni che vuoi monitorare. Ad esempio, se analizzi dati correlati in più richieste (ad esempio righe nella stessa tabella di database), puoi utilizzare gli stessi metadati nelle richieste correlate. Puoi quindi raccogliere, conteggiare e analizzare i risultati per la tabella di database.

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

Nota: in caso di problemi di configurazione o di autorizzazione per l'argomento Pub/Sub, Sensitive Data Protection prova a inviare di nuovo la notifica Pub/Sub per un massimo di due settimane. Dopo due settimane, la notifica viene eliminata.

Considerazioni

Quando lavori con job ibridi e trigger di job, considera i seguenti punti:

• I job ibridi e i trigger di job ibridi non supportano i filtri e il campionamento.
• I job e i trigger di job non sono soggetti agli obiettivi del livello di servizio (SLO), ma puoi intraprendere alcune azioni per ridurre la latenza. Per ulteriori informazioni, consulta Latenza del job.

Prima di iniziare

Prima di configurare e utilizzare job ibridi o trigger di job ibridi, assicurati di aver eseguito le seguenti operazioni:

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

1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.

2. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

4. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

5. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

6. Attiva l'API Sensitive Data Protection.

   Abilita l'API

Configurare l'origine dati

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

Per informazioni sul formato richiesto per le richieste di ispezione ibride, consulta Formattazione di 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.

Crea un trigger di job ibrido o ibrido

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

Console

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

Vai a Crea job o trigger di job

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

Scegli dati di input

In questa sezione, specificherai i dati di input che Sensitive Data Protection deve esaminare.

1. (Facoltativo) In Nome, assegna un nome al job inserendo un valore nel campo ID job. Se lasci vuoto questo campo, Sensitive Data Protection genera automaticamente un identificatore.
2. (Facoltativo) Dal menu Località della risorsa, scegli la regione in cui vuoi archiviare il trigger di job ibrido o ibrido. Per ulteriori informazioni, consulta la sezione Specifica delle località di elaborazione.

3. Per Tipo di archiviazione, seleziona Ibrido.

4. (Facoltativo) In Descrizione, descrivi il job ibrido o il trigger di job ibrido che stai creando. Ad esempio, puoi includere informazioni sulla fonte dei dati da ispezionare.

5. (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 job ibrido o trigger di job ibrido. Puoi aggiungere fino a 10 etichette obbligatorie. Per ulteriori informazioni, consulta Richiedere etichette per le richieste hybridInspect in questa pagina.

6. (Facoltativo) Per Etichette facoltative, inserisci le coppie chiave-valore da associare ai risultati di tutte le richieste hybridInspect inviate a questo job o trigger di job. Puoi aggiungere fino a 10 etichette facoltative. Per maggiori informazioni, consulta Etichette facoltative.

7. (Facoltativo) Per Opzioni per i dati tabulari, inserisci il nome del campo della colonna della chiave primaria se prevedi di inviare dati tabulari nelle richieste hybridInspect. Per maggiori informazioni, consulta Opzioni per i dati tabulari.

8. 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, quindi scegli il modello dall'elenco visualizzato.
• InfoTypes: Sensitive Data Protection seleziona gli infoType integrati più comuni da rilevare. Per modificare gli infoType o scegliere un infoType personalizzato da utilizzare, fai clic su Gestisci infoType. Puoi anche perfezionare i criteri di rilevamento nelle sezioni Set di regole di ispezione e Soglia di affidabilità. Per maggiori dettagli, consulta Configurare il rilevamento.

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

Aggiungi azioni

Questa sezione consente di specificare dove salvare i risultati di ogni scansione di ispezione e se ricevere una notifica via email o tramite un messaggio di notifica Pub/Sub al termine di una scansione. Se non salvi i risultati in BigQuery, i risultati della scansione contengono solo statistiche sul numero e sugli infoType dei risultati.

• Salva in BigQuery: ogni volta che viene eseguita una scansione, Sensitive Data Protection salva i risultati dell'analisi 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 aggiunge i risultati dell'analisi.

• Pubblicazione in Pub/Sub: al termine di un job, viene emesso un messaggio Pub/Sub.

  Nota: in caso di problemi di configurazione o di autorizzazione per l'argomento Pub/Sub, Sensitive Data Protection prova a inviare di nuovo la notifica Pub/Sub per un massimo di due settimane. Dopo due settimane, la notifica viene eliminata.

• Notifica via email: al termine di un lavoro, verrà inviato un messaggio email.

• Pubblicazione in Cloud Monitoring: al termine di un job, i 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 da eseguire immediatamente o un trigger di job che viene eseguito ogni volta che Sensitive Data Protection riceve dati instradati e formattati correttamente.

Esegui una di queste operazioni:

• Per eseguire immediatamente il job ibrido, scegli Nessuno (esegui il job una tantum immediatamente al momento della creazione).

• Per configurare il job in modo che i dati ricevuti dall'origine lo attivino, scegli Crea un trigger per eseguire il job in base a una pianificazione periodica.

  I trigger di job ibridi aggregano le chiamate API, consentendoti di visualizzare risultati e tendenze nel tempo.

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

riepilogo

Puoi esaminare un riepilogo JSON della scansione qui. Assicurati di prendere nota del nome del trigger di job ibrido ob o ibrido; queste informazioni sono necessarie quando invii dati a Sensitive Data Protection per l'ispezione.

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

Sensitive Data Protection avvia immediatamente il trigger di job ibrido o ibrido. Una scansione di ispezione viene avviata quando invii una richiesta hybridInspect a questo trigger di job ibrido o ibrido.

API

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

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

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

1. Nel campo inspectJob, imposta un oggetto InspectJobConfig.
2. Nell'oggetto InspectJobConfig, nel campo storageConfig, imposta un oggetto StorageConfig.
3. Nell'oggetto StorageConfig, nel campo hybridOptions, imposta un oggetto HybridOptions. Questo oggetto contiene metadati relativi ai dati che vuoi ispezionare.

4. Nell'oggetto InspectJobConfig, nel campo actions, aggiungi le azioni (Action) che vuoi che Sensitive Data Protection esegua alla fine di ogni job.

   Le azioni publishSummaryToCscc e publishFindingsToCloudDataCatalog non sono supportate per questa operazione. Per ulteriori informazioni sulle azioni, consulta la sezione Azioni.

5. Specifica quali elementi e come eseguire la scansione eseguendo 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 JSON che puoi inviare a Sensitive Data Protection per creare un job ibrido o un attivatore di job ibrido. Questi esempi di trigger di job ibridi e ibridi sono configurati per:

• Elabora qualsiasi richiesta hybridInspect se ha l'etichetta appointment-bookings-comments.
• Esegui la scansione dei contenuti della richiesta hybridInspect per verificare la presenza di indirizzi email.
• Applica 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 risultato, in modo che tu possa tenere traccia del risultato alla riga specifica da cui proviene.
• Invia un'email quando il job termina. L'email va ai proprietari del progetto IAM e ai contatti necessari tecnici.
• Invia i risultati a Cloud Monitoring quando il job viene arrestato.

Per visualizzare gli esempi JSON, vedi le schede seguenti.

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: l'ID del progetto in cui vuoi archiviare il job ibrido.
• REGION: l'area 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 serve nella richiesta hybridInspect.

Per arrestare 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 di trigger di job ibridi alla fine di ogni giornata.

Trigger di job ibrido

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

Per creare un trigger di job ibrido, 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: l'ID del progetto in cui vuoi archiviare il trigger del job ibrido.
• REGION: l'area geografica in cui vuoi archiviare il trigger del job ibrido.

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 il trigger di job ibrido. L'output contiene il nome del trigger del job ibrido. In questo esempio, è postgresql-table-comments. Prendi nota del nome. Ti serve nella richiesta hybridInspect.

A differenza dei job ibridi, l'API DLP interrompe automaticamente i job all'interno dei trigger di job ibridi alla fine di ogni giornata. Pertanto, non devi chiamare esplicitamente il metodo projects.locations.dlpJobs.finish.

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

• projects.locations.dlpJobs.create
• projects.locations.jobTriggers.create

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

Una richiesta andata a buon fine, anche se creata in Explorer API, crea un trigger di job ibrido o ibrido.

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

Invia dati al trigger di job ibrido o ibrido

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

Formattazione di 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 trigger di job ibrido o ibrido. Prendi nota della struttura dell'oggetto JSON, incluso il campo hybridItem, che contiene i seguenti campi:

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

{
  "hybridItem": {
    "item": {
      "value": "My email is [e-mail]"
    },
    "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 ibridi, consulta i contenuti di riferimento API per l'oggetto HybridContentItem.

Endpoint di ispezione ibridi

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 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 API per il metodo projects.locations.dlpJobs.hybridInspect.

Metodo HTTP e URL per trigger di 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 API per il metodo projects.locations.jobTriggers.hybridInspect.

Sostituisci quanto segue:

• PROJECT_ID: l'identificatore del progetto.
• REGION: la regione geografica in cui vuoi archiviare la richiesta hybridInspect. Questa regione deve essere la stessa del job ibrido.

• JOB_ID: l'ID che hai assegnato al job ibrido, preceduto da i-.

  Per cercare l'ID job, in Sensitive Data Protection, fai clic su Ispezione > Ispeziona job.

• TRIGGER_NAME: il nome che hai assegnato al trigger del job ibrido.

  Per cercare il nome del trigger di job, in Sensitive Data Protection fai clic su Ispezione > Trigger di job.

Richiedi etichette da hybridInspect richieste

Se vuoi controllare quali richieste hybridInspect possono essere elaborate da un job ibrido o trigger di job ibrido, puoi impostare le etichette obbligatorie. Qualsiasi richiesta hybridInspect per il trigger di job ibrido o ibrido che non include queste etichette obbligatorie viene rifiutata.

Per impostare un'etichetta obbligatoria:

1. Quando crei il trigger di job ibrido o ibrido, imposta il campo requiredFindingLabelKeys su un elenco di etichette obbligatorie.

   L'esempio seguente imposta appointment-bookings-comments come etichetta obbligatoria in un job ibrido o trigger di job ibrido.

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

2. Nella richiesta hybridInspect, nel campo labels, aggiungi ogni etichetta obbligatoria 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 [e-mail]"
       },
       "findingDetails": {
         "containerDetails": {...},
         "labels": {
           "appointment-bookings-comments": ""
         }
       }
     }
   }
   

Se non includi l'etichetta obbligatoria nella richiesta hybridInspect, viene visualizzato un errore come il 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 a cui inviare dati

Importante: il codice in questa pagina richiede prima la configurazione di un client Sensitive Data Protection. Per saperne di più sull'installazione e sulla creazione di un client Sensitive Data Protection, consulta Librerie client di Sensitive Data Protection. (L'invio di JSON a endpoint REST di Sensitive Data Protection non richiede una libreria client.)

C#

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

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 [e-mail] 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.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 [e-mail]"

	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.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 [e-mail] 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.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

// 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 [e-mail]';

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

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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.

Per eseguire l'autenticazione in Sensitive Data Protection, configura Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

Visualizza su GitHub Feedback

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 tipici di ispezione ibrida

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

Esegui una scansione una tantum

Esegui una scansione una tantum di un database esterno a Google Cloud come parte di un controllo casuale dei database.

1. Crea un job ibrido utilizzando la console Google Cloud o l'API DLP.

2. Invia dati al job chiamando projects.locations.dlpJobs.hybridInspect. Se vuoi esaminare più dati, ripeti questo passaggio tutte le volte necessarie.

3. Dopo aver inviato i dati per l'ispezione, chiama il metodo projects.locations.dlpJobs.finish.

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

Configura il monitoraggio continuo

Monitora tutti i nuovi contenuti aggiunti quotidianamente a un database che la protezione dei dati sensibili non supporta in modo nativo.

1. Crea un trigger di job ibrido utilizzando la console Google Cloud o l'API DLP.

2. Attiva il trigger del job chiamando il metodo projects.locations.jobTriggers.activate.

3. Invia dati al trigger di job chiamando projects.locations.jobTriggers.hybridInspect. Se vuoi esaminare più 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 inviati. Finché il trigger di job è attivo, alla fine di ogni giornata Sensitive Data Protection esegue le azioni che hai specificato al momento della creazione del trigger di job ibrido.

Scansiona i dati in entrata in un database

Esegui la scansione dei dati in entrata in un database e controlla al contempo il partizionamento dei dati. Ogni job in un trigger di job è una singola partizione.

1. Crea un trigger di job ibrido utilizzando la console Google Cloud o l'API DLP.

2. Attiva il trigger del job chiamando il metodo projects.locations.jobTriggers.activate.

   Il sistema restituisce l'ID processo di un singolo job. Questo ID job ti servirà nel passaggio successivo.

3. Invia dati al job chiamando projects.locations.dlpJobs.hybridInspect.

   In questo caso, dovrai inviare i dati al job anziché al trigger del job. Questo approccio consente di controllare la partizionamento dei dati inviati per l'ispezione. Se vuoi aggiungere altri dati per l'ispezione nella partizione corrente, ripeti questo passaggio.

4. Dopo aver inviato i dati al job, chiama il metodo projects.locations.dlpJobs.finish.

   Sensitive Data Protection esegue le azioni specificate nella richiesta projects.locations.jobTriggers.create.

5. Se vuoi creare un altro job per la partizione successiva, attiva di nuovo il trigger di job e invia i dati al job risultante.

Monitorare il traffico da un proxy

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

1. Crea un trigger di job ibrido utilizzando la console Google Cloud o l'API DLP.

2. Attiva il trigger del job chiamando il metodo projects.locations.jobTriggers.activate.

3. Invia dati al trigger di job chiamando projects.locations.jobTriggers.hybridInspect. Se vuoi esaminare più 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.

In questo caso, non è necessario chiamare il metodo projects.locations.dlpJobs.finish. Sensitive Data Protection partiziona automaticamente i dati inviati. Finché il trigger di job è attivo, alla fine di ogni giornata Sensitive Data Protection esegue le azioni che hai specificato al momento della creazione del trigger di job ibrido.

Passaggi successivi

• Scopri di più sul funzionamento dei job ibridi e degli attivatori dei job ibridi.