--- title: Azure Key Vault für CMEK konfigurieren url: https://platform.claude.com/docs/de/manage-claude/cmek-azure-key-vault description: Verwende Azure Key Vault, 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 Azure Key Vault zu konfigurieren ``` Diese Anleitung führt durch die Konfiguration eines Azure-Key-Vault-Schlüssels als [kundenverwalteter Verschlüsselungsschlüssel (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 Key-Vault-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. ## Voraussetzungen * Ein Azure Key Vault mit **aktivierter RBAC-Autorisierung** (`enableRbacAuthorization: true`) und **erlaubtem öffentlichem Netzwerkzugriff**. Anthropic ruft deinen Vault über den öffentlichen Data-Plane-Endpunkt auf; private Endpunkte werden nicht unterstützt. * **Aktivierter Purge-Schutz** (`enablePurgeProtection: true`) auf dem Vault. Ohne ihn kann ein gelöschter Schlüssel während des Soft-Delete-Aufbewahrungszeitraums dauerhaft entfernt werden, was zu einem unwiederbringlichen Verlust deiner CMEK-geschützten Daten führt. Der Purge-Schutz kann nach der Aktivierung nicht mehr deaktiviert werden. * Berechtigungen zum Erstellen von Schlüsseln im Vault und zum Zuweisen von RBAC-Rollen darauf. * Berechtigungen zum Erstellen von Dienstprinzipalen in deinem Entra-Mandanten (`Application Administrator`, `Cloud Application Administrator` oder eine gleichwertige benutzerdefinierte Rolle). * Ein Anthropic-Admin-API-Key für deine Organisation. * Die [`az`-CLI](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest) installiert und authentifiziert. * **Diagnoseeinstellungen**, die auf dem Vault so konfiguriert sind, dass die Protokollkategorie `AuditEvent` an Log Analytics, ein Speicherkonto oder einen Event Hub weitergeleitet wird. Azure Key Vault gibt standardmäßig keine Data-Plane-Audit-Protokolle (wie `KeyWrap`, `KeyUnwrap` und `KeyGet`) aus, sodass du ohne dies keinen Audit-Trail für Anthropics Schlüsseloperationen erhältst. ## Anthropic-App-Informationen Damit Anthropic deinen Verschlüsselungsschlüssel verwendet, musst du eine Anthropic-Multitenant-Anwendungs-ID und einen Anzeigenamen konfigurieren. Diese Werte sind: | Feld | Wert | | ------------------------------ | -------------------------------------- | | Multitenant-App-Client-ID (US) | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` | | App-Anzeigename | `anthropic-cmek-client-us` | Verwende nur diese veröffentlichte Client-ID und diesen Anzeigenamen. Vertraue niemals einem Identifikator, der per E-Mail, Chat oder über einen Onboarding-Kanal bereitgestellt wird. ## Einrichtung des Verschlüsselungsschlüssels Dies erstellt einen Dienstprinzipal in deinem Entra-Mandanten für Anthropics CMEK-Client-Anwendung. Die Anwendung fordert keine Microsoft-Graph-Berechtigungen an; sie existiert ausschließlich als Föderationsziel für den Key-Vault-Data-Plane-Zugriff. ```bash az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 ``` Erfasse aus der Ausgabe das Feld `id`. Dies ist die Objekt-ID des Dienstprinzipals in deinem Mandanten, die du verwendest, wenn du die RBAC-Rolle zuweist. ```json { "appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87", "displayName": "anthropic-cmek-client-us", "id": "" } ``` Wenn der Dienstprinzipal bereits in deinem Mandanten existiert (aus einem früheren Versuch oder einer anderen Integration), beendet sich `az ad sp create` mit einem „already exists"-Fehler. Rufe stattdessen seine Objekt-ID ab: ```bash az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv ``` Dieser Schritt hat kein Portal-Äquivalent. Wenn du die Azure-CLI nicht lokal installiert hast, öffne Cloud Shell über die obere Navigationsleiste des Portals. Nachdem der Befehl erfolgreich war, findest du die Objekt-ID des Dienstprinzipals unter **Microsoft Entra ID > Unternehmensanwendungen**, indem du den Standardfilter für den Anwendungstyp löschst und nach `anthropic-cmek-client-us` suchst. ![Übersicht der Unternehmensanwendung anthropic-cmek-client-us in Microsoft Entra mit ihrer Application ID (Anwendungs-ID) und Object ID.](https://platform.claude.com/docs/images/cmek/azure-service-principal.png) Azure Key Vault unterstützt kein symmetrisches Schlüssel-Wrapping, daher muss der Schlüssel RSA (3072-Bit oder größer) mit `wrapKey` und `unwrapKey` in seinen erlaubten Operationen sein. Die Option `--tags` fügt das Organisations-Tag `anthropic-org-` mit dem Wert `true` hinzu, wobei `` deine Anthropic-Organisations-ID in Kleinbuchstaben ist. Das Tag ist erforderlich, damit Anthropic den Schlüssel validieren kann. **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_`. ```bash az keyvault key create \ --vault-name \ --name \ --kty RSA --size 3072 \ --ops wrapKey unwrapKey \ --tags anthropic-org-=true ``` Für HSM-gestützte Schlüssel verwende `--kty RSA-HSM` (erfordert einen Vault mit Premium-SKU). Softwaregeschützte RSA-Schlüssel sind für diese Integration akzeptabel. Öffne im Portal deinen Key Vault, wähle **Keys** und dann **Generate/Import**. Setze den Schlüsseltyp auf RSA und die Größe auf 3072 oder größer. Um den Schlüssel auf Wrap und Unwrap zu beschränken, öffne die Schlüsselversion, scrolle zu **Permitted operations** und deaktiviere alles außer **Wrap Key** und **Unwrap Key**. Füge auf der Seite **Create a key** außerdem das Organisations-Tag unter **Tags** hinzu. ![Seite Create a key in Azure Key Vault mit RSA, Schlüsselgröße 3072 und dem auf true gesetzten Tag anthropic-org.](https://platform.claude.com/docs/images/cmek/azure-create-key-tag.png) ![Schlüsselversion in Azure Key Vault mit einem Organisations-Tag, bei der die Permitted operations auf Wrap Key und Unwrap Key beschränkt sind.](https://platform.claude.com/docs/images/cmek/azure-permitted-operations-tag.png) Um einen Schlüssel unter mehreren Anthropic-Organisationen zu teilen, füge für jede Organisation ein solches Tag hinzu. Eine Schlüsselversion kann höchstens 15 Tags tragen, einschließlich deiner eigenen. Um das Tag zu einem bereits vorhandenen Schlüssel hinzuzufügen, öffne die aktuelle Version des Schlüssels im Portal, wähle den Link neben **Tags**, füge das Tag hinzu und klicke auf **Save**. Führe mit der Azure-CLI `az keyvault key set-attributes --vault-name --name --tags anthropic-org-=true` aus. Seine Option `--tags` ersetzt die Tags der Version, also füge auch jedes Tag, das die Version bereits hat, in `--tags` als `name=value` ein. Verwende für einen Schlüssel in einem Managed HSM `--hsm-name ` anstelle von `--vault-name`. Weise dem Dienstprinzipal aus dem ersten Schritt die Rolle `Key Vault Crypto User` zu, beschränkt auf den **einzelnen Schlüssel** statt auf den gesamten Vault. ```bash VAULT_ID=$(az keyvault show --name --query id -o tsv) az role assignment create \ --role "Key Vault Crypto User" \ --assignee-object-id \ --assignee-principal-type ServicePrincipal \ --scope "${VAULT_ID}/keys/" ``` Die integrierte Rolle `Key Vault Crypto User` gewährt kryptografische Schlüsseloperationen (encrypt, decrypt, wrap, unwrap, sign, verify) sowie Lesezugriff auf den Schlüssel in ihrem zugewiesenen Geltungsbereich. Die Einschränkung `--ops wrapKey unwrapKey`, die du im vorherigen Schritt auf dem Schlüssel gesetzt hast, grenzt weiter ein, welche dieser Operationen gegen diesen Schlüssel erfolgreich sein können, sodass Anthropic in der Praxis nur wrappen und unwrappen kann. Öffne im Portal den **Schlüssel** (nicht den Vault), wähle seinen Tab **Access control (IAM)**, klicke auf **Add > Add role assignment**, wähle **Key Vault Crypto User** und weise ihn dem Dienstprinzipal `anthropic-cmek-client-us` zu. **Alternative mit dediziertem Vault:** Microsoft empfiehlt einen dedizierten Vault pro Anwendung mit Rollen, die auf Vault-Ebene zugewiesen werden. Wenn du einen Vault bereitstellst, der nur diesen Anthropic-CMEK-Schlüssel enthält, kannst du die Rolle stattdessen auf Vault-Ebene zuweisen, und der Effekt ist identisch. Beschränke auf den einzelnen Schlüssel, wenn der Schlüssel in einem gemeinsam genutzten Vault liegt. ![IAM-Rollenzuweisungen in Key Vault, in denen anthropic-cmek-client-us die Rolle Key Vault Crypto User zugewiesen ist.](https://platform.claude.com/docs/images/cmek/azure-role-assignment.png) ```bash az keyvault show --name \ --query "{rbac:properties.enableRbacAuthorization, purge:properties.enablePurgeProtection, pub:properties.publicNetworkAccess, net:properties.networkAcls.defaultAction, ipRules:properties.networkAcls.ipRules, uri:properties.vaultUri, tenantId:properties.tenantId}" ``` Bestätige, dass: * `rbac` `true` ist. * `purge` `true` ist. Wenn es `false` oder `null` ist, aktiviere den Purge-Schutz auf dem Vault, bevor du fortfährst. Ohne ihn kann ein soft-gelöschter Schlüssel während des Aufbewahrungszeitraums dauerhaft entfernt werden, wodurch deine CMEK-geschützten Daten nicht wiederherstellbar werden. * `pub` `"Enabled"` ist. Wenn es `"Disabled"` ist, kann Anthropic den Vault nicht über seinen öffentlichen Data-Plane-Endpunkt erreichen und die Validierung schlägt fehl. * `net` `"Allow"` ist, oder, wenn es `"Deny"` ist, dass `ipRules` Anthropics Egress-Bereiche enthalten (kontaktiere Anthropic für die aktuelle Liste). * `uri` die Vault-URI ist, die du verwendest, wenn du den Schlüssel registrierst. * `tenantId` der Mandant ist, der den Vault verwaltet. Verwende diesen Wert als `tenant_id`, wenn du den Schlüssel registrierst, nicht den Mandanten deines aktuell aktiven Abonnements (die beiden können sich in mandantenübergreifenden Setups unterscheiden). ## Den Schlüssel bei Anthropic registrieren Wie du den Schlüssel registrierst, hängt davon ab, welches Produkt du verwendest. 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. Klicke unter **Encryption keys** auf **Add key**. Gib einen Anzeigenamen ein, wähle **Azure Key Vault** und klicke auf **Continue**. Fülle **Vault URI**, **Key name** und **Tenant ID** aus und klicke auf **Add**. Der Schritt mit den Schlüsseldetails zeigt das Organisations-Tag. Füge es dem Schlüssel hinzu, wie [der Erstellungsschritt](https://platform.claude.com/docs/de/manage-claude/cmek-azure-key-vault#organization-tag) beschreibt, bevor du auf **Add** klickst. 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. 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). 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": "azure", "vault_uri": "https://.vault.azure.net/", "key_name": "", "tenant_id": "" } }' ``` ```bash CLI ant organization:external-keys create <<'YAML' display_name: "" geo: us provider_config: type: azure vault_uri: "https://.vault.azure.net/" key_name: "" tenant_id: "" YAML ``` ```python Python client = anthropic.Anthropic() external_key = client.organization.external_keys.create( display_name="", geo="us", provider_config={ "type": "azure", "vault_uri": "https://.vault.azure.net/", "key_name": "", "tenant_id": "", }, ) 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: "azure", vault_uri: "https://.vault.azure.net/", key_name: "", tenant_id: "" } }); 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 AzureExternalKeyConfigParam { VaultUri = "https://.vault.azure.net/", KeyName = "", TenantID = "" } }); 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{ OfAzure: &anthropic.AzureExternalKeyConfigParam{ VaultURI: "https://.vault.azure.net/", KeyName: "", TenantID: "", }, }, }) 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.AzureExternalKeyConfigParam; import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = ExternalKeyCreateParams.builder() .displayName("") .geo(ExternalKeyCreateParams.Geo.US) .providerConfig(AzureExternalKeyConfigParam.builder() .vaultUri("https://.vault.azure.net/") .keyName("") .tenantId("") .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' => 'azure', 'vaultURI' => 'https://.vault.azure.net/', 'keyName' => '', 'tenantID' => '', ], ); 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: :azure, vault_uri: "https://.vault.azure.net/", key_name: "", tenant_id: "" } ) 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 Verschlüsselungs- und Entschlüsselungs-Roundtrip gegen deinen Schlüssel aus. Dies bestätigt, dass Anthropic sich bei deinem Mandanten authentifizieren und Wrap- und Unwrap-Operationen durchführen kann. ```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 validation = client.organization.external_keys.validate("ekey_") 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, beschreibt das Feld `error` das Problem. Häufige Ursachen sind: * **RBAC-Propagierungsverzögerung:** Rollenzuweisungen können einige Minuten brauchen, um wirksam zu werden. Warte und versuche es erneut. * **Netzwerk-ACLs blockieren Anthropic:** Bestätige den öffentlichen Netzwerkzugriff und `ipRules`, wie im Überprüfungsschritt beschrieben. * **Richtlinien für bedingten Zugriff auf Workload-Identitäten:** Wenn dein Mandant Richtlinien für bedingten Zugriff hat, die auf Dienstprinzipale abzielen, schließe den Anthropic-Dienstprinzipal aus oder füge Anthropics Egress-Bereiche zu den benannten Standorten der Richtlinie hinzu. 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 = client.organization.workspaces.update( "", 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 **Azure**, gib die Vault-URI, den Schlüsselnamen und die Mandanten-ID aus dem Überprüfungsschritt 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, sodass es keinen separaten Schritt zum Anhängen an einen Workspace gibt und eine Organisation nur einen Schlüssel haben kann. ## Terraform Für Infrastructure-as-Code-Bereitstellungen werden dieselben Schritte auf die Provider `azurerm` und `azuread` abgebildet.