Membuat pendeteksi kamus kustom yang besar

Topik ini menjelaskan cara membuat dan membuat ulang kamus khusus yang besar. Artikel ini juga membahas beberapa skenario error.

Kapan harus memilih kamus kustom berukuran besar daripada kamus kustom biasa

Pendeteksi kamus kustom biasa sudah cukup jika Anda memiliki puluhan ribu kata atau frasa sensitif yang ingin dipindai untuk memindai konten. Jika Anda memiliki lebih banyak istilah atau jika daftar istilah Anda sering berubah, pertimbangkan untuk membuat kamus kustom berukuran besar, yang dapat mendukung puluhan juta istilah.

Catatan: Untuk mengetahui jumlah batas penggunaan yang tepat untuk kamus, lihat Batas penggunaan.

Perbedaan kamus khusus besar dengan infoType kustom lainnya

Kamus kustom besar berbeda dari infoType kustom lainnya karena setiap kamus kustom berukuran besar memiliki dua komponen:

• Daftar frasa yang Anda buat dan definisikan. Daftar ini disimpan sebagai file teks dalam Cloud Storage atau kolom dalam tabel BigQuery.
• File kamus, yang dihasilkan dan disimpan oleh Perlindungan Data Sensitif di Cloud Storage. File kamus terdiri dari salinan daftar istilah dan filter mekar, yang membantu dalam penelusuran dan pencocokan.

Peringatan: Jangan mengubah file kamus kustom secara langsung di Cloud Storage. Tindakan ini akan merender kamus yang tidak valid dan tidak dapat digunakan.

Membuat kamus kustom berukuran besar

Bagian ini menjelaskan cara membuat, mengedit, dan membuat ulang kamus kustom yang besar.

Membuat daftar istilah

Buat daftar yang berisi semua kata dan frasa yang Anda inginkan untuk ditelusuri oleh detektor infoType baru. Lakukan salah satu hal berikut:

• Tempatkan file teks yang berisi setiap kata atau frasa di barisnya masing-masing ke dalam bucket Cloud Storage.
• Tetapkan satu kolom tabel BigQuery sebagai penampung untuk kata dan frasa. Berikan baris tersendiri pada setiap entri di kolom. Anda dapat menggunakan tabel BigQuery yang ada selama semua kata dan frasa kamus berada dalam satu kolom.

Anda dapat menyusun daftar istilah yang terlalu besar untuk diproses oleh Perlindungan Data Sensitif. Jika Anda melihat pesan error, baca Memecahkan masalah error di topik ini nanti.

Membuat infoType tersimpan

Setelah Anda membuat daftar istilah, gunakan Perlindungan Data Sensitif untuk membuat kamus:

Konsol

1. Di bucket Cloud Storage, buat folder baru tempat Perlindungan Data Sensitif akan menyimpan kamus yang dihasilkan.

   Perlindungan Data Sensitif membuat folder yang berisi file kamus di lokasi yang Anda tentukan.

2. Di konsol Google Cloud, buka halaman Create infoType.

   Buka Create infoType

3. Untuk Jenis, pilih Kamus kustom besar.

4. Untuk InfoType ID, masukkan ID untuk infoType yang tersimpan.

   Anda akan menggunakan ID ini saat mengonfigurasi tugas pemeriksaan dan de-identifikasi. Anda dapat menggunakan huruf, angka, tanda hubung, dan garis bawah untuk nama.

5. Untuk nama tampilan InfoType, masukkan nama untuk infoType yang tersimpan.

   Anda dapat menggunakan spasi dan tanda baca dalam nama.

6. Untuk Description, masukkan deskripsi tentang apa yang terdeteksi oleh infoType tersimpan Anda.

7. Untuk Jenis penyimpanan, pilih lokasi daftar istilah Anda:

   • BigQuery: Masukkan project ID, ID set data, dan ID tabel. Di kolom Nama kolom, masukkan ID kolom. Anda dapat menentukan maksimal satu kolom dari tabel.
   • Google Cloud Storage: Masukkan jalur ke file.

8. Untuk Output bucket atau folder, masukkan lokasi Cloud Storage dari folder yang Anda buat di langkah 1.

   Catatan: Jangan menempatkan file di dalam folder yang dibuat oleh Perlindungan Data Sensitif saat membuat kamus Anda. Saat Perlindungan Data Sensitif membuat atau membangun ulang file kamus, Perlindungan Data Sensitif akan menghapus semua file lain yang disimpan dalam folder yang dibuatnya. Folder apa pun yang berada di tingkat yang sama dengan folder yang dibuat oleh Perlindungan Data Sensitif akan dipertahankan.

9. Klik Create.

Ringkasan infoType yang disimpan akan muncul. Saat kamus dibuat dan infoType baru yang tersimpan siap digunakan, status infoType akan menunjukkan Ready.

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

using System;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;

public class CreateStoredInfoTypes
{
    public static StoredInfoType Create(
        string projectId,
        string outputPath,
        string storedInfoTypeId)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the stored infotype config by specifying the public table and
        // cloud storage output path.
        var storedInfoTypeConfig = new StoredInfoTypeConfig
        {
            DisplayName = "Github Usernames",
            Description = "Dictionary of Github usernames used in commits.",
            LargeCustomDictionary = new LargeCustomDictionaryConfig
            {
                BigQueryField = new BigQueryField
                {
                    Table = new BigQueryTable
                    {
                        DatasetId = "samples",
                        ProjectId = "bigquery-public-data",
                        TableId = "github_nested"
                    },
                    Field = new FieldId
                    {
                        Name = "actor"
                    }
                },
                OutputPath = new CloudStoragePath
                {
                    Path = outputPath
                }
            },
        };

        // Construct the request.
        var request = new CreateStoredInfoTypeRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            Config = storedInfoTypeConfig,
            StoredInfoTypeId = storedInfoTypeId
        };

        // Call the API.
        StoredInfoType response = dlp.CreateStoredInfoType(request);

        // Inspect the response.
        Console.WriteLine($"Created the stored infotype at path: {response.Name}");

        return response;
    }
}

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// createStoredInfoType creates a custom stored info type based on your input data.
func createStoredInfoType(w io.Writer, projectID, outputPath string) error {
	// projectId := "my-project-id"
	// outputPath := "gs://" + "your-bucket-name" + "path/to/directory"

	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 name you want to give the dictionary.
	displayName := "Github Usernames"

	// Specify a description of the dictionary.
	description := "Dictionary of GitHub usernames used in commits"

	// Specify the path to the location in a Cloud Storage
	// bucket to store the created dictionary.
	cloudStoragePath := &dlppb.CloudStoragePath{
		Path: outputPath,
	}

	// Specify your term list is stored in BigQuery.
	bigQueryField := &dlppb.BigQueryField{
		Table: &dlppb.BigQueryTable{
			ProjectId: "bigquery-public-data",
			DatasetId: "samples",
			TableId:   "github_nested",
		},
		Field: &dlppb.FieldId{
			Name: "actor",
		},
	}

	// Specify the configuration of the large custom dictionary.
	largeCustomDictionaryConfig := &dlppb.LargeCustomDictionaryConfig{
		OutputPath: cloudStoragePath,
		Source: &dlppb.LargeCustomDictionaryConfig_BigQueryField{
			BigQueryField: bigQueryField,
		},
	}

	// Specify the configuration for stored infoType.
	storedInfoTypeConfig := &dlppb.StoredInfoTypeConfig{
		DisplayName: displayName,
		Description: description,
		Type: &dlppb.StoredInfoTypeConfig_LargeCustomDictionary{
			LargeCustomDictionary: largeCustomDictionaryConfig,
		},
	}

	// Combine configurations into a request for the service.
	req := &dlppb.CreateStoredInfoTypeRequest{
		Parent:           fmt.Sprintf("projects/%s/locations/global", projectID),
		Config:           storedInfoTypeConfig,
		StoredInfoTypeId: "github-usernames",
	}

	// Send the request and receive response from the service.
	resp, err := client.CreateStoredInfoType(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "output: %v", resp.Name)
	return nil

}

