Membuat template inspeksi Perlindungan Data Sensitif

Topik ini menjelaskan secara mendetail cara membuat template inspeksi baru. Untuk melihat penjelasan singkat tentang cara membuat template inspeksi baru menggunakan konsolGoogle Cloud , lihat Panduan memulai: Membuat template inspeksi Perlindungan Data Sensitif.

Tentang template

Anda dapat menggunakan template untuk membuat dan mempertahankan informasi konfigurasi yang akan digunakan dengan Perlindungan Data Sensitif. Template berguna untuk memisahkan informasi konfigurasi—seperti data yang Anda periksa dan cara melakukan de-identifikasi—dari penerapan yang Anda minta. Template menyediakan cara untuk menggunakan kembali konfigurasi dan memungkinkan konsistensi di seluruh pengguna dan set data. Selain itu, setiap kali Anda memperbarui template, template tersebut akan diperbarui untuk setiap pemicu tugas yang menggunakannya.

Sensitive Data Protection mendukung template inspeksi, yang dibahas dalam topik ini, dan template de-identifikasi, yang dibahas dalam Membuat template de-identifikasi Sensitive Data Protection.

Untuk mengetahui informasi konseptual tentang template di Perlindungan Data Sensitif, lihat Template.

Membuat template inspeksi baru

Penting: Kode di halaman ini mengharuskan Anda menyiapkan klien Perlindungan Data Sensitif terlebih dahulu. Untuk mengetahui informasi selengkapnya tentang cara menginstal dan membuat klien Perlindungan Data Sensitif, lihat Library klien Perlindungan Data Sensitif. (Mengirim JSON ke endpoint REST Sensitive Data Protection tidak memerlukan library klien.)

Konsol

Di konsol Google Cloud , buka halaman Create template.

Buka Membuat template

Halaman Buat template berisi bagian berikut:

• Tentukan template
• Mengonfigurasi deteksi

Tentukan template

Di bagian Tentukan template, masukkan ID untuk template pemeriksaan. Dengan cara ini, Anda akan merujuk ke template saat menjalankan tugas, membuat pemicu tugas, dan sebagainya. Anda dapat menggunakan huruf, angka, dan tanda hubung. Jika mau, Anda juga dapat memasukkan nama tampilan yang lebih mudah dipahami, serta deskripsi untuk lebih mengingat fungsi template.

Di kolom Lokasi resource, pilih region tempat data yang akan diperiksa disimpan. Template inspeksi yang Anda buat juga disimpan di region ini. Jika Anda ingin dapat menggunakan template pemeriksaan baru di region mana pun, pilih Global (any region).

Konfigurasikan deteksi

Selanjutnya, Anda mengonfigurasi apa yang dideteksi Sensitive Data Protection dalam konten Anda dengan memilih infoType dan opsi lainnya.

Detektor InfoType menemukan data sensitif dari jenis tertentu. Misalnya, detektor infoType US_SOCIAL_SECURITY_NUMBER Perlindungan Data Sensitif menemukan nomor Jaminan Sosial AS. Selain pendeteksi infoType bawaan, Anda dapat membuat pendeteksi infoType kustom Anda sendiri.

Di bagian InfoTypes, pilih detektor infoType yang sesuai dengan jenis data yang ingin Anda pindai. Sebaiknya jangan biarkan bagian ini kosong. Tindakan ini menyebabkan Sensitive Data Protection memindai data Anda dengan serangkaian infoType default, yang mungkin mencakup infoType yang tidak Anda perlukan. Informasi selengkapnya tentang setiap detektor disediakan dalam Referensi detektor InfoType.

Untuk mengetahui informasi selengkapnya tentang cara mengelola infoType bawaan dan kustom di bagian ini, lihat Mengelola infoType melalui konsol Google Cloud .

Sekumpulan aturan inspeksi

Kumpulan aturan inspeksi memungkinkan Anda menyesuaikan detektor infoType bawaan dan kustom menggunakan aturan konteks. Jenis aturan inspeksi adalah:

• Aturan pengecualian, yang membantu mengecualikan temuan yang salah atau tidak diinginkan.
• Aturan frasa pengaktif, yang membantu mendeteksi temuan tambahan.
• Aturan penyesuaian, yang menyesuaikan kemungkinan temuan berdasarkan konteks kemunculannya.

Untuk menambahkan kumpulan aturan baru, tentukan terlebih dahulu satu atau beberapa detektor infoType bawaan atau kustom di bagian InfoTypes. Pilih semua detektor infoType yang diubah oleh kumpulan aturan Anda (infoType target) atau digunakan untuk penilaian (infoType konteks). Kemudian, lakukan hal berikut:

1. Klik Add a ruleset.
2. Di kolom Pilih infoType target, pilih infoType yang diubah oleh ruleset jika aturan terpenuhi.
3. Klik Tambahkan aturan untuk membuka menu dengan opsi, termasuk Aturan kata aktif, Aturan pengecualian, dan Aturan penyesuaian.

