--- title: Configurare AWS KMS per CMEK url: https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms description: Usa AWS KMS 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 AWS KMS ``` Questa guida illustra la configurazione di una chiave [AWS KMS](https://aws.amazon.com/kms/) 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 KMS 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. **Claude Platform on AWS:** Su [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), la tua policy della chiave concede l'accesso a un principal di servizio AWS anziché al ruolo IAM di Anthropic, non c'è un passaggio di validazione separato, e registri e colleghi la chiave nella Claude Console. Segui [Configurare CMEK su Claude Platform on AWS](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#claude-platform-on-aws) in questa pagina anziché i passaggi nelle sezioni successive. ## Prerequisiti * Un account AWS con i permessi per creare chiavi KMS e impostare policy delle chiavi (`kms:CreateKey` e `kms:PutKeyPolicy`). * Una chiave Admin API per la tua organizzazione. * La [AWS CLI](https://aws.amazon.com/cli/) installata e autenticata. ## Amazon Resource Name (ARN) per Anthropic Per far sì che Anthropic utilizzi la tua chiave di crittografia, devi fornire al ruolo IAM di Anthropic una chiave KMS che possa usare per crittografare i dati. L'ARN per Anthropic CMEK è: ```text wrap arn:aws:iam::915198916910:role/anthropic-cmek-client-us ``` Usa solo questo ARN pubblicato. Non fidarti mai di un identificatore fornito via email, chat o qualsiasi canale di onboarding. ## Configurazione della chiave di crittografia **Claude Platform on AWS:** Salta questo passaggio. La tua policy della chiave concede l'accesso a un principal di servizio AWS e non ha una condizione di organizzazione. [Configurare CMEK su Claude Platform on AWS](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#claude-platform-on-aws) fornisce quella policy. La policy della chiave concede al ruolo IAM di Anthropic l'accesso cross-account. Sono richieste tre dichiarazioni: 1. **Admin root dell'account:** il pattern KMS standard. Il tuo account mantiene il pieno controllo amministrativo. 2. **Encrypt e decrypt di Anthropic:** le azioni `kms:Encrypt` e `kms:Decrypt`, che Anthropic usa per crittografare e decrittografare le chiavi dati che proteggono i dati del tuo workspace (crittografia envelope). 3. **Describe di Anthropic:** la lettura dei metadati che Anthropic esegue all'avvio. Viene concessa separatamente perché `DescribeKey` non ha un parametro `EncryptionContext`, quindi una condizione `EncryptionContext` su questa azione negherebbe sempre. Per trovare [l'ID del tuo account AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/console-account-id.html), esegui `aws sts get-caller-identity --query Account --output text`. Nella policy, sostituisci `` con l'ID del tuo account AWS e `` con l'ID della tua organizzazione. La condizione `StringEquals` su `kms:EncryptionContext:anthropic:org_uuid` vincola la chiave alla tua organizzazione Anthropic, e la validazione rifiuta una chiave senza di essa. Per condividere una chiave tra più organizzazioni Anthropic, elenca l'ID di ciascuna organizzazione nel valore della condizione. **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_`. Salva la policy come `key-policy.json`. Per creare invece la chiave nella AWS Console, incolla lì la policy, come descritto più avanti in questo passaggio. ```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": "*" } ] } ``` **Opzionale:** Per limitare la chiave ad alcuni dei tuoi workspace, usa questa dichiarazione `AllowAnthropicCMEKCrypto` anziché quella nel JSON della policy precedente, con un ID di compartimento per ciascun workspace. Aggiungi l'ID di compartimento di un workspace prima di collegare la chiave ad esso. Per un nuovo workspace, crealo senza la chiave, aggiungi il suo ID di compartimento, e poi collega la chiave. ```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 ``` Cattura `KeyMetadata.Arn` dall'output. Ne hai bisogno quando registri la chiave nel passaggio successivo. Se la chiave è già configurata per CMEK e protegge dati esistenti, devi aggiungere una dichiarazione che consenta ad Anthropic di decrittografare quei dati, oltre alle tre dichiarazioni nella policy precedente. Nella sua condizione, elenca l'ID di compartimento di ogni workspace a cui la chiave è o era collegata. ```json { "Sid": "AllowAnthropicCMEKDecryptExistingData", "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::915198916910:role/anthropic-cmek-client-us" }, "Action": "kms:Decrypt", "Resource": "*", "Condition": { "StringEquals": { "kms:EncryptionContext:anthropic:compartment_uuid": [""] } } } ``` Anthropic valida la chiave quando la verifichi o la colleghi a un workspace. Ogni validazione aggiunge quattro errori di accesso negato a CloudTrail. Questi sono previsti. Se hai bisogno di filtrarli, filtra su tutti e tre i seguenti valori. Il primo da solo non è sufficiente, perché qualsiasi chiamante può impostarlo: * `requestParameters.encryptionContext.associatedData`: `Y21lay12YWxpZGF0aW9u` * `userIdentity.accountId`: `915198916910` * `resources.ARN`: `arn:aws:kms:::key/` **Trovare l'ID del tuo compartimento:** Vedi la scheda **Claude Platform** sotto **Registra la chiave con Anthropic**. Puoi anche creare la chiave dalla AWS Console. Scegli una chiave simmetrica con l'uso chiave encrypt e decrypt, una chiave a regione singola, e origine del materiale della chiave KMS. La procedura guidata Create-key conferma una policy della chiave al suo passaggio **Review**: Se aggiungi l'ID account di Anthropic `915198916910` sotto i permessi di uso della chiave lì, la policy generata concede all'intero account Anthropic azioni più ampie (come `kms:ReEncrypt*` e `kms:GenerateDataKey*`) senza una condizione `EncryptionContext`, e la validazione la rifiuta. Per evitare di lasciare una chiave con permessi eccessivi, completa la procedura guidata con i soli permessi amministrativi, poi apri la scheda **Key policy** della chiave e sostituisci il JSON con la policy `key-policy.json` mostrata in precedenza in questo passaggio. ![Procedura guidata Create key di AWS KMS al passaggio Configure key, con il tipo di chiave simmetrica, l'uso chiave encrypt e decrypt e la chiave a regione singola selezionati.](https://platform.claude.com/docs/images/cmek/aws-configure-key.png) ![Passaggio Add labels di AWS KMS con l'alias anthropic-cmek e la descrizione Anthropic CMEK.](https://platform.claude.com/docs/images/cmek/aws-add-labels.png) ![Passaggio Define key administrative permissions di AWS KMS con l'elenco dei ruoli IAM che possono amministrare la chiave.](https://platform.claude.com/docs/images/cmek/aws-admin-permissions.png) ![Passaggio Define key usage permissions di AWS KMS con l'ID account di Anthropic inserito sotto Other AWS accounts.](https://platform.claude.com/docs/images/cmek/aws-usage-permissions.png) ## Registra la chiave con Anthropic Il modo in cui registri la chiave dipende dal prodotto che usi. **Claude Platform on AWS:** Il principal, la policy della chiave e il flusso di registrazione differiscono, e non c'è un passaggio di validazione separato. Segui [Configurare CMEK su Claude Platform on AWS](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#claude-platform-on-aws) anziché questa scheda. **Trovare l'ID di compartimento:** Ogni workspace ha un ID di compartimento che delimita i suoi dati CMEK. Per trovarlo 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. L'ID si trova in **Encryption key**, nel campo **Compartment ID**. Puoi anche leggere il campo `compartment_id` restituito dall'endpoint [Get Workspace](https://platform.claude.com/docs/it/api/organization/workspaces/retrieve). 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 **AWS KMS** e fai clic su **Continue**. Incolla l'ARN della chiave in **KMS key ARN** e fai clic su **Add**. Il passaggio dei dettagli della chiave mostra l'ID della tua organizzazione. Aggiungilo alla [policy della chiave](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#key-policy) prima di cliccare **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ò impiegare [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": "aws", "kms_arn": "" } }' ``` ```bash CLI ant organization:external-keys create <<'YAML' display_name: "" geo: us provider_config: type: aws kms_arn: "" YAML ``` ```python Python client = anthropic.Anthropic() external_key = client.organization.external_keys.create( display_name="", geo="us", provider_config={"type": "aws", "kms_arn": ""}, ) print(f"id: {external_key.id}") print(f"display_name: {external_key.display_name}") ``` ```typescript TypeScript const client = new Anthropic(); const externalKey = await client.organization.externalKeys.create({ display_name: "", geo: "us", provider_config: { type: "aws", kms_arn: "" } }); console.log(`id: ${externalKey.id}`); console.log(`display_name: ${externalKey.display_name}`); ``` ```csharp C# using Anthropic.Models.Organization.ExternalKeys; AnthropicClient client = new(); var externalKey = await client.Organization.ExternalKeys.Create(new() { DisplayName = "", Geo = Geo.Us, ProviderConfig = new AwsExternalKeyConfig { KmsArn = "" } }); Console.WriteLine($"id: {externalKey.ID}"); Console.WriteLine($"display_name: {externalKey.DisplayName}"); ``` ```go Go client := anthropic.NewClient() externalKey, err := client.Organization.ExternalKeys.New(context.Background(), anthropic.OrganizationExternalKeyNewParams{ DisplayName: anthropic.String(""), Geo: anthropic.OrganizationExternalKeyNewParamsGeoUs, ProviderConfig: anthropic.OrganizationExternalKeyNewParamsProviderConfigUnion{ OfAWS: &anthropic.AWSExternalKeyConfigParam{ KMSARN: "", }, }, }) if err != nil { log.Fatal(err) } fmt.Printf("id: %s\n", externalKey.ID) fmt.Printf("display_name: %s\n", externalKey.DisplayName) ``` ```java Java import com.anthropic.models.organization.externalkeys.AwsExternalKeyConfig; import com.anthropic.models.organization.externalkeys.ExternalKeyCreateParams; void main() { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); var params = ExternalKeyCreateParams.builder() .displayName("") .geo(ExternalKeyCreateParams.Geo.US) .providerConfig(AwsExternalKeyConfig.builder() .kmsArn("") .build()) .build(); var externalKey = client.organization().externalKeys().create(params); IO.println("id: " + externalKey.id()); IO.println("display_name: " + externalKey.displayName().orElseThrow()); } ``` ```php PHP use Anthropic\Organization\ExternalKeys\ExternalKeyCreateParams\Geo; // ... $client = new Client(); $externalKey = $client->organization->externalKeys->create( displayName: '', geo: Geo::US, providerConfig: [ 'type' => 'aws', 'kmsARN' => '', ], ); echo "id: {$externalKey->id}\n"; echo "display_name: {$externalKey->displayName}\n"; ``` ```ruby Ruby client = Anthropic::Client.new external_key = client.organization.external_keys.create( display_name: "", geo: :us, provider_config: { type: :aws, kms_arn: "" } ) puts "id: #{external_key.id}" puts "display_name: #{external_key.display_name}" ``` La risposta contiene l'ID della chiave esterna: ```json { "type": "external_key", "id": "ekey_", "display_name": "" } ``` Attiva un round-trip di encrypt e decrypt sulla tua chiave. ```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}" ``` Una risposta riuscita appare così: ```json { "type": "external_key_validation", "status": "success", "error": null } ``` Se la validazione fallisce, le cause comuni sono: * **Mancata corrispondenza del contesto di crittografia:** Se la policy ha una condizione `kms:EncryptionContext:anthropic:compartment_uuid`, assicurati che elenchi l'ID di compartimento di ogni workspace a cui la chiave è collegata. La validazione invia l'ID di compartimento del workspace che controlla. Una chiave più vecchia la cui dichiarazione di compartimento consente ancora `kms:Encrypt` viene validata con il valore tutto zeri (`00000000-0000-0000-0000-000000000000`) mentre non è collegata, quindi mantieni quel valore nel suo elenco. * **Resource control policy (RCP):** Se la tua organizzazione AWS ha una RCP che nega le operazioni KMS quando `aws:PrincipalOrgID` non corrisponde alla tua org, blocca il ruolo cross-account di Anthropic. La RCP necessita di un'eccezione per questa chiave o per l'ARN del ruolo di Anthropic. Le service control policy non si applicano qui, perché non vengono valutate per i principal esterni che chiamano tramite policy basate sulle risorse. * **Accesso concesso tramite IAM anziché la policy della chiave:** L'accesso KMS cross-account deve essere concesso nella policy della chiave stessa, non tramite una policy IAM nel tuo account. Controlla con `aws kms get-key-policy --key-id --policy-name default`. * **Mancata corrispondenza della regione:** Conferma che la regione della chiave sia una in cui Anthropic opera per il geo tier che hai configurato. Una volta validata 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ò impiegare [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_id = "" workspace = client.organization.workspaces.update( workspace_id, 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**, poi clicca **Add key**. Scegli **AWS** e clicca **Continue**, poi incolla l'ARN della chiave dal passaggio precedente e clicca **Add**. Anthropic valida la chiave con un round-trip di encrypt e decrypt. Una volta che appare come verificata, la tua organizzazione è protetta da CMEK da quel momento in poi. Il passaggio dei dettagli della chiave di questo flusso mostra il tuo **Organization ID for the key policy** con un pulsante di copia. Sostituisci quel valore per `` nella policy della chiave. Puoi aprire il flusso per copiare l'ID prima di creare la chiave. Su Claude Enterprise, CMEK si applica all'intera organizzazione, quindi non c'è un passaggio di collegamento al workspace separato, e un'organizzazione può avere solo una chiave. ## Configurare CMEK su Claude Platform on AWS Su [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws), CMEK usa solo chiavi AWS KMS, e la configurazione differisce dalle sezioni precedenti in questi modi: * **Principal:** La tua policy della chiave concede l'accesso al principal di servizio AWS `aws-external-anthropic.amazonaws.com`. Il ruolo IAM e l'ID account di Anthropic non vengono usati, quindi l'[ARN per Anthropic](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#amazon-resource-name-arn-for-anthropic) non si applica. * **Requisiti della chiave:** La chiave deve essere una chiave KMS simmetrica con uso encrypt e decrypt, a regione singola, e nello stesso account e regione AWS del workspace a cui la colleghi. Le chiavi cross-account non sono supportate: la chiave deve essere nell'account AWS che ospita la tua organizzazione. Le chiavi multi-regione (ID chiave che iniziano con `mrk-`) e gli ARN di alias vengono rifiutati quando registri la chiave; usa l'ARN della chiave. * **Nessun passaggio di validazione separato:** A parte quei controlli sull'ARN della chiave alla registrazione, la chiave viene validata quando la colleghi a un workspace. La chiamata di collegamento esegue un round di encrypt/decrypt sulla chiave con l'ID di compartimento di quel workspace come contesto di crittografia, quindi un problema della policy della chiave emerge al momento del collegamento anziché alla registrazione. Una condizione `EncryptionContext` quindi non necessita di una voce tutto zeri. * **Dove gestisci le chiavi:** Registra e collega le chiavi nella Claude Console, autenticato tramite AWS con il ruolo Admin. Gli endpoint delle chiavi esterne sono disponibili anche su Claude Platform on AWS, autorizzati tramite [azioni IAM](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#encryption-keys); lì, una chiave è identificata dal suo ARN della chiave KMS anziché da un ID `ekey_`. Usa solo questo nome di principal di servizio pubblicato. Non fidarti mai di un identificatore fornito via email, chat o qualsiasi canale di onboarding. ### Prerequisiti * L'account AWS che ospita la tua organizzazione Claude Platform on AWS, con i permessi per creare chiavi KMS e impostare policy delle chiavi (`kms:CreateKey` e `kms:PutKeyPolicy`). * Il ruolo **Admin** nella Claude Console per Claude Platform on AWS. Vedi [Usare la Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console). * Per il principal IAM con cui accedi alla Claude Console: oltre a `aws-external-anthropic:AssumeConsole`, le [azioni IAM](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#encryption-keys) per le operazioni che esegui lì, perché la registrazione, l'elenco e il collegamento delle chiavi passano attraverso il gateway AWS. La registrazione di una chiave corrisponde a `RegisterKey` (con `ListKeys` e `GetKey` per visualizzare le registrazioni) e il collegamento corrisponde a `UpdateWorkspace` o `CreateWorkspace`. Le azioni sulle chiavi esterne (e `CreateWorkspace`) hanno ambito a livello di account, quindi concedile su `Resource: "*"`; una policy limitata agli ARN dei workspace non le include. * Per il principal IAM che collega la chiave a un workspace (l'identità con cui hai effettuato l'accesso alla Claude Console): `kms:DescribeKey`, `kms:Encrypt`, e `kms:Decrypt` sulla chiave. L'accesso del tuo principal alla chiave viene controllato quando la colleghi, oltre a quello del principal di servizio. * Opzionale, per il selettore di chiavi nella Claude Console: `kms:ListKeys` e `kms:DescribeKey` per il principal con cui accedi. Senza di essi, incolla invece l'ARN della chiave. ### Crea la chiave KMS La policy della chiave ha tre dichiarazioni: la dichiarazione di amministrazione root del tuo account; una dichiarazione che consente al principal di servizio di Claude Platform on AWS di crittografare, decrittografare e generare chiavi dati; e una dichiarazione separata per `kms:DescribeKey`. La dichiarazione crittografica include una condizione `EncryptionContext` opzionale che vincola la chiave ai workspace che elenchi. `DescribeKey` viene concessa separatamente perché non ha un parametro `EncryptionContext`, quindi una condizione `EncryptionContext` su quell'azione negherebbe sempre l'accesso. Se prevedi di usare la condizione `EncryptionContext` facoltativa mostrata qui, crea prima il workspace (senza chiave), copia il suo ID di compartimento e sostituiscilo a ``. Per trovare l'ID 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. L'ID si trova in **Encryption key**, nel campo **Compartment ID**. Puoi anche leggerlo dal campo `compartment_id` restituito dall'endpoint [Get Workspace](https://platform.claude.com/docs/it/api/organization/workspaces/retrieve). Se non prevedi di usare la condizione, elimina il blocco `Condition` da quella dichiarazione. ```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\": \"*\" } ] }" ``` Cattura `KeyMetadata.Arn` dall'output. Ne hai bisogno quando registri la chiave. La condizione `EncryptionContext` è opzionale. Ogni chiamata di crittografia, decrittografia e chiave dati effettuata per un workspace, incluso il controllo al momento del collegamento, include l'ID di compartimento di quel workspace come `anthropic:compartment_uuid`, quindi la condizione elenca l'ID di compartimento di ogni workspace a cui colleghi la chiave e non necessita di alcuna voce di soli zeri. Aggiungerla vincola la chiave ai workspace che elenchi anche a livello IAM. Poiché un ID di compartimento esiste solo dopo che il relativo workspace esiste, l'ordine è: crea il workspace, inserisci il suo ID di compartimento nella condizione (alla creazione della chiave, o successivamente con `kms:PutKeyPolicy`), quindi collega la chiave. Prima di collegare la chiave a ogni workspace aggiuntivo, aggiungi l'ID di compartimento di quel workspace nello stesso modo. Per iniziare senza di essa, elimina il blocco `Condition` dalla dichiarazione `AllowClaudePlatformOnAWSCrypto`; se la aggiungi in seguito, includi l'ID di compartimento di ogni workspace a cui la chiave è già collegata. Puoi limitare ulteriormente entrambe le dichiarazioni del principal di servizio con una condizione `aws:SourceArn`. Il servizio passa l'[ARN del workspace](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#service-details) (`arn:aws:aws-external-anthropic:::workspace/`) come ARN di origine in ogni chiamata che effettua con la tua chiave, quindi `"ArnLike": {"aws:SourceArn": "arn:aws:aws-external-anthropic:*::workspace/*"}` limita la concessione ai workspace nel tuo account AWS, e un elenco di ARN completi dei workspace la limita a quei workspace. Questa condizione non è obbligatoria; la condizione `EncryptionContext` da sola vincola la chiave ai workspace che elenchi. Puoi anche creare la chiave dalla AWS Console: scegli una chiave simmetrica con l'uso chiave encrypt e decrypt, una chiave a regione singola, e origine del materiale della chiave KMS, nella regione del workspace. Lascia vuoti i permessi di uso della chiave nella procedura guidata Create-key, poi apri la scheda **Key policy** della chiave e sostituisci il JSON con la policy mostrata qui. ### Registra e collega la chiave 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, quindi scegli la chiave dal selettore di chiavi oppure scegli **Enter ARN manually** e incolla l'ARN della chiave, e fai clic su **Add**. La chiave deve trovarsi nell'account AWS che ospita la tua organizzazione; le chiavi cross-account non sono supportate. Il selettore elenca le chiavi abilitate, gestite dal cliente, simmetriche e a regione singola presenti nel tuo account in una delle regioni della tua organizzazione; per una chiave che il selettore non elenca, inserisci l'ARN. Elenca le chiavi solo se il principal con cui hai effettuato l'accesso può chiamare `kms:ListKeys` e `kms:DescribeKey`. Collega la chiave a un nuovo workspace prima di inviare qualsiasi richiesta a quel workspace. Per un workspace che riceve già richieste, la chiave può impiegare [fino a un giorno per diventare effettiva](https://platform.claude.com/docs/it/manage-claude/cmek#how-it-works). 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. Puoi anche selezionare una chiave quando crei un workspace nella Claude Console, ma solo se la tua policy della chiave non nomina ancora workspace specifici (nessuna condizione `EncryptionContext`), perché l'ID di compartimento del workspace viene assegnato alla creazione. Una volta collegata, la chiave di un workspace non può essere modificata. Questo è il momento in cui la chiave viene validata: la chiamata di collegamento controlla l'accesso del tuo principal alla chiave ed esegue un round di encrypt/decrypt su di essa con l'ID di compartimento del workspace come contesto di crittografia, quindi un problema con la policy della chiave o con i permessi del tuo principal emerge come errore su quella chiamata. Se il collegamento fallisce con un errore di accesso KMS, controlla quanto segue: * La policy della chiave nomina il principal di servizio `aws-external-anthropic.amazonaws.com` e concede `kms:Encrypt`, `kms:Decrypt`, e `kms:GenerateDataKey`, più `kms:DescribeKey` in una dichiarazione separata che non ha una condizione `EncryptionContext`. * Qualsiasi condizione `EncryptionContext` include l'ID di compartimento di questo workspace, e qualsiasi condizione `aws:SourceArn` che hai aggiunto corrisponde all'ARN di questo workspace. * La chiave è abilitata, a regione singola, e nello stesso account e regione AWS del workspace. * Il principal con cui hai effettuato l'accesso ha `kms:DescribeKey`, `kms:Encrypt`, e `kms:Decrypt` sulla chiave. * Nessuna service control policy o resource control policy nella tua organizzazione AWS impedisce al principal di servizio o al tuo principal di usare la chiave. * Se la policy sembra corretta e il collegamento continua a non riuscire, trova l'evento `kms:` negato in CloudTrail nell'account della chiave (mostra il principal chiamante e, per le chiamate crittografiche, il contesto di crittografia), quindi correggi la condizione con `kms:PutKeyPolicy` e riprova. ## Terraform Per i deployment infrastructure-as-code, gli stessi passaggi si mappano al provider `aws` con le risorse `aws_kms_key` e `aws_kms_alias`.