Java

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.BigQueryField;
import com.google.privacy.dlp.v2.BigQueryTable;
import com.google.privacy.dlp.v2.CloudStoragePath;
import com.google.privacy.dlp.v2.CreateStoredInfoTypeRequest;
import com.google.privacy.dlp.v2.FieldId;
import com.google.privacy.dlp.v2.LargeCustomDictionaryConfig;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.StoredInfoType;
import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
import java.io.IOException;

public class CreateStoredInfoType {

  public static void main(String[] args) throws IOException {
    // 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 path to the location in a GCS bucket to store the created dictionary.
    String outputPath = "gs://" + "your-bucket-name" + "path/to/directory";
    createStoredInfoType(projectId, outputPath);
  }

  // Creates a custom stored info type that contains GitHub usernames used in commits.
  public static void createStoredInfoType(String projectId, String outputPath)
      throws IOException {
    try (DlpServiceClient dlp = DlpServiceClient.create()) {

      // Optionally set a display name and a description.
      String displayName = "GitHub usernames";
      String description = "Dictionary of GitHub usernames used in commits";

      // The output path where the custom dictionary containing the GitHub usernames will be stored.
      CloudStoragePath cloudStoragePath =
          CloudStoragePath.newBuilder()
              .setPath(outputPath)
              .build();

      // The reference to the table containing the GitHub usernames.
      BigQueryTable table = BigQueryTable.newBuilder()
              .setProjectId("bigquery-public-data")
              .setDatasetId("samples")
              .setTableId("github_nested")
              .build();

      // The reference to the BigQuery field that contains the GitHub usernames.
      BigQueryField bigQueryField = BigQueryField.newBuilder()
              .setTable(table)
              .setField(FieldId.newBuilder().setName("actor").build())
              .build();

      LargeCustomDictionaryConfig largeCustomDictionaryConfig =
          LargeCustomDictionaryConfig.newBuilder()
              .setOutputPath(cloudStoragePath)
              .setBigQueryField(bigQueryField)
              .build();

      StoredInfoTypeConfig storedInfoTypeConfig = StoredInfoTypeConfig.newBuilder()
              .setDisplayName(displayName)
              .setDescription(description)
              .setLargeCustomDictionary(largeCustomDictionaryConfig)
              .build();

      // Combine configurations into a request for the service.
      CreateStoredInfoTypeRequest createStoredInfoType = CreateStoredInfoTypeRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setConfig(storedInfoTypeConfig)
              .setStoredInfoTypeId("github-usernames")
              .build();

      // Send the request and receive response from the service.
      StoredInfoType response = dlp.createStoredInfoType(createStoredInfoType);

      // Print the results.
      System.out.println("Created Stored InfoType: " + response.getName());
    }
  }
}

Node.js

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

// Import the required libraries
const dlp = require('@google-cloud/dlp');

// Create a DLP client
const dlpClient = new dlp.DlpServiceClient();

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The identifier for the stored infoType
// const infoTypeId = 'github-usernames';

// The path to the location in a Cloud Storage bucket to store the created dictionary
// const outputPath = 'cloud-bucket-path';

// The project ID the table is stored under
// This may or (for public datasets) may not equal the calling project ID
// const dataProjectId = 'my-project';

// The ID of the dataset to inspect, e.g. 'my_dataset'
// const datasetId = 'my_dataset';

// The ID of the table to inspect, e.g. 'my_table'
// const tableId = 'my_table';

// Field ID to be used for constructing dictionary
// const fieldName = 'field_name';

async function createStoredInfoType() {
  // The name you want to give the dictionary.
  const displayName = 'GitHub usernames';
  // A description of the dictionary.
  const description = 'Dictionary of GitHub usernames used in commits';

  // Specify configuration for the large custom dictionary
  const largeCustomDictionaryConfig = {
    outputPath: {
      path: outputPath,
    },
    bigQueryField: {
      table: {
        datasetId: datasetId,
        projectId: dataProjectId,
        tableId: tableId,
      },
      field: {
        name: fieldName,
      },
    },
  };

  // Stored infoType configuration that uses large custom dictionary.
  const storedInfoTypeConfig = {
    displayName: displayName,
    description: description,
    largeCustomDictionary: largeCustomDictionaryConfig,
  };

  // Construct the job creation request to be sent by the client.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    config: storedInfoTypeConfig,
    storedInfoTypeId: infoTypeId,
  };

  // Send the job creation request and process the response.
  const [response] = await dlpClient.createStoredInfoType(request);

  // Print results
  console.log(`InfoType stored successfully: ${response.name}`);
}
await createStoredInfoType();

PHP

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

use Google\Cloud\Dlp\V2\BigQueryField;
use Google\Cloud\Dlp\V2\BigQueryTable;
use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStoragePath;
use Google\Cloud\Dlp\V2\FieldId;
use Google\Cloud\Dlp\V2\LargeCustomDictionaryConfig;
use Google\Cloud\Dlp\V2\StoredInfoTypeConfig;

/**
 * Create a stored infoType.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $outputgcsPath     The path to the location in a Cloud Storage bucket to store the created dictionary.
 * @param string $storedInfoTypeId  The name of the custom stored info type.
 * @param string $displayName       The human-readable name to give the stored infoType.
 * @param string $description       A description for the stored infoType to be created.
 */
function create_stored_infotype(
    string $callingProjectId,
    string $outputgcsPath,
    string $storedInfoTypeId,
    string $displayName,
    string $description
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // The reference to the table containing the GitHub usernames.
    // The reference to the BigQuery field that contains the GitHub usernames.
    // Note: we have used public data
    $bigQueryField = (new BigQueryField())
        ->setTable((new BigQueryTable())
            ->setDatasetId('samples')
            ->setProjectId('bigquery-public-data')
            ->setTableId('github_nested'))
        ->setField((new FieldId())
            ->setName('actor'));

    $largeCustomDictionaryConfig = (new LargeCustomDictionaryConfig())
        // The output path where the custom dictionary containing the GitHub usernames will be stored.
        ->setOutputPath((new CloudStoragePath())
            ->setPath($outputgcsPath))
        ->setBigQueryField($bigQueryField);

    // Configure the StoredInfoType we want the service to perform.
    $storedInfoTypeConfig = (new StoredInfoTypeConfig())
        ->setDisplayName($displayName)
        ->setDescription($description)
        ->setLargeCustomDictionary($largeCustomDictionaryConfig);

    // Send the stored infoType creation request and process the response.
    $parent = "projects/$callingProjectId/locations/global";
    $response = $dlp->createStoredInfoType($parent, $storedInfoTypeConfig, [
        'storedInfoTypeId' => $storedInfoTypeId
    ]);

    // Print results.
    printf('Successfully created Stored InfoType : %s', $response->getName());
}

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import google.cloud.dlp