Untuk membuat aturan kata pemicu, pilih Aturan kata pemicu. Kemudian, lakukan hal berikut:

1. Di kolom Hotword, masukkan ekspresi reguler yang dicari oleh Sensitive Data Protection.
2. Dari menu Kedekatan frasa pengaktif, pilih apakah frasa pengaktif yang Anda masukkan ditemukan sebelum atau setelah infoType yang dipilih.
3. Di Jarak frasa pengaktif dari infoType, masukkan perkiraan jumlah karakter antara frasa pengaktif dan infoType yang dipilih.
4. Di Penyesuaian tingkat keyakinan, pilih apakah akan menetapkan tingkat kemungkinan tetap untuk kecocokan, atau meningkatkan atau menurunkan tingkat kemungkinan default sebesar jumlah tertentu.

Untuk membuat aturan pengecualian, pilih Aturan pengecualian dan jenis aturan pengecualian yang akan dibuat, misalnya, Ekspresi reguler. Kemudian, lakukan hal berikut:

1. Bergantung pada jenis aturan pengecualian yang Anda pilih, masukkan ekspresi reguler, frasa, frasa pengaktif, atau infoType konteks yang harus ditemukan agar aturan dapat diterapkan.
2. Bergantung pada jenis aturan pengecualian yang Anda pilih, tetapkan jenis pencocokan atau jenis pencocokan gambar:
• Jika Anda memilih aturan pengecualian berbasis teks, pilih salah satu jenis pencocokan berikut:
• Pencocokan penuh: Temuan harus cocok sepenuhnya dengan infoType teks atau konteks yang Anda berikan.
• Pencocokan parsial: Substring temuan harus cocok dengan teks atau infoType konteks yang Anda berikan.
• Pencocokan terbalik: Temuan tidak boleh cocok dengan teks atau infoType konteks yang Anda berikan.
• Jika Anda memilih aturan pengecualian berbasis gambar, pilih hubungan spasial yang diperlukan antara target dan infoType konteks. Misalnya, jika Anda memilih Mencakup, penemuan konteks harus mencakup penemuan target agar aturan dapat diterapkan.

Untuk membuat aturan penyesuaian, pilih Aturan penyesuaian dan jenis aturan penyesuaian, misalnya, Sesuaikan menurut temuan gambar. Kemudian, lakukan hal berikut:

1. Di kolom Context infoTypes, pilih detektor infoType yang memberikan konteks untuk temuan target. Sensitive Data Protection menggunakan infoType konteks untuk menilai apakah harus menyesuaikan infoType target.
2. Di kolom Kemungkinan minimum, pilih tingkat kemungkinan terendah yang dapat dimiliki infoTypes konteks dan tetap memicu aturan penyesuaian. Jika nilai kemungkinan konteks yang terdeteksi lebih rendah dari nilai ini, Sensitive Data Protection tidak akan menyesuaikan kemungkinan temuan target.
3. Untuk temuan gambar, di kolom Jenis penampungan gambar, pilih hubungan spasial yang diperlukan antara target dan infoType konteks. Misalnya, jika Anda memilih Mencakup, temuan konteks harus mencakup temuan target agar aturan dapat diterapkan.
4. Di kolom Kemungkinan, pilih tingkat kemungkinan baru yang akan ditetapkan ke temuan target.

Anda dapat menambahkan lebih banyak set aturan untuk lebih menyaring hasil pemindaian.

Ambang batas keyakinan

Setiap kali mendeteksi potensi kecocokan untuk data sensitif, Perlindungan Data Sensitif akan menetapkan nilai kemungkinan pada skala dari "Sangat tidak mungkin" hingga "Sangat mungkin". Saat Anda menetapkan nilai kemungkinan di sini, Anda menginstruksikan Perlindungan Data Sensitif untuk hanya mencocokkan data yang sesuai dengan nilai kemungkinan tersebut atau yang lebih tinggi.

Nilai default "Mungkin" sudah cukup untuk sebagian besar tujuan. Jika Anda sering mendapatkan kecocokan yang terlalu luas, geser penggeser ke atas. Jika Anda mendapatkan terlalu sedikit kecocokan, gerakkan penggeser ke bawah.

Setelah selesai, klik Buat untuk membuat template. Halaman informasi ringkasan template akan muncul.

Untuk kembali ke halaman utama Sensitive Data Protection, klik panah Kembali di konsol Google Cloud .

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

