Ispezionare i dati provenienti da origini esterne utilizzando i job ibridi

Questo argomento descrive come utilizzare i job ibridi e i trigger di job ibridi per esaminare 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 ti consentono di ampliare l'ambito della protezione fornita da Sensitive Data Protection oltre alle semplici richieste di ispezione dei contenuti e alla scansione dei repository di archiviazione.Google Cloud Utilizzando job ibridi e trigger di job ibridi, puoi trasmettere in streaming i dati da praticamente qualsiasi origine, incluse quelle esterne a Google Cloud, direttamente a Sensitive Data Protection, che ispeziona i dati per 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 entrata, purché siano instradati 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. La protezione dei dati sensibili interrompe automaticamente i job all'interno dei trigger di job ibridi alla fine di ogni giornata.

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

Per ulteriori indicazioni su quale opzione è più adatta al tuo caso d'uso, consulta la sezione Scenari tipici di ispezione ibrida 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 Sensitive Data Protection non supporta in modo nativo.

  • Job ibrido: un job di ispezione configurato per analizzare i dati provenienti da praticamente qualsiasi origine.

  • Trigger di job ibrido: un trigger di job configurato per analizzare i dati provenienti da praticamente qualsiasi origine.

  • hybridInspect richiesta: una richiesta che contiene i dati esterni che vuoi esaminare. Quando invii questa richiesta, specifica il job ibrido o l'attivatore di job ibrido a cui inviare la richiesta.

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

Procedura di ispezione ibrida

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 di Google Cloud o dall'esterno. Ad esempio, puoi configurare uno script o un'applicazione personalizzati per inviare dati a Sensitive Data Protection, consentendoti di esaminare i dati in transito da un altro servizio cloud, da un repository di dati on-premise o da praticamente qualsiasi altra origine dati.

  2. 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 ibrido o un trigger di job ibrido, Sensitive Data Protection ascolta attivamente i dati che gli vengono inviati. Quando lo script o l'applicazione personalizzati inviano dati a questo job ibrido o a questo trigger di job ibrido, i dati vengono esaminati e i risultati vengono archiviati in base alla configurazione.

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

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

    Una richiesta hybridInspect contiene i dati da scansionare. Nella richiesta, includi 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 scansionando 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, conteggiare e analizzare i risultati per quella tabella del database.

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

Diagramma che mostra il processo di ispezione dei job ibridi

Considerazioni

Quando lavori con job ibridi e trigger di job, tieni presente quanto segue:

  • I job ibridi e i trigger di job ibridi non supportano il filtro e il campionamento.
  • I job e i trigger dei job non sono soggetti agli obiettivi del livello di servizio (SLO), ma puoi adottare misure per ridurre la latenza. Per saperne di più, vedi Latenza dei job.