def create_stored_infotype(
    project: str,
    stored_info_type_id: str,
    output_bucket_name: str,
) -> None:
    """Uses the Data Loss Prevention API to create stored infoType.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        stored_info_type_id: The identifier for large custom dictionary.
        output_bucket_name: The name of the bucket in Google Cloud Storage
            that would store the created dictionary.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Construct the stored infoType Configuration dictionary. This example creates
    # a stored infoType from a term list stored in a publicly available BigQuery
    # database (bigquery-public-data.samples.github_nested).
    # The database contains all GitHub usernames used in commits.
    stored_info_type_config = {
        "display_name": "GitHub usernames",
        "description": "Dictionary of GitHub usernames used in commits",
        "large_custom_dictionary": {
            "output_path": {"path": f"gs://{output_bucket_name}"},
            # We can either use bigquery field or gcs file as a term list input option.
            "big_query_field": {
                "table": {
                    "project_id": "bigquery-public-data",
                    "dataset_id": "samples",
                    "table_id": "github_nested",
                },
                "field": {"name": "actor"},
            },
        },
    }

    # Convert the project id into a full resource id.
    parent = f"projects/{project}/locations/global"

    # Call the API.
    response = dlp.create_stored_info_type(
        request={
            "parent": parent,
            "config": stored_info_type_config,
            "stored_info_type_id": stored_info_type_id,
        }
    )

    # Print the result
    print(f"Created Stored InfoType: {response.name}")

REST

1. Buat folder baru untuk kamus di bucket Cloud Storage. Perlindungan Data Sensitif membuat folder yang berisi file kamus di lokasi yang Anda tentukan.
Catatan: Jangan menempatkan file di dalam folder yang dibuat oleh Perlindungan Data Sensitif saat membuat kamus Anda. Saat membuat atau membangun ulang file kamus, Perlindungan Data Sensitif akan menghapus file lain yang disimpan dalam folder yang dibuatnya. Folder apa pun yang berada di tingkat yang sama dengan folder yang dibuat oleh Perlindungan Data Sensitif akan dipertahankan.
2. Buat kamus menggunakan metode storedInfoTypes.create. Metode create menggunakan parameter berikut:
   • Objek StoredInfoTypeConfig, yang berisi konfigurasi infoType yang tersimpan. Hal ini mencakup:
     • description: Deskripsi kamus.
     • displayName: Nama yang ingin Anda berikan ke kamus.
     • LargeCustomDictionaryConfig: Berisi konfigurasi kamus kustom berukuran besar. Hal ini mencakup:
       • BigQueryField: Ditentukan apakah daftar istilah Anda disimpan di BigQuery. Menyertakan referensi ke tabel tempat daftar Anda disimpan, serta kolom yang berisi setiap frasa kamus.
       • CloudStorageFileSet: Ditentukan apakah daftar istilah Anda disimpan di Cloud Storage. Menyertakan URL ke lokasi sumber di Cloud Storage, dalam bentuk berikut: "gs://[PATH_TO_GS]". Karakter pengganti didukung.
       Catatan: Anda dapat menentukan BigQueryField atau CloudStorageFileSet di LargeCustomDictionaryConfig, tetapi tidak keduanya.
       • outputPath: Jalur ke lokasi di bucket Cloud Storage untuk menyimpan kamus yang dibuat.
   • storedInfoTypeId: ID untuk infoType yang disimpan. Anda menggunakan ID ini untuk merujuk ke infoType yang tersimpan saat Anda mem-build ulang, menghapusnya, atau menggunakannya dalam tugas pemeriksaan atau de-identifikasi. Jika kolom ini dibiarkan kosong, sistem akan membuat ID untuk Anda.

Berikut adalah contoh JSON yang, saat dikirim ke metode storedInfoTypes.create, akan membuat infoType tersimpan baru—khususnya, detektor kamus kustom yang besar. Contoh ini membuat infoType tersimpan dari daftar istilah yang disimpan dalam database BigQuery yang tersedia secara publik (bigquery-public-data.samples.github_nested). Database ini berisi semua nama pengguna GitHub yang digunakan dalam commit. Jalur output untuk kamus yang dihasilkan disetel ke bucket Cloud Storage yang disebut dlptesting, dan infoType yang tersimpan diberi nama github-usernames.

Input JSON

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes

{
  "config":{
    "displayName":"GitHub usernames",
    "description":"Dictionary of GitHub usernames used in commits",
    "largeCustomDictionary":{
      "outputPath":{
        "path":"gs://[PATH_TO_GS]"
      },
      "bigQueryField":{
        "table":{
          "datasetId":"samples",
          "projectId":"bigquery-public-data",
          "tableId":"github_nested"
        }
      }
    }
  },
  "storedInfoTypeId":"github-usernames"
}

Membuat ulang kamus

Jika Anda ingin memperbarui kamus, perbarui daftar istilah sumber terlebih dahulu, lalu menginstruksikan Perlindungan Data Sensitif untuk membuat ulang infoType yang tersimpan.

1. Perbarui daftar istilah sumber yang ada di Cloud Storage atau BigQuery.

   Tambahkan, hapus, atau ubah istilah atau frasa sesuai kebutuhan.

2. Buat versi baru infoType yang tersimpan dengan "mem-build ulang" infoType tersebut menggunakan konsol Google Cloud atau metode storedInfoTypes.patch.

   Dengan membuat ulang, versi kamus baru akan dibuat, yang menggantikan kamus lama.

Saat Anda mem-build ulang infoType tersimpan ke versi baru, versi lama akan dihapus. Saat Perlindungan Data Sensitif memperbarui infoType yang tersimpan, statusnya adalah "tertunda". Selama waktu ini, versi lama infoType yang disimpan masih ada. Pemindaian yang Anda jalankan saat infoType tersimpan dalam status tertunda akan dijalankan menggunakan versi lama infoType yang tersimpan.

Untuk membangun ulang infoType yang tersimpan:

Konsol

1. Perbarui dan simpan daftar istilah Anda di Cloud Storage atau BigQuery.

2. Di konsol Google Cloud, buka daftar infoType tersimpan Anda.

   Buka infoTypes tersimpan

3. Klik ID infoType tersimpan yang ingin Anda perbarui.

4. Di halaman Detail InfoType, klik Buat ulang data.

Perlindungan Data Sensitif akan membuat ulang infoType tersimpan dengan perubahan yang Anda buat pada daftar istilah sumber. Setelah status infoType yang disimpan adalah "Ready," Anda dapat menggunakannya. Setiap template atau pemicu tugas yang menggunakan infoType tersimpan akan otomatis menggunakan versi yang dibuat ulang.

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

using System;
using Google.Cloud.Dlp.V2;
using Google.Protobuf.WellKnownTypes;

public class UpdateStoredInfoTypes
{
    public static StoredInfoType Update(
        string gcsFileUri,
        string storedInfoTypePath,
        string outputPath)
    {
        // Instantiate the client.
        var dlp = DlpServiceClient.Create();

        // Construct the stored infotype config. Here, we will change the source from bigquery table to GCS file.
        var storedConfig = new StoredInfoTypeConfig
        {
            LargeCustomDictionary = new LargeCustomDictionaryConfig
            {
                CloudStorageFileSet = new CloudStorageFileSet
                {
                    Url = gcsFileUri
                },
                OutputPath = new CloudStoragePath
                {
                    Path = outputPath
                }
            }
        };

        // Construct the request using the stored config by specifying the update mask object
        // which represent the path of field to be updated.
        var request = new UpdateStoredInfoTypeRequest
        {
            Config = storedConfig,
            Name = storedInfoTypePath,
            UpdateMask = new FieldMask
            {
                Paths =
                {
                    "large_custom_dictionary.cloud_storage_file_set.url"
                }
            }
        };

        // Call the API.
        StoredInfoType response = dlp.UpdateStoredInfoType(request);

        // Inspect the result.
        Console.WriteLine(response);
        return response;
    }
}

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"google.golang.org/protobuf/types/known/fieldmaskpb"
)

// updateStoredInfoType uses the Data Loss Prevention API to update stored infoType
// detector by changing the source term list from one stored in Bigquery
// to one stored in Cloud Storage.
func updateStoredInfoType(w io.Writer, projectID, gcsUri, fileSetUrl, infoTypeId string) error {
	// projectId := "your-project-id"
	// gcsUri := "gs://" + "your-bucket-name" + "/path/to/your/file.txt"
	// fileSetUrl := "your-cloud-storage-file-set"
	// infoTypeId := "your-stored-info-type-id"

	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()

	// Set path in Cloud Storage.
	cloudStoragePath := &dlppb.CloudStoragePath{
		Path: gcsUri,
	}
	cloudStorageFileSet := &dlppb.CloudStorageFileSet{
		Url: fileSetUrl,
	}

	// Configuration for a custom dictionary created from a data source of any size
	largeCustomDictionaryConfig := &dlppb.LargeCustomDictionaryConfig{
		OutputPath: cloudStoragePath,
		Source: &dlppb.LargeCustomDictionaryConfig_CloudStorageFileSet{
			CloudStorageFileSet: cloudStorageFileSet,
		},
	}

	// Set configuration for stored infoTypes.
	storedInfoTypeConfig := &dlppb.StoredInfoTypeConfig{
		Type: &dlppb.StoredInfoTypeConfig_LargeCustomDictionary{
			LargeCustomDictionary: largeCustomDictionaryConfig,
		},
	}

	// Set mask to control which fields get updated.
	fieldMask := &fieldmaskpb.FieldMask{
		Paths: []string{"large_custom_dictionary.cloud_storage_file_set.url"},
	}
	// Construct the job creation request to be sent by the client.
	req := &dlppb.UpdateStoredInfoTypeRequest{
		Name:       fmt.Sprint("projects/" + projectID + "/storedInfoTypes/" + infoTypeId),
		Config:     storedInfoTypeConfig,
		UpdateMask: fieldMask,
	}

	// Use the client to send the API request.
	resp, err := client.UpdateStoredInfoType(ctx, req)
	if err != nil {
		return err
	}

	// Print the result.
	fmt.Fprintf(w, "output: %v", resp.Name)
	return nil
}

Java

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CloudStorageFileSet;
import com.google.privacy.dlp.v2.CloudStoragePath;
import com.google.privacy.dlp.v2.LargeCustomDictionaryConfig;
import com.google.privacy.dlp.v2.StoredInfoType;
import com.google.privacy.dlp.v2.StoredInfoTypeConfig;
import com.google.privacy.dlp.v2.StoredInfoTypeName;
import com.google.privacy.dlp.v2.UpdateStoredInfoTypeRequest;
import com.google.protobuf.FieldMask;
import java.io.IOException;

public class UpdateStoredInfoType {
  public static void main(String[] args) throws IOException {
    // 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 path to file in GCS bucket that holds a collection of words and phrases to be searched by
    // the new infoType detector.
    String filePath = "gs://" + "your-bucket-name" + "/path/to/your/file.txt";
    // The path to the location in a GCS bucket to store the created dictionary.
    String outputPath = "your-cloud-storage-file-set";
    // The name of the stored InfoType which is to be updated.
    String infoTypeId = "your-stored-info-type-id";
    updateStoredInfoType(projectId, filePath, outputPath, infoTypeId);
  }

  // Update the stored info type rebuilding the Custom dictionary.
  public static void updateStoredInfoType(
      String projectId, String filePath, String outputPath, String infoTypeId) throws 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()) {
      // Set path in Cloud Storage.
      CloudStoragePath cloudStoragePath = CloudStoragePath.newBuilder().setPath(outputPath).build();
      CloudStorageFileSet cloudStorageFileSet =
          CloudStorageFileSet.newBuilder().setUrl(filePath).build();

      // Configuration for a custom dictionary created from a data source of any size
      LargeCustomDictionaryConfig largeCustomDictionaryConfig =
          LargeCustomDictionaryConfig.newBuilder()
              .setOutputPath(cloudStoragePath)
              .setCloudStorageFileSet(cloudStorageFileSet)
              .build();

      // Set configuration for stored infoTypes.
      StoredInfoTypeConfig storedInfoTypeConfig =
          StoredInfoTypeConfig.newBuilder()
              .setLargeCustomDictionary(largeCustomDictionaryConfig)
              .build();

      // Set mask to control which fields get updated.
      // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
      FieldMask fieldMask =
          FieldMask.newBuilder()
              .addPaths("large_custom_dictionary.cloud_storage_file_set.url")
              .build();

      // Construct the job creation request to be sent by the client.
      UpdateStoredInfoTypeRequest updateStoredInfoTypeRequest =
          UpdateStoredInfoTypeRequest.newBuilder()
              .setName(
                  StoredInfoTypeName.ofProjectStoredInfoTypeName(projectId, infoTypeId).toString())
              .setConfig(storedInfoTypeConfig)
              .setUpdateMask(fieldMask)
              .build();

      // Send the job creation request and process the response.
      StoredInfoType response = dlp.updateStoredInfoType(updateStoredInfoTypeRequest);

      // Print the results.
      System.out.println("Updated stored InfoType successfully: " + response.getName());
    }
  }
}

Node.js

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

// Import the required libraries
const dlp = require('@google-cloud/dlp');

// Create a DLP client
const dlpClient = new dlp.DlpServiceClient();

// The project ID to run the API call under.
// const projectId = "your-project-id";

// The identifier for the stored infoType
// const infoTypeId = 'github-usernames';

// The path to the location in a Cloud Storage bucket to store the created dictionary
// const outputPath = 'cloud-bucket-path';

// Path of file containing term list
// const cloudStorageFileSet = 'gs://[PATH_TO_GS]';

async function updateStoredInfoType() {
  // Specify configuration of the large custom dictionary including cloudStorageFileSet and outputPath
  const largeCustomDictionaryConfig = {
    outputPath: {
      path: outputPath,
    },
    cloudStorageFileSet: {
      url: fileSetUrl,
    },
  };

  // Construct the job creation request to be sent by the client.
  const updateStoredInfoTypeRequest = {
    name: `projects/${projectId}/storedInfoTypes/${infoTypeId}`,
    config: {
      largeCustomDictionary: largeCustomDictionaryConfig,
    },
    updateMask: {
      paths: ['large_custom_dictionary.cloud_storage_file_set.url'],
    },
  };

  // Send the job creation request and process the response.
  const [response] = await dlpClient.updateStoredInfoType(
    updateStoredInfoTypeRequest
  );

  // Print the results.
  console.log(`InfoType updated successfully: ${JSON.stringify(response)}`);
}
await updateStoredInfoType();

PHP

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\CloudStorageFileSet;
use Google\Cloud\Dlp\V2\CloudStoragePath;
use Google\Cloud\Dlp\V2\LargeCustomDictionaryConfig;
use Google\Cloud\Dlp\V2\StoredInfoTypeConfig;
use Google\Protobuf\FieldMask;

/**
 * Rebuild/Update the stored infoType.
 *
 * @param string $callingProjectId  The Google Cloud Project ID to run the API call under.
 * @param string $gcsPath           The path to file in GCS bucket that holds a collection of words and phrases to be searched by the new infoType detector.
 * @param string $outputgcsPath     The path to the location in a Cloud Storage bucket to store the created dictionary.
 * @param string $storedInfoTypeId  The name of the stored InfoType which is to be updated.
 *
 */
function update_stored_infotype(
    string $callingProjectId,
    string $gcsPath,
    string $outputgcsPath,
    string $storedInfoTypeId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Set path in Cloud Storage.
    $cloudStorageFileSet = (new CloudStorageFileSet())
        ->setUrl($gcsPath);

    // Configuration for a custom dictionary created from a data source of any size
    $largeCustomDictionaryConfig = (new LargeCustomDictionaryConfig())
        ->setOutputPath((new CloudStoragePath())
            ->setPath($outputgcsPath))
        ->setCloudStorageFileSet($cloudStorageFileSet);

    // Set configuration for stored infoTypes.
    $storedInfoTypeConfig = (new StoredInfoTypeConfig())
        ->setLargeCustomDictionary($largeCustomDictionaryConfig);

    // Send the stored infoType creation request and process the response.

    $name = "projects/$callingProjectId/locations/global/storedInfoTypes/" . $storedInfoTypeId;
    // Set mask to control which fields get updated.
    // Refer https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask for constructing the field mask paths.
    $fieldMask = (new FieldMask())
        ->setPaths([
            'large_custom_dictionary.cloud_storage_file_set.url'
        ]);

    // Run request
    $response = $dlp->updateStoredInfoType($name, [
        'config' => $storedInfoTypeConfig,
        'updateMask' => $fieldMask
    ]);

    // Print results
    printf('Successfully update Stored InforType : %s' . PHP_EOL, $response->getName());
}

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import google.cloud.dlp

def update_stored_infotype(
    project: str,
    stored_info_type_id: str,
    gcs_input_file_path: str,
    output_bucket_name: str,
) -> None:
    """Uses the Data Loss Prevention API to update stored infoType
    detector by changing the source term list from one stored in Bigquery
    to one stored in Cloud Storage.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        stored_info_type_id: The identifier of stored infoType which is to
            be updated.
        gcs_input_file_path: The url in the format <bucket>/<path_to_file>
            for the location of the source term list.
        output_bucket_name: The name of the bucket in Google Cloud Storage
            where large dictionary is stored.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Construct the stored infoType configuration dictionary.
    stored_info_type_config = {
        "large_custom_dictionary": {
            "output_path": {"path": f"gs://{output_bucket_name}"},
            "cloud_storage_file_set": {"url": f"gs://{gcs_input_file_path}"},
        }
    }

    # Set mask to control which fields get updated. For more details, refer
    # https://protobuf.dev/reference/protobuf/google.protobuf/#field-mask
    # for constructing the field mask paths.
    field_mask = {"paths": ["large_custom_dictionary.cloud_storage_file_set.url"]}

    # Convert the stored infoType id into a full resource id.
    stored_info_type_name = (
        f"projects/{project}/locations/global/storedInfoTypes/{stored_info_type_id}"
    )

    # Call the API.
    response = dlp.update_stored_info_type(
        request={
            "name": stored_info_type_name,
            "config": stored_info_type_config,
            "update_mask": field_mask,
        }
    )

    # Print the result
    print(f"Updated stored infoType successfully: {response.name}")

