---
title: Configurer AWS KMS pour CMEK
url: https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms
description: Utilisez AWS KMS pour fournir une clé de chiffrement à votre organisation.
---
Laissez Claude Code configurer cette fonctionnalité pour vous
```text
/claude-api aide-moi à configurer une clé de chiffrement gérée par le client avec AWS KMS
```
Ce guide explique comment configurer une clé [AWS KMS](https://aws.amazon.com/kms/) en tant que [clé de chiffrement gérée par le client (CMEK)](https://platform.claude.com/docs/fr/manage-claude/cmek) pour votre organisation Anthropic.
L'activation de CMEK est permanente. Si votre clé KMS est supprimée ou désactivée, Anthropic ne peut pas récupérer les données chiffrées avec celle-ci. Consultez les [avertissements et limitations](https://platform.claude.com/docs/fr/manage-claude/cmek) avant de commencer.
**Claude Platform on AWS :** Sur [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), votre politique de clé accorde l'accès à un principal de service AWS au lieu du rôle IAM d'Anthropic, il n'y a pas d'étape de validation distincte, et vous enregistrez et attachez la clé dans la Claude Console. Suivez [Configurer CMEK sur Claude Platform on AWS](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#claude-platform-on-aws) sur cette page au lieu des étapes des sections suivantes.
## Prérequis
* Un compte AWS avec les autorisations de créer des clés KMS et de définir des politiques de clé (`kms:CreateKey` et `kms:PutKeyPolicy`).
* Une clé Admin API pour votre organisation Anthropic.
* L'[AWS CLI](https://aws.amazon.com/cli/) installée et authentifiée.
## Amazon Resource Name (ARN) pour Anthropic
Pour qu'Anthropic utilise votre clé de chiffrement, vous devez donner au rôle IAM d'Anthropic une clé KMS qu'il peut utiliser pour chiffrer les données. L'ARN pour Anthropic CMEK est :
```text wrap
arn:aws:iam::915198916910:role/anthropic-cmek-client-us
```
Utilisez uniquement cet ARN publié. Ne faites jamais confiance à un identifiant fourni par e-mail, chat ou tout autre canal d'intégration.
## Configuration de la clé de chiffrement
**Claude Platform on AWS :** Ignorez cette étape. Votre politique de clé accorde l'accès à un principal de service AWS, et elle n'a pas de condition d'organisation. [Configurer CMEK sur Claude Platform on AWS](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#claude-platform-on-aws) fournit cette politique.
La politique de clé accorde au rôle IAM d'Anthropic un accès inter-comptes. Trois déclarations sont requises :
1. **Administrateur racine du compte :** le modèle KMS standard. Votre compte conserve le contrôle administratif complet.
2. **Chiffrement et déchiffrement Anthropic :** les actions `kms:Encrypt` et `kms:Decrypt`, qu'Anthropic utilise pour chiffrer et déchiffrer les clés de données qui protègent les données de votre espace de travail (chiffrement par enveloppe).
3. **Description Anthropic :** la lecture des métadonnées qu'Anthropic effectue au démarrage. Elle est accordée séparément car `DescribeKey` n'a pas de paramètre `EncryptionContext`, donc une condition `EncryptionContext` sur cette action refuserait toujours.
Pour trouver [votre ID de compte AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html), exécutez `aws sts get-caller-identity --query Account --output text`.
Dans la politique, remplacez `` par votre ID de compte AWS et `` par votre ID d'organisation. La condition `StringEquals` sur `kms:EncryptionContext:anthropic:org_uuid` lie la clé à votre organisation Anthropic, et la validation refuse une clé sans celle-ci. Pour partager une clé entre plusieurs organisations Anthropic, listez chaque ID d'organisation dans la valeur de la condition.
**Trouver votre ID d'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` renvoyé par le point de terminaison [Organization Info](https://platform.claude.com/docs/fr/api/organization/retrieve). Utilisez l'UUID brut, et non l'ID préfixé par `org_`.
Enregistrez la politique sous `key-policy.json`. Pour créer la clé dans la AWS Console à la place, collez-y la politique, comme décrit plus loin dans cette étape.
```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": "*"
}
]
}
```
**Facultatif :** Pour limiter la clé à certains de vos espaces de travail, utilisez cette déclaration `AllowAnthropicCMEKCrypto` au lieu de celle de la politique JSON précédente, avec un ID de compartiment pour chaque espace de travail. Ajoutez l'ID de compartiment d'un espace de travail avant d'y attacher la clé. Pour un nouvel espace de travail, créez-le sans la clé, ajoutez son ID de compartiment, puis attachez la clé.
```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
```
Capturez `KeyMetadata.Arn` depuis la sortie. Vous en avez besoin lorsque vous enregistrez la clé à l'étape suivante.
Si la clé est déjà configurée pour CMEK et protège des données existantes, vous devez ajouter une déclaration qui permet à Anthropic de déchiffrer ces données, en plus des trois déclarations de la politique précédente. Dans sa condition, listez l'ID de compartiment de chaque espace de travail auquel la clé est ou était attachée.
```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 valide la clé lorsque vous la vérifiez ou l'attachez à un espace de travail. Chaque validation ajoute quatre erreurs d'accès refusé à CloudTrail. Celles-ci sont attendues. Si vous devez les filtrer, filtrez sur les trois valeurs suivantes. La première seule ne suffit pas, car n'importe quel appelant peut la définir :
* `requestParameters.encryptionContext.associatedData` : `Y21lay12YWxpZGF0aW9u`
* `userIdentity.accountId` : `915198916910`
* `resources.ARN` : `arn:aws:kms:::key/`
**Trouver votre ID de compartiment :** Consultez l'onglet **Claude Platform** sous **Enregistrer la clé auprès d'Anthropic**.
Vous pouvez également créer la clé depuis la AWS Console. Choisissez une clé symétrique avec l'utilisation de clé de chiffrement et déchiffrement, une clé à région unique, et une origine de matériel de clé KMS. L'assistant de création de clé valide une politique de clé à son étape **Review** : Si vous ajoutez l'ID de compte d'Anthropic `915198916910` sous les autorisations d'utilisation de clé à cet endroit, la politique générée accorde à l'ensemble du compte Anthropic des actions plus larges (telles que `kms:ReEncrypt*` et `kms:GenerateDataKey*`) sans condition `EncryptionContext`, et la validation la refuse. Pour éviter de laisser une clé trop permissive, terminez l'assistant avec uniquement les autorisations administratives, puis ouvrez l'onglet **Key policy** de la clé et remplacez le JSON par la politique `key-policy.json` présentée plus tôt dans cette étape.
## Enregistrer la clé auprès d'Anthropic
La façon dont vous enregistrez la clé dépend du produit que vous utilisez.
**Claude Platform on AWS :** Le principal, la politique de clé et le flux d'enregistrement diffèrent, et il n'y a pas d'étape de validation distincte. Suivez [Configurer CMEK sur Claude Platform on AWS](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#claude-platform-on-aws) au lieu de cet onglet.
**Trouver votre ID de compartiment :** Chaque espace de travail possède un ID de compartiment qui délimite ses données CMEK. Pour le trouver 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. L'ID se trouve sous **Encryption key**, dans le champ **Compartment ID**. Vous pouvez également lire le champ `compartment_id` renvoyé par le point de terminaison [Get Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve).
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 **AWS KMS**, puis cliquez sur **Continue**. Collez l'ARN de la clé dans **KMS key ARN**, puis cliquez sur **Add**.
L'étape des détails de la clé affiche votre ID d'organisation. Ajoutez-le à la [politique de clé](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#key-policy) 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**, puis confirmez. L'attachement d'une clé est irréversible. Pour un espace de travail qui reçoit déjà des requêtes, la clé peut mettre [jusqu'à un jour pour prendre effet](https://platform.claude.com/docs/fr/manage-claude/cmek#how-it-works).
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": "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}"
```
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 déchiffrement sur votre clé.
```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}"
```
Une réponse réussie ressemble à ceci :
```json
{ "type": "external_key_validation", "status": "success", "error": null }
```
Si la validation échoue, les causes courantes sont :
* **Incompatibilité du contexte de chiffrement :** Si la politique a une condition `kms:EncryptionContext:anthropic:compartment_uuid`, assurez-vous qu'elle liste l'ID de compartiment de chaque espace de travail auquel la clé est attachée. La validation envoie l'ID de compartiment de l'espace de travail qu'elle vérifie. Une clé plus ancienne dont la déclaration de compartiment autorise encore `kms:Encrypt` est validée avec la valeur tout à zéro (`00000000-0000-0000-0000-000000000000`) tant qu'elle n'est pas attachée, donc conservez cette valeur dans sa liste.
* **Resource control policies (RCP) :** Si votre organisation AWS a une RCP qui refuse les opérations KMS lorsque `aws:PrincipalOrgID` ne correspond pas à votre organisation, elle bloque le rôle inter-comptes d'Anthropic. La RCP a besoin d'une exception pour cette clé ou pour l'ARN du rôle d'Anthropic. Les service control policies ne s'appliquent pas ici, car elles ne s'évaluent pas pour les principaux externes appelant via des politiques basées sur les ressources.
* **Accès accordé via IAM au lieu de la politique de clé :** L'accès KMS inter-comptes doit être accordé dans la politique de clé elle-même, pas via une politique IAM dans votre compte. Vérifiez avec `aws kms get-key-policy --key-id --policy-name default`.
* **Incompatibilité de région :** Confirmez que la région de la clé est une région dans laquelle Anthropic opère pour le niveau géographique que vous avez configuré.
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'à un jour 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_id = ""
workspace = client.organization.workspaces.update(
workspace_id,
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 **AWS** et cliquez sur **Continue**, puis collez l'ARN de la clé de l'étape précédente et cliquez sur **Add**. Anthropic valide la clé avec un aller-retour de chiffrement et déchiffrement. Une fois qu'elle s'affiche comme vérifiée, votre organisation est protégée par CMEK à partir de ce moment.
L'étape des détails de la clé de ce flux affiche votre **Organization ID for the key policy** avec un bouton de copie. Substituez cette valeur à `` dans la politique de clé. Vous pouvez ouvrir le flux pour copier l'ID avant de créer la clé.
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é.
## Configurer CMEK sur Claude Platform on AWS
Sur [Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws), CMEK utilise uniquement des clés AWS KMS, et la configuration diffère des sections précédentes de ces manières :
* **Principal :** Votre politique de clé accorde l'accès au principal de service AWS `aws-external-anthropic.amazonaws.com`. Le rôle IAM et l'ID de compte d'Anthropic ne sont pas utilisés, donc l'[ARN pour Anthropic](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#amazon-resource-name-arn-for-anthropic) ne s'applique pas.
* **Exigences de clé :** La clé doit être une clé KMS symétrique avec utilisation de chiffrement et déchiffrement, à région unique, et dans le même compte et la même région AWS que l'espace de travail auquel vous l'attachez. Les clés inter-comptes ne sont pas prises en charge : la clé doit être dans le compte AWS qui héberge votre organisation. Les clés multi-régions (ID de clé commençant par `mrk-`) et les ARN d'alias sont rejetés lorsque vous enregistrez la clé ; utilisez l'ARN de la clé.
* **Pas d'étape de validation distincte :** Hormis ces vérifications sur l'ARN de la clé lors de l'enregistrement, la clé est validée lorsque vous l'attachez à un espace de travail. L'appel d'attachement effectue un aller-retour de chiffrement/déchiffrement sur la clé avec l'ID de compartiment de cet espace de travail comme contexte de chiffrement, de sorte qu'un problème de politique de clé apparaît au moment de l'attachement plutôt qu'à l'enregistrement. Une condition `EncryptionContext` n'a donc pas besoin d'entrée tout à zéro.
* **Où vous gérez les clés :** Enregistrez et attachez les clés dans la Claude Console, connecté via AWS avec le rôle Admin. Les points de terminaison de clé externe sont également disponibles sur Claude Platform on AWS, autorisés via les [actions IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#encryption-keys) ; là, une clé est identifiée par son ARN de clé KMS plutôt que par un ID `ekey_`.
Utilisez uniquement ce nom de principal de service publié. Ne faites jamais confiance à un identifiant fourni par e-mail, chat ou tout autre canal d'intégration.
### Prérequis
* Le compte AWS qui héberge votre organisation Claude Platform on AWS, avec les autorisations de créer des clés KMS et de définir des politiques de clé (`kms:CreateKey` et `kms:PutKeyPolicy`).
* Le rôle **Admin** dans la Claude Console pour Claude Platform on AWS. Consultez [Utiliser la Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console).
* Pour le principal IAM avec lequel vous vous connectez à la Claude Console : en plus de `aws-external-anthropic:AssumeConsole`, les [actions IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#encryption-keys) correspondant aux opérations que vous y effectuez, car l'enregistrement, le listage et l'attachement des clés passent par la passerelle AWS. L'enregistrement d'une clé correspond à `RegisterKey` (avec `ListKeys` et `GetKey` pour afficher les enregistrements), et son attachement à `UpdateWorkspace` ou `CreateWorkspace`. Les actions de clés externes (et `CreateWorkspace`) sont à portée de compte, donc accordez-les sur `Resource: "*"` ; une politique limitée aux ARN d'espaces de travail ne les inclut pas.
* Pour le principal IAM qui attache la clé à un espace de travail (l'identité avec laquelle vous vous êtes connecté à la Claude Console) : `kms:DescribeKey`, `kms:Encrypt`, et `kms:Decrypt` sur la clé. L'accès de votre principal à la clé est vérifié lorsque vous l'attachez, en plus de celui du principal de service.
* Facultatif, pour le sélecteur de clé dans la Claude Console : `kms:ListKeys` et `kms:DescribeKey` pour le principal avec lequel vous vous connectez. Sans eux, collez l'ARN de la clé à la place.
### Créer la clé KMS
La politique de clé comporte trois déclarations : la déclaration d'administrateur racine de votre compte ; une déclaration qui permet au principal de service de Claude Platform on AWS de chiffrer, de déchiffrer et de générer des clés de données ; et une déclaration distincte pour `kms:DescribeKey`. La déclaration cryptographique comporte une condition `EncryptionContext` facultative qui lie la clé aux espaces de travail que vous listez. `DescribeKey` est accordée séparément, car elle n'a pas de paramètre `EncryptionContext` ; une condition `EncryptionContext` sur cette action entraînerait donc toujours un refus.
Si vous prévoyez d'utiliser la condition `EncryptionContext` facultative présentée ici, créez d'abord l'espace de travail (sans clé), copiez son ID de compartiment et remplacez `` par celui-ci. Pour trouver l'ID 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. L'ID se trouve sous **Encryption key**, dans le champ **Compartment ID**. Vous pouvez également le lire dans le champ `compartment_id` renvoyé par le point de terminaison [Get Workspace](https://platform.claude.com/docs/fr/api/organization/workspaces/retrieve). Si vous ne prévoyez pas d'utiliser la condition, supprimez le bloc `Condition` de cette déclaration.
```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\": \"*\"
}
]
}"
```
Capturez `KeyMetadata.Arn` depuis la sortie. Vous en avez besoin lorsque vous enregistrez la clé.
La condition `EncryptionContext` est facultative. Chaque appel de chiffrement, de déchiffrement et de clé de données effectué pour un espace de travail, y compris la vérification au moment de l'attachement, porte l'ID de compartiment de cet espace de travail sous la forme `anthropic:compartment_uuid` ; la condition liste donc l'ID de compartiment de chaque espace de travail auquel vous attachez la clé et n'a besoin d'aucune entrée tout à zéro. L'ajouter lie également la clé aux espaces de travail que vous listez au niveau IAM. Comme un ID de compartiment n'existe qu'une fois son espace de travail créé, l'ordre est le suivant : créez l'espace de travail, placez son ID de compartiment dans la condition (lors de la création de la clé, ou plus tard avec `kms:PutKeyPolicy`), puis attachez la clé. Avant d'attacher la clé à chaque espace de travail supplémentaire, ajoutez l'ID de compartiment de cet espace de travail de la même manière. Pour commencer sans elle, supprimez le bloc `Condition` de la déclaration `AllowClaudePlatformOnAWSCrypto` ; si vous l'ajoutez plus tard, incluez l'ID de compartiment de chaque espace de travail auquel la clé est déjà attachée.
Vous pouvez restreindre davantage les deux déclarations du principal de service avec une condition `aws:SourceArn`. Le service transmet l'[ARN de l'espace de travail](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#service-details) (`arn:aws:aws-external-anthropic:::workspace/`) comme ARN source à chaque appel qu'il effectue avec votre clé ; ainsi, `"ArnLike": {"aws:SourceArn": "arn:aws:aws-external-anthropic:*::workspace/*"}` limite l'autorisation aux espaces de travail de votre propre compte AWS, et une liste d'ARN complets d'espaces de travail la limite à ces espaces de travail. Cette condition n'est pas obligatoire ; la condition `EncryptionContext` suffit à elle seule à lier la clé aux espaces de travail que vous listez.
Vous pouvez également créer la clé depuis la AWS Console : choisissez une clé symétrique avec l'utilisation de clé de chiffrement et déchiffrement, une clé à région unique, et une origine de matériel de clé KMS, dans la région de l'espace de travail. Laissez les autorisations d'utilisation de clé vides dans l'assistant de création de clé, puis ouvrez l'onglet **Key policy** de la clé et remplacez le JSON par la politique présentée ici.
### Enregistrer et attacher la clé
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, puis choisissez la clé dans le sélecteur de clé ou choisissez **Enter ARN manually** et collez l'ARN de la clé, puis cliquez sur **Add**. La clé doit se trouver dans le compte AWS qui héberge votre organisation ; les clés inter-comptes ne sont pas prises en charge. Le sélecteur liste les clés activées, gérées par le client, symétriques et à région unique de votre compte dans l'une des régions de votre organisation ; pour une clé que le sélecteur ne liste pas, saisissez l'ARN. Il ne liste les clés que si le principal avec lequel vous vous êtes connecté peut appeler `kms:ListKeys` et `kms:DescribeKey`.
Attachez la clé à 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 mettre [jusqu'à un jour pour prendre effet](https://platform.claude.com/docs/fr/manage-claude/cmek#how-it-works). Dans la Claude Console, accédez à la page [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) et sélectionnez l'espace de travail dans le menu déroulant en haut de la page. Sous **Encryption key**, sélectionnez la clé, cliquez sur **Save**, puis confirmez. Vous pouvez également sélectionner une clé lors de la création d'un espace de travail dans la Claude Console, mais uniquement si votre politique de clé ne nomme pas encore d'espaces de travail spécifiques (pas de condition `EncryptionContext`), car l'ID de compartiment de l'espace de travail est attribué lors de sa création. Une fois attachée, la clé d'un espace de travail ne peut pas être modifiée.
C'est à ce moment que la clé est validée : l'appel d'attachement vérifie l'accès de votre principal à la clé et effectue un aller-retour de chiffrement/déchiffrement sur celle-ci avec l'ID de compartiment de l'espace de travail comme contexte de chiffrement, de sorte qu'un problème avec la politique de clé ou les autorisations de votre principal apparaît comme une erreur sur cet appel. Si l'attachement échoue avec une erreur d'accès KMS, vérifiez ce qui suit :
* La politique de clé nomme le principal de service `aws-external-anthropic.amazonaws.com` et accorde `kms:Encrypt`, `kms:Decrypt`, et `kms:GenerateDataKey`, plus `kms:DescribeKey` dans une déclaration distincte qui n'a pas de condition `EncryptionContext`.
* Toute condition `EncryptionContext` inclut l'ID de compartiment de cet espace de travail, et toute condition `aws:SourceArn` que vous avez ajoutée correspond à l'ARN de cet espace de travail.
* La clé est activée, à région unique, et dans le même compte et la même région AWS que l'espace de travail.
* Le principal avec lequel vous êtes connecté a `kms:DescribeKey`, `kms:Encrypt`, et `kms:Decrypt` sur la clé.
* Aucune service control policy ou resource control policy dans votre organisation AWS n'empêche le principal de service ou votre principal d'utiliser la clé.
* Si la politique semble correcte et que l'attachement échoue toujours, recherchez l'événement `kms:` refusé dans CloudTrail dans le compte de la clé (il indique le principal appelant et, pour les appels cryptographiques, le contexte de chiffrement), puis corrigez la condition avec `kms:PutKeyPolicy` et réessayez.
## Terraform
Pour les déploiements infrastructure-as-code, les mêmes étapes correspondent au fournisseur `aws` avec les ressources `aws_kms_key` et `aws_kms_alias`.