Controlla la presenza di dati sensibili nello spazio di archiviazione e nei database di Google Cloud

La corretta gestione dei dati sensibili archiviati in un repository di archiviazione inizia con la classificazione dell'archiviazione: identificare la posizione dei dati sensibili nel repository, il tipo di dati sensibili e il modo in cui vengono utilizzati. Queste informazioni possono aiutarti a impostare correttamentecontrollo dell'accessol'accesso e le autorizzazioni di condivisione e possono far parte di un piano di monitoraggio continuo.

Sensitive Data Protection può rilevare e classificare i dati sensibili archiviati in una posizione Cloud Storage, in un tipo Datastore o in una tabella BigQuery. Quando esegue la scansione dei file nelle posizioni Cloud Storage, Sensitive Data Protection supporta la scansione di file binari, di testo, immagine, Microsoft Word, Microsoft Excel, Microsoft PowerPoint, PDF e Apache Avro. I file di tipi non riconosciuti vengono analizzati come file binari. Per maggiori informazioni sui tipi di file supportati, vedi Tipi di file supportati.

Per ispezionare lo spazio di archiviazione e i database per l'individuazione di dati sensibili, devi specificare la posizione dei dati e il tipo di dati sensibili che Sensitive Data Protection deve cercare. Sensitive Data Protection avvia un job che esamina i dati nella posizione specificata e poi rende disponibili i dettagli sugli infoTypes trovati nei contenuti, sui valori di probabilità e altro ancora.

Puoi configurare l'ispezione di spazio di archiviazione e database utilizzando Sensitive Data Protection nella console Google Cloud , tramite l'API RESTful DLP o in modo programmatico utilizzando una libreria client Sensitive Data Protection in una delle diverse lingue.

Questo argomento include:

• Best practice per la configurazione delle scansioni di Google Cloud repository di archiviazione e database.
• Istruzioni per configurare una scansione di ispezione utilizzando Sensitive Data Protection nella console Google Cloud e (facoltativamente) per pianificare scansioni di ispezione periodiche.
• Esempi di codice e JSON per ogni tipo di repository di archiviazione: (Cloud Storage, Firestore in modalità Datastore (Datastore) e BigQuery). Google Cloud
• Una panoramica dettagliata delle opzioni di configurazione per i job di scansione.
• Istruzioni su come recuperare i risultati della scansione e come gestire i job di scansione creati da ogni richiesta riuscita.

Best practice

Identificare e dare la priorità alla scansione

È importante valutare prima le risorse e specificare quelle con la priorità più alta per la scansione. Quando inizi, potresti avere un grande backlog di dati che devono essere classificati e sarà impossibile scansionarli tutti immediatamente. Scegli inizialmente i dati che presentano il rischio potenziale più elevato, ad esempio i dati a cui si accede di frequente, ampiamente accessibili o sconosciuti.

Assicurarsi che Sensitive Data Protection possa accedere ai tuoi dati

Sensitive Data Protection deve essere in grado di accedere ai dati da scansionare. Assicurati che l'account di servizio di Sensitive Data Protection sia autorizzato a leggere le tue risorse.

Limitare l'ambito delle prime scansioni

Per risultati ottimali, limita l'ambito dei primi job anziché scansionare tutti i dati. Inizia con una tabella, un bucket o alcuni file e utilizza il campionamento. Limitando l'ambito delle prime scansioni, puoi determinare meglio quali rilevatori attivare e quali regole di esclusione potrebbero essere necessarie per ridurre i falsi positivi, in modo che i risultati siano più significativi. Evita di attivare tutti i tipi di informazioni se non ti servono, in quanto i falsi positivi o i risultati inutilizzabili potrebbero rendere più difficile la valutazione del rischio. Sebbene utili in determinati scenari, gli InfoType come DATE, TIME, DOMAIN_NAME e URL corrispondono a un'ampia gamma di risultati e potrebbero non essere utili per attivare scansioni di grandi quantità di dati.

Quando campioni un file strutturato, ad esempio un file CSV, TSV o Avro, assicurati che la dimensione del campione sia sufficiente a coprire l'intera intestazione del file e una riga di dati. Per maggiori informazioni, consulta la sezione Scansione di file strutturati in modalità di analisi strutturata.

Pianificare le scansioni

Utilizza i trigger dei job di Sensitive Data Protection per eseguire automaticamente le scansioni e generare risultati giornalieri, settimanali o trimestrali. Queste scansioni possono anche essere configurate per ispezionare solo i dati che sono cambiati dall'ultima scansione, il che può far risparmiare tempo e ridurre i costi. L'esecuzione regolare di scansioni può aiutarti a identificare tendenze o anomalie nei risultati.

Latenza job

Non sono garantiti obiettivi del livello di servizio (SLO) per i job e i trigger dei job. La latenza è influenzata da diversi fattori, tra cui la quantità di dati da analizzare, il repository di archiviazione analizzato, il tipo e il numero di infoType che stai cercando, la regione in cui viene elaborato il job e le risorse di calcolo disponibili in quella regione. Pertanto, la latenza dei job di ispezione non può essere determinata in anticipo.

