Memeriksa penyimpanan dan database Google Cloud untuk menemukan data sensitif

Pengelolaan data sensitif yang disimpan dalam repositori penyimpanan dengan benar dimulai dengan klasifikasi penyimpanan: mengidentifikasi lokasi data sensitif Anda dalam repositori, jenis data sensitifnya, dan cara penggunaannya. Pengetahuan ini dapat membantu Anda menetapkan kontrol akses dan izin berbagi dengan benar, dan dapat menjadi bagian dari rencana pemantauan berkelanjutan.

Sensitive Data Protection dapat mendeteksi dan mengklasifikasikan data sensitif yang disimpan di lokasi Cloud Storage, jenis Datastore, atau tabel BigQuery. Saat memindai file di lokasi Cloud Storage, Sensitive Data Protection mendukung pemindaian file biner, teks, gambar, Microsoft Word, Microsoft Excel, Microsoft PowerPoint, PDF, dan Apache Avro. File dengan jenis yang tidak dikenal dipindai sebagai file biner. Untuk mengetahui informasi selengkapnya tentang jenis file yang didukung, lihat Jenis file yang didukung.

Untuk memeriksa penyimpanan dan database guna menemukan data sensitif, Anda menentukan lokasi data dan jenis data sensitif yang harus dicari oleh Sensitive Data Protection. Sensitive Data Protection memulai tugas yang memeriksa data di lokasi yang ditentukan, lalu menyediakan detail tentang infoTypes yang ditemukan dalam konten, nilai kemungkinan, dan lainnya.

Anda dapat menyiapkan pemeriksaan penyimpanan dan database menggunakan Sensitive Data Protection di konsol Google Cloud , melalui DLP API RESTful, atau secara terprogram menggunakan library klien Sensitive Data Protection dalam salah satu dari beberapa bahasa.

Topik ini mencakup:

• Praktik terbaik untuk menyiapkan pemindaian repositori penyimpanan dan database. Google Cloud
• Petunjuk untuk menyiapkan pemindaian inspeksi menggunakan Sensitive Data Protection di konsol Google Cloud , dan (opsional) untuk menjadwalkan pemindaian inspeksi berulang secara berkala.
• Contoh JSON dan kode untuk setiap jenis repositori penyimpanan Google Cloud : (Cloud Storage, Firestore dalam mode Datastore (Datastore), dan BigQuery).
• Ringkasan mendetail tentang opsi konfigurasi untuk tugas pemindaian.
• Petunjuk tentang cara mengambil hasil pemindaian dan cara mengelola tugas pemindaian yang dibuat dari setiap permintaan yang berhasil.

Praktik terbaik

Mengidentifikasi dan memprioritaskan pemindaian

Anda harus mengevaluasi aset terlebih dahulu dan menentukan aset mana yang memiliki prioritas pemindaian tertinggi. Saat baru memulai, Anda mungkin memiliki backlog data yang besar yang perlu diklasifikasikan, dan tidak mungkin memindai semuanya secara langsung. Pilih data yang pada awalnya berpotensi menimbulkan risiko tertinggi—misalnya, data yang sering diakses, dapat diakses secara luas, atau tidak diketahui.

Pastikan Sensitive Data Protection dapat mengakses data Anda

Sensitive Data Protection harus dapat mengakses data yang akan dipindai. Pastikan akun layanan Sensitive Data Protection diizinkan untuk membaca resource Anda.

Membatasi cakupan pemindaian pertama Anda

Untuk hasil terbaik, batasi cakupan tugas pertama Anda, alih-alih memindai semua data Anda. Mulai dengan satu tabel, satu bucket, atau beberapa file dan gunakan sampling. Dengan membatasi cakupan pemindaian pertama, Anda dapat menentukan detektor yang akan diaktifkan dan aturan pengecualian yang mungkin diperlukan untuk mengurangi positif palsu sehingga temuan Anda akan lebih bermakna. Hindari mengaktifkan semua infoType jika Anda tidak membutuhkannya, karena positif palsu atau temuan yang tidak dapat digunakan dapat mempersulit penilaian risiko Anda. Meskipun berguna dalam skenario tertentu, infoType seperti DATE, TIME, DOMAIN_NAME, dan URL cocok dengan berbagai temuan dan mungkin tidak berguna untuk diaktifkan pada pemindaian data dalam jumlah besar.