REST

Perbarui daftar istilah

Jika Anda hanya memperbarui daftar istilah dalam kamus khusus besar, permintaan storedInfoTypes.patch hanya memerlukan kolom name. Berikan nama resource lengkap untuk infoType tersimpan yang ingin Anda build ulang.

Pola berikut mewakili entri yang valid untuk kolom name:

• organizations/ORGANIZATION_ID/storedInfoTypes/STORED_INFOTYPE_ID
• projects/PROJECT_ID/storedInfoTypes/STORED_INFOTYPE_ID

Ganti STORED_INFOTYPE_ID dengan ID infoType tersimpan yang ingin Anda buat ulang.

Jika Anda tidak mengetahui ID infoType yang tersimpan, panggil metode storedInfoTypes.list untuk melihat daftar semua infoType yang tersimpan saat ini.

Catatan: Meskipun infoTypes yang tersimpan tidak memiliki nomor versi, masing-masing memiliki kolom createTime, yang dimuat ulang dengan setiap build ulang. Gunakan metode storedInfoTypes.get untuk mengambil informasi tentang infoType yang tersimpan, dan gunakan kolom createTime untuk menentukan kapan terakhir kali dibuat ulang.

Contoh

PATCH https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes/STORED_INFOTYPE_ID

Dalam hal ini, isi permintaan tidak diperlukan.

