Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Clés de chiffrement gérées par le client (CMEK)

Par défaut, Google Cloud chiffre automatiquement les données au repos à l'aide de clés de chiffrement gérées par Google.

Si vous avez des exigences réglementaires ou de conformité spécifiques concernant les clés qui protègent vos données, vous pouvez utiliser des clés de chiffrement gérées par le client (CMEK) pour Document AI. Au lieu de laisser Google gérer les clés de chiffrement qui protègent vos données, votre processeur Document AI est protégé à l'aide d'une clé que vous contrôlez et gérez dans Cloud Key Management Service (KMS).

Ce guide décrit le chiffrement CMEK pour Document AI. Pour en savoir plus sur CMEK en général, y compris quand et pourquoi l'activer, consultez la documentation de Cloud Key Management Service.

Conditions préalables

L'agent de service Document AI Service Agent doit disposer du rôle Cloud KMS CryptoKey Encrypter/Decrypter (Chiffreur/Déchiffreur de clés cryptographiques Cloud KMS) sur la clé que vous utilisez.

L'exemple suivant accorde un rôle permettant d'accéder à une clé Cloud KMS :

gcloud

gcloud kms keys add-iam-policy-binding key \
    --keyring key-ring \
    --location location \
    --project key_project_id \
    --member serviceAccount:service-project_number@gcp-sa-prod-dai-core. \
    --role roles/cloudkms.cryptoKeyEncrypterDecrypter

Remplacez key par le nom de la clé. Remplacez key-ring par le nom du trousseau de clés où se trouve la clé. Remplacez location par l'emplacement Document AI du trousseau de clés. Remplacez key_project_id par le projet du trousseau de clés. Remplacez project_number par le numéro de votre projet.

C#

Pour en savoir plus, consultez la documentation de référence de l' API Document AI C#.

Pour vous authentifier auprès de Document AI, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.


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:foo@example.com")
    {
        // 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

Pour en savoir plus, consultez la documentation de référence de l' API Go Document AI.

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:foo@example.com"

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

Pour en savoir plus, consultez la documentation de référence de l' API Java Document AI.

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:foo@example.com";
    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

Pour en savoir plus, consultez la documentation de référence de l' API Node.js Document AI.

//
// 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:foo@example.com';

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

Pour en savoir plus, consultez la documentation de référence de l'API Document AI PHP.

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:foo@example.com'
) {
    // 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

Pour en savoir plus, consultez la documentation de référence de l' API Python Document AI.

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:foo@example.com')

    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

Pour en savoir plus, consultez la documentation de référence de l' API Ruby Document AI.

# 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:foo@example.com"

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

Utiliser les clés de chiffrement gérées par le client

Les paramètres de chiffrement sont disponibles lorsque vous créez un processeur. Pour utiliser une clé de chiffrement gérée par le client, sélectionnez l'option CMEK , puis une clé.

security-3

La clé de chiffrement gérée par le client est utilisée pour toutes les données associées au processeur et à ses ressources enfants. Toutes les données client envoyées au processeur sont automatiquement chiffrées avec la clé fournie avant d'être écrites sur le disque.

Une fois qu'un processeur a été créé, vous ne pouvez plus modifier ses paramètres de chiffrement. Pour utiliser une autre clé, vous devez créer un processeur.

Clés externes

Vous pouvez utiliser Cloud External Key Manager (EKM) pour créer et gérer des clés externes afin de chiffrer des données dans Google Cloud.

Lorsque vous utilisez une clé Cloud EKM, Google n'a aucun contrôle sur la disponibilité de votre clé gérée en externe. Si vous demandez l'accès à une ressource chiffrée avec une clé gérée en externe et que la clé n'est pas disponible, Document AI rejette la requête. Vous devrez peut-être attendre jusqu'à 10 minutes avant de pouvoir accéder à la ressource une fois la clé disponible.

Pour plus d'informations sur l'utilisation des clés externes, consultez la section Considérations concernant EKM.

Ressources compatibles avec le chiffrement CMEK

Lors du stockage d'une ressource sur le disque, si des données client sont stockées dans la ressource, Document AI chiffre d'abord le contenu à l'aide de la clé de chiffrement gérée par le client.

Ressource	Éléments chiffrés
`Processor`	N/A : aucune donnée utilisateur. Toutefois, si vous spécifiez une clé de chiffrement gérée par le client lors de la création du processeur, elle doit être valide.
`ProcessorVersion`	Tous
`Evaluation`	Tous

API compatibles avec le chiffrement CMEK

Les API qui utilisent la clé de chiffrement gérée par le client pour le chiffrement sont les suivantes :

Méthode	Chiffrement
`processDocument`	N/A : aucune donnée n'est enregistrée sur le disque.
`batchProcessDocuments`	Les données sont temporairement stockées sur le disque et chiffrées à l'aide d'une clé éphémère (voir Conformité CMEK).
`trainProcessorVersion`	Les documents utilisés pour l'entraînement sont chiffrés à l'aide de la clé KMS/CMEK fournie.
`evaluateProcessorVersion`	Les évaluations sont chiffrées à l'aide de la clé KMS/CMEK fournie.

Les requêtes API qui accèdent à des ressources chiffrées échouent si la clé est désactivée ou inaccessible. Voici quelques exemples :

Méthode	Déchiffrement
`getProcessorVersion`	Les versions de processeur entraînées à l'aide de données client sont chiffrées. L'accès nécessite un déchiffrement.
`processDocument`	Le traitement des documents à l'aide d'une version de processeur chiffrée nécessite un déchiffrement.
`Import Documents`	L'importation de documents avec `auto-labeling` activée à l'aide d'une version de processeur chiffrée nécessite un déchiffrement.

Chiffrement CMEK et Cloud Storage

Les API, telles que batchProcess, peuvent lire et écrire dans des buckets Cloud Storage.

Toutes les données écrites dans Cloud Storage par Document AI sont chiffrées à l'aide de la clé de chiffrement configurée du bucket, qui peut être différente de la clé de chiffrement gérée par le client de votre processeur.

Pour en savoir plus, consultez la documentation sur le chiffrement CMEK pour Cloud Storage.

Sécurité et conformité

Ajouter la journalisation d'audit