---
title: Configurer Google Cloud KMS pour CMEK
url: https://platform.claude.com/docs/fr/manage-claude/cmek-google-cloud-kms
description: Utilisez Google Cloud KMS pour fournir une clé de chiffrement à votre organisation.
---

Laissez Claude Code configurer cette fonctionnalité pour vous

```text
/claude-api aide-moi à configurer une clé de chiffrement gérée par le client avec Google Cloud KMS
```

Ce guide explique comment configurer une clé Google Cloud KMS en tant que [clé de chiffrement gérée par le client (CMEK)](https://platform.claude.com/docs/fr/manage-claude/cmek) pour votre organisation Anthropic.

<Warning>
  L'activation de CMEK est permanente. Si votre clé KMS est supprimée ou désactivée, Anthropic ne peut pas récupérer les données chiffrées avec celle-ci. Consultez les [avertissements et limitations](https://platform.claude.com/docs/fr/manage-claude/cmek) avant de commencer.
</Warning>

## Prérequis

* Un projet Google Cloud avec la facturation activée.
* L'API Cloud KMS activée (`cloudkms.googleapis.com`).
* Les autorisations pour créer des trousseaux de clés et des clés KMS, et pour définir la politique IAM sur ceux-ci (`roles/cloudkms.admin` ou équivalent).
* Une clé Admin API pour votre organisation Anthropic.
* La [CLI `gcloud`](https://cloud.google.com/cli) installée et authentifiée.
* Les **journaux d'audit d'accès aux données** Cloud KMS activés pour le projet (IAM & Admin > Journaux d'audit > Cloud Key Management Service, avec `DATA_READ` et `DATA_WRITE`). Ceux-ci sont désactivés par défaut ; sans eux, les opérations de chiffrement et de déchiffrement d'Anthropic ne produisent aucune entrée dans Cloud Logging.

## Adresse e-mail du compte de service Anthropic

Pour qu'Anthropic utilise votre clé de chiffrement, vous devez donner au compte de service d'Anthropic une clé qu'il peut utiliser pour chiffrer les données. L'adresse e-mail du compte de service pour Anthropic CMEK est :

```text wrap
anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com
```

<Warning>
  Utilisez uniquement cette adresse e-mail de compte de service publiée. Ne faites jamais confiance à un identifiant fourni par e-mail, chat ou tout autre canal d'intégration.
</Warning>

<Note>
  **Partage restreint par domaine :** Si votre projet relève d'une organisation Google Cloud qui applique `constraints/iam.allowedPolicyMemberDomains`, les liaisons IAM suivantes sont rejetées car le compte de service Anthropic est en dehors de votre organisation. Vous avez besoin soit d'une exception au niveau du projet sur cette contrainte, soit d'ajouter l'ID client Cloud Identity d'Anthropic (format `C0xxxxxxxx`) à la liste autorisée. Contactez Anthropic pour obtenir l'ID client si nécessaire.
</Note>

## Configuration de la clé de chiffrement

<Steps>
  <Step title="Créer ou choisir un trousseau de clés">
    Ignorez cette étape si vous disposez déjà d'un trousseau de clés à réutiliser. Les trousseaux de clés sont régionaux. Choisissez un emplacement à région unique aux États-Unis tel que `us-east5` qui correspond à la géographie Anthropic que vous configurez. Les emplacements multi-régions comme `us` et `global` ne sont pas pris en charge.

    ```bash
    gcloud kms keyrings create <your-keyring-name> \
      --project=<your-project-id> \
      --location=<region>
    ```
  </Step>

  <Step title="Créer la clé cryptographique">
    Créez une clé symétrique avec l'objectif `ENCRYPT_DECRYPT`. Anthropic recommande fortement la protection HSM : les clés HSM Cloud KMS sont validées FIPS 140-2 Level 3, et l'écart de coût par rapport aux clés logicielles est faible.

    L'option `--labels` ajoute l'étiquette d'organisation, `anthropic-org-<ORGANIZATION_UUID>` avec la valeur `true`, où `<ORGANIZATION_UUID>` est l'ID de votre organisation Anthropic en minuscules. L'étiquette est requise pour qu'Anthropic valide la clé.

    <Note>
      **Trouver l'ID de votre organisation :** copiez le champ **Organization ID** sur la page [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) dans la Claude Console, ou sous **Organization settings > Organization** dans claude.ai, ou lisez le champ `id` depuis le point de terminaison [Organization Info](https://platform.claude.com/docs/fr/api/organization/retrieve). Utilisez l'UUID seul, et non l'ID préfixé par `org_`.
    </Note>

    ```bash
    gcloud kms keys create <KEY_NAME> \
      --project=<PROJECT_ID> \
      --location=<REGION> \
      --keyring=<KEYRING_NAME> \
      --purpose=encryption \
      --protection-level=hsm \
      --labels=anthropic-org-<ORGANIZATION_UUID>=true
    ```

    Pour une protection logicielle à la place, omettez `--protection-level=hsm`. Rien d'autre dans ce guide ne change.

    Vous pouvez également créer la clé depuis la Google Cloud Console. Ouvrez le trousseau de clés, cliquez sur **Create key**, sélectionnez **Generated key**, définissez l'objectif et l'algorithme sur chiffrement et déchiffrement symétriques, et choisissez **HSM** sous le niveau de protection.

    <Frame caption="Créez une clé de chiffrement/déchiffrement symétrique protégée par HSM avec l'étiquette d'organisation.">
      ![Page Create key de Google Cloud KMS avec la protection HSM, le chiffrement/déchiffrement symétrique et l'étiquette anthropic-org définie sur true.](https://platform.claude.com/docs/images/cmek/gcp-create-key-label.png)
    </Frame>

    Pour partager une clé entre plusieurs organisations Anthropic, ajoutez une telle étiquette pour chaque organisation. Une clé peut porter au maximum 64 étiquettes, y compris les vôtres.

    <Note>
      Pour ajouter l'étiquette à une clé qui ne l'a pas, exécutez `gcloud kms keys update <KEY_NAME> --project=<PROJECT_ID> --location=<REGION> --keyring=<KEYRING_NAME> --update-labels=anthropic-org-<ORGANIZATION_UUID>=true`. Cela fusionne l'étiquette avec toutes les étiquettes que la clé possède déjà.
    </Note>
  </Step>

  <Step title="Accorder au compte de service d'Anthropic l'accès à la clé">
    Deux liaisons IAM au niveau de la clé sont requises. Les deux sont limitées à la clé cryptographique unique, et non à l'ensemble du projet ou du trousseau de clés.

    Chiffrement et déchiffrement, qu'Anthropic utilise pour chiffrer et déchiffrer les clés de données qui protègent les données de votre espace de travail (chiffrement par enveloppe) :

    ```bash
    gcloud kms keys add-iam-policy-binding <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
      --role=roles/cloudkms.cryptoKeyEncrypterDecrypter
    ```

    Viewer, pour la lecture des métadonnées (`cryptoKeys.get`) qu'Anthropic effectue au démarrage pour valider l'objectif et l'algorithme de la clé :

    ```bash
    gcloud kms keys add-iam-policy-binding <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --member="serviceAccount:anthropic-cmek-client-us@gcp-anthropic-cmek-clients.iam.gserviceaccount.com" \
      --role=roles/cloudkms.viewer
    ```

    Depuis la Console, sélectionnez la clé, ouvrez le panneau **Permissions**, cliquez sur **Grant access**, et ajoutez le compte de service avec les rôles Cloud KMS CryptoKey Encrypter/Decrypter et Cloud KMS Viewer. Assurez-vous d'être sur la page des autorisations de la clé, et non du trousseau de clés ou du projet, afin que l'octroi soit limité à cette clé uniquement.

    <Frame caption="Accordez au compte de service Anthropic les deux rôles, limités à la clé.">
      ![Boîte de dialogue Grant access avec le compte de service Anthropic, auquel sont attribués les rôles Cloud KMS CryptoKey Encrypter/Decrypter et Viewer.](https://platform.claude.com/docs/images/cmek/gcp-grant-access.png)
    </Frame>
  </Step>

  <Step title="Noter le nom complet de la ressource de la clé">
    Vous le transmettez à Anthropic lorsque vous enregistrez la clé. Le format est :

    ```text wrap
    projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>
    ```

    Récupérez-le avec :

    ```bash
    gcloud kms keys describe <your-key-name> \
      --project=<your-project-id> \
      --location=<region> \
      --keyring=<your-keyring-name> \
      --format="value(name)"
    ```

    Depuis la Console, ouvrez la page de détails de la clé et cliquez sur **Copy resource name**.

    <Frame caption="Copiez le nom complet de la ressource de la clé depuis le menu d'actions.">
      ![Détails du trousseau de clés Google Cloud avec l'action Copy resource name mise en évidence dans le menu d'actions de la clé.](https://platform.claude.com/docs/images/cmek/gcp-copy-resource-name.png)
    </Frame>
  </Step>
</Steps>

## Enregistrer la clé auprès d'Anthropic

La manière dont vous enregistrez la clé dépend du produit que vous utilisez.

<Tabs>
  <Tab title="Claude Platform">
    Vous pouvez configurer la clé dans la Claude Console ou via l'Admin API, avec le même résultat.

    <Tabs>
      <Tab title="Claude Console">
        <Steps>
          <Step title="Enregistrer la clé auprès d'Anthropic">
            Dans la Claude Console, accédez à la page [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Si vous ne voyez pas **Encryption keys**, sélectionnez **Organization** dans le menu déroulant en haut de la page. Sous **Encryption keys**, cliquez sur **Add key**. Saisissez un nom d'affichage, choisissez **Google Cloud KMS**, puis cliquez sur **Continue**. Collez le nom complet de la ressource de la clé dans **Key resource name**, puis cliquez sur **Add**.

            L'étape des détails de la clé affiche l'étiquette d'organisation. Ajoutez-la à la clé, comme le décrit [l'étape de création](https://platform.claude.com/docs/fr/manage-claude/cmek-google-cloud-kms#organization-label), avant de cliquer sur **Add**.
          </Step>

          <Step title="Valider la clé">
            Dans la liste **Encryption keys**, cliquez sur **Verify** à côté de la clé. **Connected** s'affiche lorsque la vérification réussit. En cas d'échec, un message en indique la raison.
          </Step>

          <Step title="Attacher la clé à un espace de travail">
            Dans la Claude Console, accédez à la page [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) et sélectionnez l'espace de travail dans le menu déroulant en haut de la page. Sous **Encryption key**, sélectionnez la clé, cliquez sur **Save**, puis confirmez. L'attachement d'une clé est irréversible. Pour un espace de travail qui reçoit déjà des requêtes, la clé peut mettre [jusqu'à un jour pour prendre effet](https://platform.claude.com/docs/fr/manage-claude/cmek#how-it-works).
          </Step>
        </Steps>
      </Tab>

      <Tab title="API">
        <Steps>
          <Step title="Enregistrer la clé auprès d'Anthropic">
            Créez une configuration de clé externe via l'Admin API, en utilisant le nom de ressource de l'étape Noter le nom complet de la ressource de la clé sous Configuration de la clé de chiffrement.

            <CodeGroup>
              ```bash cURL
              curl -sS "https://api.anthropic.com/v1/organizations/external_keys" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "content-type: application/json" \
                -d '{
                  "display_name": "<friendly-name>",
                  "geo": "us",
                  "provider_config": {
                    "type": "gcp",
                    "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                  }
                }'
              ```

              ```bash CLI
              ant organization:external-keys create <<'YAML'
              display_name: "<friendly-name>"
              geo: us
              provider_config:
                type: gcp
                key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
              YAML
              ```

              ```python Python
              client = anthropic.Anthropic()

              external_key = client.organization.external_keys.create(
                  display_name="<friendly-name>",
                  geo="us",
                  provider_config={
                      "type": "gcp",
                      "key_name": "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
                  },
              )

              print(f"id: {external_key.id}")
              print(f"display_name: {external_key.display_name}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const externalKey = await client.organization.externalKeys.create({
                display_name: "<friendly-name>",
                geo: "us",
                provider_config: {
                  type: "gcp",
                  key_name:
                    "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                }
              });

              console.log(`id: ${externalKey.id}`);
              console.log(`display_name: ${externalKey.display_name}`);
              ```

              ```csharp C#
              using Anthropic.Models.Organization.ExternalKeys;

              AnthropicClient client = new();

              var externalKey = await client.Organization.ExternalKeys.Create(new()
              {
                  DisplayName = "<friendly-name>",
                  Geo = Geo.Us,
                  ProviderConfig = new GcpExternalKeyConfig
                  {
                      KeyName = "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                  }
              });

              Console.WriteLine($"id: {externalKey.ID}");
              Console.WriteLine($"display_name: {externalKey.DisplayName}");
              ```

              ```go Go
              client := anthropic.NewClient()

              externalKey, err := client.Organization.ExternalKeys.New(context.Background(), anthropic.OrganizationExternalKeyNewParams{
              	DisplayName: anthropic.String("<friendly-name>"),
              	Geo:         anthropic.OrganizationExternalKeyNewParamsGeoUs,
              	ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{
              		OfGCP: &anthropic.GCPExternalKeyConfigParam{
              			KeyName: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>",
              		},
              	},
              })
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("id: %s\n", externalKey.ID)
              fmt.Printf("display_name: %s\n", externalKey.DisplayName)
              ```

              ```java Java
              import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams;

              void main() {
                  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

                  var params = ExternalKeyCreateParams.builder()
                      .displayName("<friendly-name>")
                      .geo(ExternalKeyCreateParams.Geo.US)
                      .gcpProviderConfig("projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>")
                      .build();
                  var externalKey = client.organization().externalKeys().create(params);

                  IO.println("id: " + externalKey.id());
                  IO.println("display_name: " + externalKey.displayName().orElseThrow());
              }
              ```

              ```php PHP
              use Anthropic\Organization\ExternalKeys\ExternalKeyCreateParams\Geo;
              // ...

              $client = new Client();

              $externalKey = $client->organization->externalKeys->create(
                  displayName: '<friendly-name>',
                  geo: Geo::US,
                  providerConfig: [
                      'type' => 'gcp',
                      'keyName' => 'projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>',
                  ],
              );

              echo "id: {$externalKey->id}\n";
              echo "display_name: {$externalKey->displayName}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              external_key = client.organization.external_keys.create(
                display_name: "<friendly-name>",
                geo: :us,
                provider_config: {
                  type: :gcp,
                  key_name: "projects/<your-project-id>/locations/<region>/keyRings/<your-keyring-name>/cryptoKeys/<your-key-name>"
                }
              )

              puts "id: #{external_key.id}"
              puts "display_name: #{external_key.display_name}"
              ```
            </CodeGroup>

            La réponse contient l'ID de la clé externe :

            ```json
            {
              "type": "external_key",
              "id": "ekey_<id>",
              "display_name": "<friendly-name>"
            }
            ```
          </Step>

          <Step title="Valider la clé">
            Déclenchez un aller-retour de chiffrement et de déchiffrement sur votre clé.

            <CodeGroup>
              ```bash cURL
              curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_<id>/validate" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01"
              ```

              ```bash CLI
              ant organization:external-keys validate --external-key-id "ekey_<id>"
              ```

              ```python Python
              client = anthropic.Anthropic()

              validation = client.organization.external_keys.validate("ekey_<id>")

              print(f"status: {validation.status}")
              print(f"error: {validation.error}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const validation = await client.organization.externalKeys.validate("ekey_<id>");

              console.log(`status: ${validation.status}`);
              console.log(`error: ${validation.error}`);
              ```

              ```csharp C#
              AnthropicClient client = new();

              var validation = await client.Organization.ExternalKeys.Validate("ekey_<id>");

              Console.WriteLine($"status: {validation.Status.Raw()}");
              Console.WriteLine($"error: {validation.Error}");
              ```

              ```go Go
              client := anthropic.NewClient()

              validation, err := client.Organization.ExternalKeys.Validate(context.Background(), "ekey_<id>")
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("status: %s\n", validation.Status)
              fmt.Printf("error: %s\n", validation.Error)
              ```

              ```java Java
              AnthropicClient client = AnthropicOkHttpClient.fromEnv();

              var validation = client.organization().externalKeys().validate("ekey_<id>");

              IO.println("status: " + validation.status().asString());
              IO.println("error: " + validation.error().orElse(""));
              ```

              ```php PHP
              $client = new Client();

              $validation = $client->organization->externalKeys->validate(
                  externalKeyID: 'ekey_<id>',
              );

              echo "status: {$validation->status}\n";
              echo "error: {$validation->error}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              external_key_id = "ekey_<id>"
              validation = client.organization.external_keys.validate(external_key_id)

              puts "status: #{validation.status}"
              puts "error: #{validation.error}"
              ```
            </CodeGroup>

            Une réponse réussie ressemble à ceci :

            ```json
            { "type": "external_key_validation", "status": "success", "error": null }
            ```

            Si la validation échoue, les causes courantes sont :

            * **VPC Service Controls :** si un périmètre de service protège Cloud KMS dans votre projet, ajoutez Anthropic à un niveau d'accès sur le périmètre (ou excluez le projet de la clé) afin qu'Anthropic puisse atteindre la clé.
            * **Partage restreint par domaine :** la politique d'organisation `constraints/iam.allowedPolicyMemberDomains` peut supprimer la liaison du compte de service Anthropic (voir la note précédente). Confirmez que la liaison est présente avec `gcloud kms keys get-iam-policy <your-key-name> --project=<your-project-id> --location=<region> --keyring=<your-keyring-name>`.
            * **Version de clé désactivée ou détruite :** confirmez que la version principale de la clé est activée, et non désactivée, programmée pour destruction, ou détruite.
          </Step>

          <Step title="Attacher la clé à un espace de travail">
            Une fois la clé validée, attachez-la à un nouvel espace de travail avant d'envoyer des requêtes à cet espace de travail. Pour un espace de travail qui reçoit déjà des requêtes, la clé peut prendre [jusqu'à une journée pour prendre effet](https://platform.claude.com/docs/fr/manage-claude/cmek#how-it-works).

            <CodeGroup>
              ```bash cURL
              curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/<workspace-id>" \
                -H "x-api-key: $ANTHROPIC_API_KEY" \
                -H "anthropic-version: 2023-06-01" \
                -H "content-type: application/json" \
                -d '{
                  "external_key_id": "ekey_<id>"
                }'
              ```

              ```bash CLI
              ant organization:workspaces update \
                --workspace-id "<workspace-id>" \
                --external-key-id "ekey_<id>"
              ```

              ```python Python
              client = anthropic.Anthropic()

              workspace = client.organization.workspaces.update(
                  "<workspace-id>", external_key_id="ekey_<id>"
              )

              print(f"id: {workspace.id}")
              print(f"external_key_id: {workspace.external_key_id}")
              ```

              ```typescript TypeScript
              const client = new Anthropic();

              const workspace = await client.organization.workspaces.update("<workspace-id>", {
                external_key_id: "ekey_<id>"
              });

              console.log(`id: ${workspace.id}`);
              console.log(`external_key_id: ${workspace.external_key_id}`);
              ```

              ```csharp C#
              AnthropicClient client = new();

              var workspace = await client.Organization.Workspaces.Update("<workspace-id>", new()
              {
                  ExternalKeyID = "ekey_<id>"
              });

              Console.WriteLine($"id: {workspace.ID}");
              Console.WriteLine($"external_key_id: {workspace.ExternalKeyID}");
              ```

              ```go Go
              client := anthropic.NewClient()

              workspace, err := client.Organization.Workspaces.Update(
              	context.Background(),
              	"<workspace-id>",
              	anthropic.OrganizationWorkspaceUpdateParams{
              		ExternalKeyID: anthropic.String("ekey_<id>"),
              	},
              )
              if err != nil {
              	log.Fatal(err)
              }

              fmt.Printf("id: %s\n", workspace.ID)
              fmt.Printf("external_key_id: %s\n", workspace.ExternalKeyID)
              ```

              ```java Java
              import com.anthropic.models.organization.workspaces.WorkspaceUpdateParams;

              void main() {
                  AnthropicClient client = AnthropicOkHttpClient.fromEnv();

                  var params = WorkspaceUpdateParams.builder()
                      .externalKeyId("ekey_<id>")
                      .build();
                  var workspace = client.organization().workspaces().update("<workspace-id>", params);

                  IO.println("id: " + workspace.id());
                  IO.println("external_key_id: " + workspace.externalKeyId().orElseThrow());
              }
              ```

              ```php PHP
              $client = new Client();

              $workspace = $client->organization->workspaces->update(
                  workspaceID: '<workspace-id>',
                  externalKeyID: 'ekey_<id>',
              );

              echo "id: {$workspace->id}\n";
              echo "external_key_id: {$workspace->externalKeyID}\n";
              ```

              ```ruby Ruby
              client = Anthropic::Client.new

              workspace_id = "<workspace-id>"
              workspace = client.organization.workspaces.update(
                workspace_id,
                external_key_id: "ekey_<id>"
              )

              puts "id: #{workspace.id}"
              puts "external_key_id: #{workspace.external_key_id}"
              ```
            </CodeGroup>
          </Step>
        </Steps>
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="Claude Enterprise">
    Dans [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), ouvrez **Encryption keys**, puis cliquez sur **Add key**. Choisissez **Google Cloud**, collez le nom complet de la ressource de la clé de l'étape précédente, et cliquez sur **Continue**. Anthropic valide la clé avec un aller-retour de chiffrement et de déchiffrement. Une fois qu'elle s'affiche comme vérifiée, votre organisation est protégée par CMEK à partir de ce moment.

    Sur Claude Enterprise, CMEK s'applique à l'ensemble de l'organisation, il n'y a donc pas d'étape d'attachement d'espace de travail distincte, et une organisation ne peut avoir qu'une seule clé.
  </Tab>
</Tabs>

## Terraform

Pour les déploiements infrastructure-as-code, les mêmes étapes correspondent au fournisseur `google` avec les ressources `google_kms_key_ring`, `google_kms_crypto_key`, et `google_kms_crypto_key_iam_member`.