Mengganti daftar istilah sumber

Anda dapat mengubah daftar istilah sumber untuk infoType tersimpan dari yang disimpan di BigQuery menjadi yang tersimpan di Cloud Storage. Gunakan metode storedInfoTypes.patch, tetapi sertakan objek CloudStorageFileSet dalam LargeCustomDictionaryConfig tempat Anda menggunakan objek BigQueryField sebelumnya. Kemudian, tetapkan parameter updateMask ke parameter infoType tersimpan yang Anda buat ulang, dalam format FieldMask. Misalnya, JSON berikut menyatakan di parameter updateMask bahwa URL jalur Cloud Storage telah diperbarui (large_custom_dictionary.cloud_storage_file_set.url):

Contoh

PATCH https://dlp.googleapis.com/v2/projects/PROJECT_ID/storedInfoTypes/github-usernames

{
  "config":{
    "largeCustomDictionary":{
      "cloudStorageFileSet":{
        "url":"gs://[BUCKET_NAME]/[PATH_TO_FILE]"
      }
    }
  },
  "updateMask":"large_custom_dictionary.cloud_storage_file_set.url"
}

Demikian pula, Anda dapat mengubah daftar istilah yang disimpan dalam tabel BigQuery ke daftar istilah yang disimpan di bucket Cloud Storage.

