---
title: Configurar o AWS KMS para CMEK
url: https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms
description: Use o AWS KMS para fornecer uma chave de criptografia para sua organização.
---
Deixe o Claude Code configurar este recurso para você
```text
/claude-api me ajude a configurar uma chave de criptografia gerenciada pelo cliente com o AWS KMS
```
Este guia orienta a configuração de uma chave do [AWS KMS](https://aws.amazon.com/kms/) como uma [chave de criptografia gerenciada pelo cliente (CMEK)](https://platform.claude.com/docs/pt-BR/manage-claude/cmek) para sua organização Anthropic.
Habilitar o CMEK é permanente. Se sua chave KMS for excluída ou desabilitada, a Anthropic não poderá recuperar os dados criptografados com ela. Revise os [avisos e limitações](https://platform.claude.com/docs/pt-BR/manage-claude/cmek) antes de começar.
**Claude Platform on AWS:** No [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws), sua política de chave concede acesso a um principal de serviço da AWS em vez da função IAM da Anthropic, não há uma etapa de validação separada, e você registra e anexa a chave no Claude Console. Siga [Configurar o CMEK no Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms#claude-platform-on-aws) nesta página em vez das etapas nas próximas seções.
## Pré-requisitos
* Uma conta AWS com permissões para criar chaves KMS e definir políticas de chave (`kms:CreateKey` e `kms:PutKeyPolicy`).
* Uma chave de API de Admin da Anthropic para sua organização.
* A [AWS CLI](https://aws.amazon.com/cli/) instalada e autenticada.
## Amazon Resource Name (ARN) para a Anthropic
Para que a Anthropic use sua chave de criptografia, você deve fornecer à função IAM da Anthropic uma chave KMS que ela possa usar para criptografar dados. O ARN para o CMEK da Anthropic é:
```text wrap
arn:aws:iam::915198916910:role/anthropic-cmek-client-us
```
Use apenas este ARN publicado. Nunca confie em um identificador fornecido por e-mail, chat ou qualquer canal de integração.
## Configuração da chave de criptografia
**Claude Platform on AWS:** Pule esta etapa. Sua política de chave concede acesso a um principal de serviço da AWS e não tem condição de organização. [Configurar o CMEK no Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms#claude-platform-on-aws) fornece essa política.
A política de chave concede à função IAM da Anthropic acesso entre contas. Três declarações são necessárias:
1. **Admin raiz da conta:** o padrão KMS padrão. Sua conta mantém controle administrativo total.
2. **Criptografar e descriptografar da Anthropic:** as ações `kms:Encrypt` e `kms:Decrypt`, que a Anthropic usa para criptografar e descriptografar as chaves de dados que protegem os dados do seu workspace (criptografia de envelope).
3. **Describe da Anthropic:** a leitura de metadados que a Anthropic realiza na inicialização. É concedida separadamente porque `DescribeKey` não tem parâmetro `EncryptionContext`, então uma condição `EncryptionContext` nesta ação sempre negaria.
Para encontrar [o ID da sua conta AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html), execute `aws sts get-caller-identity --query Account --output text`.
Na política, substitua `` pelo ID da sua conta AWS e `` pelo ID da sua organização. A condição `StringEquals` em `kms:EncryptionContext:anthropic:org_uuid` vincula a chave à sua organização Anthropic, e a validação recusa uma chave sem ela. Para compartilhar uma chave entre várias organizações Anthropic, liste o ID de cada organização no valor da condição.
**Encontrar o ID da sua organização:** Copie o campo **Organization ID** na página [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) no Claude Console, ou em **Organization settings > Organization** no claude.ai, ou leia o campo `id` do endpoint [Organization Info](https://platform.claude.com/docs/pt-BR/api/organization/retrieve). Use o UUID puro, não o ID com prefixo `org_`.
Salve a política como `key-policy.json`. Para criar a chave no AWS Console em vez disso, cole a política lá, conforme descrito mais adiante nesta etapa.
```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": "*"
}
]
}
```
**Opcional:** Para limitar a chave a alguns dos seus workspaces, use esta declaração `AllowAnthropicCMEKCrypto` em vez da que está no JSON da política anterior, com um ID de compartimento para cada workspace. Adicione o ID de compartimento de um workspace antes de anexar a chave a ele. Para um novo workspace, crie-o sem a chave, adicione seu ID de compartimento e, em seguida, anexe a chave.
```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
```
Capture `KeyMetadata.Arn` da saída. Você precisará dele ao registrar a chave na próxima etapa.
Se a chave já estiver configurada para CMEK e proteger dados existentes, você deve adicionar uma declaração que permita à Anthropic descriptografar esses dados, além das três declarações na política anterior. Em sua condição, liste o ID de compartimento de cada workspace ao qual a chave está ou esteve anexada.
```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": [""]
}
}
}
```
A Anthropic valida a chave quando você a verifica ou a anexa a um workspace. Cada validação adiciona quatro erros de acesso negado ao CloudTrail. Isso é esperado. Se você precisar filtrá-los, filtre pelos três valores a seguir. O primeiro sozinho não é suficiente, porque qualquer chamador pode defini-lo:
* `requestParameters.encryptionContext.associatedData`: `Y21lay12YWxpZGF0aW9u`
* `userIdentity.accountId`: `915198916910`
* `resources.ARN`: `arn:aws:kms:::key/`
**Encontrar o ID do seu compartimento:** Consulte a aba **Claude Platform** em **Registrar a chave com a Anthropic**.
Você também pode criar a chave no AWS Console. Escolha uma chave simétrica com o uso de chave de criptografar e descriptografar, uma chave de região única e origem de material de chave KMS. O assistente de criação de chave confirma uma política de chave em sua etapa **Review**: Se você adicionar o ID da conta da Anthropic `915198916910` nas permissões de uso de chave lá, a política gerada concede à conta inteira da Anthropic ações mais amplas (como `kms:ReEncrypt*` e `kms:GenerateDataKey*`) sem condição `EncryptionContext`, e a validação a recusa. Para evitar deixar uma chave com permissões excessivas, conclua o assistente apenas com permissões administrativas, depois abra a aba **Key policy** da chave e substitua o JSON pela política `key-policy.json` mostrada anteriormente nesta etapa.
## Registrar a chave com a Anthropic
Como você registra a chave depende de qual produto você usa.
**Claude Platform on AWS:** O principal, a política de chave e o fluxo de registro diferem, e não há uma etapa de validação separada. Siga [Configurar o CMEK no Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms#claude-platform-on-aws) em vez desta aba.
**Encontrar o ID do seu compartimento:** Cada workspace tem um ID de compartimento que delimita seus dados de CMEK. Para encontrá-lo no Claude Console, acesse a página [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) e selecione o workspace no menu suspenso no topo da página. O ID fica em **Encryption key**, no campo **Compartment ID**. Você também pode ler o campo `compartment_id` retornado pelo endpoint [Get Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/retrieve).
Você pode configurar a chave no Claude Console ou através da Admin API, com o mesmo resultado.
No Claude Console, acesse a página [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Se você não vir **Encryption keys**, selecione **Organization** no menu suspenso no topo da página. Em **Encryption keys**, clique em **Add key**. Insira um nome de exibição, escolha **AWS KMS** e clique em **Continue**. Cole o ARN da chave em **KMS key ARN** e clique em **Add**.
A etapa de detalhes da chave mostra o ID da sua organização. Adicione-o à [política de chave](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms#key-policy) antes de clicar em **Add**.
Na lista **Encryption keys**, clique em **Verify** ao lado da chave. **Connected** aparece quando a verificação é aprovada. Se falhar, uma mensagem informa o motivo.
No Claude Console, acesse a página [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) e selecione o workspace no menu suspenso no topo da página. Em **Encryption key**, selecione a chave, clique em **Save** e confirme. Anexar uma chave não pode ser desfeito. Para um workspace que já recebe solicitações, a chave pode levar [até um dia para entrar em vigor](https://platform.claude.com/docs/pt-BR/manage-claude/cmek#how-it-works).
Crie uma configuração de chave externa através da 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}"
```
A resposta contém o ID da chave externa:
```json
{
"type": "external_key",
"id": "ekey_",
"display_name": ""
}
```
Acione uma ida e volta de criptografar e descriptografar contra sua chave.
```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}"
```
Uma resposta bem-sucedida se parece com isto:
```json
{ "type": "external_key_validation", "status": "success", "error": null }
```
Se a validação falhar, as causas comuns são:
* **Incompatibilidade de contexto de criptografia:** Se a política tiver uma condição `kms:EncryptionContext:anthropic:compartment_uuid`, certifique-se de que ela liste o ID de compartimento de cada workspace ao qual a chave está anexada. A validação envia o ID de compartimento do workspace que verifica. Uma chave mais antiga cuja declaração de compartimento ainda permite `kms:Encrypt` é validada com o valor todo-zeros (`00000000-0000-0000-0000-000000000000`) enquanto não está anexada, então mantenha esse valor em sua lista.
* **Políticas de controle de recursos (RCPs):** Se sua organização AWS tiver uma RCP que nega operações KMS quando `aws:PrincipalOrgID` não corresponde à sua organização, ela bloqueia a função entre contas da Anthropic. A RCP precisa de uma exceção para esta chave ou para o ARN da função da Anthropic. Políticas de controle de serviço não se aplicam aqui, porque não são avaliadas para principais externos que chamam através de políticas baseadas em recursos.
* **Acesso concedido através do IAM em vez da política de chave:** O acesso KMS entre contas deve ser concedido na própria política de chave, não através de uma política IAM em sua conta. Verifique com `aws kms get-key-policy --key-id --policy-name default`.
* **Incompatibilidade de região:** Confirme que a região da chave é uma em que a Anthropic opera para o nível geográfico que você configurou.
Uma vez que a chave é validada, anexe-a a um novo workspace antes de enviar qualquer solicitação a esse workspace. Para um workspace que já recebe solicitações, a chave pode levar [até um dia para entrar em vigor](https://platform.claude.com/docs/pt-BR/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}"
```
Em [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), abra **Encryption keys** e clique em **Add key**. Escolha **AWS** e clique em **Continue**, depois cole o Key ARN da etapa anterior e clique em **Add**. A Anthropic valida a chave com uma ida e volta de criptografar e descriptografar. Uma vez que ela apareça como verificada, sua organização está protegida por CMEK a partir desse ponto.
A etapa de detalhes da chave deste fluxo exibe seu **Organization ID for the key policy** com um botão de copiar. Substitua esse valor por `` na política de chave. Você pode abrir o fluxo para copiar o ID antes de criar a chave.
No Claude Enterprise, o CMEK se aplica a toda a organização, então não há uma etapa separada de anexação de workspace, e uma organização pode ter apenas uma chave.
## Configurar o CMEK no Claude Platform on AWS
No [Claude Platform on AWS](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws), o CMEK usa apenas chaves do AWS KMS, e a configuração difere das seções anteriores nestes aspectos:
* **Principal:** Sua política de chave concede acesso ao principal de serviço da AWS `aws-external-anthropic.amazonaws.com`. A função IAM e o ID da conta da Anthropic não são usados, então o [ARN para a Anthropic](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-aws-kms#amazon-resource-name-arn-for-anthropic) não se aplica.
* **Requisitos da chave:** A chave deve ser uma chave KMS simétrica com uso de criptografar e descriptografar, de região única, e na mesma conta e região AWS do workspace ao qual você a anexa. Chaves entre contas não são suportadas: a chave deve estar na conta AWS que hospeda sua organização. Chaves multirregião (IDs de chave que começam com `mrk-`) e ARNs de alias são rejeitados quando você registra a chave; use o ARN da chave.
* **Sem etapa de validação separada:** Além dessas verificações no ARN da chave no registro, a chave é validada quando você a anexa a um workspace. A chamada de anexação realiza uma ida e volta de criptografar/descriptografar contra a chave com o ID de compartimento desse workspace como contexto de criptografia, então um problema na política de chave aparece no momento da anexação em vez de no registro. Uma condição `EncryptionContext` portanto não precisa de entrada todo-zeros.
* **Onde você gerencia chaves:** Registre e anexe chaves no Claude Console, conectado através da AWS com a função Admin. Os endpoints de chave externa também estão disponíveis no Claude Platform on AWS, autorizados através de [ações IAM](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#encryption-keys); lá, uma chave é identificada por seu ARN de chave KMS em vez de um ID `ekey_`.
Use apenas este nome de principal de serviço publicado. Nunca confie em um identificador fornecido por e-mail, chat ou qualquer canal de integração.
### Pré-requisitos
* A conta AWS que hospeda sua organização Claude Platform on AWS, com permissões para criar chaves KMS e definir políticas de chave (`kms:CreateKey` e `kms:PutKeyPolicy`).
* A função **Admin** no Claude Console para Claude Platform on AWS. Consulte [Usando o Claude Console](https://platform.claude.com/docs/pt-BR/build-with-claude/claude-platform-on-aws#using-the-claude-console).
* Para o principal IAM com o qual você se conecta ao Claude Console: além de `aws-external-anthropic:AssumeConsole`, as [ações IAM](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#encryption-keys) para as operações que você realiza lá, porque registrar, listar e anexar chaves passam pelo gateway da AWS. Registrar uma chave é `RegisterKey` (com `ListKeys` e `GetKey` para visualizar registros), e anexar uma é `UpdateWorkspace` ou `CreateWorkspace`. As ações de chave externa (e `CreateWorkspace`) têm escopo de conta, então conceda-as em `Resource: "*"`; uma política limitada a ARNs de workspace não as inclui.
* Para o principal IAM que anexa a chave a um workspace (a identidade com a qual você se conectou ao Claude Console): `kms:DescribeKey`, `kms:Encrypt` e `kms:Decrypt` na chave. O acesso do seu principal à chave é verificado quando você a anexa, além do principal de serviço.
* Opcional, para o seletor de chave no Claude Console: `kms:ListKeys` e `kms:DescribeKey` para o principal com o qual você se conecta. Sem eles, cole o ARN da chave em vez disso.
### Criar a chave KMS
A política de chave tem três declarações: a declaração de administrador raiz da sua conta; uma declaração que permite ao principal de serviço do Claude Platform on AWS criptografar, descriptografar e gerar chaves de dados; e uma declaração separada para `kms:DescribeKey`. A declaração de criptografia contém uma condição `EncryptionContext` opcional que vincula a chave aos workspaces que você listar. `DescribeKey` é concedida separadamente porque não tem o parâmetro `EncryptionContext`, portanto uma condição `EncryptionContext` nessa ação sempre negaria o acesso.
Se você planeja usar a condição `EncryptionContext` opcional mostrada aqui, crie o workspace primeiro (sem uma chave), copie seu ID de compartimento e substitua `` por ele. Para encontrar o ID no Claude Console, acesse a página [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) e selecione o workspace no menu suspenso no topo da página. O ID fica em **Encryption key**, no campo **Compartment ID**. Você também pode lê-lo no campo `compartment_id` retornado pelo endpoint [Get Workspace](https://platform.claude.com/docs/pt-BR/api/organization/workspaces/retrieve). Se você não planeja usar a condição, exclua o bloco `Condition` dessa declaração.
```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\": \"*\"
}
]
}"
```
Capture `KeyMetadata.Arn` da saída. Você precisará dele ao registrar a chave.
A condição `EncryptionContext` é opcional. Toda chamada de criptografia, descriptografia e chave de dados feita para um workspace, incluindo a verificação no momento da anexação, carrega o ID de compartimento desse workspace como `anthropic:compartment_uuid`, portanto a condição lista o ID de compartimento de cada workspace ao qual você anexa a chave e não precisa de entrada todo-zeros. Adicioná-la também vincula a chave aos workspaces que você listar na camada do IAM. Como um ID de compartimento só existe depois que o workspace correspondente existe, a ordem é: criar o workspace, colocar o ID de compartimento dele na condição (na criação da chave ou posteriormente com `kms:PutKeyPolicy`) e, em seguida, anexar a chave. Antes de anexar a chave a cada workspace adicional, adicione o ID de compartimento desse workspace da mesma forma. Para começar sem ela, exclua o bloco `Condition` da declaração `AllowClaudePlatformOnAWSCrypto`; se você adicioná-la depois, inclua o ID de compartimento de cada workspace ao qual a chave já está anexada.
Você pode restringir ainda mais as duas declarações do principal de serviço com uma condição `aws:SourceArn`. O serviço passa o [ARN do workspace](https://platform.claude.com/docs/pt-BR/api/claude-platform-on-aws-iam-actions#service-details) (`arn:aws:aws-external-anthropic:::workspace/`) como ARN de origem em toda chamada que faz com sua chave, portanto `"ArnLike": {"aws:SourceArn": "arn:aws:aws-external-anthropic:*::workspace/*"}` limita a concessão aos workspaces da sua própria conta AWS, e uma lista de ARNs completos de workspaces a limita a esses workspaces. Essa condição não é obrigatória; a condição `EncryptionContext` por si só vincula a chave aos workspaces que você listar.
Você também pode criar a chave no AWS Console: escolha uma chave simétrica com o uso de chave de criptografar e descriptografar, uma chave de região única e origem de material de chave KMS, na região do workspace. Deixe as permissões de uso de chave vazias no assistente de criação de chave, depois abra a aba **Key policy** da chave e substitua o JSON pela política mostrada aqui.
### Registrar e anexar a chave
No Claude Console, acesse a página [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Se você não vir **Encryption keys**, selecione **Organization** no menu suspenso no topo da página. Em **Encryption keys**, clique em **Add key**. Insira um nome de exibição, depois escolha a chave no seletor de chave ou escolha **Enter ARN manually** e cole o ARN da chave, e clique em **Add**. A chave deve estar na conta AWS que hospeda sua organização; chaves entre contas não são suportadas. O seletor lista as chaves habilitadas, gerenciadas pelo cliente, simétricas e de região única na sua conta em uma das regiões da sua organização; para uma chave que o seletor não lista, insira o ARN. Ele lista chaves apenas se o principal com o qual você se conectou puder chamar `kms:ListKeys` e `kms:DescribeKey`.
Anexe a chave a um novo workspace antes de enviar qualquer solicitação a esse workspace. Para um workspace que já recebe solicitações, a chave pode levar [até um dia para entrar em vigor](https://platform.claude.com/docs/pt-BR/manage-claude/cmek#how-it-works). No Claude Console, acesse a página [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) e selecione o workspace no menu suspenso no topo da página. Em **Encryption key**, selecione a chave, clique em **Save** e confirme. Você também pode selecionar uma chave ao criar um workspace no Claude Console, mas somente se sua política de chave ainda não nomear workspaces específicos (sem condição `EncryptionContext`), porque o ID de compartimento do workspace é atribuído na criação. Depois de anexada, a chave de um workspace não pode ser alterada.
É quando a chave é validada: a chamada de anexação verifica o acesso do seu principal à chave e realiza uma ida e volta de criptografar/descriptografar contra ela com o ID de compartimento do workspace como contexto de criptografia, então um problema com a política de chave ou com as permissões do seu principal aparece como um erro nessa chamada. Se a anexação falhar com um erro de acesso KMS, verifique o seguinte:
* A política de chave nomeia o principal de serviço `aws-external-anthropic.amazonaws.com` e concede `kms:Encrypt`, `kms:Decrypt` e `kms:GenerateDataKey`, além de `kms:DescribeKey` em uma declaração separada que não tem condição `EncryptionContext`.
* Qualquer condição `EncryptionContext` inclui o ID de compartimento deste workspace, e qualquer condição `aws:SourceArn` que você adicionou corresponde ao ARN deste workspace.
* A chave está habilitada, é de região única e está na mesma conta e região AWS do workspace.
* O principal com o qual você está conectado tem `kms:DescribeKey`, `kms:Encrypt` e `kms:Decrypt` na chave.
* Nenhuma política de controle de serviço ou política de controle de recursos em sua organização AWS impede o principal de serviço ou seu principal de usar a chave.
* Se a política parecer correta e a anexação ainda falhar, encontre o evento `kms:` negado no CloudTrail na conta da chave (ele mostra o principal chamador e, para chamadas criptográficas, o contexto de criptografia), depois corrija a condição com `kms:PutKeyPolicy` e tente novamente.
## Terraform
Para implantações de infraestrutura como código, as mesmas etapas mapeiam para o provedor `aws` com os recursos `aws_kms_key` e `aws_kms_alias`.