대형 커스텀 사전 감지기 만들기

이 주제에서는 대형 커스텀 사전을 만들고 다시 빌드하는 방법을 설명합니다. 또한 여러 오류 시나리오도 다룹니다.

일반 커스텀 사전 대신 대형 커스텀 사전을 선택해야 하는 경우

일반 커스텀 사전 감지기는 콘텐츠에서 스캔할 민감한 단어나 구문이 수만 개 있을 때 충분합니다. 수만 개 이상이거나 용어 목록이 자주 변경될 경우에는 수천만 개의 용어를 지원할 수 있는 대형 커스텀 사전을 만드는 것이 좋습니다.

참고: 사전의 정확한 사용량 한도는 사용량 한도를 참조하세요.

대형 커스텀 사전과 다른 커스텀 infoType의 차이점

대형 커스텀 사전은 각 대형 커스텀 사전에 두 가지 구성요소가 있다는 점에서 다른 커스텀 infoType과 다릅니다.

• 사용자가 만들고 정의하는 구문 목록. 이 목록은 Cloud Storage 내에 텍스트 파일로 또는 BigQuery 테이블에 열로 저장됩니다.
• 민감한 정보 보호에서 생성되고 Cloud Storage에 저장되는 사전 파일입니다. 사전 파일은 용어 목록 사본, 그리고 검색 및 일치 확인을 보조하는 블룸 필터로 구성됩니다.

경고: Cloud Storage에서 직접 커스텀 사전 파일을 변경하지 마세요. 변경할 경우 사전이 무효화되어 사용할 수 없게 됩니다.

대형 커스텀 사전 만들기

이 섹션에서는 대형 커스텀 사전을 만들고 수정하며 다시 빌드하는 방법을 설명합니다.

용어 목록 만들기

새 infoType 감지기를 검색할 모든 단어 및 구문이 포함된 목록을 만듭니다. 다음 중 하나를 수행합니다.

• 각 단어 또는 구문이 독립된 줄로 저장된 텍스트 파일을 Cloud Storage 버킷에 넣습니다.
• BigQuery 테이블의 한 열을 단어 및 구문 컨테이너로 지정합니다. 열에서 각 항목에 자체 행을 부여합니다. 모든 사전 단어 및 구문이 하나의 열에 있다는 조건 하에 기존 BigQuery 테이블을 사용할 수 있습니다.

민감한 정보 보호에서 처리하기에 너무 큰 용어 목록이 조합될 수 있습니다. 오류 메시지가 표시되는 경우 이 주제 뒷부분에 있는 오류 문제 해결하기를 참조하세요.

저장된 infoType 만들기

용어 목록을 만든 후 민감한 정보 보호를 사용하여 사전을 만듭니다.

콘솔

1. Cloud Storage 버킷에서 민감한 정보 보호로 생성된 사전을 저장할 새 폴더를 만듭니다.

   민감한 정보 보호는 개발자가 지정한 위치에 사전 파일이 포함된 폴더를 만듭니다.

2. Google Cloud 콘솔에서 InfoType 만들기 페이지로 이동합니다.

   infoType 만들기로 이동

3. 유형에서 대형 커스텀 사전을 선택합니다.

4. InfoType ID에 저장된 infoType의 식별자를 입력합니다.

   검사 및 익명화 작업을 구성할 때 이 식별자를 사용합니다. 이름에 문자, 숫자, 하이픈, 밑줄을 사용할 수 있습니다.

5. InfoType 표시 이름에 저장된 infoType의 이름을 입력합니다.

   이름에 공백과 구두점을 사용할 수 있습니다.

6. 설명에 저장된 infoType이 감지하는 항목에 대한 설명을 입력합니다.

7. 스토리지 유형에서 용어 목록의 위치를 선택합니다.

   • BigQuery: 프로젝트 ID, 데이터 세트 ID, 테이블 ID를 입력합니다. 필드 이름 필드에 열 식별자를 입력합니다. 이 테이블에서 최대 1개의 열을 지정할 수 있습니다.
   • Google Cloud Storage: 파일 경로를 입력합니다.

8. 출력 버킷 또는 폴더에 1단계에서 만든 폴더의 Cloud Storage 위치를 입력합니다.

   참고: 민감한 정보 보호가 사전을 빌드할 때 만드는 폴더 안에 파일을 배치하지 마세요. 민감한 정보 보호는 사전 파일을 만들거나 다시 빌드할 때 생성된 폴더에 저장된 다른 모든 파일을 삭제합니다. 민감한 정보 보호가 만드는 폴더와 동일한 수준에 있는 폴더는 모두 그대로 유지됩니다.