Memindai konten menggunakan detektor kamus kustom yang besar

Memindai konten menggunakan detektor kamus kustom yang besar mirip dengan memindai konten menggunakan detektor infoType kustom lainnya.

Prosedur ini mengasumsikan bahwa Anda memiliki infoType tersimpan yang sudah ada. Untuk informasi selengkapnya, lihat Membuat infoType tersimpan di halaman ini.

Konsol

Anda dapat menerapkan pendeteksi kamus kustom berukuran besar saat melakukan hal berikut:

• Membuat tugas baru
• Membuat atau mengedit pemicu tugas
• Membuat atau mengedit template
• Mengonfigurasi pembuatan profil data

Di bagian Konfigurasi deteksi halaman, di subbagian InfoTypes, Anda dapat menentukan infoType kamus kustom berukuran besar.

1. Klik Kelola infoTypes.
2. Di panel InfoTypes, klik tab Custom.
3. Klik Tambahkan infoType kustom.

4. Di panel Add custom infoType, lakukan hal berikut:

   1. Untuk Type, pilih Stored infoType.
   2. Untuk InfoType, masukkan nama untuk infoType kustom. Anda dapat menggunakan huruf, angka, dan garis bawah.

   3. Untuk Likelihood, pilih tingkat kemungkinan default yang ingin Anda tetapkan ke semua temuan yang cocok dengan infoType kustom ini. Anda dapat lebih menyempurnakan tingkat kemungkinan setiap temuan menggunakan aturan frasa pengaktif.

      Jika Anda tidak menentukan nilai default, tingkat kemungkinan default akan ditetapkan ke VERY_LIKELY. Untuk mengetahui informasi selengkapnya, lihat Kecenderungan kecocokan.

   4. Untuk Sensitivitas, pilih tingkat sensitivitas yang ingin Anda tetapkan ke semua temuan yang cocok dengan infoType kustom ini. Jika Anda tidak menentukan nilai, tingkat sensitivitas temuan tersebut akan ditetapkan ke HIGH.

      Skor sensitivitas digunakan dalam profil data. Saat membuat profil data Anda, Perlindungan Data Sensitif menggunakan skor sensitivitas infoType untuk menghitung tingkat sensitivitas.

   5. Untuk Stored infoType name, pilih infoType tersimpan yang ingin Anda gunakan sebagai dasar infoType kustom baru.

   6. Klik Done untuk menutup panel Add custom infoType.

5. Opsional: Pada tab Built-in, edit pilihan infoType bawaan Anda.

6. Klik Done untuk menutup panel InfoTypes.

   infoType kustom ditambahkan ke daftar infoType yang dipindai oleh Perlindungan Data Sensitif. Namun, pilihan ini belum final sampai Anda menyimpan tugas, pemicu tugas, template, atau konfigurasi pemindaian.

7. Setelah selesai membuat atau mengedit konfigurasi, klik Simpan.

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

using System;
using Google.Api.Gax.ResourceNames;
using Google.Cloud.Dlp.V2;

public class InspectDataWithStoredInfotypes
{
    public static InspectContentResponse Inspect(
        string projectId,
        string storedInfotypePath,
        string text,
        InfoType infoType = null)
    {
        // Instantiate the dlp client.
        var dlp = DlpServiceClient.Create();

        // Construct the infotype if null.
        var infotype = infoType ?? new InfoType { Name = "GITHUB_LOGINS" };

        // Construct the inspect config using stored infotype.
        var inspectConfig = new InspectConfig
        {
            CustomInfoTypes =
            {
                new CustomInfoType
                {
                    InfoType = infotype,
                    StoredType = new StoredType { Name = storedInfotypePath }
                }
            },
            IncludeQuote = true
        };

        // Construct the request using inspect config.
        var request = new InspectContentRequest
        {
            ParentAsLocationName = new LocationName(projectId, "global"),
            InspectConfig = inspectConfig,
            Item = new ContentItem { Value = text }
        };

        // Call the API.
        InspectContentResponse response = dlp.InspectContent(request);

        // Inspect the results.
        var findings = response.Result.Findings;
        Console.WriteLine($"Findings: {findings.Count}");
        foreach (var f in findings)
        {
            Console.WriteLine("\tQuote: " + f.Quote);
            Console.WriteLine("\tInfo type: " + f.InfoType.Name);
            Console.WriteLine("\tLikelihood: " + f.Likelihood);
        }

        return response;
    }
}

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import (
	"context"
	"fmt"
	"io"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
)

// inspectWithStoredInfotype inspects the given text using the specified stored infoType detector.
func inspectWithStoredInfotype(w io.Writer, projectID, infoTypeId, textToDeidentify string) error {
	// projectId := "your-project-id"
	// infoTypeId := "your-info-type-id"
	// textToDeidentify := "This commit was made by kewin2010"

	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,
		},
	}

	// Specify the info type the inspection will look for.
	infoType := &dlppb.InfoType{
		Name: "GITHUB_LOGINS",
	}

	// Specify the stored info type the inspection will look for.
	storedType := &dlppb.StoredType{
		Name: infoTypeId,
	}

	customInfoType := &dlppb.CustomInfoType{
		InfoType: infoType,
		Type: &dlppb.CustomInfoType_StoredType{
			StoredType: storedType,
		},
	}

	// Specify how the content should be inspected.
	inspectConfig := &dlppb.InspectConfig{
		CustomInfoTypes: []*dlppb.CustomInfoType{
			customInfoType,
		},
		IncludeQuote: true,
	}

	// Construct the Inspect request to be sent by the client.
	req := &dlppb.InspectContentRequest{
		Parent:        fmt.Sprintf("projects/%s/locations/global", projectID),
		InspectConfig: inspectConfig,
		Item:          contentItem,
	}

	// Use the client to send the API request.
	resp, err := client.InspectContent(ctx, req)
	if err != nil {
		return err
	}

	// Process the results.
	fmt.Fprintf(w, "Findings: %d\n", len(resp.Result.Findings))
	for _, f := range resp.Result.Findings {
		fmt.Fprintf(w, "\tQuote: %s\n", f.Quote)
		fmt.Fprintf(w, "\tInfo type: %s\n", f.InfoType.Name)
		fmt.Fprintf(w, "\tLikelihood: %s\n", f.Likelihood)
	}
	return nil
}

Java

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.ContentItem;
import com.google.privacy.dlp.v2.CustomInfoType;
import com.google.privacy.dlp.v2.Finding;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectContentRequest;
import com.google.privacy.dlp.v2.InspectContentResponse;
import com.google.privacy.dlp.v2.LocationName;
import com.google.privacy.dlp.v2.ProjectStoredInfoTypeName;
import com.google.privacy.dlp.v2.StoredType;
import java.io.IOException;

public class InspectWithStoredInfotype {