Per ridurre la latenza dei job, puoi provare a:

• Se il campionamento è disponibile per il tuo job o trigger di job, abilitalo.

• Evita di attivare i tipi di informazioni che non ti servono. Sebbene i seguenti siano utili in determinati scenari, questi infoType possono rallentare notevolmente l'esecuzione delle richieste rispetto a quelle che non li includono:

  • PERSON_NAME
  • FEMALE_NAME
  • MALE_NAME
  • FIRST_NAME
  • LAST_NAME
  • DATE_OF_BIRTH
  • LOCATION
  • STREET_ADDRESS
  • ORGANIZATION_NAME

• Specifica sempre gli infoType in modo esplicito. Non utilizzare un elenco infoType vuoto.

• Se possibile, utilizza una regione di elaborazione diversa.

Se dopo aver provato queste tecniche i problemi di latenza con i job persistono, valuta la possibilità di utilizzare richieste content.inspect o content.deidentify anziché job. Questi metodi sono coperti dall'accordo sul livello del servizio. Per ulteriori informazioni, consulta l'Accordo sul livello del servizio di Sensitive Data Protection.

Prima di iniziare

Le istruzioni fornite in questo argomento presuppongono quanto segue:

• Hai abilitato la fatturazione.

  Scopri come attivare la fatturazione

• Hai attivato Sensitive Data Protection.

  Abilita Sensitive Data Protection

La classificazione dell'archiviazione richiede il seguente ambito OAuth: https://www.googleapis.com/auth/cloud-platform. Per saperne di più, consulta la sezione Autenticazione nell'API DLP.

Ispeziona una posizione Cloud Storage

Puoi configurare un'ispezione Sensitive Data Protection di una posizione Cloud Storage utilizzando la console Google Cloud , l'API DLP tramite richieste REST o RPC oppure a livello di programmazione in diversi linguaggi utilizzando una libreria client. Per informazioni sui parametri inclusi nei seguenti esempi di codice e JSON, vedi "Configurare l'ispezione dell'archiviazione" più avanti in questo argomento.

Sensitive Data Protection si basa sulle estensioni dei file e sui tipi di media (MIME) per identificare i tipi di file da analizzare e le modalità di scansione da applicare. Ad esempio, Sensitive Data Protection analizza un file .txt in modalità testo normale, anche se il file è strutturato come un file CSV, che normalmente viene analizzato in modalità di analisi strutturata.

Per configurare un job di scansione di un bucket Cloud Storage utilizzando Sensitive Data Protection:

POST https://dlp.googleapis.com/v2/projects/[PROJECT-ID]/dlpJobs?key={YOUR_API_KEY}

{
  "inspectJob":{
    "storageConfig":{
      "cloudStorageOptions":{
        "fileSet":{
          "url":"gs://[BUCKET-NAME]/*"
        },
        "bytesLimitPerFile":"1073741824"
      },
      "timespanConfig":{
        "startTime":"2017-11-13T12:34:29.965633345Z",
        "endTime":"2018-01-05T04:45:04.240912125Z"
      }
    },
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"PHONE_NUMBER"
        }
      ],
      "excludeInfoTypes":false,
      "includeQuote":true,
      "minLikelihood":"LIKELY"
    },
    "actions":[
      {
        "saveFindings":{
          "outputConfig":{
            "table":{
              "projectId":"[PROJECT-ID]",
              "datasetId":"[DATASET-ID]"
            }
          }
        }
      }
    ]
  }
}

{
  "name":"projects/[PROJECT-ID]/dlpJobs/[JOB-ID]",
  "type":"INSPECT_JOB",
  "state":"PENDING",
  "inspectDetails":{
    "requestedOptions":{
      "snapshotInspectTemplate":{

      },
      "jobConfig":{
        "storageConfig":{
          "cloudStorageOptions":{
            "fileSet":{
              "url":"gs://[BUCKET-NAME]/*"
            },
            "bytesLimitPerFile":"1073741824"
          },
          "timespanConfig":{
            "startTime":"2017-11-13T12:34:29.965633345Z",
            "endTime":"2018-01-05T04:45:04.240912125Z"
          }
        },
        "inspectConfig":{
          "infoTypes":[
            {
              "name":"PHONE_NUMBER"
            }
          ],
          "minLikelihood":"LIKELY",
          "limits":{

          },
          "includeQuote":true
        },
        "actions":[
          {
            "saveFindings":{
              "outputConfig":{
                "table":{
                  "projectId":"[PROJECT-ID]",
                  "datasetId":"[DATASET-ID]",
                  "tableId":"[NEW-TABLE-ID]"
                }
              }
            }
          }
        ]
      }
    }
  },
  "createTime":"2018-11-07T18:01:14.225Z"
}