9. 만들기를 클릭합니다.

저장된 infoType에 대한 요약이 표시됩니다. 사전이 생성되고 새로 저장된 infoType을 사용할 준비가 되면 infoType 상태가 준비로 표시됩니다.

C#

민감한 정보 보호의 클라이언트 라이브러리를 설치하고 사용하는 방법은 민감한 정보 보호 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

// 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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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. Cloud Storage 버킷에서 사전의 새 폴더를 만듭니다. 민감한 정보 보호는 개발자가 지정한 위치에 사전 파일이 포함된 폴더를 만듭니다.
참고: 민감한 정보 보호가 사전을 빌드할 때 만드는 폴더 안에 파일을 배치하지 마세요. 민감한 정보 보호는 사전 파일을 만들거나 다시 빌드할 때 생성된 폴더에 저장된 다른 모든 파일을 삭제합니다. 민감한 정보 보호가 만드는 파일과 동일한 레벨에 있는 폴더는 모두 그대로 유지됩니다.
2. storedInfoTypes.create 메서드를 사용하여 사전을 만듭니다. create 메서드에는 다음 매개변수가 사용됩니다.
   • 저장된 infoType의 구성이 포함된 StoredInfoTypeConfig 객체입니다. 포함되는 요소는 다음과 같습니다.
     • description: 사전에 대한 설명
     • displayName: 사전에 지정할 이름
     • LargeCustomDictionaryConfig: 대형 커스텀 사전의 구성을 포함합니다. 포함되는 요소는 다음과 같습니다.
       • BigQueryField: 용어 목록이 BigQuery에 저장되는 경우 지정됩니다. 목록이 저장된 테이블에 대한 참조, 그리고 각 사전 구문이 들어 있는 필드가 포함됩니다.
       • CloudStorageFileSet: 용어 목록이 Cloud Storage에 저장되는 경우 지정됩니다. Cloud Storage의 소스 위치에 대한 URL이 "gs://[PATH_TO_GS]" 형식으로 포함됩니다. 와일드카드가 지원됩니다.
       참고: LargeCustomDictionaryConfig에 BigQueryField 또는 CloudStorageFileSet를 지정할 수 있지만 둘 다 지정할 수는 없습니다.
       • outputPath: 생성된 사전을 저장할 Cloud Storage 버킷의 위치 경로입니다.
   • storedInfoTypeId: 저장된 infoType의 식별자입니다. 저장된 infoType을 다시 빌드하거나 삭제하거나 검사 또는 익명화 작업에서 사용할 때 이 식별자를 사용하여 저장된 infoType을 참조합니다. 이 필드를 비워 두면 자동으로 식별자가 생성됩니다.

다음은 storedInfoTypes.create 메서드로 전송될 때 새로운 저장된 infoType, 특히 큰 커스텀 사전 감지기를 만드는 JSON 예시입니다. 이 예시에서는 공개적으로 사용 가능한 BigQuery 데이터베이스(bigquery-public-data.samples.github_nested)에 저장된 용어 목록에서 저장된 infoType을 만듭니다. 데이터베이스에는 커밋에 사용되는 모든 GitHub 사용자 이름이 포함됩니다. 생성된 사전의 출력 경로는 dlptesting이라는 Cloud Storage 버킷으로 설정되고 저장된 infoType의 이름은 github-usernames입니다.

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

사전 다시 빌드

사전을 업데이트하려면 먼저 소스 용어 목록을 업데이트한 다음 민감한 정보 보호에 지시하여 저장된 infoType을 다시 빌드하도록 지시합니다.

1. Cloud Storage 또는 BigQuery의 기존 소스 용어 목록을 업데이트합니다.

   필요에 따라 용어 또는 구문을 추가, 삭제, 변경합니다.

2. Google Cloud 콘솔이나 storedInfoTypes.patch 메서드를 사용하여 저장된 infoType을 '다시 빌드'하여 새 버전을 만듭니다.

   다시 빌드하면 이전 사전을 대체하는 새 버전의 사전이 생성됩니다.

저장된 infoType을 새 버전으로 다시 빌드하면 이전 버전이 삭제됩니다. 민감한 정보 보호가 저장된 infoType을 업데이트하는 동안 저장된 infoType의 상태는 '대기 중'입니다. 이 기간에는 저장된 infoType의 이전 버전이 여전히 존재하는 것입니다. 저장된 infoType이 대기 중 상태일 때 실행하는 모든 스캔은 이전 버전의 저장된 infoType을 사용하여 실행됩니다.