public class InspectTemplateCreate
{
    public static InspectTemplate Create(
        string projectId,
        string templateId,
        string displayName,
        string description,
        Likelihood likelihood,
        int maxFindings,
        bool includeQuote)
    {
        var client = DlpServiceClient.Create();

        var request = new CreateInspectTemplateRequest
        {
            Parent = new LocationName(projectId, "global").ToString(),
            InspectTemplate = new InspectTemplate
            {
                DisplayName = displayName,
                Description = description,
                InspectConfig = new InspectConfig
                {
                    MinLikelihood = likelihood,
                    Limits = new InspectConfig.Types.FindingLimits
                    {
                        MaxFindingsPerRequest = maxFindings
                    },
                    IncludeQuote = includeQuote
                },
            },
            TemplateId = templateId
        };

        var response = client.CreateInspectTemplate(request);

        Console.WriteLine($"Successfully created template {response.Name}.");

        return response;
    }
}

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// createInspectTemplate creates a template with the given configuration.
func createInspectTemplate(w io.Writer, projectID string, templateID, displayName, description string, infoTypeNames []string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"
	// displayName := "My Template"
	// description := "My template description"
	// infoTypeNames := []string{"US_SOCIAL_SECURITY_NUMBER"}

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Convert the info type strings to a list of InfoTypes.
	var infoTypes []*dlppb.InfoType
	for _, it := range infoTypeNames {
		infoTypes = append(infoTypes, &dlppb.InfoType{Name: it})
	}

	// Create a configured request.
	req := &dlppb.CreateInspectTemplateRequest{
		Parent:     fmt.Sprintf("projects/%s/locations/global", projectID),
		TemplateId: templateID,
		InspectTemplate: &dlppb.InspectTemplate{
			DisplayName: displayName,
			Description: description,
			InspectConfig: &dlppb.InspectConfig{
				InfoTypes:     infoTypes,
				MinLikelihood: dlppb.Likelihood_POSSIBLE,
				Limits: &dlppb.InspectConfig_FindingLimits{
					MaxFindingsPerRequest: 10,
				},
			},
		},
	}
	// Send the request.
	resp, err := client.CreateInspectTemplate(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateInspectTemplate: %w", err)
	}
	// Print the result.
	fmt.Fprintf(w, "Successfully created inspect template: %v", resp.GetName())
	return nil
}

Java

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.CreateInspectTemplateRequest;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

class TemplatesCreate {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    createInspectTemplate(projectId);
  }

  // Creates a template to persist configuration information
  public static void createInspectTemplate(String projectId) 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 dlpServiceClient = DlpServiceClient.create()) {
      // 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());

      // Construct the inspection configuration for the template
      InspectConfig inspectConfig = InspectConfig.newBuilder().addAllInfoTypes(infoTypes).build();

      // Optionally set a display name and a description for the template
      String displayName = "Inspection Config Template";
      String description = "Save configuration for future inspection jobs";

      // Build the template
      InspectTemplate inspectTemplate =
          InspectTemplate.newBuilder()
              .setInspectConfig(inspectConfig)
              .setDisplayName(displayName)
              .setDescription(description)
              .build();

      // Create the request to be sent by the client
      CreateInspectTemplateRequest createInspectTemplateRequest =
          CreateInspectTemplateRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setInspectTemplate(inspectTemplate)
              .build();

      // Send the request to the API and process the response
      InspectTemplate response =
          dlpServiceClient.createInspectTemplate(createInspectTemplateRequest);
      System.out.printf("Template created: %s", response.getName());
    }
  }
}

Node.js

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

// 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 = 'my-project';

// The minimum likelihood required before returning a match
// const minLikelihood = 'LIKELIHOOD_UNSPECIFIED';

// The maximum number of findings to report per request (0 = server maximum)
// const maxFindings = 0;

// The infoTypes of information to match
// const infoTypes = [{ name: 'PHONE_NUMBER' }, { name: 'EMAIL_ADDRESS' }, { name: 'CREDIT_CARD_NUMBER' }];

// Whether to include the matching string
// const includeQuote = true;

// (Optional) The name of the template to be created.
// const templateId = 'my-template';

// (Optional) The human-readable name to give the template
// const displayName = 'My template';

async function createInspectTemplate() {
  // Construct the inspection configuration for the template
  const inspectConfig = {
    infoTypes: infoTypes,
    minLikelihood: minLikelihood,
    includeQuote: includeQuote,
    limits: {
      maxFindingsPerRequest: maxFindings,
    },
  };

  // Construct template-creation request
  const request = {
    parent: `projects/${projectId}/locations/global`,
    inspectTemplate: {
      inspectConfig: inspectConfig,
      displayName: displayName,
    },
    templateId: templateId,
  };

  const [response] = await dlp.createInspectTemplate(request);
  const templateName = response.name;
  console.log(`Successfully created template ${templateName}.`);
}
createInspectTemplate();

PHP

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\CreateInspectTemplateRequest;
use Google\Cloud\Dlp\V2\InfoType;
use Google\Cloud\Dlp\V2\InspectConfig;
use Google\Cloud\Dlp\V2\InspectConfig\FindingLimits;
use Google\Cloud\Dlp\V2\InspectTemplate;
use Google\Cloud\Dlp\V2\Likelihood;

