Kunci enkripsi yang dikelola pelanggan (Customer-Managed Encryption Key/CMEK)

Secara default, Google Cloud otomatis mengenkripsi data saat dalam penyimpanan menggunakan kunci enkripsi yang dikelola oleh Google.

Jika Anda memiliki persyaratan kepatuhan atau peraturan khusus terkait kunci yang melindungi data, Anda dapat menggunakan kunci enkripsi yang dikelola pelanggan (CMEK) untuk Document AI. Alih-alih Google yang mengelola kunci enkripsi yang melindungi data Anda, pemroses Document AI Anda dilindungi menggunakan kunci yang Anda kontrol dan kelola di Cloud Key Management Service (KMS).

Panduan ini menjelaskan CMEK untuk Document AI. Untuk mengetahui informasi selengkapnya tentang CMEK secara umum, termasuk waktu dan alasan mengaktifkannya, lihat dokumentasi Cloud Key Management Service.

Prasyarat

Agen Layanan Document AI harus memiliki peran Pengenkripsi/Pendekripsi Cloud KMS CryptoKey pada kunci yang Anda gunakan.

Contoh berikut memberikan peran yang memberikan akses ke kunci Cloud KMS:

gcloud

gcloud kms keys add-iam-policy-binding key \
    --keyring key-ring \
    --location location \
    --project key_project_id \
    --member serviceAccount:[e-mail] \
    --role roles/cloudkms.cryptoKeyEncrypterDecrypter

Ganti key dengan nama kunci. Ganti key-ring dengan nama key ring tempat kunci berada. Ganti location dengan lokasi Document AI untuk key ring. Ganti key_project_id dengan project untuk ring kunci. Ganti project_number dengan nomor project Anda.

C#

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API C# Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

using Google.Cloud.Iam.V1;
using Google.Cloud.Kms.V1;

public class IamAddMemberSample
{
    public Policy IamAddMember(
      string projectId = "my-project", string locationId = "us-east1", string keyRingId = "my-key-ring", string keyId = "my-key",
      string member = "user:[e-mail]")
    {
        // Create the client.
        KeyManagementServiceClient client = KeyManagementServiceClient.Create();

        // Build the resource name.
        CryptoKeyName resourceName = new CryptoKeyName(projectId, locationId, keyRingId, keyId);

        // The resource name could also be a key ring.
        // var resourceName = new KeyRingName(projectId, locationId, keyRingId);

        // Get the current IAM policy.
        Policy policy = client.IAMPolicyClient.GetIamPolicy(
            new GetIamPolicyRequest
            { 
                ResourceAsResourceName = resourceName
            });

        // Add the member to the policy.
        policy.AddRoleMember("roles/cloudkms.cryptoKeyEncrypterDecrypter", member);

        // Save the updated IAM policy.
        Policy result = client.IAMPolicyClient.SetIamPolicy(
            new SetIamPolicyRequest
            {
                ResourceAsResourceName = resourceName,
                Policy = policy
            });

        // Return the resulting policy.
        return result;
    }
}

Go

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Go Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import (
	"context"
	"fmt"
	"io"

	kms "cloud.google.com/go/kms/apiv1"
)

// iamAddMember adds a new IAM member to the Cloud KMS key
func iamAddMember(w io.Writer, name, member string) error {
	// NOTE: The resource name can be either a key or a key ring. If IAM
	// permissions are granted on the key ring, the permissions apply to all keys
	// in the key ring.
	//
	// name := "projects/my-project/locations/us-east1/keyRings/my-key-ring/cryptoKeys/my-key"
	// member := "user:[e-mail]"

	// Create the client.
	ctx := context.Background()
	client, err := kms.NewKeyManagementClient(ctx)
	if err != nil {
		return fmt.Errorf("failed to create kms client: %w", err)
	}
	defer client.Close()

	// Get the current IAM policy.
	handle := client.ResourceIAM(name)
	policy, err := handle.Policy(ctx)
	if err != nil {
		return fmt.Errorf("failed to get IAM policy: %w", err)
	}

	// Grant the member permissions. This example grants permission to use the key
	// to encrypt data.
	policy.Add(member, "roles/cloudkms.cryptoKeyEncrypterDecrypter")
	if err := handle.SetPolicy(ctx, policy); err != nil {
		return fmt.Errorf("failed to save policy: %w", err)
	}

	fmt.Fprintf(w, "Updated IAM policy for %s\n", name)
	return nil
}

