--- title: Configurer Azure Key Vault pour CMEK url: https://platform.claude.com/docs/fr/manage-claude/cmek-azure-key-vault description: Utilisez Azure Key Vault 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 Azure Key Vault ``` Ce guide explique comment configurer une clé Azure Key Vault 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. L'activation de CMEK est permanente. Si votre clé Key Vault 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. ## Prérequis * Un Azure Key Vault avec **l'autorisation RBAC activée** (`enableRbacAuthorization: true`) et **l'accès réseau public autorisé**. Anthropic appelle votre coffre via le point de terminaison public du plan de données ; les points de terminaison privés ne sont pas pris en charge. * **La protection contre la purge activée** (`enablePurgeProtection: true`) sur le coffre. Sans elle, une clé supprimée peut être purgée définitivement pendant la fenêtre de rétention de suppression réversible, entraînant une perte irréversible de vos données protégées par CMEK. La protection contre la purge ne peut pas être désactivée une fois activée. * Les autorisations pour créer des clés dans le coffre et pour y attribuer des rôles RBAC. * Les autorisations pour créer des principaux de service dans votre locataire Entra (`Application Administrator`, `Cloud Application Administrator`, ou un rôle personnalisé équivalent). * Une clé API Admin Anthropic pour votre organisation. * La [CLI `az`](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest) installée et authentifiée. * Des **paramètres de diagnostic** configurés sur le coffre pour acheminer la catégorie de journaux `AuditEvent` vers Log Analytics, un compte de stockage ou un hub d'événements. Azure Key Vault n'émet pas de journaux d'audit du plan de données (tels que `KeyWrap`, `KeyUnwrap` et `KeyGet`) par défaut, donc sans cela, vous n'obtenez aucune piste d'audit pour les opérations de clé d'Anthropic. ## Informations sur l'application Anthropic Pour qu'Anthropic utilise votre clé de chiffrement, vous devez configurer un ID d'application multilocataire Anthropic et un nom d'affichage. Ces valeurs sont : | Champ | Valeur | | ---------------------------------------------- | -------------------------------------- | | ID client de l'application multilocataire (US) | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` | | Nom d'affichage de l'application | `anthropic-cmek-client-us` | Utilisez uniquement cet ID client et ce nom d'affichage publiés. Ne faites jamais confiance à un identifiant fourni par e-mail, chat ou tout autre canal d'intégration. ## Configuration de la clé de chiffrement Cela crée un principal de service dans votre locataire Entra pour l'application cliente CMEK d'Anthropic. L'application ne demande aucune autorisation Microsoft Graph ; elle existe uniquement comme cible de fédération pour l'accès au plan de données de Key Vault. ```bash az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 ``` À partir de la sortie, capturez le champ `id`. Il s'agit de l'ID d'objet du principal de service dans votre locataire, que vous utilisez lorsque vous attribuez le rôle RBAC. ```json { "appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87", "displayName": "anthropic-cmek-client-us", "id": "" } ``` Si le principal de service existe déjà dans votre locataire (à la suite d'une tentative précédente ou d'une autre intégration), `az ad sp create` se termine avec une erreur « already exists ». Récupérez plutôt son ID d'objet : ```bash az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv ``` Cette étape n'a pas d'équivalent dans le Portail. Si vous n'avez pas la CLI Azure installée localement, ouvrez Cloud Shell depuis la barre de navigation supérieure du Portail. Une fois la commande réussie, vous pouvez trouver l'ID d'objet du principal de service dans **Microsoft Entra ID > Applications d'entreprise** en effaçant le filtre de type d'application par défaut et en recherchant `anthropic-cmek-client-us`. ![Vue d'ensemble de l'application d'entreprise Microsoft Entra pour anthropic-cmek-client-us, affichant son Application ID (ID d'application) et son Object ID (ID d'objet).](https://platform.claude.com/docs/images/cmek/azure-service-principal.png) Azure Key Vault ne prend pas en charge l'encapsulation de clés symétriques, donc la clé doit être RSA (3072 bits ou plus) avec `wrapKey` et `unwrapKey` dans ses opérations autorisées. L'option `--tags` ajoute la balise d'organisation, `anthropic-org-` avec la valeur `true`, où `` est l'ID de votre organisation Anthropic en minuscules. La balise est requise pour qu'Anthropic valide la clé. **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_`. ```bash az keyvault key create \ --vault-name \ --name \ --kty RSA --size 3072 \ --ops wrapKey unwrapKey \ --tags anthropic-org-=true ``` Pour les clés protégées par HSM, utilisez `--kty RSA-HSM` (nécessite un coffre de SKU Premium). Les clés RSA protégées par logiciel sont acceptables pour cette intégration. Depuis le Portail, ouvrez votre Key Vault, sélectionnez **Keys**, puis **Generate/Import**. Définissez le type de clé sur RSA et la taille sur 3072 ou plus. Pour restreindre la clé à l'encapsulation et au désencapsulation uniquement, ouvrez la version de la clé, faites défiler jusqu'à **Permitted operations**, et décochez tout sauf **Wrap Key** et **Unwrap Key**. Sur la page **Create a key**, ajoutez également la balise d'organisation sous **Tags**. ![Page Create a key d'Azure Key Vault, avec une clé RSA de taille 3072 et la balise anthropic-org définie sur true.](https://platform.claude.com/docs/images/cmek/azure-create-key-tag.png) ![Version de clé Azure Key Vault avec une balise et les Permitted operations (opérations autorisées) limitées à Wrap Key et Unwrap Key.](https://platform.claude.com/docs/images/cmek/azure-permitted-operations-tag.png) Pour partager une clé entre plusieurs organisations Anthropic, ajoutez une telle balise pour chaque organisation. Une version de clé peut porter au maximum 15 balises, y compris les vôtres. Pour ajouter la balise à une clé que vous possédez déjà, ouvrez la version actuelle de la clé dans le Portail, sélectionnez le lien à côté de **Tags**, ajoutez la balise, et cliquez sur **Save**. Avec la CLI Azure, exécutez `az keyvault key set-attributes --vault-name --name --tags anthropic-org-=true`. Son option `--tags` remplace les balises de la version, donc placez également chaque balise que la version possède déjà dans `--tags`, sous la forme `name=value`. Pour une clé dans un Managed HSM, utilisez `--hsm-name ` au lieu de `--vault-name`. Attribuez le rôle `Key Vault Crypto User` au principal de service de la première étape, limité à la **clé individuelle** plutôt qu'à l'ensemble du coffre. ```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/" ``` Le rôle intégré `Key Vault Crypto User` accorde les opérations cryptographiques de clé (chiffrer, déchiffrer, encapsuler, désencapsuler, signer, vérifier) ainsi que la lecture de clé sur sa portée attribuée. La restriction `--ops wrapKey unwrapKey` que vous avez définie sur la clé à l'étape précédente réduit davantage lesquelles de ces opérations peuvent réussir sur cette clé, donc en pratique Anthropic ne peut qu'encapsuler et désencapsuler. Depuis le Portail, ouvrez la **clé** (pas le coffre), sélectionnez son onglet **Access control (IAM)**, cliquez sur **Add > Add role assignment**, sélectionnez **Key Vault Crypto User**, et attribuez-le au principal de service `anthropic-cmek-client-us`. **Alternative de coffre dédié :** Microsoft recommande un coffre dédié par application avec des rôles attribués à la portée du coffre. Si vous provisionnez un coffre qui ne contient que cette clé CMEK Anthropic, vous pouvez attribuer le rôle à la portée du coffre à la place et l'effet est identique. Limitez à la clé individuelle lorsque la clé réside dans un coffre partagé. ![Attributions de rôles IAM de Key Vault montrant le rôle Key Vault Crypto User attribué à anthropic-cmek-client-us.](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}" ``` Confirmez que : * `rbac` est `true`. * `purge` est `true`. S'il est `false` ou `null`, activez la protection contre la purge sur le coffre avant de continuer. Sans elle, une clé supprimée de manière réversible peut être purgée définitivement pendant la fenêtre de rétention, rendant vos données protégées par CMEK irrécupérables. * `pub` est `"Enabled"`. S'il est `"Disabled"`, Anthropic ne peut pas atteindre le coffre via son point de terminaison public du plan de données et la validation échoue. * `net` est `"Allow"`, ou, s'il est `"Deny"`, que `ipRules` inclut les plages de sortie d'Anthropic (contactez Anthropic pour la liste actuelle). * `uri` est l'URI du coffre que vous utilisez lorsque vous enregistrez la clé. * `tenantId` est le locataire qui régit le coffre. Utilisez cette valeur comme `tenant_id` lorsque vous enregistrez la clé, pas le locataire de votre abonnement actuellement actif (les deux peuvent différer dans les configurations inter-locataires). ## Enregistrer la clé auprès d'Anthropic La manière dont vous enregistrez la clé dépend du produit que vous utilisez. Vous pouvez configurer la clé dans la Claude Console ou via l'Admin API, avec le même résultat. 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 **Azure Key Vault** et cliquez sur **Continue**. Renseignez **Vault URI**, **Key name** et **Tenant ID**, puis cliquez sur **Add**. L'étape des détails de la clé affiche la balise d'organisation. Ajoutez-la à la clé, comme le décrit [l'étape de création](https://platform.claude.com/docs/fr/manage-claude/cmek-azure-key-vault#organization-tag), avant de cliquer sur **Add**. 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. 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** et 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). Créez une configuration de clé externe via l'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}" ``` La réponse contient l'ID de la clé externe : ```json { "type": "external_key", "id": "ekey_", "display_name": "" } ``` Déclenchez un aller-retour de chiffrement et de déchiffrement sur votre clé. Cela confirme qu'Anthropic peut s'authentifier auprès de votre locataire et effectuer des opérations d'encapsulation et de désencapsulation. ```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}" ``` Une réponse réussie ressemble à ceci : ```json { "type": "external_key_validation", "status": "success", "error": null } ``` Si la validation échoue, le champ `error` décrit le problème. Les causes courantes sont : * **Délai de propagation RBAC :** les attributions de rôles peuvent prendre quelques minutes pour prendre effet. Attendez et réessayez. * **ACL réseau bloquant Anthropic :** confirmez l'accès réseau public et `ipRules` comme décrit dans l'étape de vérification. * **Politiques d'accès conditionnel sur les identités de charge de travail :** si votre locataire a des politiques d'accès conditionnel qui ciblent les principaux de service, excluez le principal de service Anthropic ou ajoutez les plages de sortie d'Anthropic aux emplacements nommés de la politique. 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). ```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}" ``` 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 **Azure**, entrez l'URI du coffre, le nom de la clé et l'ID du locataire de l'étape de vérification, 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é. ## Terraform Pour les déploiements d'infrastructure-as-code, les mêmes étapes correspondent aux fournisseurs `azurerm` et `azuread`.