/**
 * Create a new DLP inspection configuration template.
 *
 * @param string $callingProjectId project ID to run the API call under
 * @param string $templateId       name of the template to be created
 * @param string $displayName      (Optional) The human-readable name to give the template
 * @param string $description      (Optional) A description for the trigger to be created
 * @param int    $maxFindings      (Optional) The maximum number of findings to report per request (0 = server maximum)
 */
function create_inspect_template(
    string $callingProjectId,
    string $templateId,
    string $displayName = '',
    string $description = '',
    int $maxFindings = 0
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // ----- Construct inspection config -----
    // The infoTypes of information to match
    $personNameInfoType = (new InfoType())
        ->setName('PERSON_NAME');
    $phoneNumberInfoType = (new InfoType())
        ->setName('PHONE_NUMBER');
    $infoTypes = [$personNameInfoType, $phoneNumberInfoType];

    // Whether to include the matching string in the response
    $includeQuote = true;

    // The minimum likelihood required before returning a match
    $minLikelihood = likelihood::LIKELIHOOD_UNSPECIFIED;

    // Specify finding limits
    $limits = (new FindingLimits())
        ->setMaxFindingsPerRequest($maxFindings);

    // Create the configuration object
    $inspectConfig = (new InspectConfig())
        ->setMinLikelihood($minLikelihood)
        ->setLimits($limits)
        ->setInfoTypes($infoTypes)
        ->setIncludeQuote($includeQuote);

    // Construct inspection template
    $inspectTemplate = (new InspectTemplate())
        ->setInspectConfig($inspectConfig)
        ->setDisplayName($displayName)
        ->setDescription($description);

    // Run request
    $parent = "projects/$callingProjectId/locations/global";
    $createInspectTemplateRequest = (new CreateInspectTemplateRequest())
        ->setParent($parent)
        ->setInspectTemplate($inspectTemplate)
        ->setTemplateId($templateId);
    $template = $dlp->createInspectTemplate($createInspectTemplateRequest);

    // Print results
    printf('Successfully created template %s' . PHP_EOL, $template->getName());
}

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

from typing import List
from typing import Optional

import google.cloud.dlp


