---
title: Configurar o Azure Key Vault para CMEK
url: https://platform.claude.com/docs/pt-BR/manage-claude/cmek-azure-key-vault
description: Use o Azure Key Vault 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 Azure Key Vault
```
Este guia orienta a configuração de uma chave do Azure Key Vault 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 do Key Vault 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.
## Pré-requisitos
* Um Azure Key Vault com **autorização RBAC habilitada** (`enableRbacAuthorization: true`) e **acesso de rede pública permitido**. A Anthropic chama seu vault pelo endpoint público do plano de dados; endpoints privados não são suportados.
* **Proteção contra limpeza habilitada** (`enablePurgeProtection: true`) no vault. Sem ela, uma chave excluída pode ser permanentemente limpa durante a janela de retenção de exclusão reversível, causando perda irreversível dos seus dados protegidos por CMEK. A proteção contra limpeza não pode ser desabilitada depois de habilitada.
* Permissões para criar chaves no vault e atribuir funções RBAC nele.
* Permissões para criar entidades de serviço no seu locatário Entra (`Application Administrator`, `Cloud Application Administrator` ou uma função personalizada equivalente).
* Uma chave de API de Admin da Anthropic para sua organização.
* A [CLI `az`](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest) instalada e autenticada.
* **Configurações de diagnóstico** configuradas no vault para rotear a categoria de log `AuditEvent` para o Log Analytics, uma conta de armazenamento ou um hub de eventos. O Azure Key Vault não emite logs de auditoria do plano de dados (como `KeyWrap`, `KeyUnwrap` e `KeyGet`) por padrão, então sem isso você não obtém nenhuma trilha de auditoria para as operações de chave da Anthropic.
## Informações do aplicativo Anthropic
Para que a Anthropic use sua chave de criptografia, você deve configurar um ID de aplicativo multilocatário da Anthropic e um nome de exibição. Esses valores são:
| Campo | Valor |
| ------------------------------------------------ | -------------------------------------- |
| ID de cliente do aplicativo multilocatário (EUA) | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` |
| Nome de exibição do aplicativo | `anthropic-cmek-client-us` |
Use apenas este ID de cliente e nome de exibição publicados. Nunca confie em um identificador fornecido por e-mail, chat ou qualquer canal de integração.
## Configuração da chave de criptografia
Isso cria uma entidade de serviço no seu locatário Entra para o aplicativo cliente CMEK da Anthropic. O aplicativo não solicita permissões do Microsoft Graph; ele existe apenas como um alvo de federação para acesso ao plano de dados do Key Vault.
```bash
az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87
```
Na saída, capture o campo `id`. Este é o ID de objeto da entidade de serviço no seu locatário, que você usa ao atribuir a função RBAC.
```json
{
"appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87",
"displayName": "anthropic-cmek-client-us",
"id": ""
}
```
Se a entidade de serviço já existir no seu locatário (de uma tentativa anterior ou de outra integração), `az ad sp create` sai com um erro de "já existe". Em vez disso, busque seu ID de objeto:
```bash
az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv
```
Esta etapa não tem equivalente no Portal. Se você não tiver a CLI do Azure instalada localmente, abra o Cloud Shell na barra de navegação superior do Portal. Depois que o comando for bem-sucedido, você pode encontrar o ID de objeto da entidade de serviço em **Microsoft Entra ID > Aplicativos empresariais** limpando o filtro de tipo de aplicativo padrão e pesquisando por `anthropic-cmek-client-us`.
O Azure Key Vault não suporta encapsulamento de chave simétrica, então a chave deve ser RSA (3072 bits ou maior) com `wrapKey` e `unwrapKey` em suas operações permitidas.
A opção `--tags` adiciona a tag da organização, `anthropic-org-` com o valor `true`, onde `` é o ID da sua organização Anthropic em minúsculas. A tag é necessária para que a Anthropic valide a chave.
**Encontrando 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_`.
```bash
az keyvault key create \
--vault-name \
--name \
--kty RSA --size 3072 \
--ops wrapKey unwrapKey \
--tags anthropic-org-=true
```
Para chaves com suporte de HSM, use `--kty RSA-HSM` (requer um vault de SKU Premium). Chaves RSA protegidas por software são aceitáveis para esta integração.
No Portal, abra seu Key Vault, selecione **Keys** e, em seguida, **Generate/Import**. Defina o tipo de chave como RSA e o tamanho como 3072 ou maior. Para restringir a chave apenas a encapsular e desencapsular, abra a versão da chave, role até **Permitted operations** e desmarque tudo, exceto **Wrap Key** e **Unwrap Key**.
Na página **Create a key**, adicione também a tag da organização em **Tags**.
Para compartilhar uma chave entre várias organizações Anthropic, adicione uma tag dessas para cada organização. Uma versão de chave pode ter no máximo 15 tags, incluindo as suas próprias.
Para adicionar a tag a uma chave que você já tem, abra a versão atual da chave no Portal, selecione o link ao lado de **Tags**, adicione a tag e clique em **Save**. Com a CLI do Azure, execute `az keyvault key set-attributes --vault-name --name --tags anthropic-org-=true`. Sua opção `--tags` substitui as tags da versão, então coloque também cada tag que a versão já tem em `--tags`, como `name=value`. Para uma chave em um Managed HSM, use `--hsm-name ` em vez de `--vault-name`.
Atribua a função `Key Vault Crypto User` à entidade de serviço da primeira etapa, com escopo para a **chave individual** em vez de todo o 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/"
```
A função interna `Key Vault Crypto User` concede operações criptográficas de chave (criptografar, descriptografar, encapsular, desencapsular, assinar, verificar) mais leitura de chave no seu escopo atribuído. A restrição `--ops wrapKey unwrapKey` que você definiu na chave na etapa anterior restringe ainda mais quais dessas operações podem ser bem-sucedidas contra esta chave, então, na prática, a Anthropic só pode encapsular e desencapsular.
No Portal, abra a **chave** (não o vault), selecione sua aba **Access control (IAM)**, clique em **Add > Add role assignment**, selecione **Key Vault Crypto User** e atribua-a à entidade de serviço `anthropic-cmek-client-us`.
**Alternativa de vault dedicado:** A Microsoft recomenda um vault dedicado por aplicativo com funções atribuídas no escopo do vault. Se você provisionar um vault que contém apenas esta chave CMEK da Anthropic, você pode atribuir a função no escopo do vault e o efeito é idêntico. Defina o escopo para a chave individual quando a chave residir em um vault compartilhado.
```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}"
```
Confirme que:
* `rbac` é `true`.
* `purge` é `true`. Se for `false` ou `null`, habilite a proteção contra limpeza no vault antes de prosseguir. Sem ela, uma chave excluída de forma reversível pode ser permanentemente limpa durante a janela de retenção, tornando seus dados protegidos por CMEK irrecuperáveis.
* `pub` é `"Enabled"`. Se for `"Disabled"`, a Anthropic não pode alcançar o vault pelo seu endpoint público do plano de dados e a validação falha.
* `net` é `"Allow"`, ou, se for `"Deny"`, que `ipRules` inclua os intervalos de saída da Anthropic (entre em contato com a Anthropic para a lista atual).
* `uri` é o URI do vault que você usa ao registrar a chave.
* `tenantId` é o locatário que governa o vault. Use este valor como `tenant_id` ao registrar a chave, não o locatário da sua assinatura atualmente ativa (os dois podem diferir em configurações entre locatários).
## Registrar a chave com a Anthropic
Como você registra a chave depende de qual produto você usa.
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 na parte superior da página. Em **Encryption keys**, clique em **Add key**. Insira um nome de exibição, escolha **Azure Key Vault** e clique em **Continue**. Preencha **Vault URI**, **Key name** e **Tenant ID** e clique em **Add**.
A etapa de detalhes da chave mostra a tag da organização. Adicione-a à chave, como [a etapa de criação](https://platform.claude.com/docs/pt-BR/manage-claude/cmek-azure-key-vault#organization-tag) descreve, 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 na parte superior 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": "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}"
```
A resposta contém o ID da chave externa:
```json
{
"type": "external_key",
"id": "ekey_",
"display_name": ""
}
```
Acione um ciclo de criptografia e descriptografia contra sua chave. Isso confirma que a Anthropic pode autenticar no seu locatário e realizar operações de encapsulamento e desencapsulamento.
```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}"
```
Uma resposta bem-sucedida se parece com isto:
```json
{ "type": "external_key_validation", "status": "success", "error": null }
```
Se a validação falhar, o campo `error` descreve o problema. Causas comuns são:
* **Atraso de propagação do RBAC:** atribuições de função podem levar alguns minutos para entrar em vigor. Aguarde e tente novamente.
* **ACLs de rede bloqueando a Anthropic:** confirme o acesso de rede pública e `ipRules` conforme descrito na etapa de verificação.
* **Políticas de acesso condicional em identidades de carga de trabalho:** se seu locatário tiver políticas de acesso condicional que visam entidades de serviço, exclua a entidade de serviço da Anthropic ou adicione os intervalos de saída da Anthropic aos locais nomeados da política.
Depois que a chave for validada, anexe-a a um novo workspace antes de enviar qualquer solicitação para 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 = client.organization.workspaces.update(
"",
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 **Azure**, insira o URI do vault, o nome da chave e o ID do locatário da etapa de verificação, e clique em **Continue**. A Anthropic valida a chave com um ciclo de criptografia e descriptografia. Depois que ela aparecer como verificada, sua organização estará protegida por CMEK a partir desse ponto.
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.
## Terraform
Para implantações de infraestrutura como código, as mesmas etapas mapeiam para os provedores `azurerm` e `azuread`.