Java

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Java Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

import com.google.cloud.kms.v1.CryptoKeyName;
import com.google.cloud.kms.v1.KeyManagementServiceClient;
import com.google.iam.v1.Binding;
import com.google.iam.v1.Policy;
import java.io.IOException;

public class IamAddMember {

  public void iamAddMember() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "your-project-id";
    String locationId = "us-east1";
    String keyRingId = "my-key-ring";
    String keyId = "my-key";
    String member = "user:[e-mail]";
    iamAddMember(projectId, locationId, keyRingId, keyId, member);
  }

  // Add the given IAM member to the key.
  public void iamAddMember(
      String projectId, String locationId, String keyRingId, String keyId, String member)
      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 (KeyManagementServiceClient client = KeyManagementServiceClient.create()) {
      // Build the key version name from the project, location, key ring, key,
      // and key version.
      CryptoKeyName resourceName = CryptoKeyName.of(projectId, locationId, keyRingId, keyId);

      // The resource name could also be a key ring.
      // KeyRingName resourceName = KeyRingName.of(projectId, locationId, keyRingId);

      // Get the current policy.
      Policy policy = client.getIamPolicy(resourceName);

      // Create a new IAM binding for the member and role.
      Binding binding =
          Binding.newBuilder()
              .setRole("roles/cloudkms.cryptoKeyEncrypterDecrypter")
              .addMembers(member)
              .build();

      // Add the binding to the policy.
      Policy newPolicy = policy.toBuilder().addBindings(binding).build();

      client.setIamPolicy(resourceName, newPolicy);
      System.out.printf("Updated IAM policy for %s%n", resourceName.toString());
    }
  }
}

Node.js

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Node.js Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

//
// TODO(developer): Uncomment these variables before running the sample.
//
// const projectId = 'my-project';
// const locationId = 'us-east1';
// const keyRingId = 'my-key-ring';
// const keyId = 'my-key';
// const member = 'user:[e-mail]';

// Imports the Cloud KMS library
const {KeyManagementServiceClient} = require('@google-cloud/kms');

// Instantiates a client
const client = new KeyManagementServiceClient();

// Build the resource name
const resourceName = client.cryptoKeyPath(
  projectId,
  locationId,
  keyRingId,
  keyId
);

// The resource name could also be a key ring.
// const resourceName = client.keyRingPath(projectId, locationId, keyRingId);

async function iamAddMember() {
  // Get the current IAM policy.
  const [policy] = await client.getIamPolicy({
    resource: resourceName,
  });

  // Add the member to the policy.
  policy.bindings.push({
    role: 'roles/cloudkms.cryptoKeyEncrypterDecrypter',
    members: [member],
  });

  // Save the updated policy.
  const [updatedPolicy] = await client.setIamPolicy({
    resource: resourceName,
    policy: policy,
  });

  console.log('Updated policy');
  return updatedPolicy;
}

return iamAddMember();

PHP

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API PHP Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

use Google\Cloud\Iam\V1\Binding;
use Google\Cloud\Iam\V1\GetIamPolicyRequest;
use Google\Cloud\Iam\V1\SetIamPolicyRequest;
use Google\Cloud\Kms\V1\Client\KeyManagementServiceClient;