Prima di iniziare

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

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

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

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

    Go to project selector

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

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

    Go to project selector

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

  6. Enable the Sensitive Data Protection API.

    Enable the API

    7. 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 il trigger del job ibrido, devi configurare l'origine esterna per inviare i 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 tua richiesta, consulta Tipi di metadati che puoi fornire.

    Crea un job ibrido o un trigger di job ibrido

    Per consentire a Sensitive Data Protection di ispezionare 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 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 che Sensitive Data Protection deve ispezionare.

    1. (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.
    2. (Facoltativo) Nel menu Posizione risorsa, scegli la regione in cui vuoi archiviare il job ibrido o il trigger del job ibrido. Per ulteriori informazioni, consulta Specificare le località di trattamento.

    3. Per Tipo di archiviazione, seleziona Ibrido.

    4. (Facoltativo) In Descrizione, descrivi il job ibrido o il trigger del job ibrido che stai creando. Ad esempio, puoi includere informazioni sull'origine 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 da questo trigger di job ibrido. Puoi aggiungere fino a 10 etichette obbligatorie. Per ulteriori informazioni, consulta la sezione Richiedere etichette dalle richieste hybridInspect in questa pagina.

    6. (Facoltativo) Per Etichette facoltative, inserisci le coppie chiave-valore che vuoi allegare ai risultati di tutte le richieste hybridInspect inviate a questo job o a questo trigger del job. Puoi aggiungere fino a 10 etichette facoltative. Per saperne di più, consulta la sezione Etichette facoltative.

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

    8. Fai clic su Continua.

    Configura il rilevamento

    In questa sezione, specifica i tipi di dati sensibili che Sensitive Data Protection ispezionerà nei 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 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 confidenza. Per maggiori dettagli, vedi Configurare il rilevamento.

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

    Aggiungi azioni

    In questa sezione specifichi dove salvare i risultati di ogni scansione di ispezione e se ricevere una notifica via email o Pub/Sub ogni volta che una scansione viene completata. 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 della scansione nella tabella BigQuery che specifichi 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 della scansione.

    • Pubblica in Pub/Sub: al termine di un job, verrà emesso un messaggio Pub/Sub.

    • 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 su Monitoring.

    Dopo aver scelto le azioni, fai clic su Continua.

    Pianificazione

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

    Esegui una di queste operazioni:

    • Per eseguire immediatamente il job ibrido, scegli Nessuno (esegui il job solo per una volta immediatamente dopo la creazione).

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

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

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

    Rivedi

    Puoi consultare un riepilogo JSON della scansione qui. Assicurati di annotare il nome del trigger di job ibrido o dell'oggetto ibrido; ti servirà 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 il trigger del job ibrido. Una scansione di ispezione viene avviata quando invii una hybridInspect richiesta a questo job ibrido o 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 trigger del job è rappresentato nell'API DLP dalla risorsa JobTrigger. Per creare un trigger di job ibrido, chiama 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 sui dati che vuoi esaminare.

    4. Nell'oggetto InspectJobConfig, nel campo actions, aggiungi le 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, vedi Azioni.

    5. Specifica cosa cercare e come eseguire la scansione effettuando una o entrambe le seguenti operazioni:

      • Imposta il campo inspectTemplateName sul nome risorsa completo di un modello di ispezione che vuoi utilizzare, se disponibile.

      • Imposta il campo inspectConfig.

      Se imposti entrambi i campi inspectTemplateName e inspectConfig, le loro 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 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 la richiesta ha l'etichetta appointment-bookings-comments.
    • Scansiona i contenuti della richiesta hybridInspect per gli indirizzi email.
    • Allega l'etichetta "env": "prod" ai risultati.
    • Per i dati tabellari, recupera 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 da poterlo ricondurre 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 tecnici fondamentali.
    • 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 di 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: 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 di 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 dei trigger di job ibridi alla fine di ogni giornata.

    Trigger job ibrido

    Questa scheda contiene un esempio JSON che puoi utilizzare per creare un trigger del 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: la regione 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 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 richiesta hybridInspect.

    A differenza dei job ibridi, l'API DLP arresta automaticamente i job all'interno dei trigger dei job ibridi alla fine di ogni giornata. 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 nelle seguenti pagine di riferimento dell'API, rispettivamente:

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

    Una richiesta riuscita, anche una creata in APIs Explorer, crea 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 rapida JSON.

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

    • item: contiene i contenuti effettivi da esaminare.
    • 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

    Per ispezionare i dati utilizzando un job ibrido o un trigger di job ibrido, devi inviare una richiesta hybridInspect all'endpoint corretto.

    Metodo HTTP e URL per i lavori 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 i trigger 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 del progetto.
    • REGION: la regione geografica in cui vuoi archiviare la richiesta hybridInspect. Questa regione deve essere la stessa della regione del job ibrido.

    • JOB_ID: l'ID che hai assegnato al job ibrido, con il prefisso i-.

      Per cercare l'ID job, in Protezione dei dati sensibili, fai clic su Ispezione > Job di ispezione.

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

    Richiedere etichette dalle richieste di hybridInspect

    Se vuoi controllare quali richieste hybridInspect possono essere elaborate da un job ibrido o da un trigger di job ibrido, puoi impostare le etichette richieste. Tutte le richieste hybridInspect per quel job ibrido o trigger di job ibrido che non includono queste etichette obbligatorie vengono rifiutate.

    Per impostare un'etichetta obbligatoria:

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

      Il seguente esempio 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"
  },
  ...
}

    2. 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 richiesta, 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, riceverai 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 e inviagli dati

    C#

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

    Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura 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, vedi Librerie client di Sensitive Data Protection.

    Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

    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, vedi Librerie client di Sensitive Data Protection.

    Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

    
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, vedi Librerie client di Sensitive Data Protection.

    Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

    // 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, vedi Librerie client di Sensitive Data Protection.

    Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

    
use Google\ApiCore\ApiException;
use Google\Cloud\Dlp\V2\ActivateJobTriggerRequest;
use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\Container;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\DlpJob\JobState;
use Google\Cloud\Dlp\V2\GetDlpJobRequest;
use Google\Cloud\Dlp\V2\HybridContentItem;
use Google\Cloud\Dlp\V2\HybridFindingDetails;
use Google\Cloud\Dlp\V2\HybridInspectJobTriggerRequest;
use Google\Cloud\Dlp\V2\ListDlpJobsRequest;

/**
 * Inspect data hybrid job trigger.
 * Send data to the hybrid job or hybrid job trigger.
 *
 * @param string $callingProjectId  The Google Cloud project id to use as a parent resource.
 * @param string $string            The string to inspect (will be treated as text).
 */