def create_inspect_template(
    project: str,
    info_types: List[str],
    template_id: Optional[str] = None,
    display_name: Optional[str] = None,
    min_likelihood: Optional[int] = None,
    max_findings: Optional[int] = None,
    include_quote: Optional[bool] = None,
) -> None:
    """Creates a Data Loss Prevention API inspect template.
    Args:
        project: The Google Cloud project id to use as a parent resource.
        info_types: A list of strings representing info types to look for.
            A full list of info type categories can be fetched from the API.
        template_id: The id of the template. If omitted, an id will be randomly
            generated.
        display_name: The optional display name of the template.
        min_likelihood: A string representing the minimum likelihood threshold
            that constitutes a match. One of: 'LIKELIHOOD_UNSPECIFIED',
            'VERY_UNLIKELY', 'UNLIKELY', 'POSSIBLE', 'LIKELY', 'VERY_LIKELY'.
        max_findings: The maximum number of findings to report; 0 = no maximum.
        include_quote: Boolean for whether to display a quote of the detected
            information in the results.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

    # Prepare info_types by converting the list of strings into a list of
    # dictionaries (protos are also accepted).
    info_types = [{"name": info_type} for info_type in info_types]

    # Construct the configuration dictionary. Keys which are None may
    # optionally be omitted entirely.
    inspect_config = {
        "info_types": info_types,
        "min_likelihood": min_likelihood,
        "include_quote": include_quote,
        "limits": {"max_findings_per_request": max_findings},
    }

    inspect_template = {
        "inspect_config": inspect_config,
        "display_name": display_name,
    }

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

    # Call the API.
    response = dlp.create_inspect_template(
        request={
            "parent": parent,
            "inspect_template": inspect_template,
            "template_id": template_id,
        }
    )

    print(f"Successfully created template {response.name}")

REST

Template inspeksi adalah konfigurasi inspeksi yang dapat digunakan ulang beserta beberapa metadata. Dalam istilah API, objek InspectTemplate secara efektif adalah objek InspectConfig yang menyertakan beberapa kolom metadata lagi, seperti nama tampilan dan deskripsi. Oleh karena itu, untuk membuat template inspeksi baru, langkah-langkah dasarnya adalah:

1. Mulai dengan objek InspectConfig.
2. Panggil atau POST metode create dari resource projects.inspectTemplates atau organizations.inspectTemplates, termasuk dalam permintaan Anda objek InspectTemplate yang berisi nama tampilan, deskripsi, dan objek InspectConfig tersebut.

InspectTemplate yang dikembalikan akan segera siap digunakan. Anda dapat mereferensikannya dalam panggilan atau tugas lain berdasarkan name-nya. Anda dapat mencantumkan template yang ada dengan memanggil metode *.inspectTemplates.list. Untuk melihat template tertentu, panggil metode *.inspectTemplates.get. Perhatikan bahwa batas jumlah template yang dapat Anda buat adalah 1.000.

Jika Anda sudah memiliki pengalaman dalam memeriksa teks, gambar, atau konten terstruktur untuk menemukan konten sensitif menggunakan Sensitive Data Protection, Anda sudah membuat objek InspectConfig. Satu langkah tambahan mengubahnya menjadi objek InspectTemplate.

JSON berikut adalah contoh yang dapat Anda kirim ke metode projects.inspectTemplates.create. JSON ini membuat template baru dengan nama tampilan dan deskripsi yang diberikan, serta memindai kecocokan pada infoType PHONE_NUMBER dan US_TOLLFREE_PHONE_NUMBER. Hasilnya akan mencakup hingga 100 kecocokan yang memiliki kemungkinan setidaknya POSSIBLE, dan akan menyertakan cuplikan konteks untuk setiap kecocokan.

Input JSON:

POST https://dlp.googleapis.com/v2/projects/[PROJECT_ID]/inspectTemplates?key={YOUR_API_KEY}

{
  "inspectTemplate":{
    "displayName":"Phone number inspection",
    "description":"Scans for phone numbers",
    "inspectConfig":{
      "infoTypes":[
        {
          "name":"PHONE_NUMBER"
        },
        {
          "name":"US_TOLLFREE_PHONE_NUMBER"
        }
      ],
      "minLikelihood":"POSSIBLE",
      "limits":{
        "maxFindingsPerRequest":100
      },
      "includeQuote":true
    }
  }
}

Output JSON:

JSON respons akan terlihat seperti berikut:

{
  "name":"projects/[PROJECT_ID]/inspectTemplates/[JOB_ID]",
  "displayName":"Phone number inspection",
  "description":"Scans for phone numbers",
  "createTime":"2018-11-30T07:26:28.164136Z",
  "updateTime":"2018-11-30T07:26:28.164136Z",
  "inspectConfig":{
    "infoTypes":[
      {
        "name":"PHONE_NUMBER"
      },
      {
        "name":"US_TOLLFREE_PHONE_NUMBER"
      }
    ],
    "minLikelihood":"POSSIBLE",
    "limits":{
      "maxFindingsPerRequest":100
    },
    "includeQuote":true
  }
}

Catatan: Template ini dibuat di level project, tetapi Anda juga dapat membuatnya di level organisasi menggunakan metode organizations.inspectTemplates.create.

Untuk mencobanya dengan cepat, Anda dapat menggunakan APIs Explorer yang disematkan di bawah. Untuk informasi umum tentang penggunaan JSON untuk mengirim permintaan ke DLP API, lihat mulai cepat JSON.

Menggunakan template inspeksi

Setelah membuat template inspeksi baru, Anda dapat menggunakannya saat membuat tugas inspeksi atau pemicu tugas baru. Setiap kali Anda memperbarui template tersebut, template tersebut akan diperbarui di pemicu tugas yang menggunakannya. Untuk mengetahui informasi selengkapnya, termasuk contoh kode, lihat:

• Memeriksa penyimpanan dan database untuk data sensitif
• Membuat dan menjadwalkan tugas inspeksi Sensitive Data Protection

Konsol

Untuk mulai menggunakan template baru dengan cepat, ikuti petunjuk yang diberikan di Mulai cepat membuat template inspeksi Sensitive Data Protection dengan perubahan berikut:

• Di bagian Konfigurasi deteksi > Template, klik di kolom Nama template, lalu pilih template yang baru saja Anda buat.

Untuk mengetahui panduan yang lebih mendalam tentang cara memindai konten Anda, lihat Membuat dan menjadwalkan tugas inspeksi Sensitive Data Protection, dengan memperhatikan bagian "Konfigurasi deteksi".

REST

Anda dapat menggunakan ID template yang ditentukan saat membuat template di mana pun inspectTemplateName diterima, seperti:

• projects.content.inspect: Menemukan data yang berpotensi sensitif dalam konten menggunakan template sebagai konfigurasinya.
• projects.content.deidentify: Menemukan dan melakukan de-identifikasi data yang berpotensi sensitif dalam konten menggunakan template sebagai konfigurasinya. Perhatikan bahwa metode ini menggunakan template inspeksi dan template de-identifikasi.
• projects.dlpJobs.create, dalam objek InspectJobConfig: Membuat tugas inspeksi yang menyertakan template sebagai konfigurasinya.

Mencantumkan template inspeksi

Untuk mencantumkan semua template inspeksi yang telah dibuat dalam project atau organisasi saat ini:

Konsol

Catatan: Saat ini tidak ada cara untuk melihat template tingkat organisasi di konsol.

1. Di konsol Google Cloud , buka halaman Konfigurasi Sensitive Data Protection.

   Buka Configuration

2. Pilih project yang berisi templat inspeksi.

3. Klik tab Template.

Konsol menampilkan daftar semua template inspeksi untuk project saat ini.

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

public class InspectTemplateList
{
    public static PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> List(string projectId)
    {
        var client = DlpServiceClient.Create();

        var response = client.ListInspectTemplates(
            new ListInspectTemplatesRequest
            {
                Parent = new LocationName(projectId, "global").ToString(),
            }
        );

        // Uncomment to list templates
        //PrintTemplates(response);

        return response;
    }

    public static void PrintTemplates(PagedEnumerable<ListInspectTemplatesResponse, InspectTemplate> response)
    {
        foreach (var template in response)
        {
            Console.WriteLine($"Template {template.Name}:");
            Console.WriteLine($"\tDisplay Name: {template.DisplayName}");
            Console.WriteLine($"\tDescription: {template.Description}");
            Console.WriteLine($"\tCreated: {template.CreateTime}");
            Console.WriteLine($"\tUpdated: {template.UpdateTime}");
            Console.WriteLine("Configuration:");
            Console.WriteLine($"\tMin Likelihood: {template.InspectConfig?.MinLikelihood}");
            Console.WriteLine($"\tInclude quotes: {template.InspectConfig?.IncludeQuote}");
            Console.WriteLine($"\tMax findings per request: {template.InspectConfig?.Limits.MaxFindingsPerRequest}");
        }
    }
}

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"
	"time"

	dlp "cloud.google.com/go/dlp/apiv2"
	"cloud.google.com/go/dlp/apiv2/dlppb"
	"github.com/golang/protobuf/ptypes"
	"google.golang.org/api/iterator"
)

// listInspectTemplates lists the inspect templates in the project.
func listInspectTemplates(w io.Writer, projectID string) error {
	// projectID := "my-project-id"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	// Create a configured request.
	req := &dlppb.ListInspectTemplatesRequest{
		Parent: fmt.Sprintf("projects/%s/locations/global", projectID),
	}

	// Send the request and iterate over the results.
	it := client.ListInspectTemplates(ctx, req)
	for {
		t, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("Next: %w", err)
		}
		fmt.Fprintf(w, "Inspect template %v\n", t.GetName())
		c, err := ptypes.Timestamp(t.GetCreateTime())
		if err != nil {
			return fmt.Errorf("CreateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Created: %v\n", c.Format(time.RFC1123))
		u, err := ptypes.Timestamp(t.GetUpdateTime())
		if err != nil {
			return fmt.Errorf("UpdateTime Timestamp: %w", err)
		}
		fmt.Fprintf(w, "  Updated: %v\n", u.Format(time.RFC1123))
		fmt.Fprintf(w, "  Display Name: %q\n", t.GetDisplayName())
		fmt.Fprintf(w, "  Description: %q\n", t.GetDescription())
	}

	return nil
}

Java

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.cloud.dlp.v2.DlpServiceClient.ListInspectTemplatesPagedResponse;
import com.google.privacy.dlp.v2.InfoType;
import com.google.privacy.dlp.v2.InspectConfig;
import com.google.privacy.dlp.v2.InspectTemplate;
import com.google.privacy.dlp.v2.ListInspectTemplatesRequest;
import com.google.privacy.dlp.v2.LocationName;
import java.io.IOException;

class TemplatesList {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    listInspectTemplates(projectId);
  }

  // Lists all templates associated with a given project
  public static void listInspectTemplates(String projectId) 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 dlpServiceClient = DlpServiceClient.create()) {

      // Create the request to be sent by the client
      ListInspectTemplatesRequest request =
          ListInspectTemplatesRequest.newBuilder()
              .setParent(LocationName.of(projectId, "global").toString())
              .setPageSize(1)
              .build();

      // Send the request
      ListInspectTemplatesPagedResponse response = dlpServiceClient.listInspectTemplates(request);

      // Parse through and process the response
      System.out.println("Templates found:");
      for (InspectTemplate template : response.getPage().getResponse().getInspectTemplatesList()) {
        System.out.printf("Template name: %s\n", template.getName());
        if (template.getDisplayName() != null) {
          System.out.printf("\tDisplay name: %s \n", template.getDisplayName());
          System.out.printf("\tCreate time: %s \n", template.getCreateTime());
          System.out.printf("\tUpdate time: %s \n", template.getUpdateTime());

          // print inspection config
          InspectConfig inspectConfig = template.getInspectConfig();
          for (InfoType infoType : inspectConfig.getInfoTypesList()) {
            System.out.printf("\tInfoType: %s\n", infoType.getName());
          }
          System.out.printf("\tMin likelihood: %s\n", inspectConfig.getMinLikelihood());
          System.out.printf("\tLimits: %s\n", inspectConfig.getLimits().getMaxFindingsPerRequest());
        }
      }
    }
  }
}

Node.js

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

// 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 = 'my-project';

// Helper function to pretty-print dates
const formatDate = date => {
  const msSinceEpoch = parseInt(date.seconds, 10) * 1000;
  return new Date(msSinceEpoch).toLocaleString('en-US');
};

async function listInspectTemplates() {
  // Construct template-listing request
  const request = {
    parent: `projects/${projectId}/locations/global`,
  };

  // Run template-deletion request
  const [templates] = await dlp.listInspectTemplates(request);

  templates.forEach(template => {
    console.log(`Template ${template.name}`);
    if (template.displayName) {
      console.log(`  Display name: ${template.displayName}`);
    }

    console.log(`  Created: ${formatDate(template.createTime)}`);
    console.log(`  Updated: ${formatDate(template.updateTime)}`);

    const inspectConfig = template.inspectConfig;
    const infoTypes = inspectConfig.infoTypes.map(x => x.name);
    console.log('  InfoTypes:', infoTypes.join(' '));
    console.log('  Minimum likelihood:', inspectConfig.minLikelihood);
    console.log('  Include quotes:', inspectConfig.includeQuote);

    const limits = inspectConfig.limits;
    console.log('  Max findings per request:', limits.maxFindingsPerRequest);
  });
}

listInspectTemplates();

PHP

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\ListInspectTemplatesRequest;

/**
 * List DLP inspection configuration templates.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 */
function list_inspect_templates(string $callingProjectId): void
{
    // Instantiate a client.
    $dlp = new DlpServiceClient();

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

    // Run request
    $listInspectTemplatesRequest = (new ListInspectTemplatesRequest())
        ->setParent($parent);
    $response = $dlp->listInspectTemplates($listInspectTemplatesRequest);

    // Print results
    $templates = $response->iterateAllElements();

    foreach ($templates as $template) {
        printf('Template %s' . PHP_EOL, $template->getName());
        printf('  Created: %s' . PHP_EOL, $template->getCreateTime()->getSeconds());
        printf('  Updated: %s' . PHP_EOL, $template->getUpdateTime()->getSeconds());
        printf('  Display Name: %s' . PHP_EOL, $template->getDisplayName());
        printf('  Description: %s' . PHP_EOL, $template->getDescription());

        $inspectConfig = $template->getInspectConfig();
        if ($inspectConfig === null) {
            print('  No inspect config.' . PHP_EOL);
        } else {
            printf('  Minimum likelihood: %s' . PHP_EOL, $inspectConfig->getMinLikelihood());
            printf('  Include quotes: %s' . PHP_EOL, $inspectConfig->getIncludeQuote());
            $limits = $inspectConfig->getLimits();
            printf('  Max findings per request: %s' . PHP_EOL, $limits->getMaxFindingsPerRequest());
        }
    }
}

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import google.cloud.dlp


def list_inspect_templates(project: str) -> None:
    """Lists all Data Loss Prevention API inspect templates.
    Args:
        project: The Google Cloud project id to use as a parent resource.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Call the API.
    response = dlp.list_inspect_templates(request={"parent": parent})

    for template in response:
        print(f"Template {template.name}:")
        if template.display_name:
            print(f"  Display Name: {template.display_name}")
        print(f"  Created: {template.create_time}")
        print(f"  Updated: {template.update_time}")

        config = template.inspect_config
        print(
            "  InfoTypes: {}".format(", ".join([it.name for it in config.info_types]))
        )
        print(f"  Minimum likelihood: {config.min_likelihood}")
        print(f"  Include quotes: {config.include_quote}")
        print(
            "  Max findings per request: {}".format(
                config.limits.max_findings_per_request
            )
        )

