--- title: Configurare Azure Key Vault per CMEK url: https://platform.claude.com/docs/it/manage-claude/cmek-azure-key-vault description: Usa Azure Key Vault per fornire una chiave di crittografia per la tua organizzazione. --- Lascia che Claude Code configuri questa funzionalità per te ```text /claude-api aiutami a configurare una chiave di crittografia gestita dal cliente con Azure Key Vault ``` Questa guida illustra la configurazione di una chiave di Azure Key Vault come [chiave di crittografia gestita dal cliente (CMEK)](https://platform.claude.com/docs/it/manage-claude/cmek) per la tua organizzazione Anthropic. L'abilitazione di CMEK è permanente. Se la tua chiave di Key Vault viene eliminata o disabilitata, Anthropic non può recuperare i dati crittografati con essa. Esamina le [avvertenze e limitazioni](https://platform.claude.com/docs/it/manage-claude/cmek) prima di iniziare. ## Prerequisiti * Un Azure Key Vault con **autorizzazione RBAC abilitata** (`enableRbacAuthorization: true`) e **accesso alla rete pubblica consentito**. Anthropic chiama il tuo vault tramite l'endpoint pubblico del piano dati; gli endpoint privati non sono supportati. * **Protezione dall'eliminazione definitiva abilitata** (`enablePurgeProtection: true`) sul vault. Senza di essa, una chiave eliminata può essere eliminata definitivamente durante la finestra di conservazione dell'eliminazione temporanea, causando una perdita irreversibile dei tuoi dati protetti da CMEK. La protezione dall'eliminazione definitiva non può essere disabilitata una volta abilitata. * Autorizzazioni per creare chiavi nel vault e per assegnare ruoli RBAC su di esso. * Autorizzazioni per creare entità servizio nel tuo tenant Entra (`Application Administrator`, `Cloud Application Administrator`, o un ruolo personalizzato equivalente). * Una chiave API Admin di Anthropic per la tua organizzazione. * La [CLI `az`](https://learn.microsoft.com/en-us/cli/azure/?view=azure-cli-latest) installata e autenticata. * **Impostazioni di diagnostica** configurate sul vault per instradare la categoria di log `AuditEvent` a Log Analytics, un account di archiviazione o un hub eventi. Azure Key Vault non emette log di audit del piano dati (come `KeyWrap`, `KeyUnwrap` e `KeyGet`) per impostazione predefinita, quindi senza questo non ottieni alcuna traccia di audit per le operazioni sulle chiavi di Anthropic. ## Informazioni sull'app Anthropic Per far sì che Anthropic utilizzi la tua chiave di crittografia, devi configurare un ID applicazione multitenant e un nome visualizzato di Anthropic. Questi valori sono: | Campo | Valore | | ----------------------------------- | -------------------------------------- | | ID client dell'app multitenant (US) | `8635ae1a-3e5d-44e8-a4ed-e0f614466f87` | | Nome visualizzato dell'app | `anthropic-cmek-client-us` | Usa solo questo ID client e nome visualizzato pubblicati. Non fidarti mai di un identificatore fornito tramite email, chat o qualsiasi canale di onboarding. ## Configurazione della chiave di crittografia Questo crea un'entità servizio nel tuo tenant Entra per l'applicazione client CMEK di Anthropic. L'applicazione non richiede autorizzazioni Microsoft Graph; esiste esclusivamente come destinazione di federazione per l'accesso al piano dati di Key Vault. ```bash az ad sp create --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 ``` Dall'output, acquisisci il campo `id`. Questo è l'ID oggetto dell'entità servizio nel tuo tenant, che usi quando assegni il ruolo RBAC. ```json { "appId": "8635ae1a-3e5d-44e8-a4ed-e0f614466f87", "displayName": "anthropic-cmek-client-us", "id": "" } ``` Se l'entità servizio esiste già nel tuo tenant (da un tentativo precedente o da un'altra integrazione), `az ad sp create` termina con un errore "already exists". Recupera invece il suo ID oggetto: ```bash az ad sp show --id 8635ae1a-3e5d-44e8-a4ed-e0f614466f87 --query id -o tsv ``` Questo passaggio non ha un equivalente nel Portale. Se non hai la CLI di Azure installata localmente, apri Cloud Shell dalla barra di navigazione superiore del Portale. Dopo che il comando ha avuto successo, puoi trovare l'ID oggetto dell'entità servizio in **Microsoft Entra ID > Applicazioni aziendali** cancellando il filtro predefinito per tipo di applicazione e cercando `anthropic-cmek-client-us`. ![Panoramica dell'applicazione aziendale Microsoft Entra per anthropic-cmek-client-us, che mostra l'Application ID e l'Object ID.](https://platform.claude.com/docs/images/cmek/azure-service-principal.png) Azure Key Vault non supporta il wrapping di chiavi simmetriche, quindi la chiave deve essere RSA (3072 bit o superiore) con `wrapKey` e `unwrapKey` nelle sue operazioni consentite. L'opzione `--tags` aggiunge il tag dell'organizzazione, `anthropic-org-` con il valore `true`, dove `` è l'ID della tua organizzazione Anthropic in minuscolo. Il tag è necessario affinché Anthropic convalidi la chiave. **Trovare l'ID della tua organizzazione:** copia il campo **Organization ID** nella pagina [Organization](https://platform.claude.com/settings/organization) (`platform.claude.com/settings/organization`) nella Claude Console, oppure in **Organization settings > Organization** su claude.ai, oppure leggi il campo `id` dall'endpoint [Organization Info](https://platform.claude.com/docs/it/api/organization/retrieve). Usa l'UUID semplice, non l'ID con prefisso `org_`. ```bash az keyvault key create \ --vault-name \ --name \ --kty RSA --size 3072 \ --ops wrapKey unwrapKey \ --tags anthropic-org-=true ``` Per le chiavi supportate da HSM, usa `--kty RSA-HSM` (richiede un vault con SKU Premium). Le chiavi RSA protette da software sono accettabili per questa integrazione. Dal Portale, apri il tuo Key Vault, seleziona **Keys**, quindi **Generate/Import**. Imposta il tipo di chiave su RSA e la dimensione su 3072 o superiore. Per limitare la chiave solo al wrap e unwrap, apri la versione della chiave, scorri fino a **Permitted operations** e deseleziona tutto tranne **Wrap Key** e **Unwrap Key**. Nella pagina **Create a key**, aggiungi anche il tag dell'organizzazione in **Tags**. ![Pagina Create a key di Azure Key Vault con RSA, dimensione della chiave 3072 e il tag anthropic-org impostato su true.](https://platform.claude.com/docs/images/cmek/azure-create-key-tag.png) ![Versione della chiave di Azure Key Vault con 1 tag e le operazioni consentite limitate a Wrap Key e Unwrap Key.](https://platform.claude.com/docs/images/cmek/azure-permitted-operations-tag.png) Per condividere una chiave tra più organizzazioni Anthropic, aggiungi un tag di questo tipo per ciascuna organizzazione. Una versione della chiave può contenere al massimo 15 tag, inclusi i tuoi. Per aggiungere il tag a una chiave che hai già, apri la versione corrente della chiave nel Portale, seleziona il link accanto a **Tags**, aggiungi il tag e fai clic su **Save**. Con la CLI di Azure, esegui `az keyvault key set-attributes --vault-name --name --tags anthropic-org-=true`. La sua opzione `--tags` sostituisce i tag della versione, quindi inserisci anche ogni tag che la versione ha già in `--tags`, come `name=value`. Per una chiave in un Managed HSM, usa `--hsm-name ` invece di `--vault-name`. Assegna il ruolo `Key Vault Crypto User` all'entità servizio del primo passaggio, con ambito limitato alla **singola chiave** anziché all'intero 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/" ``` Il ruolo integrato `Key Vault Crypto User` concede operazioni crittografiche sulle chiavi (encrypt, decrypt, wrap, unwrap, sign, verify) più la lettura della chiave nel suo ambito assegnato. La restrizione `--ops wrapKey unwrapKey` che hai impostato sulla chiave nel passaggio precedente restringe ulteriormente quali di queste operazioni possono avere successo su questa chiave, quindi in pratica Anthropic può solo eseguire wrap e unwrap. Dal Portale, apri la **chiave** (non il vault), seleziona la sua scheda **Access control (IAM)**, fai clic su **Add > Add role assignment**, seleziona **Key Vault Crypto User** e assegnalo all'entità servizio `anthropic-cmek-client-us`. **Alternativa con vault dedicato:** Microsoft consiglia un vault dedicato per applicazione con ruoli assegnati all'ambito del vault. Se esegui il provisioning di un vault che contiene solo questa chiave CMEK di Anthropic, puoi invece assegnare il ruolo all'ambito del vault e l'effetto è identico. Limita l'ambito alla singola chiave quando la chiave risiede in un vault condiviso. ![Assegnazioni di ruolo IAM di Key Vault che mostrano il ruolo Key Vault Crypto User assegnato ad anthropic-cmek-client-us.](https://platform.claude.com/docs/images/cmek/azure-role-assignment.png) ```bash az keyvault show --name \ --query "{rbac:properties.enableRbacAuthorization, purge:properties.enablePurgeProtection, pub:properties.publicNetworkAccess, net:properties.networkAcls.defaultAction, ipRules:properties.networkAcls.ipRules, uri:properties.vaultUri, tenantId:properties.tenantId}" ``` Conferma che: * `rbac` sia `true`. * `purge` sia `true`. Se è `false` o `null`, abilita la protezione dall'eliminazione definitiva sul vault prima di procedere. Senza di essa, una chiave eliminata temporaneamente può essere eliminata definitivamente durante la finestra di conservazione, rendendo irrecuperabili i tuoi dati protetti da CMEK. * `pub` sia `"Enabled"`. Se è `"Disabled"`, Anthropic non può raggiungere il vault tramite il suo endpoint pubblico del piano dati e la convalida fallisce. * `net` sia `"Allow"`, oppure, se è `"Deny"`, che `ipRules` includa gli intervalli di uscita di Anthropic (contatta Anthropic per l'elenco corrente). * `uri` sia l'URI del vault che usi quando registri la chiave. * `tenantId` sia il tenant che governa il vault. Usa questo valore come `tenant_id` quando registri la chiave, non il tenant della tua sottoscrizione attualmente attiva (i due possono differire nelle configurazioni cross-tenant). ## Registra la chiave con Anthropic Il modo in cui registri la chiave dipende dal prodotto che usi. Puoi configurare la chiave nella Claude Console o tramite l'Admin API, con lo stesso risultato. Nella Claude Console, vai alla pagina [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`). Se non vedi **Encryption keys**, seleziona **Organization** dal menu a discesa nella parte superiore della pagina. In **Encryption keys**, fai clic su **Add key**. Inserisci un nome visualizzato, scegli **Azure Key Vault** e fai clic su **Continue**. Compila **Vault URI**, **Key name** e **Tenant ID**, e fai clic su **Add**. Il passaggio dei dettagli della chiave mostra il tag dell'organizzazione. Aggiungilo alla chiave, come descrive [il passaggio di creazione](https://platform.claude.com/docs/it/manage-claude/cmek-azure-key-vault#organization-tag), prima di fare clic su **Add**. Nell'elenco **Encryption keys**, fai clic su **Verify** accanto alla chiave. Quando il controllo ha esito positivo appare **Connected**. Se non riesce, un messaggio ne indica il motivo. Nella Claude Console, vai alla pagina [Data retention](https://platform.claude.com/settings/privacy) (`platform.claude.com/settings/privacy`) e seleziona il workspace dal menu a discesa nella parte superiore della pagina. In **Encryption key**, seleziona la chiave, fai clic su **Save** e conferma. Il collegamento di una chiave non può essere annullato. Per un workspace che riceve già richieste, la chiave può richiedere [fino a un giorno per avere effetto](https://platform.claude.com/docs/it/manage-claude/cmek#how-it-works). Crea una configurazione di chiave esterna tramite l'Admin API. ```bash cURL curl -sS "https://api.anthropic.com/v1/organizations/external_keys" \ -H "x-api-key: $ANTHROPIC_API_KEY" \ -H "anthropic-version: 2023-06-01" \ -H "content-type: application/json" \ -d '{ "display_name": "", "geo": "us", "provider_config": { "type": "azure", "vault_uri": "https://.vault.azure.net/", "key_name": "", "tenant_id": "" } }' ``` ```bash CLI ant organization:external-keys create <<'YAML' display_name: "" geo: us provider_config: type: azure vault_uri: "https://.vault.azure.net/" key_name: "" tenant_id: "" YAML ``` ```python Python client = anthropic.Anthropic() external_key = client.organization.external_keys.create( display_name="", geo="us", provider_config={ "type": "azure", "vault_uri": "https://.vault.azure.net/", "key_name": "", "tenant_id": "", }, ) print(f"id: {external_key.id}") print(f"display_name: {external_key.display_name}") ``` ```typescript TypeScript const client = new Anthropic(); const externalKey = await client.organization.externalKeys.create({ display_name: "", geo: "us", provider_config: { type: "azure", vault_uri: "https://.vault.azure.net/", key_name: "", tenant_id: "" } }); console.log(`id: ${externalKey.id}`); console.log(`display_name: ${externalKey.display_name}`); ``` ```csharp C# using Anthropic.Models.Organization.ExternalKeys; AnthropicClient client = new(); var externalKey = await client.Organization.ExternalKeys.Create(new() { DisplayName = "", Geo = Geo.Us, ProviderConfig = new AzureExternalKeyConfigParam { VaultUri = "https://.vault.azure.net/", KeyName = "", TenantID = "" } }); Console.WriteLine($"id: {externalKey.ID}"); Console.WriteLine($"display_name: {externalKey.DisplayName}"); ``` ```go Go client := anthropic.NewClient() externalKey, err := client.Organization.ExternalKeys.New(context.Background(), anthropic.OrganizationExternalKeyNewParams{ DisplayName: anthropic.String(""), Geo: anthropic.OrganizationExternalKeyNewParamsGeoUs, ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{ OfAzure: &anthropic.AzureExternalKeyConfigParam{ VaultURI: "https://.vault.azure.net/", KeyName: "", TenantID: "", }, }, }) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", externalKey.ID) fmt.Printf("display_name: %s\n", externalKey.DisplayName) ``` ```java Java import com.anthropic.models.organization.externalkeys.AzureExternalKeyConfigParam; import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = ExternalKeyCreateParams.builder() .displayName("") .geo(ExternalKeyCreateParams.Geo.US) .providerConfig(AzureExternalKeyConfigParam.builder() .vaultUri("https://.vault.azure.net/") .keyName("") .tenantId("") .build()) .build(); var externalKey = client.organization().externalKeys().create(params); IO.println("id: " + externalKey.id()); IO.println("display_name: " + externalKey.displayName().orElseThrow()); } ``` ```php PHP use Anthropic\Organization\ExternalKeys\ExternalKeyCreateParams\Geo; // ... $client = new Client(); $externalKey = $client->organization->externalKeys->create( displayName: '', geo: Geo::US, providerConfig: [ 'type' => 'azure', 'vaultURI' => 'https://.vault.azure.net/', 'keyName' => '', 'tenantID' => '', ], ); echo "id: {$externalKey->id}\n"; echo "display_name: {$externalKey->displayName}\n"; ``` ```ruby Ruby client = Anthropic::Client.new external_key = client.organization.external_keys.create( display_name: "", geo: :us, provider_config: { type: :azure, vault_uri: "https://.vault.azure.net/", key_name: "", tenant_id: "" } ) puts "id: #{external_key.id}" puts "display_name: #{external_key.display_name}" ``` La risposta contiene l'ID della chiave esterna: ```json { "type": "external_key", "id": "ekey_", "display_name": "" } ``` Attiva un ciclo completo di crittografia e decrittografia sulla tua chiave. Questo conferma che Anthropic può autenticarsi al tuo tenant ed eseguire operazioni di wrap e unwrap. ```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 risposta riuscita appare così: ```json { "type": "external_key_validation", "status": "success", "error": null } ``` Se la convalida fallisce, il campo `error` descrive il problema. Le cause comuni sono: * **Ritardo di propagazione RBAC:** le assegnazioni di ruolo possono richiedere alcuni minuti per avere effetto. Attendi e riprova. * **ACL di rete che bloccano Anthropic:** conferma l'accesso alla rete pubblica e `ipRules` come descritto nel passaggio di verifica. * **Criteri di accesso condizionale sulle identità del carico di lavoro:** se il tuo tenant ha criteri di accesso condizionale che prendono di mira le entità servizio, escludi l'entità servizio di Anthropic o aggiungi gli intervalli di uscita di Anthropic alle posizioni denominate del criterio. Una volta convalidata la chiave, collegala a un nuovo workspace prima di inviare qualsiasi richiesta a quel workspace. Per un workspace che riceve già richieste, la chiave può richiedere [fino a un giorno per avere effetto](https://platform.claude.com/docs/it/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}" ``` In [claude.ai > Organization settings > Data and privacy](https://claude.ai/admin-settings/data-privacy-controls), apri **Encryption keys**, quindi fai clic su **Add key**. Scegli **Azure**, inserisci l'URI del vault, il nome della chiave e l'ID del tenant dal passaggio di verifica, e fai clic su **Continue**. Anthropic convalida la chiave con un ciclo completo di crittografia e decrittografia. Una volta che appare come verificata, la tua organizzazione è protetta da CMEK da quel momento in poi. Su Claude Enterprise, CMEK si applica all'intera organizzazione, quindi non c'è un passaggio separato di collegamento al workspace, e un'organizzazione può avere solo una chiave. ## Terraform Per le distribuzioni infrastructure-as-code, gli stessi passaggi corrispondono ai provider `azurerm` e `azuread`.