  public static void main(String[] args) throws IOException {
    // 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 sample assumes that you have an existing stored infoType.
    // To create a stored InfoType refer:
    // https://cloud.google.com/dlp/docs/creating-stored-infotypes#create-storedinfotye
    String storedInfoTypeId = "your-info-type-id";
    // The string to de-identify.
    String textToInspect =
        "My phone number is [phone] and my email address is [e-mail].";
    inspectWithStoredInfotype(projectId, storedInfoTypeId, textToInspect);
  }

  //  Inspects the given text using the specified stored infoType detector.
  public static void inspectWithStoredInfotype(
      String projectId, String storedInfoTypeId, String textToInspect) throws 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 content to be inspected.
      ContentItem contentItem = ContentItem.newBuilder().setValue(textToInspect).build();

      InfoType infoType = InfoType.newBuilder().setName("STORED_TYPE").build();

      // Reference to the existing StoredInfoType to inspect the data.
      StoredType storedType = StoredType.newBuilder()
              .setName(ProjectStoredInfoTypeName.of(projectId, storedInfoTypeId).toString())
              .build();

      CustomInfoType customInfoType =
          CustomInfoType.newBuilder().setInfoType(infoType).setStoredType(storedType).build();

      // Construct the configuration for the Inspect request.
      InspectConfig inspectConfig =
          InspectConfig.newBuilder()
              .addCustomInfoTypes(customInfoType)
              .setIncludeQuote(true)
              .build();

      // Construct the Inspect request to be sent by the client.
      InspectContentRequest inspectContentRequest =
          InspectContentRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectConfig(inspectConfig)
              .setItem(contentItem)
              .build();

      // Use the client to send the API request.
      InspectContentResponse response = dlp.inspectContent(inspectContentRequest);

      // Parse the response and process results.
      System.out.println("Findings: " + "" + response.getResult().getFindingsCount());
      for (Finding f : response.getResult().getFindingsList()) {
        System.out.println("\tQuote: " + f.getQuote());
        System.out.println("\tInfoType: " + f.getInfoType().getName());
        System.out.println("\tLikelihood: " + f.getLikelihood() + "\n");
      }
    }
  }
}

Node.js

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

// Imports the Google Cloud Data Loss Prevention library
const DLP = require('@google-cloud/dlp');

// Instantiates a client
const dlp = new DLP.DlpServiceClient();

// The project ID to run the API call under.
// const projectId = 'your-project-id';

// The custom info-type id created and stored in the bucket.
// const infoTypeId = 'your-info-type-id';

// The string to inspect.
// const string = 'My phone number is [phone] and my email address is [e-mail].';

async function inspectWithStoredInfotype() {
  // Reference to the existing StoredInfoType to inspect the data.
  const customInfoType = {
    infoType: {
      name: 'GITHUB_LOGINS',
    },
    storedType: {
      name: infoTypeId,
    },
  };

  // Construct the configuration for the Inspect request.
  const inspectConfig = {
    customInfoTypes: [customInfoType],
    includeQuote: true,
  };

  // Construct the Inspect request to be sent by the client.
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectConfig: inspectConfig,
    item: {
      value: string,
    },
  };
  // Run request
  const [response] = await dlp.inspectContent(request);

  // Print Findings
  const findings = response.result.findings;
  if (findings.length > 0) {
    console.log(`Findings: ${findings.length}\n`);
    findings.forEach(finding => {
      console.log(`InfoType: ${finding.infoType.name}`);
      console.log(`\tQuote: ${finding.quote}`);
      console.log(`\tLikelihood: ${finding.likelihood} \n`);
    });
  } else {
    console.log('No findings.');
  }
}
await inspectWithStoredInfotype();

PHP

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

use Google\Cloud\Dlp\V2\DlpServiceClient;
use Google\Cloud\Dlp\V2\ContentItem;
use Google\Cloud\Dlp\V2\CustomInfoType;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\Likelihood;
use Google\Cloud\Dlp\V2\StoredType;

/**
 * Inspect with stored infoType.
 * Scan content using a large custom dictionary detector.
 *
 * @param string $projectId             The Google Cloud Project ID to run the API call under.
 * @param string $storedInfoTypeName    The name of the stored infotype whose This value must be in the format
 * projects/projectName/(locations/locationId)/storedInfoTypes/storedInfoTypeName.
 * @param string $textToInspect         The string to inspect.
 */
function inspect_with_stored_infotype(
    string $projectId,
    string $storedInfoTypeName,
    string $textToInspect
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    $parent = "projects/$projectId/locations/global";

    // Specify the content to be inspected.
    $item = (new ContentItem())
        ->setValue($textToInspect);

    // Reference to the existing StoredInfoType to inspect the data.
    $customInfoType = (new CustomInfoType())
        ->setInfoType((new InfoType())
            ->setName('STORED_TYPE'))
        ->setStoredType((new StoredType())
            ->setName($storedInfoTypeName));

    // Construct the configuration for the Inspect request.
    $inspectConfig = (new InspectConfig())
        ->setCustomInfoTypes([$customInfoType])
        ->setIncludeQuote(true);

    // Run request.
    $response = $dlp->inspectContent([
        'parent' => $parent,
        'inspectConfig' => $inspectConfig,
        'item' => $item
    ]);

    // Print the results.
    $findings = $response->getResult()->getFindings();
    if (count($findings) == 0) {
        printf('No findings.' . PHP_EOL);
    } else {
        printf('Findings:' . PHP_EOL);
        foreach ($findings as $finding) {
            printf('  Quote: %s' . PHP_EOL, $finding->getQuote());
            printf('  Info type: %s' . PHP_EOL, $finding->getInfoType()->getName());
            printf('  Likelihood: %s' . PHP_EOL, Likelihood::name($finding->getLikelihood()));
        }
    }
}

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif.

Untuk mengautentikasi Perlindungan Data Sensitif, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

Lihat di GitHub Masukan

import google.cloud.dlp

def inspect_with_stored_infotype(
    project: str,
    stored_info_type_id: str,
    content_string: str,
) -> None:
    """Uses the Data Loss Prevention API to inspect/scan content using stored
    infoType.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        content_string: The string to inspect.
        stored_info_type_id: The identifier of stored infoType used to inspect.
    """

    # Instantiate a client.
    dlp = google.cloud.dlp_v2.DlpServiceClient()

    # Convert stored infoType id into full resource id
    stored_type_name = f"projects/{project}/storedInfoTypes/{stored_info_type_id}"

    # Construct a custom info type dictionary using stored infoType.
    custom_info_types = [
        {
            "info_type": {"name": "STORED_TYPE"},
            "stored_type": {
                "name": stored_type_name,
            },
        }
    ]

    # Construct the inspection configuration dictionary.
    inspect_config = {
        "custom_info_types": custom_info_types,
        "include_quote": True,
    }

    # Construct the `item` to be inspected using stored infoType.
    item = {"value": content_string}

    # Convert the project id into a full resource id.
    parent = f"projects/{project}/locations/global"

    # Call the API.
    response = dlp.inspect_content(
        request={
            "parent": parent,
            "inspect_config": inspect_config,
            "item": item,
        }
    )

    # Print out the results.
    if response.result.findings:
        for finding in response.result.findings:
            print(f"Quote: {finding.quote}")
            print(f"Info type: {finding.info_type.name}")
            print(f"Likelihood: {finding.likelihood}")
    else:
        print("No findings.")