function inspect_send_data_to_hybrid_job_trigger(
    // TODO(developer): Replace sample parameters before running the code.
    string $callingProjectId,
    string $jobTriggerId,
    string $string
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $content = (new ContentItem())
        ->setValue($string);

    $container = (new Container())
        ->setFullPath('10.0.0.2:logs1:app1')
        ->setRelativePath('app1')
        ->setRootPath('10.0.0.2:logs1')
        ->setType('logging_sys')
        ->setVersion('1.2');

    $findingDetails = (new HybridFindingDetails())
        ->setContainerDetails($container)
        ->setLabels([
            'env' => 'prod',
            'appointment-bookings-comments' => ''
        ]);

    $hybridItem = (new HybridContentItem())
        ->setItem($content)
        ->setFindingDetails($findingDetails);

    $parent = "projects/$callingProjectId/locations/global";
    $name = "projects/$callingProjectId/locations/global/jobTriggers/" . $jobTriggerId;

    $triggerJob = null;
    try {
        $activateJobTriggerRequest = (new ActivateJobTriggerRequest())
            ->setName($name);
        $triggerJob = $dlp->activateJobTrigger($activateJobTriggerRequest);
    } catch (ApiException $e) {
        $listDlpJobsRequest = (new ListDlpJobsRequest())
            ->setParent($parent)
            ->setFilter('trigger_name=' . $name);
        $result = $dlp->listDlpJobs($listDlpJobsRequest);
        foreach ($result as $job) {
            $triggerJob = $job;
        }
    }
    $hybridInspectJobTriggerRequest = (new HybridInspectJobTriggerRequest())
        ->setName($name)
        ->setHybridItem($hybridItem);

    $dlp->hybridInspectJobTrigger($hybridInspectJobTriggerRequest);

    $numOfAttempts = 10;
    do {
        printf('Waiting for job to complete' . PHP_EOL);
        sleep(10);
        $getDlpJobRequest = (new GetDlpJobRequest())
            ->setName($triggerJob->getName());
        $job = $dlp->getDlpJob($getDlpJobRequest);
        if ($job->getState() != JobState::RUNNING) {
            break;
        }
        $numOfAttempts--;
    } while ($numOfAttempts > 0);

    // Print finding counts.
    printf('Job %s status: %s' . PHP_EOL, $job->getName(), JobState::name($job->getState()));
    switch ($job->getState()) {
        case JobState::DONE:
            $infoTypeStats = $job->getInspectDetails()->getResult()->getInfoTypeStats();
            if (count($infoTypeStats) === 0) {
                printf('No findings.' . PHP_EOL);
            } else {
                foreach ($infoTypeStats as $infoTypeStat) {
                    printf(
                        '  Found %s instance(s) of infoType %s' . PHP_EOL,
                        $infoTypeStat->getCount(),
                        $infoTypeStat->getInfoType()->getName()
                    );
                }
            }
            break;
        case JobState::FAILED:
            printf('Job %s had errors:' . PHP_EOL, $job->getName());
            $errors = $job->getErrors();
            foreach ($errors as $error) {
                var_dump($error->getDetails());
            }
            break;
        case JobState::PENDING:
            printf('Job has not completed. Consider a longer timeout or an asynchronous execution model' . PHP_EOL);
            break;
        default:
            printf('Unexpected job state. Most likely, the job is either running or has not yet started.');
    }
}

    Python

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

    Per eseguire l'autenticazione in Sensitive Data Protection, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi Configura l'autenticazione per un ambiente di sviluppo locale. 

    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.

    Eseguire una scansione una tantum

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

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

    2. Invia i 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 tua richiesta projects.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.

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

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

    3. Invia i 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 che invii. Finché il trigger di job è attivo, alla fine di ogni giorno Sensitive Data Protection esegue le azioni specificate al momento della creazione del trigger di job ibrido.

    Scansionare i dati in arrivo in un database

    Eseguire la scansione dei dati in entrata in un database, controllando al contempo la modalità di partizionamento dei dati. Ogni job in un trigger di job è una singola partizione.

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

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

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

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

      In questo caso, invii i dati al job anziché al trigger del job. Questo approccio ti consente di controllare il modo in cui vengono partizionati i dati che invii 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 tua richiesta projects.locations.jobTriggers.create.

    5. Se vuoi creare un altro job per la partizione successiva, attiva di nuovo il trigger del 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 consoleGoogle Cloud o l'API DLP.

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

    3. Invia i 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 in modo indefinito 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 che invii. Finché il trigger di job è attivo, alla fine di ogni giorno Sensitive Data Protection esegue le azioni specificate al momento della creazione del trigger di job ibrido.

    Passaggi successivi