function iam_add_member(
    string $projectId = 'my-project',
    string $locationId = 'us-east1',
    string $keyRingId = 'my-key-ring',
    string $keyId = 'my-key',
    string $member = 'user:[e-mail]'
) {
    // Create the Cloud KMS client.
    $client = new KeyManagementServiceClient();

    // Build the resource name.
    $resourceName = $client->cryptoKeyName($projectId, $locationId, $keyRingId, $keyId);

    // The resource name could also be a key ring.
    // $resourceName = $client->keyRingName($projectId, $locationId, $keyRingId);

    // Get the current IAM policy.
    $getIamPolicyRequest = (new GetIamPolicyRequest())
        ->setResource($resourceName);
    $policy = $client->getIamPolicy($getIamPolicyRequest);

    // Add the member to the policy.
    $bindings = $policy->getBindings();
    $bindings[] = (new Binding())
        ->setRole('roles/cloudkms.cryptoKeyEncrypterDecrypter')
        ->setMembers([$member]);
    $policy->setBindings($bindings);

    // Save the updated IAM policy.
    $setIamPolicyRequest = (new SetIamPolicyRequest())
        ->setResource($resourceName)
        ->setPolicy($policy);
    $updatedPolicy = $client->setIamPolicy($setIamPolicyRequest);
    printf('Added %s' . PHP_EOL, $member);

    return $updatedPolicy;
}

Python

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Python Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

from google.cloud import kms
from google.iam.v1 import policy_pb2 as iam_policy


def iam_add_member(
    project_id: str, location_id: str, key_ring_id: str, key_id: str, member: str
) -> iam_policy.Policy:
    """
    Add an IAM member to a resource.

    Args:
        project_id (string): Google Cloud project ID (e.g. 'my-project').
        location_id (string): Cloud KMS location (e.g. 'us-east1').
        key_ring_id (string): ID of the Cloud KMS key ring (e.g. 'my-key-ring').
        key_id (string): ID of the key to use (e.g. 'my-key').
        member (string): Member to add (e.g. 'user:[e-mail]')

    Returns:
        Policy: Updated Cloud IAM policy.

    """

    # Create the client.
    client = kms.KeyManagementServiceClient()

    # Build the resource name.
    resource_name = client.crypto_key_path(project_id, location_id, key_ring_id, key_id)

    # The resource name could also be a key ring.
    # resource_name = client.key_ring_path(project_id, location_id, key_ring_id);

    # Get the current policy.
    policy = client.get_iam_policy(request={"resource": resource_name})

    # Add the member to the policy.
    policy.bindings.add(
        role="roles/cloudkms.cryptoKeyEncrypterDecrypter", members=[member]
    )

    # Save the updated IAM policy.
    request = {"resource": resource_name, "policy": policy}

    updated_policy = client.set_iam_policy(request=request)
    print(f"Added {member} to {resource_name}")
    return updated_policy

Ruby

Untuk mengetahui informasi selengkapnya, lihat dokumentasi referensi API Ruby Document AI.

Untuk melakukan autentikasi ke Document AI, siapkan Kredensial Default Aplikasi. Untuk mengetahui informasi selengkapnya, baca Menyiapkan autentikasi untuk lingkungan pengembangan lokal.

# TODO(developer): uncomment these values before running the sample.
# project_id  = "my-project"
# location_id = "us-east1"
# key_ring_id = "my-key-ring"
# key_id      = "my-key"
# member      = "user:[e-mail]"

# Require the library.
require "google/cloud/kms"

# Create the client.
client = Google::Cloud::Kms.key_management_service

# Build the resource name.
resource_name = client.crypto_key_path project:    project_id,
                                       location:   location_id,
                                       key_ring:   key_ring_id,
                                       crypto_key: key_id

# The resource name could also be a key ring.
# resource_name = client.key_ring_path project: project_id, location: location_id, key_ring: key_ring_id

# Create the IAM client.
iam_client = Google::Cloud::Kms::V1::IAMPolicy::Client.new

# Get the current IAM policy.
policy = iam_client.get_iam_policy resource: resource_name

# Add the member to the policy.
policy.bindings << Google::Iam::V1::Binding.new(
  members: [member],
  role:    "roles/cloudkms.cryptoKeyEncrypterDecrypter"
)

# Save the updated policy.
updated_policy = iam_client.set_iam_policy resource: resource_name, policy: policy
puts "Added #{member}"

Menggunakan CMEK

Setelan enkripsi tersedia saat Anda membuat pemroses. Untuk menggunakan CMEK, pilih opsi CMEK, lalu pilih kunci.