저장된 infoType을 다시 빌드하려면 다음 안내를 따르세요.

콘솔

1. Cloud Storage 또는 BigQuery에서 용어 목록을 업데이트하고 저장합니다.

2. Google Cloud 콘솔에서 저장된 infoType 목록으로 이동합니다.

   저장된 infoType으로 이동

3. 업데이트하려는 저장된 infoType의 ID를 클릭합니다.

4. infoType 세부정보 화면에서 데이터 다시 빌드를 클릭합니다.

민감한 정보 보호는 소스 용어 목록의 변경사항으로 저장된 infoType을 다시 빌드합니다. 저장된 infoType의 상태가 '준비됨'이면 사용할 수 있습니다. 저장된 infoType을 사용하는 모든 템플릿 또는 작업 트리거에서 자동으로 다시 빌드된 버전을 사용합니다.

C#

민감한 정보 보호의 클라이언트 라이브러리를 설치하고 사용하는 방법은 민감한 정보 보호 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

// 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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

용어 목록 업데이트

대형 커스텀 사전의 용어 목록만 업데이트할 경우 storedInfoTypes.patch 요청에 name 필드만 필요합니다. 다시 빌드하려는 저장된 infoType의 전체 리소스 이름을 제공합니다.

다음 패턴은 name 필드의 유효한 항목을 나타냅니다.

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

STORED_INFOTYPE_ID를 다시 빌드하려는 저장된 infoType의 식별자로 바꿉니다.

저장된 infoType의 식별자를 모르는 경우 storedInfoTypes.list 메서드를 호출하여 현재 저장된 모든 infoType의 목록을 확인합니다.

참고: 저장된 infoType에는 버전 번호가 없지만 createTime 필드가 있습니다. 이 필드는 다시 빌드할 때마다 새로고침됩니다. storedInfoTypes.get 메서드를 사용하여 저장된 infoType에 대한 정보를 가져오고, createTime 필드를 사용하여 마지막으로 다시 빌드된 시점을 확인합니다.

예

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

이 경우에는 요청 본문이 필요하지 않습니다.

원본 용어 목록 전환

저장된 infoType의 소스 용어 목록을 BigQuery에 저장된 것에서 Cloud Storage에 저장된 것으로 변경할 수 있습니다. storedInfoTypes.patch 메서드를 사용하되, CloudStorageFileSet 객체를 이전에 BigQueryField 객체에서 사용한 LargeCustomDictionaryConfig에 포함합니다. 그런 다음 updateMask 매개변수를 FieldMask 형식을 사용해 다시 빌드한 저장된 infoType 매개변수로 설정합니다. 예를 들어 다음 JSON은 updateMask 매개변수에서 Cloud Storage 경로의 URL이 업데이트되었음을 명시합니다(large_custom_dictionary.cloud_storage_file_set.url).

예

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

마찬가지로 BigQuery 테이블에 저장된 용어 목록을 Cloud Storage 버킷에 저장된 것으로 전환할 수 있습니다.

대형 커스텀 사전 감지기를 사용한 콘텐츠 스캔

대형 커스텀 사전 감지기를 사용한 콘텐츠 스캔은 다른 커스텀 infoType 감지기를 사용한 콘텐츠 스캔과 비슷합니다.

이 절차에서는 저장된 기존 infoType이 있다고 가정합니다. 자세한 내용은 이 페이지의 저장된 infoType 만들기를 참조하세요.

콘솔

다음 작업을 할 때 대형 커스텀 사전 감지기를 적용할 수 있습니다.

• 새 작업 만들기
• 작업 트리거 만들기 또는 수정
• 템플릿 만들기 또는 수정
• 데이터 프로파일링 구성

페이지의 감지 구성 섹션에 있는 InfoType 하위 섹션에서 대형 커스텀 사전 infoType을 지정할 수 있습니다.

1. infoType 관리를 클릭합니다.
2. InfoType 창에서 커스텀 탭을 클릭합니다.
3. 커스텀 infoType 추가를 클릭합니다.