REST

Saat dikirim ke metode content.inspect, contoh berikut memindai teks tertentu menggunakan detektor infoType tersimpan yang ditentukan. Parameter infoType diperlukan karena semua infoTypes kustom harus memiliki nama yang tidak bertentangan dengan infoTypes bawaan atau infoType kustom lainnya. Parameter storedType berisi jalur resource lengkap dari infoType yang tersimpan.

Input JSON

POST https://dlp.googleapis.com/v2/projects/PROJECT_ID/content:inspect

{
  "inspectConfig":{
    "customInfoTypes":[
      {
        "infoType":{
          "name":"GITHUB_LOGINS"
        },
        "storedType":{
          "name":"projects/PROJECT_ID/storedInfoTypes/github-logins"
        }
      }
    ]
  },
  "item":{
    "value":"The commit was made by githubuser."
  }
}

Memecahkan masalah error

Jika Anda mendapatkan error saat mencoba membuat infoType tersimpan dari daftar istilah yang disimpan di Cloud Storage, kemungkinan penyebabnya adalah sebagai berikut:

• Anda mencapai batas atas untuk infoTypes yang tersimpan. Bergantung pada masalahnya, ada beberapa solusi:
  • Jika Anda mencapai batas atas untuk satu file input di Cloud Storage (200 MB), coba bagi file tersebut menjadi beberapa file. Anda dapat menggunakan beberapa file untuk menyusun satu kamus kustom selama ukuran gabungan semua file tidak melebihi 1 GB.
  • BigQuery tidak memiliki batasan yang sama dengan Cloud Storage. Pertimbangkan untuk memindahkan persyaratan ke dalam tabel BigQuery. Ukuran maksimum kolom kamus kustom di BigQuery adalah 1 GB dan jumlah baris maksimum adalah 5.000.000.
  • Jika file daftar istilah melebihi semua batas yang berlaku untuk daftar istilah sumber, Anda harus membagi file daftar istilah menjadi beberapa file dan membuat kamus untuk setiap file. Kemudian, buat tugas pemindaian terpisah untuk setiap kamus.
• Satu atau beberapa istilah Anda tidak berisi setidaknya satu huruf atau angka. Perlindungan Data Sensitif tidak dapat memindai istilah yang hanya terdiri dari spasi atau simbol. Teks harus memiliki setidaknya satu huruf atau angka. Lihat daftar istilah Anda dan lihat apakah ada istilah yang disertakan, lalu perbaiki atau hapus istilah tersebut.
• Daftar istilah Anda berisi frasa dengan terlalu banyak "komponen". Komponen dalam konteks ini adalah urutan berkelanjutan yang hanya berisi huruf, angka saja, atau hanya karakter non-huruf maupun non-angka seperti spasi atau simbol. Lihat daftar istilah Anda dan lihat apakah ada istilah yang disertakan, lalu perbaiki atau hapus istilah tersebut.
• Agen layanan Perlindungan Data Sensitif tidak memiliki akses ke data sumber kamus atau ke bucket Cloud Storage untuk menyimpan file kamus. Untuk memperbaiki masalah ini, berikan peran Storage Admin (roles/storage.admin) atau peran BigQuery Data Owner (roles/bigquery.dataOwner) dan BigQuery Job User (roles/bigquery.jobUser) kepada agen layanan Perlindungan Data Sensitif.

Ringkasan API

Pembuatan infoType tersimpan diperlukan jika Anda membuat detektor kamus kustom yang besar.

Catatan: Jika Anda membuat pendeteksi kamus kustom reguler atau detektor ekspresi reguler, Anda tidak perlu membuat infoType yang tersimpan. Lebih mudah untuk menentukannya secara langsung dalam objek CustomInfoType.

infoType tersimpan ditampilkan dalam Perlindungan Data Sensitif oleh objek StoredInfoType. Class ini terdiri dari objek terkait berikut:

• StoredInfoTypeVersion mencakup tanggal dan waktu pembuatan serta lima pesan error terakhir yang terjadi saat versi saat ini dibuat.

  • StoredInfoTypeConfig berisi konfigurasi infoType yang tersimpan, termasuk nama dan deskripsinya. Untuk kamus kustom berukuran besar, type harus berupa LargeCustomDictionaryConfig.

    • LargeCustomDictionaryConfig menentukan kedua hal berikut:
      • Lokasi dalam Cloud Storage atau BigQuery tempat daftar frasa disimpan.
      • Lokasi di Cloud Storage untuk menyimpan file kamus yang dihasilkan.

  • StoredInfoTypeState berisi status versi terbaru dan versi tertunda dari infoType yang tersimpan. Informasi status mencakup apakah infoType yang tersimpan sedang dibuat ulang, siap digunakan, atau tidak valid.

Detail pencocokan kamus

Berikut adalah panduan tentang cara Perlindungan Data Sensitif mencocokkan kata dan frasa kamus. Poin-poin ini berlaku untuk kamus khusus reguler dan besar:

• Kata kamus tidak peka huruf besar/kecil. Jika kamus Anda menyertakan Abby, kamus akan cocok dengan abby, ABBY, Abby, dan seterusnya.
• Semua karakter—dalam kamus atau dalam konten yang akan dipindai—selain huruf dan angka yang terdapat dalam Basic Multilingual Plane Unicode dianggap sebagai spasi kosong saat memindai kecocokan. Jika kamus Anda memindai Abby Abernathy, kamus akan cocok di abby abernathy, Abby, Abernathy, Abby (ABERNATHY), dan seterusnya.
• Karakter yang mengelilingi pencocokan apa pun harus memiliki jenis yang berbeda (huruf atau angka) dari karakter yang bersebelahan dalam kata. Jika kamus Anda memindai Abi, kamus akan cocok dengan tiga karakter pertama Abi904, tetapi bukan Abigail.
• Kata kamus yang berisi karakter dalam Sistem Multibahasa Tambahan standar Unicode dapat menghasilkan temuan yang tidak terduga. Contoh karakter tersebut adalah bahasa China, Jepang, Korea, dan emoji.

Untuk membuat, mengedit, atau menghapus infoType yang tersimpan, Anda menggunakan metode berikut:

• storedInfoTypes.create: Membuat infoType tersimpan baru dengan mempertimbangkan StoredInfoTypeConfig yang Anda tentukan.
• storedInfoTypes.patch: Membuat ulang infoType tersimpan dengan StoredInfoTypeConfig baru yang Anda tentukan. Jika tidak ada yang ditentukan, metode ini akan membuat versi baru dari infoType tersimpan dengan StoredInfoTypeConfig yang ada.
• storedInfoTypes.get: Mengambil StoredInfoTypeConfig dan versi tertunda dari infoType tersimpan yang ditentukan.
• storedInfoTypes.list: Mencantumkan semua infoType yang tersimpan saat ini.
• storedInfoTypes.delete: Menghapus infoType tersimpan yang ditentukan.