--- title: Configurar Azure Key Vault para CMEK url: https://platform.claude.com/docs/es/manage-claude/cmek-azure-key-vault description: Usa Azure Key Vault para proporcionar una clave de cifrado para tu organización. --- Deja que Claude Code configure esta función por ti ```text /claude-api ayúdame a configurar una clave de cifrado administrada por el cliente con Azure Key Vault ``` Esta guía explica cómo configurar una clave de Azure Key Vault como una [clave de cifrado administrada por el cliente (CMEK)](https://platform.claude.com/docs/es/manage-claude/cmek) para tu organización de Anthropic. Habilitar CMEK es permanente. Si tu clave de Key Vault se elimina o deshabilita, Anthropic no puede recuperar los datos cifrados con ella. Revisa las [advertencias y limitaciones](https://platform.claude.com/docs/es/manage-claude/cmek) antes de comenzar. ## Requisitos previos * Un Azure Key Vault con **autorización RBAC habilitada** (`enableRbacAuthorization: true`) y **acceso a la red pública permitido**. Anthropic llama a tu vault a través del endpoint público del plano de datos; los endpoints privados no son compatibles. * **Protección contra purga habilitada** (`enablePurgeProtection: true`) en el vault. Sin ella, una clave eliminada puede purgarse permanentemente durante la ventana de retención de eliminación temporal, causando la pérdida irreversible de tus datos protegidos por CMEK. La protección contra purga no se puede deshabilitar una vez habilitada. * Permisos para crear claves en el vault y para asignar roles RBAC en él. * Permisos para crear entidades de servicio en tu tenant de Entra (`Application Administrator`, `Cloud Application Administrator`, o un rol personalizado equivalente). * Una clave de API de administrador de Anthropic para tu organización. * La [CLI `az`](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest) instalada y autenticada. * **Configuración de diagnóstico** configurada en el vault para enrutar la categoría de registro `AuditEvent` a Log Analytics, una cuenta de almacenamiento o un centro de eventos. Azure Key Vault no emite registros de auditoría del plano de datos (como `KeyWrap`, `KeyUnwrap` y `KeyGet`) de forma predeterminada, por lo que sin esto no obtienes ningún rastro de auditoría para las operaciones de clave de Anthropic. ## Información de la aplicación de Anthropic Para que Anthropic use tu clave de cifrado, debes configurar un ID de aplicación multitenant y un nombre para mostrar de Anthropic. Esos valores son: | Campo | Valor | | ----------------------------------------------- | -------------------------------------- | | ID de cliente de la aplicación multitenant (US) | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` | | Nombre para mostrar de la aplicación | `anthropic-cmek-client-us` | Usa únicamente este ID de cliente y nombre para mostrar publicados. Nunca confíes en un identificador proporcionado por correo electrónico, chat o cualquier canal de incorporación. ## Configuración de la clave de cifrado Esto crea una entidad de servicio en tu tenant de Entra para la aplicación cliente CMEK de Anthropic. La aplicación no solicita permisos de Microsoft Graph; existe únicamente como un objetivo de federación para el acceso al plano de datos de Key Vault. ```bash az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 ``` De la salida, captura el campo `id`. Este es el ID de objeto de la entidad de servicio en tu tenant, que usas cuando asignas el rol RBAC. ```json { "appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87", "displayName": "anthropic-cmek-client-us", "id": "" } ``` Si la entidad de servicio ya existe en tu tenant (de un intento anterior u otra integración), `az ad sp create` sale con un error de "already exists". En su lugar, obtén su ID de objeto: ```bash az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv ``` Este paso no tiene equivalente en el Portal. Si no tienes la CLI de Azure instalada localmente, abre Cloud Shell desde la barra de navegación superior del Portal. Después de que el comando tenga éxito, puedes encontrar el ID de objeto de la entidad de servicio en **Microsoft Entra ID > Enterprise applications** borrando el filtro de tipo de aplicación predeterminado y buscando `anthropic-cmek-client-us`. ![Descripción general de la aplicación empresarial de Microsoft Entra para anthropic-cmek-client-us, que muestra su Application ID y su Object ID.](https://platform.claude.com/docs/images/cmek/azure-service-principal.png) Azure Key Vault no admite el ajuste de claves simétricas, por lo que la clave debe ser RSA (3072 bits o más) con `wrapKey` y `unwrapKey` en sus operaciones permitidas. La opción `--tags` agrega la etiqueta de organización, `anthropic-org-` con el valor `true`, donde `` es el ID de tu organización de Anthropic en minúsculas. La etiqueta es necesaria para que Anthropic valide la clave. **Encontrar el ID de tu organización:** Copia el campo **Organization ID** en la página [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) en la Claude Console, o en **Organization settings > Organization** en claude.ai, o lee el campo `id` del endpoint [Organization Info](https://platform.claude.com/docs/es/api/organization/retrieve). Usa el UUID sin prefijo, no el ID con el prefijo `org_`. ```bash az keyvault key create \ --vault-name \ --name \ --kty RSA --size 3072 \ --ops wrapKey unwrapKey \ --tags anthropic-org-=true ``` Para claves respaldadas por HSM, usa `--kty RSA-HSM` (requiere un vault de SKU Premium). Las claves RSA protegidas por software son aceptables para esta integración. Desde el Portal, abre tu Key Vault, selecciona **Keys**, luego **Generate/Import**. Establece el tipo de clave en RSA y el tamaño en 3072 o más. Para restringir la clave solo a ajustar y desajustar, abre la versión de la clave, desplázate hasta **Permitted operations** y desmarca todo excepto **Wrap Key** y **Unwrap Key**. En la página **Create a key**, también agrega la etiqueta de organización en **Tags**. ![Página Create a key de Azure Key Vault con RSA, un tamaño de clave de 3072 y la etiqueta anthropic-org establecida en true.](https://platform.claude.com/docs/images/cmek/azure-create-key-tag.png) ![Versión de una clave de Azure Key Vault con 1 etiqueta y, en Permitted operations, solo Wrap Key y Unwrap Key marcados.](https://platform.claude.com/docs/images/cmek/azure-permitted-operations-tag.png) Para compartir una clave entre varias organizaciones de Anthropic, agrega una etiqueta de este tipo por cada organización. Una versión de clave puede llevar como máximo 15 etiquetas, incluidas las tuyas. Para agregar la etiqueta a una clave que ya tienes, abre la versión actual de la clave en el Portal, selecciona el enlace junto a **Tags**, agrega la etiqueta y haz clic en **Save**. Con la CLI de Azure, ejecuta `az keyvault key set-attributes --vault-name --name --tags anthropic-org-=true`. Su opción `--tags` reemplaza las etiquetas de la versión, así que también incluye cada etiqueta que la versión ya tiene en `--tags`, como `name=value`. Para una clave en un Managed HSM, usa `--hsm-name ` en lugar de `--vault-name`. Asigna el rol `Key Vault Crypto User` a la entidad de servicio del primer paso, con alcance a la **clave individual** en lugar de a todo el 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/" ``` El rol integrado `Key Vault Crypto User` otorga operaciones criptográficas de clave (cifrar, descifrar, ajustar, desajustar, firmar, verificar) más la lectura de clave en su alcance asignado. La restricción `--ops wrapKey unwrapKey` que estableciste en la clave en el paso anterior reduce aún más cuáles de esas operaciones pueden tener éxito contra esta clave, por lo que en la práctica Anthropic solo puede ajustar y desajustar. Desde el Portal, abre la **clave** (no el vault), selecciona su pestaña **Access control (IAM)**, haz clic en **Add > Add role assignment**, selecciona **Key Vault Crypto User** y asígnalo a la entidad de servicio `anthropic-cmek-client-us`. **Alternativa de vault dedicado:** Microsoft recomienda un vault dedicado por aplicación con roles asignados en el alcance del vault. Si aprovisionas un vault que contiene solo esta clave CMEK de Anthropic, puedes asignar el rol en el alcance del vault en su lugar y el efecto es idéntico. Usa el alcance de la clave individual cuando la clave reside en un vault compartido. ![Asignaciones de roles de IAM de Key Vault que muestran a anthropic-cmek-client-us con el rol Key Vault Crypto User asignado.](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}" ``` Confirma que: * `rbac` es `true`. * `purge` es `true`. Si es `false` o `null`, habilita la protección contra purga en el vault antes de continuar. Sin ella, una clave eliminada temporalmente puede purgarse permanentemente durante la ventana de retención, haciendo que tus datos protegidos por CMEK sean irrecuperables. * `pub` es `"Enabled"`. Si es `"Disabled"`, Anthropic no puede alcanzar el vault a través de su endpoint público del plano de datos y la validación falla. * `net` es `"Allow"`, o, si es `"Deny"`, que `ipRules` incluya los rangos de salida de Anthropic (contacta a Anthropic para obtener la lista actual). * `uri` es el URI del vault que usas cuando registras la clave. * `tenantId` es el tenant que gobierna el vault. Usa este valor como `tenant_id` cuando registres la clave, no el tenant de tu suscripción actualmente activa (los dos pueden diferir en configuraciones entre tenants). ## Registrar la clave con Anthropic La forma en que registras la clave depende del producto que uses. Puedes configurar la clave en la Claude Console o a través de la Admin API, con el mismo resultado. En la Claude Console, ve a la página [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Si no ves **Encryption keys**, selecciona **Organization** en el menú desplegable de la parte superior de la página. En **Encryption keys**, haz clic en **Add key**. Ingresa un nombre para mostrar, elige **Azure Key Vault** y haz clic en **Continue**. Completa **Vault URI**, **Key name** y **Tenant ID**, y haz clic en **Add**. El paso de detalles de la clave muestra la etiqueta de organización. Agrégala a la clave, como describe [el paso de creación](https://platform.claude.com/docs/es/manage-claude/cmek-azure-key-vault#organization-tag), antes de hacer clic en **Add**. En la lista **Encryption keys**, haz clic en **Verify** junto a la clave. Aparece **Connected** cuando la verificación se completa correctamente. Si falla, un mensaje indica el motivo. En la Claude Console, ve a la página [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) y selecciona el workspace en el menú desplegable de la parte superior de la página. En **Encryption key**, selecciona la clave, haz clic en **Save** y confirma. Adjuntar una clave no se puede deshacer. Para un workspace que ya recibe solicitudes, la clave puede tardar [hasta un día en surtir efecto](https://platform.claude.com/docs/es/manage-claude/cmek#how-it-works). Crea una configuración de clave externa a través de la 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 respuesta contiene el ID de la clave externa: ```json { "type": "external_key", "id": "ekey_", "display_name": "" } ``` Activa un ciclo de cifrado y descifrado contra tu clave. Esto confirma que Anthropic puede autenticarse en tu tenant y realizar operaciones de ajuste y desajuste. ```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}" ``` Una respuesta exitosa se ve así: ```json { "type": "external_key_validation", "status": "success", "error": null } ``` Si la validación falla, el campo `error` describe el problema. Las causas comunes son: * **Retraso en la propagación de RBAC:** las asignaciones de roles pueden tardar unos minutos en surtir efecto. Espera y vuelve a intentarlo. * **ACLs de red bloqueando a Anthropic:** confirma el acceso a la red pública y `ipRules` como se describe en el paso de verificación. * **Políticas de acceso condicional en identidades de carga de trabajo:** si tu tenant tiene políticas de acceso condicional que apuntan a entidades de servicio, excluye la entidad de servicio de Anthropic o agrega los rangos de salida de Anthropic a las ubicaciones con nombre de la política. Una vez que la clave esté validada, adjúntala a un nuevo workspace antes de enviar cualquier solicitud a ese workspace. Para un workspace que ya recibe solicitudes, la clave puede tardar [hasta un día en surtir efecto](https://platform.claude.com/docs/es/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}" ``` En [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), abre **Encryption keys**, luego haz clic en **Add key**. Elige **Azure**, ingresa el URI del vault, el nombre de la clave y el ID del tenant del paso de verificación, y haz clic en **Continue**. Anthropic valida la clave con un ciclo de cifrado y descifrado. Una vez que se muestra como verificada, tu organización está protegida por CMEK a partir de ese momento. En Claude Enterprise, CMEK se aplica a toda la organización, por lo que no hay un paso separado para adjuntar al workspace, y una organización solo puede tener una clave. ## Terraform Para implementaciones de infraestructura como código, los mismos pasos se asignan a los proveedores `azurerm` y `azuread`.