4. 커스텀 infoType 추가 창에서 다음을 수행합니다.

   1. 유형에서 저장된 infoType을 선택합니다.
   2. InfoType에 커스텀 infoType의 이름을 입력합니다. 문자, 숫자, 밑줄을 사용할 수 있습니다.

   3. 가능성에서 이 커스텀 infoType과 일치하는 모든 발견 항목에 할당할 기본 가능성 수준을 선택합니다. 핫워드 규칙을 사용하여 개별 발견 항목의 가능성 수준을 더 세밀하게 조정할 수 있습니다.

      기본값을 지정하지 않으면 기본 가능성 수준이 VERY_LIKELY로 설정됩니다. 자세한 내용은 일치 가능성을 참조하세요.

   4. 민감도에서 이 커스텀 infoType과 일치하는 모든 발견 항목에 할당할 민감도 수준을 선택합니다. 값을 지정하지 않으면 이러한 발견 항목의 민감도 수준이 HIGH로 설정됩니다.

      민감도 점수는 데이터 프로필에서 사용됩니다. 데이터를 프로파일링할 때 민감한 정보 보호는 infoTypes의 민감도 점수를 사용하여 민감도 수준을 계산합니다.

   5. 저장된 infoType 이름에 새 커스텀 infoType의 기반으로 사용할 저장된 infoType을 선택합니다.

   6. 완료를 클릭하여 커스텀 infoType 추가 창을 닫습니다.

5. 선택사항: 기본 제공 탭에서 선택한 기본 제공 infoType을 수정합니다.

6. 완료를 클릭하여 InfoType 창을 닫습니다.

   커스텀 infoType이 민감한 정보 보호가 스캔하는 infoType 목록에 추가됩니다. 하지만 작업, 작업 트리거, 템플릿 또는 스캔 구성을 저장하기 전에는 이 선택이 최종 선택이 아닙니다.

7. 구성 만들기 또는 수정을 완료했으면 저장을 클릭합니다.

C#

민감한 정보 보호의 클라이언트 라이브러리를 설치하고 사용하는 방법은 민감한 정보 보호 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

// 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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

Sensitive Data Protection의 클라이언트 라이브러리를 설치하고 사용하는 방법은 Sensitive Data Protection 클라이언트 라이브러리를 참조하세요.

Sensitive Data Protection에 인증하려면 애플리케이션 기본 사용자 인증 정보를 설정합니다. 자세한 내용은 로컬 개발 환경의 인증 설정을 참조하세요.

GitHub에서 보기 의견 보내기

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

content.inspect 메서드로 전송된 경우 다음 예시가 지정되고 저장된 infoType 감지기를 사용해서 제공된 텍스트를 스캔합니다. 모든 커스텀 infoType에는 기본 제공 infoType 또는 다른 커스텀 infoType과 충돌하지 않는 이름이 있어야 하므로 infoType 매개변수가 필요합니다. storedType 매개변수에는 저장된 infoType의 전체 리소스 경로가 포함됩니다.

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."
  }
}

오류 문제 해결하기

Cloud Storage에 저장된 용어 목록에서 저장된 infoType을 만드는 중에 오류가 발생하면 다음과 같은 원인이 있을 수 있습니다.

• 저장된 infoType의 상한에 도달했습니다. 문제에 따라 몇 가지 해결 방법이 있습니다.
  • Cloud Storage에서 단일 입력 파일의 상한(200MB)에 도달한 경우 파일을 여러 파일로 분할합니다. 모든 파일을 합친 크기가 1GB를 초과하지 않는 한 여러 파일을 사용하여 단일 커스텀 사전을 조합할 수 있습니다.
  • BigQuery의 한도는 Cloud Storage와 다릅니다. 용어를 BigQuery 테이블로 이동하는 것을 고려해 보세요. BigQuery에서는 커스텀 사전 열의 최대 크기가 1GB이고 최대 행 수는 5,000,000개입니다.
  • 용어 목록 파일이 소스 용어 목록에 적용되는 모든 한도를 초과하는 경우 용어 목록 파일을 여러 파일로 분할하고 각 파일에 대한 사전을 만들어야 합니다. 그런 다음 사전마다 별도의 스캔 작업을 만듭니다.
