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 le service Cloud Key Management Service (KMS).

Ce guide décrit 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 doit disposer du rôle 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:[e-mail] \
    --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:[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.IAMPolicyClientte-xref-link" href="https://cloud.google.com/dotnet/docs/reference/Google.Cloud.Iam.V1/latest/Google.Cloud.Iam.V1.IAMPolicyClient.html" track-type="exampleCode" track-name="xrefLink" track-metadata-lang="DOT"NET" track-metadata-modifier="Google.Cloud".Iam.V1" track-metadata-href="https://cloud.google.com/dotnet/docs/reference/Google.Cloud.Iam.V1/latest/Google.Cloud.Iam.V1.IAMPolicyClient.html">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.IAMPolicyClientte-xref-link" href="https://cloud.google.com/dotnet/docs/reference/Google.Cloud.Iam.V1/latest/Google.Cloud.Iam.V1.IAMPolicyClient.html" track-type="exampleCode" track-name="xrefLink" track-metadata-lang="DOTNET" track-metadata-modifier="Google.Cloud.Iam.V1" track-metadata-href="https://cloud.google.com/dotnet/docs/reference/Google.Cloud.Iam.V1/latest/Google.Cloud.Iam.V1.IAMPolicyClient.html">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 Document AI Go.

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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

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.

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

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é CMEK, sélectionnez l'option CMEK, puis une clé.

Remarque :L'emplacement de votre clé doit correspondre à celui de votre processeur. Par exemple, si votre processeur se trouve dans europe-west2, la clé CMEK correspondante doit également se trouver dans europe-west2. Toutefois, pour les emplacements multirégionaux us et eu, la clé doit se trouver dans us-central1 et europe-west4, respectivement.

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

Une fois un processeur créé, vous ne pouvez plus modifier ses paramètres de chiffrement. Pour utiliser une clé différente, 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 les 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. Il peut s'écouler jusqu'à 10 minutes avant que vous ne puissiez accéder à la ressource une fois la clé disponible.

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

Ressources compatibles avec le chiffrement CMEK

Lorsque vous stockez une ressource sur un disque, si des données client sont stockées dans la ressource, Document AI chiffre d'abord le contenu à l'aide de la clé CMEK.

Ressource	Matériel chiffré
Processor	N/A : aucune donnée utilisateur. Toutefois, si vous spécifiez une clé CMEK lors de la création du processeur, elle doit être valide.
ProcessorVersion	Tous
Evaluation	Tous

API compatibles avec le chiffrement CMEK

Voici les API qui utilisent la clé CMEK pour le chiffrement:

Méthode	Chiffrement
processDocument	N/A : aucune donnée n'est enregistrée sur le disque.
batchProcessDocuments	Les données sont stockées temporairement sur le disque et chiffrées à l'aide d'une clé éphémère (voir la section Compatibilité avec les 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 d'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 de 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é à l'aide d'une version de processeur chiffrée nécessite un dé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é CMEK de votre processeur.

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