import com.google.api.core.SettableApiFuture;
import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.cloud.pubsub.v1.AckReplyConsumer;
import com.google.cloud.pubsub.v1.MessageReceiver;
import com.google.cloud.pubsub.v1.Subscriber;
import com.google.privacy.dlp.v2.Action;
import com.google.privacy.dlp.v2.CloudStorageOptions;
import com.google.privacy.dlp.v2.CloudStorageOptions.FileSet;
import com.google.privacy.dlp.v2.CreateDlpJobRequest;
import com.google.privacy.dlp.v2.DlpJob;
import com.google.privacy.dlp.v2.GetDlpJobRequest;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InfoTypeStats;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectDataSourceDetails;
import com.google.privacy.dlp.v2.InspectJobConfig;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.StorageConfig;
import com.google.pubsub.v1.ProjectSubscriptionName;
import com.google.pubsub.v1.PubsubMessage;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class InspectGcsFile {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String gcsUri = "gs://" + "your-bucket-name" + "/path/to/your/file.txt";
    String topicId = "your-pubsub-topic-id";
    String subscriptionId = "your-pubsub-subscription-id";
    inspectGcsFile(projectId, gcsUri, topicId, subscriptionId);
  }

  // Inspects a file in a Google Cloud Storage Bucket.
  public static void inspectGcsFile(
      String projectId, String gcsUri, String topicId, String subscriptionId)
      throws ExecutionException, InterruptedException, IOException {
    // 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 dlp = DlpServiceClient.create()) {
      // Specify the GCS file to be inspected.
      CloudStorageOptions cloudStorageOptions =
          CloudStorageOptions.newBuilder().setFileSet(FileSet.newBuilder().setUrl(gcsUri)).build();

      StorageConfig storageConfig =
          StorageConfig.newBuilder().setCloudStorageOptions(cloudStorageOptions).build();

      // Specify the type of info the inspection will look for.
      // See https://cloud.google.com/dlp/docs/infotypes-reference for complete list of info types
      List<InfoType> infoTypes =
          Stream.of("PHONE_NUMBER", "EMAIL_ADDRESS", "CREDIT_CARD_NUMBER")
              .map(it -> InfoType.newBuilder().setName(it).build())
              .collect(Collectors.toList());

      // Specify how the content should be inspected.
      InspectConfig inspectConfig =
          InspectConfig.newBuilder().addAllInfoTypes(infoTypes).setIncludeQuote(true).build();

      // Specify the action that is triggered when the job completes.
      String pubSubTopic = String.format("projects/%s/topics/%s", projectId, topicId);
      Action.PublishToPubSub publishToPubSub =
          Action.PublishToPubSub.newBuilder().setTopic(pubSubTopic).build();
      Action action = Action.newBuilder().setPubSub(publishToPubSub).build();

      // Configure the long running job we want the service to perform.
      InspectJobConfig inspectJobConfig =
          InspectJobConfig.newBuilder()
              .setStorageConfig(storageConfig)
              .setInspectConfig(inspectConfig)
              .addActions(action)
              .build();

      // Create the request for the job configured above.
      CreateDlpJobRequest createDlpJobRequest =
          CreateDlpJobRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectJob(inspectJobConfig)
              .build();

      // Use the client to send the request.
      final DlpJob dlpJob = dlp.createDlpJob(createDlpJobRequest);
      System.out.println("Job created: " + dlpJob.getName());

      // Set up a Pub/Sub subscriber to listen on the job completion status
      final SettableApiFuture<Boolean> done = SettableApiFuture.create();

      ProjectSubscriptionName subscriptionName =
          ProjectSubscriptionName.of(projectId, subscriptionId);

      MessageReceiver messageHandler =
          (PubsubMessage pubsubMessage, AckReplyConsumer ackReplyConsumer) -> {
            handleMessage(dlpJob, done, pubsubMessage, ackReplyConsumer);
          };
      Subscriber subscriber = Subscriber.newBuilder(subscriptionName, messageHandler).build();
      subscriber.startAsync();

      // Wait for job completion semi-synchronously
      // For long jobs, consider using a truly asynchronous execution model such as Cloud Functions
      try {
        done.get(15, TimeUnit.MINUTES);
      } catch (TimeoutException e) {
        System.out.println("Job was not completed after 15 minutes.");
        return;
      } finally {
        subscriber.stopAsync();
        subscriber.awaitTerminated();
      }

      // Get the latest state of the job from the service
      GetDlpJobRequest request = GetDlpJobRequest.newBuilder().setName(dlpJob.getName()).build();
      DlpJob completedJob = dlp.getDlpJob(request);

      // Parse the response and process results.
      System.out.println("Job status: " + completedJob.getState());
      System.out.println("Job name: " + dlpJob.getName());
      InspectDataSourceDetails.Result result = completedJob.getInspectDetails().getResult();
      System.out.println("Findings: ");
      for (InfoTypeStats infoTypeStat : result.getInfoTypeStatsList()) {
        System.out.print("\tInfo type: " + infoTypeStat.getInfoType().getName());
        System.out.println("\tCount: " + infoTypeStat.getCount());
      }
    }
  }

  // handleMessage injects the job and settableFuture into the message reciever interface
  private static void handleMessage(
      DlpJob job