--- title: AWS KMS für CMEK konfigurieren url: https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms description: Verwende AWS 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 AWS KMS zu konfigurieren ``` Diese Anleitung führt durch die Konfiguration eines [AWS KMS](https://aws.amazon.com/kms/)-Schlüssels als [customer-managed encryption key (CMEK)](https://platform.claude.com/docs/de/manage-claude/cmek) für deine Anthropic-Organisation. 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. **Claude Platform on AWS:** Auf [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) gewährt deine Schlüsselrichtlinie einem AWS-Service-Principal Zugriff anstelle von Anthropics IAM-Rolle, es gibt keinen separaten Validierungsschritt, und du registrierst und verknüpfst den Schlüssel in der Claude Console. Folge [CMEK auf Claude Platform on AWS einrichten](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms#claude-platform-on-aws) auf dieser Seite anstelle der Schritte in den nächsten Abschnitten. ## Voraussetzungen * Ein AWS-Konto mit Berechtigungen zum Erstellen von KMS-Schlüsseln und Festlegen von Schlüsselrichtlinien (`kms:CreateKey` und `kms:PutKeyPolicy`). * Ein Anthropic Admin-API-Key für deine Organisation. * Die [AWS CLI](https://aws.amazon.com/cli/) installiert und authentifiziert. ## Amazon Resource Name (ARN) für Anthropic Damit Anthropic deinen Verschlüsselungsschlüssel verwendet, musst du Anthropics IAM-Rolle einen KMS-Schlüssel geben, den sie zum Verschlüsseln von Daten verwenden kann. Der ARN für Anthropic CMEK lautet: ```text wrap arn:aws:iam::915198916910:role/anthropic-cmek-client-us ``` Verwende nur diesen veröffentlichten ARN. Vertraue niemals einer Kennung, die per E-Mail, Chat oder über einen Onboarding-Kanal bereitgestellt wird. ## Einrichtung des Verschlüsselungsschlüssels **Claude Platform on AWS:** Überspringe diesen Schritt. Deine Schlüsselrichtlinie gewährt einem AWS-Service-Principal Zugriff und hat keine Organisationsbedingung. [CMEK auf Claude Platform on AWS einrichten](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms#claude-platform-on-aws) gibt diese Richtlinie an. Die Schlüsselrichtlinie gewährt Anthropics IAM-Rolle kontoübergreifenden Zugriff. Drei Anweisungen sind erforderlich: 1. **Account-Root-Admin:** das Standard-KMS-Muster. Dein Konto behält die volle Admin-Kontrolle. 2. **Anthropic encrypt und decrypt:** die Aktionen `kms:Encrypt` und `kms:Decrypt`, die Anthropic verwendet, um die Datenschlüssel zu verschlüsseln und zu entschlüsseln, die deine Workspace-Daten schützen (Envelope-Verschlüsselung). 3. **Anthropic describe:** der Metadaten-Lesevorgang, den Anthropic beim Start durchführt. Er wird separat gewährt, weil `DescribeKey` keinen `EncryptionContext`-Parameter hat, sodass eine `EncryptionContext`-Bedingung für diese Aktion immer verweigern würde. Um [deine AWS-Konto-ID](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html) zu finden, führe `aws sts get-caller-identity --query Account --output text` aus. Ersetze in der Richtlinie `` durch deine AWS-Konto-ID und `` durch deine Organisations-ID. Die `StringEquals`-Bedingung für `kms:EncryptionContext:anthropic:org_uuid` bindet den Schlüssel an deine Anthropic-Organisation, und die Validierung lehnt einen Schlüssel ohne sie ab. Um einen Schlüssel unter mehreren Anthropic-Organisationen zu teilen, liste jede Organisations-ID im Bedingungswert auf. **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). Verwende die reine UUID, nicht die ID mit dem Präfix `org_`. Speichere die Richtlinie als `key-policy.json`. Um den Schlüssel stattdessen in der AWS Console zu erstellen, füge die Richtlinie dort ein, wie später in diesem Schritt beschrieben. ```json key-policy.json { "Version": "2012-10-17", "Statement": [ { "Sid": "AccountRootAdmin", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam:::root" }, "Action": "kms:*", "Resource": "*" }, { "Sid": "AllowAnthropicCMEKCrypto", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us" }, "Action": ["kms:Encrypt", "kms:Decrypt"], "Resource": "*", "Condition": { "StringEquals": { "kms:EncryptionContext:anthropic:org_uuid": [""] } } }, { "Sid": "AllowAnthropicCMEKDescribe", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us" }, "Action": "kms:DescribeKey", "Resource": "*" } ] } ``` **Optional:** Um den Schlüssel auf einige deiner Workspaces zu beschränken, verwende diese `AllowAnthropicCMEKCrypto`-Anweisung anstelle der im vorherigen Richtlinien-JSON, mit einer Compartment-ID für jeden Workspace. Füge die Compartment-ID eines Workspaces hinzu, bevor du den Schlüssel daran anhängst. Erstelle für einen neuen Workspace diesen ohne den Schlüssel, füge seine Compartment-ID hinzu und hänge dann den Schlüssel an. ```json { "Sid": "AllowAnthropicCMEKCrypto", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us" }, "Action": ["kms:Encrypt", "kms:Decrypt"], "Resource": "*", "Condition": { "StringEquals": { "kms:EncryptionContext:anthropic:org_uuid": [""] }, "StringEqualsIfExists": { "kms:EncryptionContext:anthropic:compartment_uuid": [""] } } } ``` ```bash aws kms create-key \ --region \ --description "Anthropic CMEK" \ --key-usage ENCRYPT_DECRYPT \ --policy file://key-policy.json ``` Erfasse `KeyMetadata.Arn` aus der Ausgabe. Du benötigst es, wenn du den Schlüssel im nächsten Schritt registrierst. Wenn der Schlüssel bereits für CMEK konfiguriert ist und vorhandene Daten schützt, musst du zusätzlich zu den drei Anweisungen in der vorherigen Richtlinie eine Anweisung hinzufügen, die es Anthropic erlaubt, diese Daten zu entschlüsseln. Liste in ihrer Bedingung die Compartment-ID jedes Workspaces auf, an den der Schlüssel angehängt ist oder war. ```json { "Sid": "AllowAnthropicCMEKDecryptExistingData", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us" }, "Action": "kms:Decrypt", "Resource": "*", "Condition": { "StringEquals": { "kms:EncryptionContext:anthropic:compartment_uuid": [""] } } } ``` Anthropic validiert den Schlüssel, wenn du ihn verifizierst oder an einen Workspace anhängst. Jede Validierung fügt CloudTrail vier Access-Denied-Fehler hinzu. Diese sind zu erwarten. Wenn du sie herausfiltern musst, filtere nach allen drei der folgenden Werte. Der erste allein reicht nicht aus, weil jeder Aufrufer ihn setzen kann: * `requestParameters.encryptionContext.associatedData`: `Y21lay12YWxpZGF0aW9u` * `userIdentity.accountId`: `915198916910` * `resources.ARN`: `arn:aws:kms:::key/` **Deine Compartment-ID finden:** Siehe den Tab **Claude Platform** unter **Den Schlüssel bei Anthropic registrieren**. Du kannst den Schlüssel auch über die AWS Console erstellen. Wähle einen symmetrischen Schlüssel mit der Schlüsselverwendung „encrypt and decrypt", einen Single-Region-Schlüssel und KMS-Schlüsselmaterial-Ursprung. Der Create-Key-Assistent legt bei seinem Schritt **Review** eine Schlüsselrichtlinie fest: Wenn du dort Anthropics Konto-ID `915198916910` unter den Schlüsselverwendungsberechtigungen hinzufügst, gewährt die generierte Richtlinie dem gesamten Anthropic-Konto umfassendere Aktionen (wie `kms:ReEncrypt*` und `kms:GenerateDataKey*`) ohne `EncryptionContext`-Bedingung, und die Validierung lehnt sie ab. Um keinen überberechtigten Schlüssel zu hinterlassen, beende den Assistenten nur mit administrativen Berechtigungen, öffne dann den Tab **Key policy** des Schlüssels und ersetze das JSON durch die `key-policy.json`-Richtlinie, die zuvor in diesem Schritt gezeigt wurde. ![Create-Key-Assistent in AWS KMS beim Schritt Configure key (Schlüssel konfigurieren). Ausgewählt sind der Schlüsseltyp symmetrisch, die Schlüsselverwendung „encrypt and decrypt“ und ein Single-Region-Schlüssel.](https://platform.claude.com/docs/images/cmek/aws-configure-key.png) ![Schritt Add labels (Labels hinzufügen) in AWS KMS mit dem Alias anthropic-cmek und der Beschreibung Anthropic CMEK.](https://platform.claude.com/docs/images/cmek/aws-add-labels.png) ![Schritt Define key administrative permissions (administrative Schlüsselberechtigungen definieren) in AWS KMS mit einer Liste der IAM-Rollen, die den Schlüssel verwalten können.](https://platform.claude.com/docs/images/cmek/aws-admin-permissions.png) ![Schritt Define key usage permissions (Schlüsselverwendungsberechtigungen definieren) in AWS KMS, in dem Anthropics Konto-ID unter Other AWS accounts (andere AWS-Konten) eingetragen ist.](https://platform.claude.com/docs/images/cmek/aws-usage-permissions.png) ## Den Schlüssel bei Anthropic registrieren Wie du den Schlüssel registrierst, hängt davon ab, welches Produkt du verwendest. **Claude Platform on AWS:** Der Principal, die Schlüsselrichtlinie und der Registrierungsablauf unterscheiden sich, und es gibt keinen separaten Validierungsschritt. Folge [CMEK auf Claude Platform on AWS einrichten](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms#claude-platform-on-aws) anstelle dieses Tabs. **Deine Compartment-ID finden:** Jeder Workspace hat eine Compartment-ID, die seine CMEK-Daten abgrenzt. Um sie in der Claude Console zu finden, gehe 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 aus. Die ID befindet sich unter **Encryption key** im Feld **Compartment ID**. Du kannst auch das Feld `compartment_id` lesen, das vom Endpunkt [Get Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve) zurückgegeben wird. Du kannst den Schlüssel in der Claude Console oder über die Admin-API einrichten, mit demselben Ergebnis. 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 aus. Klicke unter **Encryption keys** auf **Add key**. Gib einen Anzeigenamen ein, wähle **AWS KMS** und klicke auf **Continue**. Füge den Schlüssel-ARN in **KMS key ARN** ein und klicke auf **Add**. Der Schlüsseldetails-Schritt zeigt deine Organisations-ID an. Füge sie der [Schlüsselrichtlinie](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms#key-policy) hinzu, bevor du auf **Add** klickst. Klicke in der Liste **Encryption keys** neben dem Schlüssel auf **Verify**. **Connected** erscheint, wenn die Prüfung erfolgreich ist. Wenn sie fehlschlägt, nennt eine Meldung den Grund. 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 aus. 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). Erstelle eine externe Schlüsselkonfiguration über die Admin-API. ```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": "", "geo": "us", "provider_config": { "type": "aws", "kms_arn": "" } }' ``` ```bash CLI ant organization:external-keys create <<'YAML' display_name: "" geo: us provider_config: type: aws kms_arn: "" YAML ``` ```python Python client = anthropic.Anthropic() external_key = client.organization.external_keys.create( display_name="", geo="us", provider_config={"type": "aws", "kms_arn": ""}, ) 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: "", geo: "us", provider_config: { type: "aws", kms_arn: "" } }); 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 = "", Geo = Geo.Us, ProviderConfig = new AwsExternalKeyConfig { KmsArn = "" } }); 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(""), Geo: anthropic.OrganizationExternalKeyNewParamsGeoUs, ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{ OfAWS: &anthropic.AWSExternalKeyConfigParam{ KMSARN: "", }, }, }) 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.AwsExternalKeyConfig; import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = ExternalKeyCreateParams.builder() .displayName("") .geo(ExternalKeyCreateParams.Geo.US) .providerConfig(AwsExternalKeyConfig.builder() .kmsArn("") .build()) .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: '', geo: Geo::US, providerConfig: [ 'type' => 'aws', 'kmsARN' => '', ], ); 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: "", geo: :us, provider_config: { type: :aws, kms_arn: "" } ) puts "id: #{external_key.id}" puts "display_name: #{external_key.display_name}" ``` Die Antwort enthält die externe Schlüssel-ID: ```json { "type": "external_key", "id": "ekey_", "display_name": "" } ``` Löse einen Encrypt-und-Decrypt-Roundtrip gegen deinen Schlüssel aus. ```bash cURL curl -sS -X POST "https://api.anthropic.com/v1/organizations/external_keys/ekey_/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_" ``` ```python Python client = anthropic.Anthropic() validation = client.organization.external_keys.validate("ekey_") print(f"status: {validation.status}") print(f"error: {validation.error}") ``` ```typescript TypeScript const client = new Anthropic(); const validation = await client.organization.externalKeys.validate("ekey_"); console.log(`status: ${validation.status}`); console.log(`error: ${validation.error}`); ``` ```csharp C# AnthropicClient client = new(); var validation = await client.Organization.ExternalKeys.Validate("ekey_"); 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_") 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_"); IO.println("status: " + validation.status().asString()); IO.println("error: " + validation.error().orElse("")); ``` ```php PHP $client = new Client(); $validation = $client->organization->externalKeys->validate( externalKeyID: 'ekey_', ); echo "status: {$validation->status}\n"; echo "error: {$validation->error}\n"; ``` ```ruby Ruby client = Anthropic::Client.new external_key_id = "ekey_" validation = client.organization.external_keys.validate(external_key_id) puts "status: #{validation.status}" puts "error: #{validation.error}" ``` Eine erfolgreiche Antwort sieht so aus: ```json { "type": "external_key_validation", "status": "success", "error": null } ``` Wenn die Validierung fehlschlägt, sind häufige Ursachen: * **Encryption-Context-Nichtübereinstimmung:** Wenn die Richtlinie eine `kms:EncryptionContext:anthropic:compartment_uuid`-Bedingung hat, stelle sicher, dass sie die Compartment-ID jedes Workspaces auflistet, an den der Schlüssel angehängt ist. Die Validierung sendet die Compartment-ID des Workspaces, den sie prüft. Ein älterer Schlüssel, dessen Compartment-Anweisung noch `kms:Encrypt` erlaubt, wird mit dem Nur-Nullen-Wert (`00000000-0000-0000-0000-000000000000`) validiert, während er nicht angehängt ist, also behalte diesen Wert in seiner Liste. * **Resource Control Policies (RCPs):** Wenn deine AWS-Organisation eine RCP hat, die KMS-Operationen verweigert, wenn `aws:PrincipalOrgID` nicht mit deiner Organisation übereinstimmt, blockiert sie Anthropics kontoübergreifende Rolle. Die RCP benötigt eine Ausnahme für diesen Schlüssel oder für Anthropics Rollen-ARN. Service Control Policies gelten hier nicht, weil sie nicht für externe Principals ausgewertet werden, die über ressourcenbasierte Richtlinien aufrufen. * **Zugriff über IAM statt über die Schlüsselrichtlinie gewährt:** Kontoübergreifender KMS-Zugriff muss in der Schlüsselrichtlinie selbst gewährt werden, nicht über eine IAM-Richtlinie in deinem Konto. Prüfe mit `aws kms get-key-policy --key-id --policy-name default`. * **Regions-Nichtübereinstimmung:** Bestätige, dass die Region des Schlüssels eine ist, in der Anthropic für die von dir konfigurierte Geo-Stufe tätig ist. 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). ```bash cURL curl -sS -X POST "https://api.anthropic.com/v1/organizations/workspaces/" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "external_key_id": "ekey_" }' ``` ```bash CLI ant organization:workspaces update \ --workspace-id "" \ --external-key-id "ekey_" ``` ```python Python client = anthropic.Anthropic() workspace = client.organization.workspaces.update( "", external_key_id="ekey_" ) 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("", { external_key_id: "ekey_" }); 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("", new() { ExternalKeyID = "ekey_" }); 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(), "", anthropic.OrganizationWorkspaceUpdateParams{ ExternalKeyID: anthropic.String("ekey_"), }, ) 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_") .build(); var workspace = client.organization().workspaces().update("", 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: '', externalKeyID: 'ekey_', ); echo "id: {$workspace->id}\n"; echo "external_key_id: {$workspace->externalKeyID}\n"; ``` ```ruby Ruby client = Anthropic::Client.new workspace_id = "" workspace = client.organization.workspaces.update( workspace_id, external_key_id: "ekey_" ) puts "id: #{workspace.id}" puts "external_key_id: #{workspace.external_key_id}" ``` Ö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 **AWS** und klicke auf **Continue**, füge dann den Key-ARN aus dem vorherigen Schritt ein und klicke auf **Add**. Anthropic validiert den Schlüssel mit einem Encrypt-und-Decrypt-Roundtrip. Sobald er als verifiziert angezeigt wird, ist deine Organisation ab diesem Zeitpunkt CMEK-geschützt. Der Schlüsseldetails-Schritt dieses Ablaufs zeigt deine **Organization ID for the key policy** mit einer Kopierschaltfläche an. Ersetze diesen Wert für `` in der Schlüsselrichtlinie. Du kannst den Ablauf öffnen, um die ID zu kopieren, bevor du den Schlüssel erstellst. Auf Claude Enterprise gilt CMEK für die gesamte Organisation, sodass es keinen separaten Workspace-Anhängeschritt gibt und eine Organisation nur einen Schlüssel haben kann. ## CMEK auf Claude Platform on AWS einrichten Auf [Claude Platform on AWS](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws) verwendet CMEK nur AWS-KMS-Schlüssel, und die Einrichtung unterscheidet sich von den vorherigen Abschnitten in folgenden Punkten: * **Principal:** Deine Schlüsselrichtlinie gewährt dem AWS-Service-Principal `aws-external-anthropic.amazonaws.com` Zugriff. Anthropics IAM-Rolle und Konto-ID werden nicht verwendet, sodass der [ARN für Anthropic](https://platform.claude.com/docs/de/manage-claude/cmek-aws-kms#amazon-resource-name-arn-for-anthropic) nicht gilt. * **Schlüsselanforderungen:** Der Schlüssel muss ein symmetrischer KMS-Schlüssel mit Encrypt-und-Decrypt-Verwendung sein, Single-Region und im selben AWS-Konto und derselben Region wie der Workspace, an den du ihn anhängst. Kontoübergreifende Schlüssel werden nicht unterstützt: Der Schlüssel muss sich in dem AWS-Konto befinden, das deine Organisation hostet. Multi-Region-Schlüssel (Schlüssel-IDs, die mit `mrk-` beginnen) und Alias-ARNs werden abgelehnt, wenn du den Schlüssel registrierst; verwende den Schlüssel-ARN. * **Kein separater Validierungsschritt:** Abgesehen von diesen Prüfungen des Schlüssel-ARN bei der Registrierung wird der Schlüssel validiert, wenn du ihn an einen Workspace anhängst. Der Anhängeaufruf führt einen Encrypt/Decrypt-Durchlauf gegen den Schlüssel mit der Compartment-ID dieses Workspaces als Encryption Context durch, sodass ein Problem mit der Schlüsselrichtlinie beim Anhängen statt bei der Registrierung auftritt. Eine `EncryptionContext`-Bedingung benötigt daher keinen Nur-Nullen-Eintrag. * **Wo du Schlüssel verwaltest:** Registriere und hänge Schlüssel in der Claude Console an, angemeldet über AWS mit der Admin-Rolle. Die externen Schlüssel-Endpunkte sind auch auf Claude Platform on AWS verfügbar, autorisiert über [IAM-Aktionen](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#encryption-keys); dort wird ein Schlüssel durch seinen KMS-Schlüssel-ARN statt durch eine `ekey_`-ID identifiziert. Verwende nur diesen veröffentlichten Service-Principal-Namen. Vertraue niemals einer Kennung, die per E-Mail, Chat oder über einen Onboarding-Kanal bereitgestellt wird. ### Voraussetzungen * Das AWS-Konto, das deine Claude Platform on AWS-Organisation hostet, mit Berechtigungen zum Erstellen von KMS-Schlüsseln und Festlegen von Schlüsselrichtlinien (`kms:CreateKey` und `kms:PutKeyPolicy`). * Die **Admin**-Rolle in der Claude Console für Claude Platform on AWS. Siehe [Die Claude Console verwenden](https://platform.claude.com/docs/de/build-with-claude/claude-platform-on-aws#using-the-claude-console). * Für den IAM-Principal, mit dem du dich bei der Claude Console anmeldest: neben `aws-external-anthropic:AssumeConsole` die [IAM-Aktionen](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#encryption-keys) für die Operationen, die du dort ausführst, weil das Registrieren, Auflisten und Anhängen von Schlüsseln über das AWS-Gateway läuft. Das Registrieren eines Schlüssels ist `RegisterKey` (mit `ListKeys` und `GetKey` zum Anzeigen von Registrierungen), und das Anhängen ist `UpdateWorkspace` oder `CreateWorkspace`. Die Aktionen für externe Schlüssel (und `CreateWorkspace`) sind kontobezogen, gewähre sie also auf `Resource: "*"`; eine auf Workspace-ARNs beschränkte Richtlinie schließt sie nicht ein. * Für den IAM-Principal, der den Schlüssel an einen Workspace anhängt (die Identität, mit der du dich bei der Claude Console angemeldet hast): `kms:DescribeKey`, `kms:Encrypt` und `kms:Decrypt` für den Schlüssel. Der Zugriff deines Principals auf den Schlüssel wird beim Anhängen geprüft, zusätzlich zu dem des Service-Principals. * Optional, für den Schlüssel-Picker in der Claude Console: `kms:ListKeys` und `kms:DescribeKey` für den Principal, mit dem du dich anmeldest. Ohne sie füge stattdessen den Schlüssel-ARN ein. ### Den KMS-Schlüssel erstellen Die Schlüsselrichtlinie hat drei Anweisungen: die Root-Admin-Anweisung deines Kontos; eine Anweisung, die dem Claude Platform on AWS-Service-Principal das Verschlüsseln, Entschlüsseln und Generieren von Datenschlüsseln erlaubt; und eine separate Anweisung für `kms:DescribeKey`. Die Krypto-Anweisung enthält eine optionale `EncryptionContext`-Bedingung, die den Schlüssel an die von dir aufgelisteten Workspaces bindet. `DescribeKey` wird separat gewährt, weil es keinen `EncryptionContext`-Parameter hat, sodass eine `EncryptionContext`-Bedingung für diese Aktion immer zu einer Ablehnung führen würde. Wenn du die hier gezeigte optionale `EncryptionContext`-Bedingung verwenden möchtest, erstelle zuerst den Workspace (ohne Schlüssel), kopiere seine Compartment-ID und setze sie für `` ein. Um die ID in der Claude Console zu finden, gehe 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 aus. Die ID befindet sich unter **Encryption key** im Feld **Compartment ID**. Du kannst sie auch aus dem Feld `compartment_id` lesen, das vom Endpunkt [Get Workspace](https://platform.claude.com/docs/de/api/organization/workspaces/retrieve) zurückgegeben wird. Wenn du die Bedingung nicht verwenden möchtest, lösche den `Condition`-Block aus dieser Anweisung. ```bash export YOUR_ACCOUNT=$(aws sts get-caller-identity --query Account --output text) aws kms create-key \ --region \ --description "Anthropic CMEK (Claude Platform on AWS)" \ --key-usage ENCRYPT_DECRYPT \ --policy "{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Sid\": \"AccountRootAdmin\", \"Effect\": \"Allow\", \"Principal\": {\"AWS\": \"arn:aws:iam::${YOUR_ACCOUNT}:root\"}, \"Action\": \"kms:*\", \"Resource\": \"*\" }, { \"Sid\": \"AllowClaudePlatformOnAWSCrypto\", \"Effect\": \"Allow\", \"Principal\": {\"Service\": \"aws-external-anthropic.amazonaws.com\"}, \"Action\": [\"kms:Encrypt\", \"kms:Decrypt\", \"kms:GenerateDataKey\"], \"Resource\": \"*\", \"Condition\": { \"StringEquals\": { \"kms:EncryptionContext:anthropic:compartment_uuid\": [ \"\" ] } } }, { \"Sid\": \"AllowClaudePlatformOnAWSDescribe\", \"Effect\": \"Allow\", \"Principal\": {\"Service\": \"aws-external-anthropic.amazonaws.com\"}, \"Action\": \"kms:DescribeKey\", \"Resource\": \"*\" } ] }" ``` Erfasse `KeyMetadata.Arn` aus der Ausgabe. Du benötigst es, wenn du den Schlüssel registrierst. Die `EncryptionContext`-Bedingung ist optional. Jeder Verschlüsselungs-, Entschlüsselungs- und Datenschlüsselaufruf für einen Workspace, einschließlich der Prüfung beim Anhängen, enthält die Compartment-ID dieses Workspaces als `anthropic:compartment_uuid`. Die Bedingung listet daher die Compartment-ID jedes Workspaces auf, an den du den Schlüssel anhängst, und benötigt keinen Nur-Nullen-Eintrag. Wenn du sie hinzufügst, wird der Schlüssel auch auf IAM-Ebene an die von dir aufgelisteten Workspaces gebunden. Da eine Compartment-ID erst existiert, wenn ihr Workspace existiert, ist die Reihenfolge: Workspace erstellen, seine Compartment-ID in die Bedingung eintragen (bei der Schlüsselerstellung oder später mit `kms:PutKeyPolicy`), dann den Schlüssel anhängen. Bevor du den Schlüssel an jeden weiteren Workspace anhängst, füge die Compartment-ID dieses Workspaces auf dieselbe Weise hinzu. Um ohne die Bedingung zu beginnen, lösche den `Condition`-Block aus der Anweisung `AllowClaudePlatformOnAWSCrypto`; wenn du sie später hinzufügst, nimm die Compartment-ID jedes Workspaces auf, an den der Schlüssel bereits angehängt ist. Du kannst beide Service-Principal-Anweisungen mit einer `aws:SourceArn`-Bedingung weiter einschränken. Der Service übergibt bei jedem Aufruf, den er mit deinem Schlüssel durchführt, den [ARN des Workspaces](https://platform.claude.com/docs/de/api/claude-platform-on-aws-iam-actions#service-details) (`arn:aws:aws-external-anthropic:::workspace/`) als Source-ARN. Daher beschränkt `"ArnLike": {"aws:SourceArn": "arn:aws:aws-external-anthropic:*::workspace/*"}` die Berechtigung auf Workspaces in deinem eigenen AWS-Konto, und eine Liste vollständiger Workspace-ARNs beschränkt sie auf diese Workspaces. Diese Bedingung ist nicht erforderlich; die `EncryptionContext`-Bedingung allein bindet den Schlüssel an die von dir aufgelisteten Workspaces. Du kannst den Schlüssel auch über die AWS Console erstellen: Wähle einen symmetrischen Schlüssel mit der Schlüsselverwendung „encrypt and decrypt", einen Single-Region-Schlüssel und KMS-Schlüsselmaterial-Ursprung, in der Region des Workspaces. Lasse die Schlüsselverwendungsberechtigungen im Create-Key-Assistenten leer, öffne dann den Tab **Key policy** des Schlüssels und ersetze das JSON durch die hier gezeigte Richtlinie. ### Den Schlüssel registrieren und anhängen 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 aus. Klicke unter **Encryption keys** auf **Add key**. Gib einen Anzeigenamen ein, wähle dann den Schlüssel aus dem Schlüssel-Picker oder wähle **Enter ARN manually** und füge den Schlüssel-ARN ein, und klicke auf **Add**. Der Schlüssel muss sich in dem AWS-Konto befinden, das deine Organisation hostet; kontoübergreifende Schlüssel werden nicht unterstützt. Der Picker listet die aktivierten, kundenverwalteten, symmetrischen Single-Region-Schlüssel in deinem Konto in einer der Regionen deiner Organisation auf; für einen Schlüssel, den der Picker nicht auflistet, gib den ARN ein. Er listet Schlüssel nur auf, wenn der Principal, mit dem du dich angemeldet hast, `kms:ListKeys` und `kms:DescribeKey` aufrufen kann. Hänge den Schlüssel an einen neuen Workspace an, bevor du Anfragen an diesen Workspace sendest. 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). 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 aus. Wähle unter **Encryption key** den Schlüssel aus, klicke auf **Save** und bestätige. Du kannst auch beim Erstellen eines Workspaces in der Claude Console einen Schlüssel auswählen, aber nur, wenn deine Schlüsselrichtlinie noch keine bestimmten Workspaces benennt (keine `EncryptionContext`-Bedingung), weil die Compartment-ID des Workspaces bei der Erstellung zugewiesen wird. Nach dem Anhängen kann der Schlüssel eines Workspaces nicht mehr geändert werden. Dies ist der Zeitpunkt, an dem der Schlüssel validiert wird: Der Anhängeaufruf prüft den Zugriff deines Principals auf den Schlüssel und führt einen Encrypt/Decrypt-Durchlauf gegen ihn mit der Compartment-ID des Workspaces als Encryption Context durch, sodass ein Problem entweder mit der Schlüsselrichtlinie oder den Berechtigungen deines Principals als Fehler bei diesem Aufruf auftritt. Wenn das Anhängen mit einem KMS-Zugriffsfehler fehlschlägt, prüfe Folgendes: * Die Schlüsselrichtlinie benennt den Service-Principal `aws-external-anthropic.amazonaws.com` und gewährt `kms:Encrypt`, `kms:Decrypt` und `kms:GenerateDataKey`, plus `kms:DescribeKey` in einer separaten Anweisung, die keine `EncryptionContext`-Bedingung hat. * Jede `EncryptionContext`-Bedingung enthält die Compartment-ID dieses Workspaces, und jede von dir hinzugefügte `aws:SourceArn`-Bedingung stimmt mit dem ARN dieses Workspaces überein. * Der Schlüssel ist aktiviert, Single-Region und im selben AWS-Konto und derselben Region wie der Workspace. * Der Principal, als der du angemeldet bist, hat `kms:DescribeKey`, `kms:Encrypt` und `kms:Decrypt` für den Schlüssel. * Keine Service Control Policy oder Resource Control Policy in deiner AWS-Organisation verhindert, dass der Service-Principal oder dein Principal den Schlüssel verwendet. * Wenn die Richtlinie korrekt aussieht und das Anhängen trotzdem fehlschlägt, suche das abgelehnte `kms:`-Ereignis in CloudTrail im Konto des Schlüssels (es zeigt den aufrufenden Principal und bei kryptografischen Aufrufen den Encryption Context), korrigiere dann die Bedingung mit `kms:PutKeyPolicy` und versuche es erneut. ## Terraform Für Infrastructure-as-Code-Bereitstellungen werden dieselben Schritte auf den `aws`-Provider mit den Ressourcen `aws_kms_key` und `aws_kms_alias` abgebildet.