Saat mengambil sampel file terstruktur—seperti file CSV, TSV, atau Avro—pastikan ukuran sampel cukup besar untuk mencakup header lengkap file dan baris data. Untuk mengetahui informasi selengkapnya, lihat Memindai file terstruktur dalam mode penguraian terstruktur.

Menjadwalkan pemindaian

Gunakan pemicu tugas Perlindungan Data Sensitif untuk menjalankan pemindaian dan membuat temuan secara otomatis setiap hari, mingguan, atau per kuartal. Pemindaian ini juga dapat dikonfigurasi untuk hanya memeriksa data yang telah berubah sejak pemindaian terakhir, sehingga dapat menghemat waktu dan mengurangi biaya. Menjalankan pemindaian secara rutin dapat membantu Anda mengidentifikasi tren atau anomali dalam hasil pemindaian.

Latensi tugas

Tidak ada jaminan tujuan tingkat layanan (SLO) untuk tugas dan pemicu tugas. Latensi dipengaruhi oleh beberapa faktor, termasuk jumlah data yang dipindai, repositori penyimpanan yang dipindai, jenis dan jumlah infoType yang Anda pindai, region tempat tugas diproses, dan resource komputasi yang tersedia di region tersebut. Oleh karena itu, latensi tugas pemeriksaan tidak dapat ditentukan sebelumnya.

Untuk membantu mengurangi latensi tugas, Anda dapat mencoba hal berikut:

• Jika pengambilan sampel tersedia untuk tugas atau pemicu tugas Anda, aktifkan.

• Hindari mengaktifkan infoType yang tidak Anda perlukan. Meskipun berikut ini berguna dalam skenario tertentu, infoType ini dapat membuat permintaan berjalan jauh lebih lambat daripada permintaan yang tidak menyertakannya:

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

• Selalu tentukan infoTypes secara eksplisit. Jangan gunakan daftar infoTypes kosong.

• Jika memungkinkan, gunakan region pemrosesan yang berbeda.

Jika Anda masih mengalami masalah latensi dengan tugas setelah mencoba teknik ini, pertimbangkan untuk menggunakan permintaan content.inspect atau content.deidentify, bukan tugas. Metode ini tercakup dalam Perjanjian Tingkat Layanan. Untuk mengetahui informasi selengkapnya, lihat Perjanjian Tingkat Layanan Perlindungan Data Sensitif.

Sebelum memulai

Petunjuk yang diberikan dalam topik ini mengasumsikan hal berikut:

• Anda telah mengaktifkan penagihan.

  Pelajari cara mengaktifkan penagihan

• Anda telah mengaktifkan Sensitive Data Protection.

  Mengaktifkan Sensitive Data Protection

Klasifikasi penyimpanan memerlukan cakupan OAuth berikut: https://www.googleapis.com/auth/cloud-platform. Untuk mengetahui informasi selengkapnya, lihat Mengautentikasi ke DLP API.

Memeriksa lokasi Cloud Storage

Anda dapat menyiapkan pemeriksaan Perlindungan Data Sensitif di lokasi Cloud Storage menggunakan konsol Google Cloud , DLP API melalui permintaan REST atau RPC, atau secara terprogram dalam beberapa bahasa menggunakan library klien. Untuk mengetahui informasi tentang parameter yang disertakan dengan contoh kode dan JSON berikut, lihat "Konfigurasi inspeksi penyimpanan," di bagian selanjutnya dalam topik ini.

Sensitive Data Protection mengandalkan ekstensi file dan jenis media (MIME) untuk mengidentifikasi jenis file yang akan dipindai dan mode pemindaian yang akan diterapkan. Misalnya, Sensitive Data Protection memindai file .txt dalam mode teks biasa, meskipun file tersebut terstruktur sebagai file CSV, yang biasanya dipindai dalam mode penguraian terstruktur.

Untuk menyiapkan tugas pemindaian bucket Cloud Storage menggunakan 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