Catatan: Lokasi kunci Anda harus cocok dengan lokasi prosesor Anda. Misalnya, jika prosesor Anda berada di europe-west2, kunci CMEK yang sesuai juga harus berada di europe-west2. Namun, untuk multi-region us dan eu, kunci harus berada di us-central1 dan europe-west4.

Kunci CMEK digunakan untuk semua data yang terkait dengan prosesor dan resource turunannya. Semua data terkait pelanggan yang dikirim ke pemroses secara otomatis mengenkripsi dengan kunci yang disediakan sebelum menulis ke disk.

Setelah pemroses dibuat, Anda tidak dapat mengubah setelan enkripsinya. Untuk menggunakan kunci yang berbeda, Anda harus membuat pemroses baru.

Kunci eksternal

Anda dapat menggunakan Cloud External Key Manager (EKM) untuk membuat dan mengelola kunci eksternal guna mengenkripsi data dalam Google Cloud.

Saat Anda menggunakan kunci Cloud EKM, Google tidak memiliki kontrol atas ketersediaan kunci yang dikelola secara eksternal. Jika Anda meminta akses ke resource yang dienkripsi menggunakan kunci yang dikelola secara eksternal dan kunci tersebut tidak tersedia, Document AI akan menolak permintaan tersebut. Mungkin ada penundaan hingga 10 menit sebelum Anda dapat mengakses resource setelah kunci tersedia.

Untuk pertimbangan lainnya saat menggunakan kunci eksternal, lihat Pertimbangan EKM.

Resource yang didukung CMEK

Saat menyimpan resource ke disk, jika ada data pelanggan yang disimpan sebagai bagian dari resource, Document AI akan mengenkripsi konten terlebih dahulu menggunakan kunci CMEK.

Resource	Materi Dienkripsi
Processor	T/A - tidak ada data pengguna. Namun, jika Anda menentukan kunci CMEK selama pembuatan prosesor, kunci tersebut harus valid.
ProcessorVersion	Semua
Evaluation	Semua

API yang didukung CMEK

API yang menggunakan kunci CMEK untuk enkripsi mencakup hal berikut:

Metode	Enkripsi
processDocument	T/A - tidak ada data yang disimpan ke disk.
batchProcessDocuments	Data disimpan sementara di disk dan dienkripsi menggunakan kunci sementara (lihat Kepatuhan CMEK).
reviewDocument	Dokumen yang menunggu peninjauan disimpan di bucket Cloud Storage yang dienkripsi menggunakan kunci KMS/CMEK yang disediakan.
trainProcessorVersion	Dokumen yang digunakan untuk pelatihan dienkripsi menggunakan kunci KMS/CMEK yang disediakan.
evaluateProcessorVersion	Evaluasi dienkripsi menggunakan kunci KMS/CMEK yang disediakan.

Permintaan API yang mengakses resource terenkripsi akan gagal jika kunci dinonaktifkan atau tidak dapat dijangkau. Contohnya mencakup:

Metode	Dekripsi
getProcessorVersion	Versi pemroses yang dilatih menggunakan data pelanggan dienkripsi. Akses memerlukan dekripsi.
processDocument	Memproses dokumen menggunakan versi pemroses terenkripsi memerlukan dekripsi.
Import Documents	Mengimpor dokumen dengan auto-labeling diaktifkan menggunakan versi pemroses terenkripsi memerlukan dekripsi.

Catatan: Human-in-the-Loop (HITL) tidak didukung dengan kunci eksternal dari Cloud EKM.

CMEK dan Cloud Storage

API, seperti batchProcess dan reviewDocument, dapat membaca dari dan menulis ke bucket Cloud Storage.

Setiap data yang ditulis ke Cloud Storage oleh Document AI dienkripsi menggunakan kunci enkripsi yang dikonfigurasi bucket, yang dapat berbeda dengan kunci CMEK pemroses Anda.

Untuk mengetahui informasi selengkapnya, lihat dokumentasi CMEK untuk Cloud Storage.