REST

Gunakan salah satu metode *.*.list:

• organizations.inspectTemplates.list
• projects.inspectTemplates.list

Menyalin template inspeksi ke wilayah global

1. Di konsol Google Cloud , buka halaman Konfigurasi Sensitive Data Protection.

   Buka Configuration

2. Di toolbar, klik pemilih project, lalu pilih project yang berisi template inspeksi yang ingin Anda gunakan.

3. Klik tab Template, lalu klik subtab Periksa.

4. Klik ID template yang ingin Anda gunakan.

5. Di halaman Detail template inspeksi, klik Salin.

6. Di halaman Create template, dalam daftar Resource location, pilih Global (any region).

7. Klik Create.

Template disalin ke region global.

Menyalin template inspeksi ke project lain

1. Di konsol Google Cloud , buka halaman Konfigurasi Sensitive Data Protection.

   Buka Configuration

2. Di toolbar, klik pemilih project, lalu pilih project yang berisi template inspeksi yang ingin Anda gunakan.

3. Klik tab Template, lalu klik subtab Periksa.

4. Klik ID template yang ingin Anda gunakan.

5. Di halaman Detail template inspeksi, klik Salin.

6. Pilih project yang ingin Anda salini template pemeriksaannya.

   Halaman Create template dimuat ulang di project yang Anda pilih.