• 최소 하나의 글자 또는 숫자가 포함되지 않은 용어가 하나 이상 있습니다. 민감한 정보 보호는 공백 또는 기호로만 구성된 용어를 스캔할 수 없습니다. 최소 하나의 글자 또는 숫자가 있어야 합니다. 용어 목록에 문제가 되는 용어가 포함되어 있는지 확인하고, 있는 경우 수정하거나 삭제하세요.
• 용어 목록에 '구성요소'가 너무 많은 구문이 포함되어 있습니다. 이 맥락에서 구성요소란 글자만, 숫자만 또는 글자도 숫자도 아닌 문자(공백 또는 기호)만 포함된 연속된 시퀀스를 의미합니다. 용어 목록에 문제가 되는 용어가 포함되어 있는지 확인하고, 있는 경우 수정하거나 삭제하세요.
• 민감한 정보 보호 서비스 에이전트에 사전 파일 저장을 위한 사전 소스 데이터 또는 Cloud Storage 버킷 액세스 권한이 없습니다. 이 문제를 해결하려면 민감한 정보 보호 서비스 에이전트에 스토리지 관리자(roles/storage.admin) 역할 또는 BigQuery 데이터 소유자(roles/bigquery.dataOwner) 및 BigQuery 작업 사용자(roles/bigquery.jobUser) 역할을 부여합니다.

API 개요

대형 커스텀 사전 감지기를 만드는 경우 저장된 infoType을 만들어야 합니다.

참고: 일반 커스텀 사전 감지기 또는 정규 표현식 감지기를 만드는 경우에는 저장된 infoType을 만들 필요가 없습니다. CustomInfoType 객체에서 직접 정의하는 것이 더 간단합니다.

저장된 infoType은 민감한 정보 보호에서 StoredInfoType 객체로 표시됩니다. 다음과 같은 관련 객체로 구성됩니다.

• StoredInfoTypeVersion에는 생성 날짜 및 시간, 현재 버전이 생성될 때 마지막으로 발생한 오류 메시지 5개가 포함됩니다.

  • StoredInfoTypeConfig에는 이름 및 설명을 포함하여 저장된 infoType의 구성이 포함됩니다. 대형 커스텀 사전의 경우 type이 LargeCustomDictionaryConfig여야 합니다.

    • LargeCustomDictionaryConfig는 다음 두 가지를 모두 지정합니다.
      • Cloud Storage 또는 BigQuery 내에서 구문 목록이 저장된 위치
      • 생성된 사전 파일을 저장할 Cloud Storage 내의 위치

  • StoredInfoTypeState에는 저장된 infoType의 가장 최신 버전 및 모든 보류 중인 버전의 상태가 포함됩니다. 상태 정보에는 저장된 infoType이 다시 빌드되는 중인지, 사용할 준비가 되었는지, 잘못되었는지 여부가 포함됩니다.

사전 일치 세부 사항

다음은 Sensitive Data Protection에서 사전 단어 및 구문의 일치를 판단하는 방법에 관한 지침입니다. 이러한 항목은 일반 및 대형 커스텀 사전에 모두 적용됩니다.

• 사전 단어는 대소문자를 구분하지 않습니다. 사전에 Abby가 포함된 경우 abby, ABBY, Abby 등과 일치합니다.
• 유니코드 기본 다국어 평면에 포함된 글자 및 숫자를 제외한 사전 또는 스캔할 콘텐츠의 모든 문자는 일치 항목을 스캔할 때 공백으로 간주됩니다. 사전에서 Abby Abernathy를 스캔하는 경우 abby abernathy, Abby, Abernathy, Abby (ABERNATHY) 등과 일치합니다.
• 일치 항목의 주변 문자는 단어 내의 인접 문자와 유형(문자 또는 숫자)이 달라야 합니다. 사전에서 Abi를 스캔하는 경우 Abi904의 처음 3개 문자는 일치하지만 Abigail은 일치하지 않습니다.
• 유니코드 표준의 보조 다중 언어 영역에 있는 문자가 포함된 사전 단어는 예상치 않은 발견 항목을 발생시킬 수 있습니다. 이러한 문자의 예시에는 중국어, 일본어, 한국어, 이모지 등이 있습니다.

저장된 infoType을 생성, 편집, 삭제하려면 다음 메서드를 사용합니다.

• storedInfoTypes.create: 지정한 StoredInfoTypeConfig로 새 저장된 infoType을 만듭니다.
• storedInfoTypes.patch: 지정한 새 StoredInfoTypeConfig로 저장된 infoType을 다시 빌드합니다. 아무 것도 지정하지 않으면 이 메서드가 기존 StoredInfoTypeConfig를 사용하여 새 버전의 저장된 infoType을 만듭니다.
• storedInfoTypes.get : 지정된 저장된 infoType의 StoredInfoTypeConfig 및 대기 중인 버전을 검색합니다.
• storedInfoTypes.list: 현재 저장된 infoType을 모두 나열합니다.
• storedInfoTypes.delete: 지정된 저장된 infoType을 삭제합니다.