---
title: Google Cloud KMS für CMEK konfigurieren
url: https://platform.claude.com/docs/de/manage-claude/cmek-google-cloud-kms
description: Verwende Google Cloud KMS, um einen Verschlüsselungsschlüssel für deine Organisation bereitzustellen.
---

Lass Claude Code diese Funktion für dich einrichten

```text
/claude-api hilf mir, einen kundenverwalteten Verschlüsselungsschlüssel mit Google Cloud KMS zu konfigurieren
```

Diese Anleitung führt durch die Konfiguration eines Google Cloud KMS-Schlüssels als [customer-managed encryption key (CMEK)](https://platform.claude.com/docs/de/manage-claude/cmek) für deine Anthropic-Organisation.

<Warning>
  Die Aktivierung von CMEK ist dauerhaft. Wenn dein KMS-Schlüssel gelöscht oder deaktiviert wird, kann Anthropic die damit verschlüsselten Daten nicht wiederherstellen. Lies die [Warnungen und Einschränkungen](https://platform.claude.com/docs/de/manage-claude/cmek), bevor du beginnst.
</Warning>

## Voraussetzungen

* Ein Google Cloud-Projekt mit aktivierter Abrechnung.
* Die aktivierte Cloud KMS API (`cloudkms.googleapis.com`).
* Berechtigungen zum Erstellen von KMS-Schlüsselbunden und -Schlüsseln sowie zum Festlegen der IAM-Richtlinie für diese (`roles/cloudkms.admin` oder gleichwertig).
* Ein Anthropic Admin-API-Key für deine Organisation.
* Die installierte und authentifizierte [`gcloud` CLI](https://cloud.google.com/cli).
* Aktivierte Cloud KMS **Data Access Audit Logs** für das Projekt (IAM & Admin > Audit Logs > Cloud Key Management Service, mit `DATA_READ` und `DATA_WRITE`). Diese sind standardmäßig deaktiviert; ohne sie erzeugen die Verschlüsselungs- und Entschlüsselungsvorgänge von Anthropic keine Einträge in Cloud Logging.

## E-Mail-Adresse des Anthropic-Dienstkontos

Damit Anthropic deinen Verschlüsselungsschlüssel verwenden kann, musst du dem Dienstkonto von Anthropic einen Schlüssel geben, den es zum Verschlüsseln von Daten verwenden kann. Die E-Mail-Adresse des Dienstkontos für Anthropic CMEK lautet:

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

<Warning>
  Verwende ausschließlich diese veröffentlichte E-Mail-Adresse des Dienstkontos. Vertraue niemals einer Kennung, die per E-Mail, Chat oder über einen Onboarding-Kanal bereitgestellt wird.
</Warning>

<Note>
  **Domänenbeschränkte Freigabe:** Wenn dein Projekt unter einer Google Cloud-Organisation liegt, die `constraints/iam.allowedPolicyMemberDomains` erzwingt, werden die folgenden IAM-Bindungen abgelehnt, da sich das Anthropic-Dienstkonto außerhalb deiner Organisation befindet. Du benötigst entweder eine projektbezogene Ausnahme für diese Einschränkung oder musst die Cloud Identity-Kundennummer von Anthropic (Format `C0xxxxxxxx`) zur Zulassungsliste hinzufügen. Kontaktiere Anthropic bei Bedarf für die Kundennummer.
</Note>

## Einrichtung des Verschlüsselungsschlüssels

<Steps>
  <Step title="Einen Schlüsselbund erstellen oder auswählen">
    Überspringe diesen Schritt, wenn du bereits einen Schlüsselbund zur Wiederverwendung hast. Schlüsselbunde sind regional. Wähle einen US-Standort mit einer einzelnen Region wie `us-east5`, der zur Anthropic-Geografie passt, die du konfigurierst. Multi-Region-Standorte wie `us` und `global` werden nicht unterstützt.

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

  <Step title="Den Krypto-Schlüssel erstellen">
    Erstelle einen symmetrischen Schlüssel mit dem Zweck `ENCRYPT_DECRYPT`. Anthropic empfiehlt dringend HSM-Schutz: Cloud KMS HSM-Schlüssel sind FIPS 140-2 Level 3 validiert, und der Kostenunterschied gegenüber Software-Schlüsseln ist gering.

    Die Option `--labels` fügt das Organisations-Label `anthropic-org-<ORGANIZATION_UUID>` mit dem Wert `true` hinzu, wobei `<ORGANIZATION_UUID>` deine Anthropic-Organisations-ID in Kleinbuchstaben ist. Das Label ist erforderlich, damit Anthropic den Schlüssel validieren kann.

    <Note>
      **Deine Organisations-ID finden:** Kopiere das Feld **Organization ID** auf der Seite [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) in der Claude Console oder unter **Organization settings > Organization** in claude.ai, oder lies das Feld `id` aus dem Endpunkt [Organization Info](https://platform.claude.com/docs/de/api/organization/retrieve) aus. Verwende die reine UUID, nicht die ID mit dem Präfix `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
    ```

    Für Software-Schutz stattdessen lasse `--protection-level=hsm` weg. Nichts anderes in dieser Anleitung ändert sich.

    Du kannst den Schlüssel auch über die Google Cloud Console erstellen. Öffne den Schlüsselbund, klicke auf **Create key**, wähle **Generated key**, setze Zweck und Algorithmus auf symmetrisches Verschlüsseln und Entschlüsseln und wähle **HSM** unter Schutzebene.

    <Frame caption="Erstelle einen HSM-geschützten symmetrischen Verschlüsselungs-/Entschlüsselungsschlüssel mit dem Organisations-Label.">
      ![Seite Create key in Google Cloud KMS mit HSM-Schutz, dem Zweck symmetrisches Verschlüsseln und Entschlüsseln sowie dem auf true gesetzten Label anthropic-org.](https://platform.claude.com/docs/images/cmek/gcp-create-key-label.png)
    </Frame>

    Um einen Schlüssel unter mehreren Anthropic-Organisationen zu teilen, füge für jede Organisation ein solches Label hinzu. Ein Schlüssel kann höchstens 64 Labels tragen, einschließlich deiner eigenen.

    <Note>
      Um das Label zu einem Schlüssel hinzuzufügen, der es nicht hat, führe `gcloud kms keys update <KEY_NAME> --project=<PROJECT_ID> --location=<REGION> --keyring=<KEYRING_NAME> --update-labels=anthropic-org-<ORGANIZATION_UUID>=true` aus. Es führt das Label mit allen Labels zusammen, die der Schlüssel bereits hat.
    </Note>
  </Step>

  <Step title="Dem Anthropic-Dienstkonto Zugriff auf den Schlüssel gewähren">
    Zwei IAM-Bindungen auf Schlüsselebene sind erforderlich. Beide sind auf den einzelnen Krypto-Schlüssel beschränkt, nicht projektweit oder schlüsselbundweit.

    Verschlüsseln und Entschlüsseln, was Anthropic verwendet, um die Datenschlüssel zu verschlüsseln und zu entschlüsseln, die deine Workspace-Daten schützen (Envelope-Verschlüsselung):

    ```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, für das Lesen der Metadaten (`cryptoKeys.get`), das Anthropic beim Start durchführt, um Zweck und Algorithmus des Schlüssels zu validieren:

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

    Wähle in der Console den Schlüssel aus, öffne das Panel **Permissions**, klicke auf **Grant access** und füge das Dienstkonto mit den Rollen Cloud KMS CryptoKey Encrypter/Decrypter und Cloud KMS Viewer hinzu. Stelle sicher, dass du dich auf der Berechtigungsseite des Schlüssels befindest, nicht auf der des Schlüsselbunds oder Projekts, damit die Gewährung nur auf diesen Schlüssel beschränkt ist.

    <Frame caption="Gewähre dem Anthropic-Dienstkonto beide Rollen, beschränkt auf den Schlüssel.">
      ![Dialog Grant access mit dem Anthropic-Dienstkonto und den zugewiesenen Rollen Cloud KMS CryptoKey Encrypter/Decrypter und Cloud KMS Viewer.](https://platform.claude.com/docs/images/cmek/gcp-grant-access.png)
    </Frame>
  </Step>

  <Step title="Den vollständigen Ressourcennamen des Schlüssels notieren">
    Diesen übergibst du an Anthropic, wenn du den Schlüssel registrierst. Das Format ist:

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

    Rufe ihn ab mit:

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

    Öffne in der Console die Detailseite des Schlüssels und klicke auf **Copy resource name**.

    <Frame caption="Kopiere den vollständigen Ressourcennamen des Schlüssels aus dem Aktionsmenü.">
      ![Details des Schlüsselbunds in Google Cloud mit der hervorgehobenen Aktion Copy resource name im Aktionsmenü des Schlüssels.](https://platform.claude.com/docs/images/cmek/gcp-copy-resource-name.png)
    </Frame>
  </Step>
</Steps>

## Den Schlüssel bei Anthropic registrieren

Wie du den Schlüssel registrierst, hängt davon ab, welches Produkt du verwendest.

<Tabs>
  <Tab title="Claude Platform">
    Du kannst den Schlüssel in der Claude Console oder über die Admin API einrichten, mit demselben Ergebnis.

    <Tabs>
      <Tab title="Claude Console">
        <Steps>
          <Step title="Den Schlüssel bei Anthropic registrieren">
            Gehe in der Claude Console zur Seite [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Wenn du **Encryption keys** nicht siehst, wähle **Organization** aus dem Dropdown-Menü oben auf der Seite. Klicke unter **Encryption keys** auf **Add key**. Gib einen Anzeigenamen ein, wähle **Google Cloud KMS** und klicke auf **Continue**. Füge den vollständigen Ressourcennamen des Schlüssels in **Key resource name** ein und klicke auf **Add**.

            Der Schritt mit den Schlüsseldetails zeigt das Organisations-Label an. Füge es dem Schlüssel hinzu, wie [der Erstellungsschritt](https://platform.claude.com/docs/de/manage-claude/cmek-google-cloud-kms#organization-label) beschreibt, bevor du auf **Add** klickst.
          </Step>

          <Step title="Den Schlüssel validieren">
            Klicke in der Liste **Encryption keys** neben dem Schlüssel auf **Verify**. **Connected** wird angezeigt, wenn die Prüfung erfolgreich ist. Schlägt sie fehl, nennt eine Meldung den Grund.
          </Step>

          <Step title="Den Schlüssel an einen Workspace anhängen">
            Gehe in der Claude Console zur Seite [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) und wähle den Workspace aus dem Dropdown-Menü oben auf der Seite. Wähle unter **Encryption key** den Schlüssel aus, klicke auf **Save** und bestätige. Das Anhängen eines Schlüssels kann nicht rückgängig gemacht werden. Bei einem Workspace, der bereits Anfragen erhält, kann es [bis zu einem Tag dauern, bis der Schlüssel wirksam wird](https://platform.claude.com/docs/de/manage-claude/cmek#how-it-works).
          </Step>
        </Steps>
      </Tab>

      <Tab title="API">
        <Steps>
          <Step title="Den Schlüssel bei Anthropic registrieren">
            Erstelle eine externe Schlüsselkonfiguration über die Admin API, unter Verwendung des Ressourcennamens aus dem Schritt „Den vollständigen Ressourcennamen des Schlüssels notieren" unter „Einrichtung des Verschlüsselungsschlüssels".

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

            Die Antwort enthält die externe Schlüssel-ID:

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

          <Step title="Den Schlüssel validieren">
            Löse einen Verschlüsselungs- und Entschlüsselungs-Roundtrip gegen deinen Schlüssel aus.

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

            Eine erfolgreiche Antwort sieht so aus:

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

            Wenn die Validierung fehlschlägt, sind häufige Ursachen:

            * **VPC Service Controls:** Wenn ein Service-Perimeter Cloud KMS in deinem Projekt schützt, füge Anthropic zu einer Zugriffsebene auf dem Perimeter hinzu (oder schließe das Projekt des Schlüssels aus), damit Anthropic den Schlüssel erreichen kann.
            * **Domänenbeschränkte Freigabe:** Die Organisationsrichtlinie `constraints/iam.allowedPolicyMemberDomains` kann die Bindung des Anthropic-Dienstkontos entfernen (siehe den vorherigen Hinweis). Bestätige, dass die Bindung vorhanden ist, mit `gcloud kms keys get-iam-policy <your-key-name> --project=<your-project-id> --location=<region> --keyring=<your-keyring-name>`.
            * **Deaktivierte oder zerstörte Schlüsselversion:** Bestätige, dass die primäre Version des Schlüssels aktiviert ist und nicht deaktiviert, zur Zerstörung vorgesehen oder zerstört ist.
          </Step>

          <Step title="Den Schlüssel an einen Workspace anhängen">
            Sobald der Schlüssel validiert ist, hänge ihn an einen neuen Workspace an, bevor du Anfragen an diesen Workspace sendest. Bei einem Workspace, der bereits Anfragen empfängt, kann es [bis zu einem Tag dauern, bis der Schlüssel wirksam wird](https://platform.claude.com/docs/de/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">
    Öffne in [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls) **Encryption keys** und klicke dann auf **Add key**. Wähle **Google Cloud**, füge den vollständigen Ressourcennamen des Schlüssels aus dem vorherigen Schritt ein und klicke auf **Continue**. Anthropic validiert den Schlüssel mit einem Verschlüsselungs- und Entschlüsselungs-Roundtrip. Sobald er als verifiziert angezeigt wird, ist deine Organisation ab diesem Zeitpunkt CMEK-geschützt.

    Bei Claude Enterprise gilt CMEK für die gesamte Organisation, daher gibt es keinen separaten Schritt zum Anhängen an einen Workspace, und eine Organisation kann nur einen Schlüssel haben.
  </Tab>
</Tabs>

## Terraform

Für Infrastructure-as-Code-Bereitstellungen werden dieselben Schritte auf den `google`-Provider mit den Ressourcen `google_kms_key_ring`, `google_kms_crypto_key` und `google_kms_crypto_key_iam_member` abgebildet.