7. Klik Create.

Template dibuat di project yang Anda pilih.

Menghapus template inspeksi

Untuk menghapus template inspeksi:

Konsol

1. Di konsol Google Cloud , buka halaman Konfigurasi Sensitive Data Protection.

   Buka Configuration

2. Pilih project yang berisi template inspeksi yang ingin Anda hapus.

3. Klik tab Template. Konsol menampilkan daftar semua template untuk project saat ini.

4. Di kolom Actions untuk template yang ingin Anda hapus, klik menu tindakan lainnya (ditampilkan sebagai tiga titik yang disusun secara vertikal) , lalu klik Hapus.

Atau, dari daftar template, klik nama template yang ingin dihapus. Di halaman detail template, klik Hapus.

C#

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

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

public class InspectTemplateDelete
{
    public static object Delete(string projectId, string templateName)
    {
        var client = DlpServiceClient.Create();

        var request = new DeleteInspectTemplateRequest
        {
            Name = templateName
        };

        client.DeleteInspectTemplate(request);
        Console.WriteLine($"Successfully deleted template {templateName}.");

        return templateName;
    }
}

Go

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

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

// deleteInspectTemplate deletes the given template.
func deleteInspectTemplate(w io.Writer, templateID string) error {
	// projectID := "my-project-id"
	// templateID := "my-template"

	ctx := context.Background()

	client, err := dlp.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("dlp.NewClient: %w", err)
	}
	defer client.Close()

	req := &dlppb.DeleteInspectTemplateRequest{
		Name: templateID,
	}

	if err := client.DeleteInspectTemplate(ctx, req); err != nil {
		return fmt.Errorf("DeleteInspectTemplate: %w", err)
	}
	fmt.Fprintf(w, "Successfully deleted inspect template %v", templateID)
	return nil
}

