---
title: Claude Platform su AWS
url: https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws
description: Accedi a tutte le funzionalità della piattaforma Claude tramite AWS, con un'infrastruttura gestita da Anthropic.
---
Claude Platform on AWS ti offre l'esperienza completa della piattaforma Anthropic, inclusi la Messages API, le Agent Skills, l'esecuzione di codice e le funzionalità beta, accessibile tramite il tuo account AWS. A differenza di [Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock), dove è AWS a gestire lo stack di inferenza, Claude Platform on AWS è gestita da Anthropic. AWS fornisce il livello di autenticazione (SigV4 o chiave API), il controllo degli accessi basato su IAM e l'integrazione della fatturazione tramite AWS Marketplace.
Gli SDK di Anthropic supportano Claude Platform on AWS.
## Come funziona l'integrazione della piattaforma
I modelli Claude vengono eseguiti su un'infrastruttura gestita da Anthropic. Si tratta di un'integrazione commerciale per la fatturazione e l'accesso tramite AWS. Anthropic è il responsabile del trattamento dei dati per gli input e gli output dell'inferenza. AWS tratta i metadati di fatturazione e di identità secondo il modello del marketplace. I clienti che usano Claude tramite Claude Platform on AWS sono soggetti ai [termini di utilizzo dei dati](https://www.anthropic.com/legal) di Anthropic.
Anthropic usa l'infrastruttura AWS per elaborare le tue richieste API, eseguire l'inferenza dei modelli e archiviare i contenuti del tuo workspace (come prompt, output, file, Skills e batch). Per i workspace creati prima del 18 settembre 2026, 00:00 UTC, Anthropic potrebbe elaborare le richieste, archiviare i dati ed eseguire l'inferenza al di fuori di AWS. In entrambi i casi, i sottoservizi potrebbero cambiare senza preavviso. Imposta il parametro [`inference_geo`](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#data-residency) per ogni richiesta per vincolare l'inferenza a un'area geografica specifica.
Claude Platform on AWS segue la stessa politica di conservazione dei dati della Claude API di prima parte. La "Zero Data Retention" (conservazione zero dei dati), o ZDR, è disponibile su richiesta. Contatta il tuo referente Anthropic per abilitarla per la tua organizzazione.
## Claude Platform on AWS a confronto con Amazon Bedrock
Entrambe le offerte ti consentono di utilizzare Claude tramite AWS, ma differiscono per architettura, superficie API e disponibilità delle funzionalità.
| Aspetto | Claude Platform on AWS | [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock) | [Amazon Bedrock (Opus 4.6 e precedenti)](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy) |
| ------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- |
| **Chi gestisce lo stack** | Anthropic | AWS | AWS |
| **Superficie API** | Claude API (`/v1/{endpoint}`) | Messages API su `/anthropic/v1/messages` | Bedrock Converse / InvokeModel |
| **Disponibilità delle funzionalità** | In genere lo stesso giorno della Claude API (vedi [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported)) | Secondo il calendario di rilascio di Amazon Bedrock | Secondo il calendario di rilascio di Amazon Bedrock |
| **Agent Skills** | Disponibili | Non disponibili (richiedono l'esecuzione di codice) | Non disponibili |
| **Funzionalità beta** | Inoltrate con gli header `anthropic-beta` (vedi [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported)) | Le funzionalità beta supportate da Amazon Bedrock, tramite l'header `anthropic-beta` | Le funzionalità beta supportate da Amazon Bedrock, tramite il campo `anthropic_beta` del corpo della richiesta InvokeModel |
| **Autenticazione** | AWS IAM / SigV4 o chiave API | AWS IAM / SigV4 | AWS IAM / SigV4 o bearer token |
| **Fatturazione** | AWS Marketplace | AWS (servizio nativo) | AWS (servizio nativo) |
| **URL di base** | `aws-external-anthropic.{region}.api.aws` | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` |
| **Client SDK** | `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), in beta | `AnthropicBedrockMantle` | `AnthropicBedrock` / Bedrock SDK |
| **Console** | Claude Console (`platform.claude.com`, accesso tramite la AWS Console) | Bedrock Console | Bedrock Console |
| **"Rate limit" (limiti di velocità) e quote** | Gestiti da Anthropic | Gestiti da AWS | Gestiti da AWS |
| **Responsabile del trattamento dei dati di inferenza** | Anthropic | AWS | AWS |
Se hai bisogno di Claude gestito da AWS, consulta [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock). Claude Platform on AWS utilizza un pool di capacità separato sia dalla Claude API di prima parte sia da Amazon Bedrock. Puoi eseguire carichi di lavoro su più di una piattaforma ed effettuare il failover tra di esse.
[AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) è supportato per collegare il tuo VPC all'endpoint di Claude Platform on AWS.
**Quando scegliere Bedrock:** le organizzazioni in settori regolamentati che richiedono la conformità FedRAMP High, IL4, IL5 o HIPAA, o che necessitano che AWS sia l'unico responsabile del trattamento dei dati, dovrebbero utilizzare [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock). Bedrock viene eseguito interamente su un'infrastruttura controllata da AWS, con AWS come parte che lo gestisce.
**Quale offerta stai utilizzando?** Claude è disponibile tramite diversi prodotti distinti:
* **Claude Platform on AWS** (questa pagina): la piattaforma Claude API fatturata tramite AWS Marketplace. Gestita nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console) e nella AWS Console.
* **[Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock):** un servizio nativo AWS. Gestito nella console di Amazon Bedrock e fatturato come utilizzo di servizi AWS.
* **Claude Enterprise acquistato tramite AWS Marketplace:** un piano [claude.ai](https://claude.ai) (il prodotto di chat Claude), non una piattaforma API. Gestito su claude.ai, e il comportamento del suo account e della migrazione differisce da quanto descritto in questa pagina. Consulta il [Centro assistenza Claude](https://support.claude.com).
* **Account Anthropic diretti:** la Claude API di prima parte e i piani claude.ai fatturati da Anthropic. Gestiti nella Claude Console e su claude.ai.
## Configura il tuo account
La configurazione di Claude Platform on AWS avviene in quattro fasi: registrati nella pagina del servizio della AWS Console, completa la configurazione della tua organizzazione Anthropic, annota l'ID del tuo workspace e accedi alla Claude Console.
La registrazione tramite la AWS Console crea una nuova organizzazione Anthropic collegata al tuo account AWS. Questa organizzazione è separata da qualsiasi organizzazione esistente che la tua azienda ha con Anthropic, incluse le organizzazioni Claude Enterprise acquistate tramite AWS Marketplace. Le chiavi API, i workspace e le impostazioni della Claude Console di un'organizzazione Anthropic di prima parte non vengono trasferiti.
Se hai un'offerta privata esistente per Amazon Bedrock, contatta il tuo referente Anthropic o AWS prima di registrarti, in modo che lo sconto si applichi fin dalla tua prima richiesta. Gli sconti non possono essere applicati retroattivamente all'utilizzo sostenuto prima dell'accettazione della tua offerta privata. Consulta [Offerte private](https://platform.claude.com/docs/it/about-claude/pricing#private-offers).
1. Apri la [AWS Console](https://console.aws.amazon.com/) e vai alla pagina del servizio **Claude Platform on AWS**.
2. Scegli **Sign up**.
3. Nella pagina di registrazione, esamina i termini (il Contratto di licenza con l'utente finale di Anthropic, l'Informativa sulla privacy di AWS e il Contratto cliente AWS) e seleziona la casella di accettazione.
4. Scegli **Continue**.
La pagina mostra un banner **Sign-up in progress**. Rimani sulla pagina. La registrazione richiede alcuni minuti, durante i quali AWS gestisce per te l'abbonamento ad AWS Marketplace, quindi ti reindirizza automaticamente.
Se la tua organizzazione ha un'offerta privata da Anthropic, la Console la individua e ti chiede di accettarla in AWS Marketplace. Consulta [Offerte private](https://platform.claude.com/docs/it/about-claude/pricing#private-offers) per i dettagli.
Quando usi Claude Platform on AWS, Anthropic elabora e archivia i tuoi contenuti (come prompt e output) sull'infrastruttura AWS. Per i workspace creati prima del 18 settembre 2026, 00:00 UTC, Anthropic potrebbe elaborare e archiviare tali contenuti al di fuori di AWS. Le [politiche di utilizzo dei dati](https://www.anthropic.com/legal) di Anthropic descrivono come vengono elaborati e archiviati i contenuti e i metadati.
Al termine della registrazione, vieni reindirizzato a `platform.claude.com/partner-signup`.
1. Inserisci l'indirizzo email del proprietario della tua organizzazione e scegli **Get started**.
2. Controlla la casella di posta di quell'indirizzo per trovare un link di configurazione e seguilo. Se il browser mostra una pagina **Signed in as a different account**, scegli **Log out and continue**.
3. Compila il modulo con i dettagli dell'organizzazione (nome dell'organizzazione, tipo di entità, paese, uso previsto) e scegli **Complete setup**.
Il completamento della configurazione crea la tua organizzazione Anthropic e accetta i Termini di servizio commerciali e la Politica di utilizzo di Anthropic. La pagina del servizio nella AWS Console ora mostra una navigazione a sinistra con **Home**, **API keys**, **Quickstart** e **Workspaces**.
Dopo aver completato la configurazione, la AWS Console ti chiede di creare un workspace. Consulta [Workspace](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#workspaces) per i dettagli sul vincolo alla regione, sull'ambito delle risorse IAM e sulla creazione di workspace aggiuntivi.
Trova l'ID del workspace in **Workspaces** nella pagina del servizio **Claude Platform on AWS** della AWS Console oppure nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console). Gli ID dei workspace usano il formato `wrkspc_` seguito da un identificatore alfanumerico.
L'accesso alla Claude Console è federato tramite AWS IAM:
1. Assumi un ruolo IAM con l'autorizzazione `aws-external-anthropic:AssumeConsole`. Consulta [Azioni IAM per Claude Platform on AWS](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#console-access).
2. Dalla pagina del servizio **Claude Platform on AWS**, scegli **Open Claude Console**. La AWS Console emette un JWT e ti reindirizza a `platform.claude.com`.
3. Al primo accesso, ti viene richiesto un indirizzo email. Inserisci la tua email di lavoro. La piattaforma crea il tuo utente della Claude Console al momento (just-in-time).
Quando accedi tramite la AWS Console, la Claude Console è limitata alla tua organizzazione Claude Platform on AWS. Un indicatore **Account managed by AWS** appare in basso a sinistra nella barra laterale della Claude Console.
### Passaggio da un'organizzazione Anthropic esistente
La registrazione a Claude Platform on AWS crea sempre una nuova organizzazione Anthropic collegata al tuo account AWS. Non esiste una conversione sul posto: un'organizzazione esistente, come un'organizzazione della Claude API di prima parte, non può diventare un'organizzazione Claude Platform on AWS.
Pianifica il passaggio da un'organizzazione esistente come una migrazione verso una nuova organizzazione:
* **Crea prima la nuova organizzazione.** Registrati tramite la AWS Console (vedi [Configura il tuo account](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#set-up-your-account)). Se il passaggio prevede un'offerta privata, completa la registrazione prima che l'offerta venga accettata: gli sconti si applicano dal momento dell'accettazione, non retroattivamente. Consulta [Offerte private](https://platform.claude.com/docs/it/about-claude/pricing#private-offers).
* **Ricrea accessi e configurazione.** Le chiavi API, i workspace e le impostazioni della Claude Console non vengono trasferiti da un'organizzazione esistente. Crea i workspace nella nuova organizzazione e passa le tue applicazioni all'[autenticazione di Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#authentication).
* **Aggiorna la tua integrazione.** Claude Platform on AWS serve la Claude API (`/v1/{endpoint}`), quindi la struttura di richieste e risposte è invariata rispetto alla Claude API di prima parte. Cambiano l'URL di base, il metodo di autenticazione e l'header `anthropic-workspace-id` sulle richieste di inferenza e sulle risorse; consulta [Effettuare richieste](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#making-requests). Alcune funzionalità della piattaforma differiscono; consulta [Funzionalità non supportate](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Effettua la migrazione secondo i tuoi tempi.** La nuova organizzazione è indipendente da quella esistente ed entrambe possono servire traffico in parallelo. Non è necessaria una migrazione netta: sposta gradualmente i carichi di lavoro finché tutto il tuo traffico non si trova sulla nuova organizzazione.
Una volta che la nuova organizzazione è operativa, le differenze si concentrano su fatturazione e autenticazione, gestite tramite AWS:
* **La fatturazione** passa ad AWS Marketplace: l'utilizzo viene fatturato in Claude Consumption Units anziché in crediti prepagati (vedi [Fatturazione](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#billing)) e i limiti di spesa si impostano nella pagina Billing (vedi [Limiti di spesa](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#spend-limits)). Durante la transizione, la fatturazione rimane separata: l'organizzazione esistente continua a essere fatturata come avviene oggi.
* **Autenticazione e accesso** passano ad AWS: le richieste si autenticano con credenziali AWS o con chiavi API generate nella AWS Console, non nella Claude Console (vedi [Autenticazione](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#authentication)). L'appartenenza all'organizzazione è gestita tramite AWS IAM anziché tramite la Claude Console (vedi [Pagine disponibili](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#available-pages)) e gli SDK client di Anthropic forniscono classi client specifiche per la piattaforma (vedi [Installa un SDK](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#install-an-sdk)).
* **L'uso quotidiano dell'API** funziona come sulla Claude API di prima parte, salvo quanto indicato nelle [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported). Prima di spostare il traffico di produzione, controlla i tuoi limiti di velocità: le nuove organizzazioni vengono assegnate al livello Start e gli aumenti dei limiti passano attraverso il tuo referente Anthropic (vedi [Limiti di velocità e quote](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Per le organizzazioni Claude Enterprise (claude.ai), che si comportano in modo diverso, consulta il [confronto tra le offerte](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock).
### Risoluzione dei problemi di configurazione dell'account
* **"Sign-up failed: Failed to enable OutboundWebIdentityFederation":** se vedi questo banner al primo invio, scegli di nuovo **Continue**. L'abilitazione IAM può richiedere qualche istante per diventare effettiva.
* **Nessun indicatore di avanzamento durante la registrazione:** la registrazione richiede alcuni minuti. La pagina mostra un banner statico **Sign-up in progress** senza barra di avanzamento mentre AWS crea il tuo account.
* **"Signed in as a different account" dopo aver seguito il link di configurazione:** scegli **Log out and continue**. La pagina ti autentica di nuovo con l'indirizzo email che hai inserito.
* **Messaggio "Not found" durante l'accesso:** questo messaggio potrebbe apparire brevemente durante il reindirizzamento. Puoi ignorarlo.
* **La pagina Usage non mostra dati dopo la tua prima chiamata API:** i dati di utilizzo possono richiedere alcuni minuti per apparire nella Claude Console.
* **"Outbound web identity federation is disabled" alla tua prima chiamata API:** abilita la federazione una volta per account. Consulta [Abilita la federazione delle identità web in uscita](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation).
## Prima di effettuare chiamate API
Assicurati di avere:
1. Un account AWS attivo con un abbonamento a Claude Platform on AWS (vedi [Configura il tuo account](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#set-up-your-account))
2. La [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) installata e configurata
3. **La federazione delle identità web in uscita abilitata** sul tuo account AWS, un passaggio di configurazione da eseguire una sola volta (vedi [Abilita la federazione delle identità web in uscita](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation))
4. L'ID del tuo workspace (vedi [Ottieni l'ID del tuo workspace](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id))
5. L'autorizzazione IAM per chiamare l'API: l'azione `aws-external-anthropic:CreateInference` sul tuo workspace, più `aws-external-anthropic:CallWithBearerToken` se ti autentichi con una chiave API (vedi [Policy IAM](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#iam-policies))
### Abilita la federazione delle identità web in uscita
Il gateway di Claude Platform on AWS chiama `sts:GetWebIdentityToken` lato server per generare un JWT che inoltra ad Anthropic. Questa funzionalità STS è **disabilitata per impostazione predefinita** su ogni account AWS. Abilitala una volta per account:
```bash CLI
aws iam enable-outbound-web-identity-federation
```
Se la risposta è `[ERROR] (FeatureEnabled) ... already enabled`, l'impostazione è già attiva per il tuo account e puoi proseguire. Verifica e recupera l'URL dell'emittente del tuo account:
```bash CLI
aws iam get-outbound-web-identity-federation-info
```
Senza questo passaggio, ogni richiesta restituisce `"Outbound web identity federation is disabled for your account"`. Questo è l'errore di configurazione più comune.
### Ottieni l'ID del tuo workspace
Crei un workspace dalla AWS Console dopo aver completato la configurazione dell'account (vedi [Configura il tuo account](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#set-up-your-account)). I workspace sono vincolati a una singola regione AWS. Puoi trovare l'ID del workspace nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console) in **Workspaces** o nella sezione **Workspaces** della pagina del servizio nella AWS Console.
Imposta le variabili d'ambiente `ANTHROPIC_AWS_WORKSPACE_ID` e `AWS_REGION` in modo che i client SDK le leggano automaticamente:
```bash CLI
export ANTHROPIC_AWS_WORKSPACE_ID='wrkspc_01AbCdEf23GhIj'
export AWS_REGION='us-west-2' # Your workspace's AWS region
```
La regione è obbligatoria. Il client SDK genera un errore se non è impostata alcuna regione. Passa `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) quando crei il client, oppure imposta `AWS_REGION` (o `AWS_DEFAULT_REGION`). Tutte le regioni commerciali AWS sono supportate.
## Autenticazione
Claude Platform on AWS supporta due metodi di autenticazione: AWS IAM con firma delle richieste Signature Version 4 (SigV4) (principale) e autenticazione con "API key" (chiave API). Entrambi usano lo stesso URL di base e lo stesso formato di richiesta.
### Autenticazione SigV4
SigV4 è il percorso nativo per le aziende e si integra con le tue policy, i tuoi ruoli e i tuoi sistemi di audit AWS IAM esistenti. Configura le credenziali AWS usando uno qualsiasi dei metodi supportati dalla [catena predefinita dei provider di credenziali AWS](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html):
* Variabili d'ambiente (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`)
* File di credenziali condiviso (`~/.aws/credentials`)
* File di configurazione condiviso (`~/.aws/config`), inclusi SSO e `credential_process`
* Identità web (`AWS_WEB_IDENTITY_TOKEN_FILE` e `AWS_ROLE_ARN`) per IRSA e GitHub Actions
* Credenziali dei container ECS
* Servizio di metadati delle istanze EC2 (IMDS)
Verifica che le tue credenziali funzionino:
```bash CLI
aws sts get-caller-identity
```
### Autenticazione con chiave API
Per percorsi di integrazione più semplici (sviluppo locale e script), puoi autenticarti con una chiave API invece che con SigV4. Imposta la variabile d'ambiente `ANTHROPIC_AWS_API_KEY` oppure passa `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) quando crei il client.
Genera le chiavi API nella **AWS Console** in **Claude Platform on AWS → API keys**. Scegli **Generate a key**, quindi copia il valore della chiave. Concedi l'azione IAM `aws-external-anthropic:CallWithBearerToken` ai principal che devono essere autorizzati a utilizzare l'autenticazione con chiave API.
Le chiavi API per Claude Platform on AWS sono gestite nella AWS Console, non nella Claude Console. Le chiavi create nella [Claude Console](https://platform.claude.com/) standard (per l'accesso all'API di prima parte) non funzionano con l'endpoint di Claude Platform on AWS.
#### Chiavi API a breve termine
Per i carichi di lavoro che devono passare una credenziale a un processo separato (come un gateway per "large language model" (grandi modelli linguistici), o LLM, una funzione serverless o uno strumento che supporta l'autenticazione con bearer token ma non SigV4), genera una chiave API a breve termine dalle tue credenziali AWS anziché creare una chiave a lunga durata nella AWS Console.
AWS pubblica librerie per la generazione di token per [JavaScript](https://github.com/aws/token-generator-for-aws-external-anthropic-js), [Python](https://github.com/aws/token-generator-for-aws-external-anthropic-python) e [Java](https://github.com/aws/token-generator-for-aws-external-anthropic-java). Ogni libreria legge le tue credenziali AWS tramite la catena di provider standard e restituisce un token a tempo limitato che funziona con l'header `x-api-key`. La durata del token è di 12 ore per impostazione predefinita ed è limitata al valore minore tra la durata richiesta, la scadenza delle tue credenziali AWS e 12 ore. Consulta i README dei repository collegati per l'installazione e tutte le opzioni di configurazione.
Passa il token generato all'SDK nello stesso modo in cui passeresti una chiave API generata nella AWS Console:
```python Python
from token_generator_for_aws_external_anthropic import TokenGenerator
from anthropic import AnthropicAWS
token = TokenGenerator(region="us-west-2").get_token()
client = AnthropicAWS(api_key=token, aws_region="us-west-2")
```
```typescript TypeScript
import { getTokenProvider } from "@aws/token-generator-for-aws-external-anthropic";
import AnthropicAws from "@anthropic-ai/aws-sdk";
const tokenProvider = getTokenProvider({ region: "us-west-2" });
const token = await tokenProvider();
const client = new AnthropicAws({ apiKey: token, awsRegion: "us-west-2" });
```
```java Java
import software.amazon.awsexternalanthropic.TokenGenerator;
import software.amazon.awssdk.regions.Region;
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
void main() {
String token = TokenGenerator.builder().region(Region.US_WEST_2).build().getToken();
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.builder()
.apiKey(token)
.region(Region.US_WEST_2)
.workspaceId(System.getenv("ANTHROPIC_AWS_WORKSPACE_ID"))
.build())
.build();
}
```
Se puoi generare il token localmente, il tuo processo dispone già di credenziali SigV4 e l'autenticazione SigV4 è di solito la scelta più semplice. Usa le chiavi a breve termine quando il processo che effettua le chiamate API è separato dal processo che detiene le credenziali AWS.
L'SDK non rinnova automaticamente le chiavi a breve termine. Quando un token scade, generane uno nuovo e crea un nuovo client. Il principal che usa il token necessita comunque dell'azione IAM `aws-external-anthropic:CallWithBearerToken`.
### Precedenza delle credenziali
Il client specifico per la piattaforma risolve l'autenticazione nel seguente ordine, a partire da ciò che passi quando lo crei:
1. `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) → header `x-api-key`
2. `aws_access_key` (typescript, php: `awsAccessKey`; go: `AWSAccessKey`; java: `.awsAccessKey()`; csharp: `AwsClientOptions.AwsAccessKey`) + `aws_secret_key` (ruby: `aws_secret_access_key`; typescript, php: `awsSecretAccessKey`; go: `AWSSecretAccessKey`; java: `.awsSecretAccessKey()`; csharp: `AwsClientOptions.AwsSecretAccessKey`) → AWS SigV4
3. `aws_profile` (typescript, php: `awsProfile`; go: `AWSProfile`; java: `.awsProfile()`; csharp: `AwsClientOptions.AwsProfile`) → AWS SigV4 con profilo denominato
4. Variabile d'ambiente `ANTHROPIC_AWS_API_KEY` → header `x-api-key`
5. Catena predefinita dei provider di credenziali AWS → AWS SigV4
### Risoluzione della regione
Il client legge `AWS_REGION` dall'ambiente se non imposti `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`), ricorrendo a `AWS_DEFAULT_REGION` per compatibilità con gli SDK AWS standard. La regione è obbligatoria e non esiste un valore predefinito: `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`) genera un errore se non sono impostati né l'argomento del costruttore né una variabile d'ambiente.
## Installa un SDK
Gli [SDK client](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) di Anthropic supportano Claude Platform on AWS. Il tuo SDK fornisce `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), che gestisce la firma SigV4, la costruzione dell'URL di base in base alla regione e l'header `anthropic-workspace-id`.
```bash
pip install -U "anthropic[aws]"
```
Su macOS con Python di Homebrew o altri ambienti Python gestiti esternamente, `pip install` può fallire con un errore PEP 668 `externally-managed-environment`. Crea e attiva prima un ambiente virtuale: `python3 -m venv .venv && source .venv/bin/activate`.
```bash
npm install @anthropic-ai/aws-sdk
```
```bash
dotnet add package Anthropic.Aws
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:2.73.0")
implementation("com.anthropic:anthropic-java-aws:2.73.0")
```
```xml Maven
com.anthropic
anthropic-java
2.73.0
com.anthropic
anthropic-java-aws
2.73.0
```
```bash
composer require anthropic-ai/sdk aws/aws-sdk-php
```
```bash
gem install anthropic aws-sdk-core
```
I client SDK per Claude Platform on AWS sono in beta.
## Modelli disponibili
I seguenti modelli sono disponibili su Claude Platform on AWS:
| Model | Model ID |
| :---------------------------------------------------------------------------------------------------- | :------------------ |
| Claude Fable 5.1 | `claude-fable-5-1` |
| Claude Fable 5 | `claude-fable-5` |
| Claude Opus 5.5 | `claude-opus-5-5` |
| Claude Opus 5 | `claude-opus-5` |
| Claude Opus 4.8 | `claude-opus-4-8` |
| Claude Opus 4.7 | `claude-opus-4-7` |
| Claude Opus 4.6 | `claude-opus-4-6` |
| Claude Opus 4.5 | `claude-opus-4-5` |
| Claude Sonnet 5.5 | `claude-sonnet-5-5` |
| Claude Sonnet 5 | `claude-sonnet-5` |
| Claude Sonnet 4.6 | `claude-sonnet-4-6` |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/it/about-claude/model-deprecations)) | `claude-sonnet-4-5` |
| Claude Haiku 5.5 | `claude-haiku-5-5` |
| Claude Haiku 4.5 | `claude-haiku-4-5` |
Gli ID dei modelli sono identici a quelli della Claude API di prima parte. Non ci sono ARN in stile Bedrock né prefissi `anthropic.`.
I nuovi modelli vengono in genere lanciati su Claude Platform on AWS lo stesso giorno della Claude API di prima parte.
Stai passando a un modello Claude più recente? In Claude Code, esegui `/claude-api migrate` per applicare le sostituzioni degli ID dei modelli e le modifiche incompatibili ai parametri in tutta la tua codebase. La skill rileva a quale piattaforma cloud è destinato il tuo codice e adatta i formati degli ID dei modelli e le modifiche alle funzionalità per quella piattaforma. Consulta [Migrazione a un modello Claude più recente](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
## Effettuare richieste
Claude Platform on AWS utilizza gli stessi endpoint API della Claude API di prima parte. Le differenze sono l'URL di base, il metodo di autenticazione e l'header `anthropic-workspace-id`, che identifica il [workspace](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#workspaces) a cui è destinata una richiesta. L'header è obbligatorio sulle richieste di inferenza e sulle risorse, come le chiamate alla Messages API, alla Models API, alla Files API e agli endpoint di Claude Managed Agents. Le richieste all'[Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api) non lo richiedono.
Prima di eseguire questi esempi, completa i passaggi in [Prima di effettuare chiamate API](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#before-making-api-calls).
```bash cURL
# Sostituisci us-west-2 con la tua regione AWS sia nell'URL sia in --aws-sigv4
# Ometti l'header x-amz-security-token se usi credenziali utente IAM a lungo termine
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Sostituisci us-west-2 con la tua regione AWS
# ant legge ANTHROPIC_API_KEY e la invia come x-api-key. Genera una chiave nella
# AWS Console (vedi autenticazione con chiave API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}' \
--transform content
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new() { Role = Role.User, Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Il client legge `AWS_REGION` (o `AWS_DEFAULT_REGION`) e `ANTHROPIC_AWS_WORKSPACE_ID` dall'ambiente. Puoi sovrascrivere entrambi passando `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) o `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `AwsClientOptions.WorkspaceId`) quando crei il client. Sia la regione sia l'ID del workspace sono obbligatori. Il costruttore genera un errore se uno dei due non può essere risolto.
L'header `x-amz-security-token` (cURL) è richiesto solo per le credenziali temporanee come ruoli IAM, SSO o STS. Omettilo quando utilizzi credenziali utente IAM a lungo termine. I client SDK gestiscono questo aspetto automaticamente in base all'origine delle credenziali.
Il valore `--aws-sigv4` segue il formato `aws:amz::`. Il nome del servizio SigV4 è `aws-external-anthropic` e la regione deve corrispondere alla regione nell'URL del tuo endpoint. Una mancata corrispondenza in uno dei due produce un errore generico di rifiuto della firma anziché una diagnostica specifica.
### Finestra di contesto
Le dimensioni della "context window" (finestra di contesto) su Claude Platform on AWS sono identiche a quelle della Claude API di prima parte. Consulta [Finestre di contesto](https://platform.claude.com/docs/it/build-with-claude/context-windows) per i limiti di ciascun modello.
## Supporto delle funzionalità
Claude Platform on AWS usa direttamente gli endpoint della Claude API, il che significa che ottieni la piena parità di funzionalità con la Claude API di prima parte (salvo quanto indicato nelle [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported)):
* **Accesso alle funzionalità:** poiché Anthropic gestisce entrambe le piattaforme, la maggior parte delle nuove funzionalità e degli header beta diventa disponibile su Claude Platform on AWS senza un passaggio di integrazione separato. Consulta le [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported) per le eccezioni.
* **Funzionalità beta:** passa l'header standard `anthropic-beta` per accedere alle funzionalità beta, esattamente come faresti con la Claude API.
* **Agent Skills:** usa le [Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview) predefinite e personalizzate con lo stesso parametro `container.skills` della Claude API. Tutte le Skills predefinite (PowerPoint, Excel, Word, PDF) funzionano immediatamente.
* **Esecuzione di codice:** esegui codice nella sandbox gestita da Anthropic usando lo [strumento di esecuzione del codice](https://platform.claude.com/docs/it/agents-and-tools/tool-use/code-execution-tool).
* **Uso degli strumenti:** tutte le [funzionalità di "tool use" (uso degli strumenti)](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview) sono disponibili, ad eccezione dei toolset di computer use e browser use; consulta [Funzionalità non supportate](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Ragionamento:** l'["adaptive thinking" (ragionamento adattivo)](https://platform.claude.com/docs/it/build-with-claude/thinking), il [parametro effort](https://platform.claude.com/docs/it/build-with-claude/effort) e, sui modelli che lo supportano, l'["extended thinking" (ragionamento esteso)](https://platform.claude.com/docs/it/build-with-claude/extended-thinking) funzionano con gli stessi parametri della Claude API.
* **"Streaming":** supporto completo dello streaming SSE per risposte in tempo reale.
* **Elaborazione batch:** invia richieste batch per carichi di lavoro ad alto throughput.
* **"Prompt caching" (cache dei prompt):** memorizza nella cache strumenti, "system prompt" (prompt di sistema) e cronologia dei messaggi per ridurre latenza e costi. Sono disponibili tutte le funzionalità di cache dei prompt (TTL di 5 minuti, TTL di 1 ora e caching automatico).
* **Files API:** carica file e fai riferimento a essi tra più richieste.
* **Chiavi di crittografia gestite dal cliente (CMEK):** le [CMEK](https://platform.claude.com/docs/it/manage-claude/cmek) sono disponibili solo con chiavi [AWS KMS](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms). Le chiavi Google Cloud KMS e Azure Key Vault non possono essere registrate. La chiave deve essere una chiave KMS a regione singola nello stesso account AWS e nella stessa regione del workspace a cui è associata, e la sua key policy deve concedere l'accesso al service principal `aws-external-anthropic.amazonaws.com`; consulta [Configurare le CMEK su Claude Platform on AWS](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#claude-platform-on-aws). Registra e associa le chiavi nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console); sono disponibili anche gli endpoint delle chiavi esterne, autorizzati tramite [azioni IAM](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#encryption-keys). Non esiste un passaggio di convalida separato: la chiave viene convalidata implicitamente quando la associ a un workspace (la chiamata di associazione esegue un ciclo di crittografia/decrittografia), quindi un problema con la key policy emerge al momento dell'associazione anziché al momento della registrazione.
* **Compliance API:** la [Compliance API](https://platform.claude.com/docs/it/manage-claude/compliance-api) è disponibile. L'accesso è autorizzato tramite l'[azione `ListComplianceActivities`](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#compliance) di AWS IAM.
Consulta la [tabella di confronto](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock) per le differenze di disponibilità delle funzionalità rispetto ad Amazon Bedrock.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) è disponibile su Claude Platform on AWS, inclusi [agenti](https://platform.claude.com/docs/it/managed-agents/agent-setup), [ambienti](https://platform.claude.com/docs/it/managed-agents/environments), [sessioni](https://platform.claude.com/docs/it/managed-agents/sessions), [deployment pianificati](https://platform.claude.com/docs/it/managed-agents/scheduled-deployments), [vault delle credenziali](https://platform.claude.com/docs/it/managed-agents/vaults), [archivi di memoria](https://platform.claude.com/docs/it/managed-agents/memory), [webhook](https://platform.claude.com/docs/it/managed-agents/webhooks), [orchestrazione multiagente](https://platform.claude.com/docs/it/managed-agents/multiagent-orchestration) e [sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes).
Le sessioni e i worker self-hosted su Claude Platform on AWS differiscono da Claude Managed Agents di prima parte in tre modi:
* **Riautenticazione delle sessioni autonome:** una sessione può essere eseguita in modo autonomo, senza alcun [evento utente](https://platform.claude.com/docs/it/managed-agents/reference#event-types), per un massimo di 6 ore. Dopo 6 ore, la sessione richiede una riautenticazione prima di proseguire. Per riautenticarti, invia alla sessione un qualsiasi evento con ruolo utente (vedi [Eventi e streaming](https://platform.claude.com/docs/it/managed-agents/events-and-streaming)). Claude Managed Agents di prima parte non ha alcun limite di durata per le sessioni autonome.
* **[Archivi di memoria su ambienti self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory):** una sessione eseguita su un ambiente self-hosted non può collegare archivi di memoria; una sessione che ne include uno viene rifiutata al momento della creazione. Le sessioni su ambienti cloud collegano gli archivi di memoria come di consueto. Su Claude Managed Agents di prima parte, le sessioni sia su ambienti cloud sia su ambienti self-hosted possono collegare archivi di memoria.
* **[Autenticazione dei worker negli ambienti self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes#prerequisites):** un worker si autentica con AWS IAM (SigV4) o con una [chiave API generata nella AWS Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#api-key-authentication), non con una chiave dell'ambiente. Le chiavi dell'ambiente generate nella Claude Console non funzionano con l'endpoint di Claude Platform on AWS.
### Funzionalità non supportate
Le seguenti funzionalità non sono attualmente disponibili su Claude Platform on AWS:
* **Conformità HIPAA:** il programma di conformità HIPAA di Anthropic non è disponibile. Consulta [API e conservazione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention).
* **Toolset di computer use e browser use:** `computer_toolset_20260801` e `browser_toolset_20260801` non sono attualmente disponibili su Claude Platform on AWS. Le versioni beta dello strumento computer use restano disponibili per i modelli elencati in [Versioni precedenti dello strumento](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
- **Admin API:** sono disponibili gli endpoint dei workspace (creazione, recupero, elenco, aggiornamento e archiviazione su `/v1/organizations/workspaces`), gli endpoint delle chiavi esterne (registrazione, recupero, elenco, aggiornamento ed eliminazione su `/v1/organizations/external_keys`, per [CMEK](https://platform.claude.com/docs/it/manage-claude/cmek); le chiavi vengono convalidate quando vengono associate a un workspace anziché tramite un endpoint di convalida) e gli [endpoint delle destinazioni di telemetria](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#telemetry-destinations). Gli altri endpoint dell'Admin API (membri dell'organizzazione, membri dei workspace, inviti, chiavi API, report di utilizzo, report dei costi e report dei limiti di velocità) non sono attualmente disponibili. Visualizza invece i dati di utilizzo e di costo nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console). AWS IAM gestisce l'appartenenza all'organizzazione.
- **Gestione dei membri dei workspace:** l'aggiunta o la rimozione di utenti dai singoli workspace non è disponibile. Le policy AWS IAM sugli ARN dei workspace controllano l'accesso.
- **Workspace di Claude Code e Analytics API:** il workspace di Claude Code con limiti di velocità automatici non è disponibile. L'utilizzo di Claude Code appare nella vista generale dell'utilizzo anziché in una schermata dedicata.
- **Autenticazione OAuth:** non supportata. Usa l'autenticazione SigV4 o con chiave API.
- **Modalità veloce:** non disponibile su Claude Platform on AWS.
- **Endpoint API compatibili con OpenAI:** non disponibili su Claude Platform on AWS.
- **Tunnel MCP:** sono supportati solo i server MCP esposti sulla rete internet pubblica.
## Residenza dei dati
Claude Platform on AWS supporta le seguenti aree geografiche di inferenza:
* **US:** l'inferenza rimane all'interno dei data center statunitensi. Si applica un moltiplicatore di prezzo di 1,1x.
* **Global:** l'inferenza può essere instradata verso qualsiasi data center gestito da Anthropic nel mondo. Si applicano i prezzi standard.
La regione AWS a cui è associato il tuo workspace determina quale endpoint del gateway chiami e in quale ambito si trovano le risorse lato AWS (IAM, CloudTrail, fatturazione). Non determina dove viene eseguita l'inferenza del modello. Per vincolare l'inferenza a un'area geografica specifica, imposta `inference_geo` su ogni richiesta oppure configura un valore predefinito per il workspace.
Imposta l'area geografica di inferenza per ogni richiesta con il parametro `inference_geo`:
Il parametro `inference_geo` è supportato su Claude 4.6 e sui modelli successivi. Le richieste con `inference_geo` su Claude Opus 4.5, Claude Sonnet 4.5 (deprecato) o Claude Haiku 4.5 restituiscono un errore 400. Consulta [Residenza dei dati](https://platform.claude.com/docs/it/manage-claude/data-residency) per i dettagli sulla disponibilità dei modelli.
```bash cURL
# Sostituisci us-west-2 con la tua regione AWS sia nell'URL sia in --aws-sigv4
# Ometti l'header x-amz-security-token se usi credenziali utente IAM a lungo termine
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"inference_geo": "us",
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Sostituisci us-west-2 con la tua regione AWS
# ant legge ANTHROPIC_API_KEY e la invia come x-api-key. Genera una chiave nella
# AWS Console (vedi autenticazione con chiave API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--inference-geo us \
--message '{role: user, content: "Hello!"}' \
--transform content
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
inference_geo="us",
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
InferenceGeo = "us",
Messages = [new() { Role = Role.User, Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
InferenceGeo: anthropic.String("us"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.inferenceGeo("us")
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
inferenceGeo: 'us',
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Se ometti `inference_geo`, la richiesta usa il `default_inference_geo` del workspace, se configurato, altrimenti `global`.
I controlli dell'area geografica di inferenza a livello di workspace (`allowed_inference_geos` e `default_inference_geo`) sono disponibili anche su Claude Platform on AWS. Consulta [Restrizioni a livello di workspace](https://platform.claude.com/docs/it/manage-claude/data-residency#workspace-level-restrictions).
## Workspace
Le richieste di inferenza e di risorse su Claude Platform on AWS sono indirizzate a un workspace. Passa l'ID del workspace nell'header `anthropic-workspace-id` in queste chiamate API. Gli ID dei workspace usano il formato con tag `wrkspc_` seguito da un identificatore alfanumerico (ad esempio, `wrkspc_01AbCdEf23GhIj`). Consulta [Ottenere l'ID del workspace](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id) se non lo hai ancora.
### Ambito dei workspace
I workspace sono associati a una singola regione AWS. Un workspace creato in `us-west-2` è accessibile solo tramite l'endpoint `us-west-2`. Utilizzo, quote, costi, file, batch e Skills vengono tutti aggregati per workspace, offrendoti suddivisioni per regione nella Claude Console.
I workspace fungono anche da risorsa IAM principale per Claude Platform on AWS. Concedi o neghi l'accesso a workspace specifici tramite policy AWS IAM usando l'ARN del workspace. Il segmento di risorsa dell'ARN è lo stesso ID con prefisso `wrkspc_` che passi nell'header `anthropic-workspace-id`:
```text wrap
arn:aws:aws-external-anthropic:{region}:{account-id}:workspace/{workspace-id}
```
Ad esempio:
```text wrap
arn:aws:aws-external-anthropic:us-west-2:123456789012:workspace/wrkspc_01AbCdEf23GhIj
```
Consulta [Policy IAM](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#iam-policies) per esempi di policy.
### Gestione dei workspace
Crea workspace aggiuntivi, rinomina un workspace o archivia un workspace dalla pagina **Workspaces** della AWS Console oppure con gli endpoint dei workspace dell'[Admin API](https://platform.claude.com/docs/it/manage-claude/admin-api). Questi endpoint non richiedono l'header `anthropic-workspace-id`. Le operazioni di creazione ed elenco agiscono sull'organizzazione; quelle di recupero, aggiornamento e archiviazione accettano l'ID del workspace nel percorso dell'URL. Un nuovo workspace è associato alla regione AWS dell'endpoint che chiami per crearlo (consulta [Ambito dei workspace](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#workspace-scoping)). Con il ruolo Admin, puoi anche creare, rinominare e archiviare workspace dalla pagina **Workspaces** della Claude Console.
## Utilizzo della Claude Console
Claude Platform on AWS usa la Claude Console standard su [platform.claude.com](https://platform.claude.com). Quando accedi dalla AWS Console, nell'angolo in basso a sinistra della barra laterale della Claude Console compare un indicatore **Account managed by AWS** e l'ambito della Console viene limitato alla tua organizzazione Claude Platform on AWS. La Console fornisce analisi dell'utilizzo, suddivisioni dei costi, visibilità sui "rate limit" (limiti di velocità), gestione dei workspace e pagine per gestire file, Agent Skills, job batch e risorse di Claude Managed Agents (agenti, sessioni, ambienti, vault delle credenziali, archivi di memoria e webhook).
### Accesso
L'accesso alla Claude Console è federato tramite AWS IAM. Consulta [Configurare l'account](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#set-up-your-account) per il flusso completo del primo accesso. In breve:
1. Assumi un ruolo IAM con il permesso `aws-external-anthropic:AssumeConsole`. Consulta [Azioni IAM per Claude Platform on AWS](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#console-access).
2. Vai alla pagina Claude Platform on AWS nella [AWS Console](https://console.aws.amazon.com/).
3. Scegli **Open Claude Console**. La AWS Console emette un JWT e ti reindirizza a `platform.claude.com`.
4. Al primo accesso, ti viene richiesto un indirizzo email. Inserisci la tua email di lavoro. La piattaforma effettua il provisioning just-in-time del tuo utente della Claude Console.
Sono disponibili due ruoli della Claude Console: **Admin** e **Developer**. Il ruolo Admin concede l'accesso a tutte le pagine e le impostazioni della Claude Console disponibili per Claude Platform on AWS. Il ruolo Developer concede l'accesso in lettura alle informazioni su utilizzo, costi, limiti di velocità e workspace. Contatta il tuo referente Anthropic per assegnare il ruolo Admin o Developer a un principal.
### Pagine disponibili
La colonna **Tramite gateway AWS** indica se la pagina legge e scrive dati tramite il gateway AWS (ed è quindi soggetta alle [azioni IAM](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions)). Le pagine contrassegnate con **No** leggono i metadati a livello di organizzazione direttamente da Anthropic e aggirano i controlli delle azioni IAM.
| Pagina | Disponibile | Tramite gateway AWS | Note |
| --------------------- | ------------- | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Usage** | Sì | No | Visualizza l'utilizzo dei token per modello, workspace e dimensione. I dati possono richiedere alcuni minuti per comparire dopo una richiesta. |
| **Cost** | Sì | No | Visualizza le suddivisioni dei costi per modello e workspace. AWS Cost Explorer mostra la voce aggregata [Claude Consumption Unit (CCU)](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#billing). |
| **Rate limits** | Sì | No | Visualizza i limiti di velocità (sola lettura). Gli aumenti di livello passano tramite il tuo referente Anthropic; consulta [Limiti di velocità e quote](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas). |
| **Workspaces** | Sì | Sì (eccetto i limiti di spesa) | Visualizza i workspace per regione. Con il ruolo Admin, puoi anche creare, rinominare e archiviare workspace e impostare [limiti di spesa](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#spend-limits) per singolo workspace. |
| **Encryption keys** | Sì | Sì | Una sezione della pagina [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`) nella Claude Console, mostrata quando **Organization** è selezionato nel menu a discesa nella parte superiore della pagina. Registra lì le chiavi AWS KMS per [CMEK](https://platform.claude.com/docs/it/manage-claude/cmek-aws-kms#claude-platform-on-aws) (ruolo Admin). Per associare una chiave registrata a un workspace, seleziona il workspace da quel menu a discesa, quindi seleziona la chiave in **Encryption key**. |
| **Files** | Sì | Sì | Visualizza e gestisci i file caricati. |
| **Skills** | Sì | Sì | Visualizza e gestisci le Agent Skills. |
| **Batches** | Sì | Sì | Visualizza e gestisci i job di elaborazione batch. |
| **Agents** | Sì | Sì | Visualizza e gestisci le definizioni degli agenti. |
| **Sessions** | Sì | Sì | Visualizza le sessioni degli agenti e la cronologia degli eventi. |
| **Environments** | Sì | Sì | Visualizza e gestisci le configurazioni delle sandbox cloud per le sessioni. |
| **Credential vaults** | Sì | Sì | Visualizza e gestisci i vault delle credenziali per l'autenticazione delle sessioni. |
| **Memory stores** | Sì | Sì | Visualizza e gestisci la memoria persistente degli agenti. |
| **Webhooks** | Sì | Sì | Visualizza e gestisci gli endpoint webhook. |
| **API keys** | No | N/D | Gestisci le "API key" (chiavi API) nella AWS Console (**Claude Platform on AWS → API keys**). Consulta [Autenticazione con chiave API](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#api-key-authentication). |
| **Members** | No | N/D | Non applicabile. AWS IAM gestisce l'accesso. |
| **Billing** | Sì (limitata) | No | Imposta un limite di spesa mensile per l'organizzazione; consulta [Limiti di spesa](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#spend-limits). AWS Marketplace gestisce la fatturazione. Visualizza le suddivisioni dei costi nella pagina Cost. |
| **Claude Code** | No | N/D | Visualizza l'utilizzo di Claude Code nella pagina Usage. |
### Cambio di organizzazione
La Claude Console non supporta il cambio di organizzazione per Claude Platform on AWS. Per accedere a un'organizzazione diversa, esci ed esegui nuovamente l'autenticazione tramite la AWS Console usando il ruolo IAM dell'account AWS di quell'organizzazione.
## Limiti di velocità e quote
Le organizzazioni su Claude Platform on AWS vengono collocate nel livello Start. Anthropic gestisce i limiti di velocità direttamente, non tramite i sistemi di quote di AWS.
Le organizzazioni su Claude Platform on AWS possono passare automaticamente a un livello di utilizzo superiore man mano che accumulano uno storico di fatture AWS Marketplace pagate. Il flusso self-service **Request tier increase** nella Claude Console non è disponibile: la pagina Rate limits ti indirizza invece al tuo referente Anthropic.
Per richiedere limiti più elevati, contatta il tuo referente Anthropic o il [supporto Anthropic](https://support.claude.com). Includi quanto segue nella richiesta:
* I modelli per cui ti serve un aumento
* Il picco di token di input al minuto e di token di output al minuto per ciascun modello (non i totali giornalieri)
* La quota approssimativa del tuo input costituita da contesto memorizzato nella cache o ripetuto (per la maggior parte dei modelli, le letture dalla cache non vengono conteggiate nei limiti dei token di input; consulta [ITPM con riconoscimento della cache](https://platform.claude.com/docs/it/api/rate-limits#cache-aware-itpm))
I livelli di utilizzo sono gradini fissi: ogni livello abbina i limiti di velocità a un [tetto di spesa mensile](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#spend-limits), e il passaggio a un livello superiore aumenta entrambi. Per i dettagli sui livelli e sui limiti per modello, consulta [Limiti di velocità](https://platform.claude.com/docs/it/api/rate-limits).
## Fatturazione
Claude Platform on AWS fattura tramite [AWS Marketplace](https://aws.amazon.com/marketplace). L'utilizzo è espresso in Claude Consumption Units (CCU), misurato su base oraria e fatturato mensilmente a posteriori sulla tua fattura AWS. Le CCU non sono crediti prepagati. Non esiste alcun saldo né alcun impegno di CCU.
Per il prezzo delle CCU, i meccanismi di conversione, l'applicazione degli sconti e le tariffe dei token per modello, consulta [Prezzi di Claude Platform on AWS](https://platform.claude.com/docs/it/about-claude/pricing#claude-platform-on-aws-pricing).
### Limiti di spesa
I livelli di utilizzo Start, Build e Scale prevedono ciascuno un tetto di spesa mensile; consulta i [tetti di spesa per livello](https://platform.claude.com/docs/it/api/rate-limits#spend-limits) per i valori attuali. Quando l'utilizzo della tua organizzazione nel mese solare raggiunge il tetto del suo livello, le richieste API falliscono con l'[errore di tetto di spesa](https://platform.claude.com/docs/it/api/rate-limits#reaching-your-spend-cap) fino alle 00:00 UTC del primo giorno del mese successivo, e i nuovi tentativi effettuati prima di allora non vanno a buon fine. Il tetto di spesa e i limiti di velocità appartengono allo stesso livello. Per aumentare il tetto, o per ripristinare l'accesso dopo averlo raggiunto, richiedi un aumento di livello tramite il tuo referente Anthropic o il [supporto Anthropic](https://support.claude.com) (consulta [Limiti di velocità e quote](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Puoi anche impostare i tuoi "spend limit" (limiti di spesa) mensili al di sotto del tetto, dopo aver aggiunto almeno un destinatario in **Email recipients** nella pagina Billing:
* **Limite di spesa dell'organizzazione:** Vai a [Settings > Billing](https://platform.claude.com/settings/billing) nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#using-the-claude-console) per impostare un limite di spesa mensile.
* **Limiti di spesa dei workspace:** Nella pagina [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) della Claude Console, seleziona un workspace. Nel pannello che si apre, fai clic su **Spend limits**.
Quando l'utilizzo raggiunge un limite che hai impostato, le richieste falliscono con HTTP 400 (consulta l'[errore del limite di spesa](https://platform.claude.com/docs/it/api/rate-limits#setting-your-own-spend-limit)) fino alle 00:00 UTC del primo giorno del mese successivo, oppure finché non aumenti o rimuovi il limite.
La spesa è calcolata ai prezzi di listino e può richiedere circa 2 ore per riflettere l'utilizzo recente, quindi l'utilizzo può superare il tetto o un limite prima che le richieste inizino a fallire. L'eccedenza viene fatturata. Quando il tetto del livello o un limite di spesa dell'organizzazione blocca le tue richieste, viene inviata una notifica email ai destinatari elencati in **Email recipients** nella pagina Billing. I destinatari basati sui ruoli, come tutti gli amministratori, non sono disponibili su Claude Platform on AWS. La notifica relativa al tetto del livello viene inviata anche all'indirizzo email utilizzato al momento della registrazione su AWS Marketplace.
## Monitoraggio e logging
AWS CloudTrail può acquisire tutte le richieste a Claude Platform on AWS. Le operazioni su workspace, chiavi esterne, destinazioni di telemetria, conformità, vault e webhook vengono registrate come eventi di gestione (Management events) per impostazione predefinita. Le operazioni di inferenza, batch, file, skill, modelli, profili utente e Claude Managed Agents (diverse da vault e webhook) sono classificate come eventi di dati (Data events) e richiedono una configurazione esplicita del logging degli eventi di dati, che comporta costi aggiuntivi di CloudTrail. Consulta il [riferimento delle azioni IAM](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#route-to-action-mapping) per la classificazione completa dei tipi di evento e la [documentazione di AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/) per i dettagli di configurazione.
### ID delle richieste
Ogni risposta include due ID di richiesta negli header della risposta:
* **ID richiesta AWS (`x-amzn-requestid`):** L'ID principale, indicizzato in CloudTrail. Usalo quando analizzi le richieste tramite gli strumenti AWS o quando contatti il supporto AWS.
* **ID richiesta Anthropic (`request-id`):** L'ID secondario. Usalo quando contatti il supporto Anthropic.
```bash cURL
# Sostituisci us-west-2 con la tua regione AWS sia nell'URL sia in --aws-sigv4
# -i include gli header della risposta nell'output
# Ometti l'header x-amz-security-token se usi credenziali utente IAM a lungo termine
curl -i "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Sostituisci us-west-2 con la tua regione AWS
# ant legge ANTHROPIC_API_KEY e la invia come x-api-key. Genera una chiave nella
# AWS Console (vedi autenticazione con chiave API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
# --debug stampa la risposta HTTP, inclusi gli header X-Amzn-Requestid e
# Request-Id, su stderr
ant --debug messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
response = client.messages.with_raw_response.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.headers.get("x-amzn-requestid")) # AWS request ID
print(response.headers.get("request-id")) # Anthropic request ID
message = response.parse()
print(message.content)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const { data: message, response } = await client.messages
.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
})
.withResponse();
console.log(response.headers.get("x-amzn-requestid")); // AWS request ID
console.log(response.headers.get("request-id")); // Anthropic request ID
console.log(message.content);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var response = await client.WithRawResponse.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new() { Role = Role.User, Content = "Hello!" }]
});
Console.WriteLine(response.Headers.GetValues("x-amzn-requestid").First()); // AWS request ID
Console.WriteLine(response.Headers.GetValues("request-id").First()); // Anthropic request ID
Console.WriteLine(response.Value.Content);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
var response *http.Response
message, err := client.Messages.New(
context.Background(),
anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
},
option.WithResponseInto(&response),
)
if err != nil {
panic(err)
}
fmt.Println(response.Header.Get("x-amzn-requestid")) // AWS request ID
fmt.Println(response.Header.Get("request-id")) // Anthropic request ID
fmt.Println(message.Content)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponseFor;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
HttpResponseFor response = client.messages().withRawResponse().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(response.headers().values("x-amzn-requestid").get(0)); // AWS request ID
IO.println(response.requestId().orElse(null)); // Anthropic request ID
IO.println(response.parse().content());
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$response = $client->messages->raw->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $response->getHeaderLine('x-amzn-requestid') . "\n"; // AWS request ID
echo $response->getHeaderLine('request-id') . "\n"; // Anthropic request ID
echo $response->parse()->content;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
# Leggi gli header della risposta nel middleware per richiesta, che riceve la
# risposta HTTP grezza prima che l'SDK la analizzi
aws_request_id = nil
anthropic_request_id = nil
read_request_ids = lambda do |request, call_next|
response = call_next.call(request)
# Le chiavi in response.headers sono in minuscolo
aws_request_id = response.headers["x-amzn-requestid"]
anthropic_request_id = response.headers["request-id"]
response
end
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }],
request_options: { middleware: [read_request_ids] }
)
puts aws_request_id # AWS request ID
puts anthropic_request_id # Anthropic request ID
puts message.content
```
Anthropic consiglia di registrare la tua attività su una finestra mobile di almeno 30 giorni per comprendere i modelli di utilizzo e analizzare i problemi.
AWS CloudTrail è configurato all'interno del tuo account AWS. L'abilitazione del logging non fornisce ad AWS o ad Anthropic l'accesso ai tuoi contenuti oltre quanto necessario per la fatturazione e il funzionamento del servizio.
## Migrazione da Amazon Bedrock
Se attualmente usi Claude su Bedrock, la migrazione a Claude Platform on AWS richiede modifiche in tutta la tua integrazione. La firma SigV4 rimane supportata, ma cambiano il contesto di firma, l'URL di base, il formato dell'API, gli ID dei modelli, il client e il pacchetto SDK, il formato di streaming, gli header delle richieste e la disponibilità per regione. Claude Platform on AWS effettua inoltre il provisioning di una nuova organizzazione Anthropic. La tabella seguente riassume le differenze.
### Cosa cambia
L'entità della migrazione dipende dall'integrazione Bedrock da cui provieni. La tabella seguente mostra sia l'[integrazione Bedrock attuale](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock) (Messages API su `bedrock-mantle.{region}.api.aws`) sia l'[integrazione legacy InvokeModel](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy).
| Aspetto | Da [Claude in Amazon Bedrock](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock) | Da [Amazon Bedrock (Opus 4.6 e precedenti)](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy) | A Claude Platform on AWS |
| ----------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **URL di base** | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` | `aws-external-anthropic.{region}.api.aws` |
| **Formato API** | Messages API su `/anthropic/v1/messages` | Bedrock Converse / InvokeModel | Claude API (`/v1/{endpoint}`) |
| **ID dei modelli** | anthropic.claude-haiku-4-5 | anthropic.claude-haiku-4-5-20251001-v1:0(con un prefisso del profilo di inferenza `us.` o `global.`) | claude-haiku-4-5 |
| **Client SDK** | `AnthropicBedrockMantle` | `AnthropicBedrock` / Bedrock SDK | Client specifico per la piattaforma (consulta [Installare un SDK](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#install-an-sdk)), in beta |
| **Pacchetto SDK** | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`) | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`), oppure l'AWS SDK | `anthropic[aws]` (typescript: `@anthropic-ai/aws-sdk`; csharp: `Anthropic.Aws`; go: `github.com/anthropics/anthropic-sdk-go/aws`; java: `com.anthropic:anthropic-java-aws`; php: `anthropic-ai/sdk`; ruby: `anthropic`) (consulta [Installa un SDK](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#install-an-sdk)) |
| **Nome del servizio SigV4** | `bedrock-mantle` | `bedrock` | `aws-external-anthropic` |
| **Formato di streaming** | SSE | AWS EventStream | SSE (come la Claude API) |
| **Header del workspace** | Non applicabile | Non applicabile | `anthropic-workspace-id`, obbligatorio nelle richieste di inferenza e di risorse |
| **Disponibilità per regione** | Consulta [Regioni di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Consulta [Regioni di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Tutte le regioni commerciali AWS |
| **Organizzazione Anthropic** | Nessuna richiesta | Nessuna richiesta | Nuova organizzazione creata al momento della registrazione. Le organizzazioni esistenti non possono essere convertite (consulta [Passare da un'organizzazione Anthropic esistente](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#moving-from-an-existing-anthropic-organization)) |
Se usi l'integrazione Bedrock attuale, il formato del corpo della richiesta è già quello della Messages API. Le modifiche riguardano l'URL di base, il nome del servizio SigV4, gli ID dei modelli e l'aggiunta dell'header `anthropic-workspace-id`. Se usi l'API legacy InvokeModel o Converse, dovrai anche riscrivere la struttura delle richieste e delle risposte nel formato della Messages API. Consulta [Claude su Amazon Bedrock (Opus 4.6 e precedenti)](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy) per la mappatura della struttura delle richieste.
### Cosa ottieni
* Accesso, in genere nello stesso giorno, a nuovi modelli e funzionalità (consulta le [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported))
* Agent Skills per la generazione di documenti (PowerPoint, Excel, Word, PDF)
* Esecuzione del codice nella sandbox gestita di Anthropic
* Funzionalità beta della Claude API che Amazon Bedrock non offre, tramite l'header `anthropic-beta` (consulta le [limitazioni delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#features-not-supported))
* Claude Console per la visibilità sulle quote e l'analisi dell'utilizzo
* Supporto diretto di Anthropic
* Autenticazione con chiave API come alternativa a SigV4 (consulta [Autenticazione con chiave API](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#api-key-authentication))
### Cosa rimane invariato
* Autenticazione AWS IAM (SigV4)
* AWS come soggetto che emette la fattura. Il canale di fatturazione passa dal servizio AWS nativo ad AWS Marketplace (consulta [Considerazioni commerciali](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#commercial-considerations)).
* Consumo degli impegni di spesa AWS (AWS commitment retirement)
### Insidie della migrazione
**Abilita prima la federazione delle identità web in uscita.** Se il tuo account AWS non ha mai usato Claude Platform on AWS, devi [abilitare la federazione delle identità web in uscita](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) una volta per account prima di effettuare richieste. Senza questo passaggio, tutte le richieste falliscono con un errore di federazione (consulta [Abilitare la federazione delle identità web in uscita](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) per l'errore esatto e la soluzione). Questo passaggio non è richiesto per Bedrock.
**La "Zero Data Retention" (conservazione zero dei dati), o ZDR, è su adesione volontaria su Claude Platform on AWS.** Su Bedrock, AWS è il responsabile del trattamento dei dati e Anthropic non conserva gli input o gli output dell'inferenza. Il programma ZDR di Anthropic non si applica in quel caso. Su Claude Platform on AWS, Anthropic tratta i dati di inferenza come responsabile del trattamento indipendente, e la ZDR segue il modello della Claude API di prima parte: è disponibile su richiesta tramite il tuo referente Anthropic. Conferma l'adesione alla ZDR prima di migrare carichi di lavoro di produzione che dipendono da garanzie sulla conservazione dei dati.
### Considerazioni commerciali
* **Termini di servizio di Anthropic:** L'uso di Claude Platform on AWS richiede l'accettazione dei Termini di servizio commerciali e della Politica di utilizzo di Anthropic. Se la tua organizzazione non li ha già accettati (ad esempio, se hai usato Claude solo tramite Bedrock), ti verrà chiesto di farlo durante la configurazione dell'account. Consulta [Configurare l'account](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws#set-up-your-account).
* **Sconti e offerte private:** Gli sconti negoziati e le offerte private di AWS Marketplace non vengono trasferiti automaticamente tra Bedrock e Claude Platform on AWS. Collabora con il tuo referente Anthropic per definire i termini commerciali per Claude Platform on AWS.
## Policy IAM
Claude Platform on AWS si integra con AWS IAM per il controllo degli accessi. Concedi o neghi l'accesso a specifiche azioni API su specifici workspace usando la sintassi standard delle policy IAM.
Il nome del servizio SigV4 e il namespace delle azioni IAM è `aws-external-anthropic`. Le azioni seguono lo schema `aws-external-anthropic:` (ad esempio, `aws-external-anthropic:CreateInference`).
### Esempio: negare l'inferenza batch
La seguente policy consente l'inferenza in tempo reale bloccando l'elaborazione batch:
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aws-external-anthropic:CreateInference",
"aws-external-anthropic:CountTokens",
"aws-external-anthropic:GetModel",
"aws-external-anthropic:ListModels",
"aws-external-anthropic:GetWorkspace"
],
"Resource": "arn:aws:aws-external-anthropic:*:*:workspace/*"
},
{
"Effect": "Allow",
"Action": "aws-external-anthropic:ListWorkspaces",
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"aws-external-anthropic:CreateBatchInference",
"aws-external-anthropic:GetBatchInference",
"aws-external-anthropic:ListBatchInferences"
],
"Resource": "*"
}
]
}
```
L'azione `GetBatchInference` autorizza sia la route dei metadati del batch sia la route dei risultati del batch. Negarla blocca entrambe le letture. Per una policy solo Deny adatta a carichi di lavoro sensibili alla ZDR, consulta [Blocco delle funzionalità per un workspace sensibile alla ZDR](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#feature-lockdown-for-a-zdr-sensitive-workspace).
`ListWorkspaces` ha un ambito a livello di account, quindi compare in un'istruzione Allow separata con `"Resource": "*"`. Specificare l'ARN di un workspace su un'azione con ambito a livello di account non ha alcun effetto (consulta [Automazione del provisioning](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#provisioning-automation)).
Questa policy presuppone l'autenticazione AWS SigV4. Se il principal si autentica con una chiave API, aggiungi anche `aws-external-anthropic:CallWithBearerToken` all'istruzione Allow con `"Resource": "*"`. `CallWithBearerToken` è un'azione del livello di autenticazione, priva di route, che non si associa all'ARN di un workspace. Consulta [Isolamento dei workspace per cliente](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#per-customer-workspace-isolation) per lo schema a due istruzioni.
### Policy gestite
AWS fornisce cinque policy gestite (`AnthropicFullAccess`, `AnthropicReadOnlyAccess`, `AnthropicInferenceAccess`, `AnthropicLimitedAccess` e `AnthropicSelfHostedEnvironmentAccess`) per i modelli di accesso più comuni. Per le azioni concesse da ciascuna policy, l'elenco completo delle azioni IAM, la mappatura tra route e azioni e ulteriori esempi di policy, consulta [Azioni IAM per Claude Platform on AWS](https://platform.claude.com/docs/it/api/claude-platform-on-aws-iam-actions#managed-policies).
## Passaggi successivi
Esplora le funzionalità e le capacità avanzate di Claude.
Scopri i prezzi di Claude Platform on AWS e le tariffe delle Claude Consumption Unit.
Man mano che vengono lanciati modelli più sicuri e capaci, Anthropic ritira regolarmente quelli più vecchi. Consulta tutte le deprecazioni dell'API, insieme alle sostituzioni consigliate.
## Risorse aggiuntive
Visualizza utilizzo, costi e workspace nella Claude Console. Accedi tramite la AWS Console.
Usa Claude gestito da AWS se hai bisogno che AWS sia l'unico responsabile del trattamento dei dati.
Gestisci il tuo abbonamento e la fatturazione di AWS Marketplace.