Java

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import com.google.cloud.dlp.v2.DlpServiceClient;
import com.google.privacy.dlp.v2.DeleteInspectTemplateRequest;
import java.io.IOException;

class TemplatesDelete {

  public static void main(String[] args) throws Exception {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String templateId = "your-template-id";
    deleteInspectTemplate(projectId, templateId);
  }

  // Delete an existing template
  public static void deleteInspectTemplate(String projectId, String templateId) throws IOException {
    // Construct the template name to be deleted
    String templateName = String.format("projects/%s/inspectTemplates/%s", projectId, templateId);

    // 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 dlpServiceClient = DlpServiceClient.create()) {

      // Create delete template request to be sent by the client
      DeleteInspectTemplateRequest request =
          DeleteInspectTemplateRequest.newBuilder().setName(templateName).build();

      // Send the request with the client
      dlpServiceClient.deleteInspectTemplate(request);
      System.out.printf("Deleted template: %s\n", templateName);
    }
  }
}

Node.js

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

// 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 = 'my-project';

// The name of the template to delete
// Parent project ID is automatically extracted from this parameter
// const templateName = 'projects/YOUR_PROJECT_ID/inspectTemplates/#####'
async function deleteInspectTemplate() {
  // Construct template-deletion request
  const request = {
    name: templateName,
  };

  // Run template-deletion request
  await dlp.deleteInspectTemplate(request);
  console.log(`Successfully deleted template ${templateName}.`);
}

deleteInspectTemplate();

PHP

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

use Google\Cloud\Dlp\V2\Client\DlpServiceClient;
use Google\Cloud\Dlp\V2\DeleteInspectTemplateRequest;

/**
 * Delete a DLP inspection configuration template.
 *
 * @param string $callingProjectId  The project ID to run the API call under
 * @param string $templateId        The name of the template to delete
 */
function delete_inspect_template(
    string $callingProjectId,
    string $templateId
): void {
    // Instantiate a client.
    $dlp = new DlpServiceClient();

    // Run template deletion request
    $templateName = "projects/$callingProjectId/locations/global/inspectTemplates/$templateId";
    $deleteInspectTemplateRequest = (new DeleteInspectTemplateRequest())
        ->setName($templateName);
    $dlp->deleteInspectTemplate($deleteInspectTemplateRequest);

    // Print results
    printf('Successfully deleted template %s' . PHP_EOL, $templateName);
}

Python

Untuk mempelajari cara menginstal dan menggunakan library klien untuk Sensitive Data Protection, lihat library klien Sensitive Data Protection.

Untuk melakukan autentikasi ke Sensitive Data Protection, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import google.cloud.dlp


def delete_inspect_template(project: str, template_id: str) -> None:
    """Deletes a Data Loss Prevention API template.
    Args:
        project: The id of the Google Cloud project which owns the template.
        template_id: The id of the template to delete.
    Returns:
        None; the response from the API is printed to the terminal.
    """

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

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

    # Combine the template id with the parent id.
    template_resource = f"{parent}/inspectTemplates/{template_id}"

    # Call the API.
    dlp.delete_inspect_template(request={"name": template_resource})

    print(f"Template {template_resource} successfully deleted.")

REST

Gunakan salah satu metode *.*.delete:

• organizations.inspectTemplates.delete
• projects.inspectTemplates.delete

Dengan setiap metode *.*.delete, Anda menyertakan nama resource template yang akan dihapus.