---
title: Claude in Amazon Bedrock (Opus 4.7 e successivi)
url: https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock
description: Accedi ai modelli Claude tramite Amazon Bedrock con autenticazione, fatturazione e perimetri di sicurezza nativi di AWS.
---

Questa guida ti accompagna nella configurazione e nell'esecuzione di chiamate API a Claude in Amazon Bedrock. Claude in Amazon Bedrock viene eseguito su un'infrastruttura gestita da AWS con zero accesso da parte degli operatori (il personale di Anthropic non ha alcun accesso all'infrastruttura di inferenza), consentendoti di creare applicazioni sensibili interamente all'interno del perimetro di sicurezza AWS, utilizzando la stessa struttura della Messages API che usi con l'API di prima parte di Anthropic.

<Note>
  Questa pagina riguarda Claude in Amazon Bedrock, che serve Claude tramite la Messages API all'indirizzo `/anthropic/v1/messages` su infrastruttura gestita da AWS. La precedente integrazione con Amazon Bedrock (le API `InvokeModel` e `Converse` con identificatori di modello versionati tramite ARN) rimane disponibile ed è documentata in [Claude su Amazon Bedrock (Opus 4.6 e precedenti)](https://platform.claude.com/docs/it/build-with-claude/claude-on-amazon-bedrock-legacy). Per un'alternativa gestita da Anthropic su AWS con fatturazione tramite AWS Marketplace e accesso alle funzionalità tipicamente nello stesso giorno, consulta [Claude Platform on AWS](https://platform.claude.com/docs/it/build-with-claude/claude-platform-on-aws).
</Note>

## Accesso

Amazon Bedrock stabilisce i criteri di accesso per ciascun modello Claude individualmente. Claude Fable 5.1, Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5, Claude Opus 4.7 e Claude Haiku 4.5 sono aperti a tutti i clienti Amazon Bedrock. Per i criteri attuali di qualsiasi altro modello, controlla [Amazon Bedrock model access](https://console.aws.amazon.com/bedrock/home#/modelaccess) nella console AWS. Claude Mythos Preview richiede un invito tramite [Project Glasswing](https://anthropic.com/glasswing). Per la disponibilità nelle regioni, consulta [Regioni](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#regions).

## Prerequisiti

Prima di iniziare, assicurati di avere:

* Un account AWS con [Amazon Bedrock model access](https://console.aws.amazon.com/bedrock/home#/modelaccess) abilitato per i modelli Claude che intendi utilizzare.
* La [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) installata e configurata (opzionale, per la gestione delle credenziali).

Claude Mythos Preview richiede inoltre un account AWS dedicato che sia stato inserito nella allowlist dal team di Bedrock Marketplace. Il tuo account executive di Anthropic può inviare l'ID del tuo account per l'inserimento nella allowlist (in genere elaborato entro 24 ore), e AWS invia un'email di benvenuto una volta completata l'operazione.

## Autenticazione

Claude in Amazon Bedrock supporta tre percorsi di autenticazione. Scegli quello che meglio si adatta ai tuoi requisiti di sicurezza.

### Ruolo di servizio Bedrock (consigliato)

Usa un ruolo di servizio Bedrock con chiavi gestite da AWS per l'accesso più sicuro e di lunga durata:

<Steps>
  <Step title="Amministratore: predisponi il ruolo di servizio">
    Un amministratore AWS predispone un ruolo di servizio Bedrock e concede agli sviluppatori il permesso `iam:PassRole` sull'ARN del ruolo di servizio.
  </Step>

  <Step title="Sviluppatore: passa il ruolo">
    Quando chiami l'API, Bedrock assume il ruolo di servizio per tuo conto. Consulta la [documentazione di Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-mantle.html) per sapere come associare il ruolo alle tue richieste.
  </Step>
</Steps>

### Ruoli IAM assunti

Per l'accesso federato tramite identità con una sessione massima di 12 ore:

<Steps>
  <Step title="Amministratore: configura il ruolo IAM">
    Crea un ruolo IAM con ambito limitato ai tuoi modelli Claude. La trust policy indica il tuo identity provider (SAML, OIDC o AWS Identity Center). La permissions policy concede `bedrock-mantle:CreateInference` solo sugli ARN dei modelli consentiti.
  </Step>

  <Step title="Sviluppatore: autenticati e assumi il ruolo">
    Autenticati tramite l'identity provider aziendale, quindi assumi il ruolo IAM. AWS STS emette credenziali temporanee che l'SDK o la CLI utilizza per firmare le richieste.
  </Step>
</Steps>

### Bearer token

Per l'accesso a breve termine senza ruoli IAM (massimo 12 ore, opzione meno preferibile):

<Steps>
  <Step title="Amministratore: limita i tipi di token">
    Blocca le chiavi a lungo termine allegando una policy che nega `bedrock:CallWithBearerToken` a meno che la condizione `bedrock:BearerTokenType` non corrisponda a un token a breve termine.
  </Step>

  <Step title="Sviluppatore: genera un token">
    Usa la CLI `aws-bedrock-token-generator` per generare un bearer token. Passalo nell'header `x-api-key` in ogni richiesta.
  </Step>
</Steps>

## Installa un SDK

Gli [SDK client](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) di Anthropic supportano Claude in Amazon Bedrock tramite un pacchetto o modulo specifico per Bedrock.

<Tabs>
  <Tab title="Python">
    ```bash
    pip install -U "anthropic[bedrock]"
    ```
  </Tab>

  <Tab title="TypeScript">
    ```bash
    npm install @anthropic-ai/bedrock-sdk
    ```
  </Tab>

  <Tab title="C#">
    ```bash
    dotnet add package Anthropic.Bedrock
    ```
  </Tab>

  <Tab title="Go">
    ```bash
    go get github.com/anthropics/anthropic-sdk-go/bedrock
    ```
  </Tab>

  <Tab title="Java">
    <Tabs>
      <Tab title="Gradle">
        ```kotlin
        implementation("com.anthropic:anthropic-java:2.73.0")
        implementation("com.anthropic:anthropic-java-bedrock:2.73.0")
        ```
      </Tab>

      <Tab title="Maven">
        ```xml
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java</artifactId>
            <version>2.73.0</version>
        </dependency>
        <dependency>
            <groupId>com.anthropic</groupId>
            <artifactId>anthropic-java-bedrock</artifactId>
            <version>2.73.0</version>
        </dependency>
        ```
      </Tab>
    </Tabs>
  </Tab>

  <Tab title="PHP">
    ```bash
    composer require anthropic-ai/sdk aws/aws-sdk-php
    ```
  </Tab>

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "aws-sdk-core"
    ```
  </Tab>
</Tabs>

## Effettuare la prima richiesta

L'endpoint segue lo schema `https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages`. A differenza dell'integrazione basata su `InvokeModel`, questo endpoint utilizza lo "streaming" (trasmissione in flusso) SSE standard e la stessa struttura del corpo della richiesta dell'API di prima parte di Anthropic.

L'SDK risolve le credenziali e la regione utilizzando l'ordine di precedenza standard di AWS: argomenti del costruttore, poi variabili d'ambiente (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`, `AWS_REGION`), poi il file di configurazione AWS e la catena delle credenziali (SSO, ruoli assunti, ruolo del task ECS, IMDS).

<Tabs>
  <Tab title="cURL">
    ```bash
    curl https://bedrock-mantle.us-east-1.api.aws/anthropic/v1/messages \
      --aws-sigv4 "aws:amz:us-east-1:bedrock-mantle" \
      --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" \
      -d '{
        "model": "anthropic.claude-opus-5-5",
        "max_tokens": 1024,
        "messages": [
          {"role": "user", "content": "Hello, Claude"}
        ]
      }'
    ```
  </Tab>

  <Tab title="CLI">
    La CLI `ant` non supporta Amazon Bedrock. Usa cURL oppure un SDK.
  </Tab>

  <Tab title="Python">
    ```python
    from anthropic import AnthropicBedrockMantle

    client = AnthropicBedrockMantle(aws_region="us-east-1")

    message = client.messages.create(
        model="anthropic.claude-opus-5-5",
        max_tokens=1024,
        messages=[{"role": "user", "content": "Hello, Claude"}],
    )

    print(next(block.text for block in message.content if block.type == "text"))
    ```
  </Tab>

  <Tab title="TypeScript">
    ```typescript
    import { AnthropicBedrockMantle } from "@anthropic-ai/bedrock-sdk";

    const client = new AnthropicBedrockMantle({
      awsRegion: "us-east-1"
    });

    const message = await client.messages.create({
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{ role: "user", content: "Hello, Claude" }]
    });

    const textBlock = message.content.find((block) => block.type === "text");
    if (textBlock) {
      console.log(textBlock.text);
    }
    ```
  </Tab>

  <Tab title="C#">
    ```csharp
    using Anthropic.Bedrock;
    using Anthropic.Models.Messages;

    var client = new AnthropicBedrockMantleClient(new() { AwsRegion = "us-east-1" });

    var message = await client.Messages.Create(new()
    {
        Model = "anthropic.claude-opus-5-5",
        MaxTokens = 1024,
        Messages = [new() { Role = Role.User, Content = "Hello, Claude" }],
    });

    foreach (var item in message.Content)
    {
        if (item.Value is TextBlock block)
        {
            Console.WriteLine(block.Text);
            break;
        }
    }
    ```
  </Tab>

  <Tab title="Go">
    ```go
    client, err := bedrock.NewMantleClient(context.Background(), bedrock.MantleClientConfig{
    	AWSRegion: "us-east-1",
    })
    if err != nil {
    	panic(err)
    }

    message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
    	Model:     "anthropic.claude-opus-5-5",
    	MaxTokens: 1024,
    	Messages: []anthropic.MessageParam{
    		anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
    	},
    })
    if err != nil {
    	panic(err)
    }

    for _, block := range message.Content {
    	if textBlock, ok := block.AsAny().(anthropic.TextBlock); ok {
    		fmt.Println(textBlock.Text)
    		break
    	}
    }
    ```
  </Tab>

  <Tab title="Java">
    ```java
    import com.anthropic.bedrock.backends.BedrockMantleBackend;
    import com.anthropic.client.AnthropicClient;
    import com.anthropic.client.okhttp.AnthropicOkHttpClient;
    import com.anthropic.models.messages.ContentBlock;
    import com.anthropic.models.messages.Message;
    import com.anthropic.models.messages.MessageCreateParams;

    void main() {
        AnthropicClient client = AnthropicOkHttpClient.builder()
            .backend(BedrockMantleBackend.fromEnv())
            .build();

        Message message = client.messages().create(
            MessageCreateParams.builder()
                .model("anthropic.claude-opus-5-5")
                .maxTokens(1024)
                .addUserMessage("Hello, Claude")
                .build()
        );

        message.content().stream()
                .filter(ContentBlock::isText)
                .findFirst()
                .ifPresent(block -> IO.println(block.asText().text()));
    }
    ```
  </Tab>

  <Tab title="PHP">
    ```php
    use Anthropic\Bedrock\MantleClient;

    $client = new MantleClient(awsRegion: 'us-east-1');

    $message = $client->messages->create(
        model: 'anthropic.claude-opus-5-5',
        maxTokens: 1024,
        messages: [
            ['role' => 'user', 'content' => 'Hello, Claude'],
        ],
    );

    echo array_find($message->content, fn ($block) => $block->type === 'text')->text;
    ```
  </Tab>

  <Tab title="Ruby">
    ```ruby
    require "anthropic"

    client = Anthropic::BedrockMantleClient.new(aws_region: "us-east-1")

    message = client.messages.create(
      model: "anthropic.claude-opus-5-5",
      max_tokens: 1024,
      messages: [{role: "user", content: "Hello, Claude"}]
    )

    puts message.content.find { it.type == :text }.text
    ```
  </Tab>
</Tabs>

<Tip>
  Puoi anche creare il client standard con `Anthropic` (go: `anthropic.NewClient()`; java: `AnthropicOkHttpClient.builder()`; csharp: `AnthropicClient`; php: `Anthropic\Client`; ruby: `Anthropic::Client`): imposta `base_url` (typescript: `baseURL`; go: `option.WithBaseURL()`; java: `.baseUrl()`; csharp: `BaseUrl`; php: `baseUrl`) su `https://bedrock-mantle.{region}.api.aws/anthropic` e passa il tuo bearer token come `api_key` (typescript, php: `apiKey`; go: `option.WithAPIKey()`; java: `.apiKey()`; csharp: `ApiKey`). Questa modalità supporta solo l'autenticazione tramite bearer token. La firma SigV4 richiede `AnthropicBedrockMantle` (csharp: `AnthropicBedrockMantleClient`; go: `bedrock.NewMantleClient`; java: `BedrockMantleBackend`; php: `MantleClient`; ruby: `Anthropic::BedrockMantleClient`).
</Tip>

## Modelli supportati

Gli ID dei modelli in Claude in Amazon Bedrock hanno il prefisso del provider `anthropic.`. Le capacità e i comportamenti dei modelli sono documentati nella pagina [Panoramica dei modelli](https://platform.claude.com/docs/it/models/overview).

| Model                                                                                       | Model ID                          | Access                                                                                              |
| :------------------------------------------------------------------------------------------ | :-------------------------------- | :-------------------------------------------------------------------------------------------------- |
| Claude Fable 5.1                                                                            | `anthropic.claude-fable-5-1`      | Open                                                                                                |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842)) | `anthropic.claude-mythos-5-1`     | Active (verification required)                                                                      |
| Claude Fable 5                                                                              | `anthropic.claude-fable-5`        | Open                                                                                                |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))   | `anthropic.claude-mythos-5`       | Active (verification required)                                                                      |
| Claude Mythos Preview ([limited availability](https://anthropic.com/glasswing))             | `anthropic.claude-mythos-preview` | Invitation only                                                                                     |
| Claude Opus 5.5                                                                             | `anthropic.claude-opus-5-5`       | [See Access](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 5                                                                               | `anthropic.claude-opus-5`         | [See Access](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Opus 4.8                                                                             | `anthropic.claude-opus-4-8`       | Open                                                                                                |
| Claude Opus 4.7                                                                             | `anthropic.claude-opus-4-7`       | Open                                                                                                |
| Claude Sonnet 5.5                                                                           | `anthropic.claude-sonnet-5-5`     | [See Access](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Sonnet 5                                                                             | `anthropic.claude-sonnet-5`       | Open                                                                                                |
| Claude Haiku 5.5                                                                            | `anthropic.claude-haiku-5-5`      | [See Access](https://platform.claude.com/docs/it/build-with-claude/claude-in-amazon-bedrock#access) |
| Claude Haiku 4.5                                                                            | `anthropic.claude-haiku-4-5`      | Open                                                                                                |

Usa la versione più recente di Claude Code con Claude in Amazon Bedrock; esegui `claude update` per aggiornare.

<Tip>
  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).
</Tip>

## Supporto delle funzionalità

Per l'elenco completo delle funzionalità con la disponibilità su Amazon Bedrock, consulta la [Panoramica delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/overview).

### Funzionalità supportate principali

* [Messages API](https://platform.claude.com/docs/it/api/messages/create) (`/anthropic/v1/messages`)
* [Prompt caching](https://platform.claude.com/docs/it/build-with-claude/prompt-caching) (cache dei prompt)
* [Thinking](https://platform.claude.com/docs/it/build-with-claude/thinking) (ragionamento)
* [Tool use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview) (uso degli strumenti), inclusi lo [strumento Bash](https://platform.claude.com/docs/it/agents-and-tools/tool-use/bash-tool), lo [strumento Computer use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool), lo [strumento Memory](https://platform.claude.com/docs/it/agents-and-tools/tool-use/memory-tool) e lo [strumento Text editor](https://platform.claude.com/docs/it/agents-and-tools/tool-use/text-editor-tool)
* [Citazioni](https://platform.claude.com/docs/it/build-with-claude/citations)

### Funzionalità non supportate

* [Output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs)
* Sorgenti di input (sorgenti URL per immagini e documenti, Files API)
* Strumenti lato server (esecuzione di codice, ricerca web, web fetch, advisor)
* Infrastruttura per agenti (Agent Skills, connettore MCP, chiamata programmatica degli strumenti)
* Endpoint API (Message Batches, Models, Admin, Compliance, Usage and Cost)
* Claude Managed Agents
* Fallback lato server (il [parametro `fallbacks`](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback); usa invece il [pattern di fallback lato client](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#client-side-fallback))
* Toolset [Computer use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool) e [browser use](https://platform.claude.com/docs/it/agents-and-tools/tool-use/browser-use-tool) (`computer_toolset_20260801` e `browser_toolset_20260801` non sono attualmente disponibili su Amazon Bedrock; le versioni beta dello strumento computer use rimangono disponibili)

## Regioni

Claude in Amazon Bedrock è disponibile nelle seguenti regioni AWS. Amazon Bedrock offre due tipi di endpoint:

* **Globale:** instradamento dinamico tra tutte le regioni disponibili per la massima disponibilità. Nessun sovrapprezzo.
* **Regionale:** l'endpoint si risolve nella singola regione AWS che specifichi, per i requisiti di residenza dei dati. Gli endpoint regionali comportano un sovrapprezzo del 10% rispetto agli endpoint globali. Per instradare tra più regioni all'interno di un'area geografica, usa un ["inference profile" (profilo di inferenza)](https://docs.aws.amazon.com/bedrock/latest/userguide/cross-region-inference.html) (US, EU, JP o AU). Le regioni contrassegnate con **Solo nella regione** nella tabella supportano l'instradamento diretto in una singola regione senza un profilo di inferenza.

L'endpoint globale è disponibile per Claude Fable 5.1, Claude Fable 5, Claude Opus 5.5, Claude Opus 5, Claude Opus 4.8, Claude Opus 4.7, Claude Sonnet 5.5, Claude Sonnet 5, Claude Haiku 5.5 e Claude Haiku 4.5. Per Claude Fable 5.1, gli endpoint regionali sono attualmente disponibili solo in `us-east-1`. Claude Mythos Preview è solo regionale ed è disponibile in `us-east-1`.

| Regione AWS      | Località                                | Tipi di endpoint                |
| ---------------- | --------------------------------------- | ------------------------------- |
| `af-south-1`     | Africa (Città del Capo)                 | Globale                         |
| `ap-northeast-1` | Asia Pacifico (Tokyo)                   | Globale, JP, Solo nella regione |
| `ap-northeast-2` | Asia Pacifico (Seul)                    | Globale                         |
| `ap-northeast-3` | Asia Pacifico (Osaka)                   | Globale, JP                     |
| `ap-south-1`     | Asia Pacifico (Mumbai)                  | Globale                         |
| `ap-south-2`     | Asia Pacifico (Hyderabad)               | Globale                         |
| `ap-southeast-1` | Asia Pacifico (Singapore)               | Globale                         |
| `ap-southeast-2` | Asia Pacifico (Sydney)                  | Globale, AU                     |
| `ap-southeast-3` | Asia Pacifico (Giacarta)                | Globale                         |
| `ap-southeast-4` | Asia Pacifico (Melbourne)               | Globale, AU, Solo nella regione |
| `ca-central-1`   | Canada (Centrale)                       | Globale, US                     |
| `ca-west-1`      | Canada Ovest (Calgary)                  | Globale                         |
| `eu-central-1`   | Europa (Francoforte)                    | Globale, EU                     |
| `eu-central-2`   | Europa (Zurigo)                         | Globale, EU                     |
| `eu-north-1`     | Europa (Stoccolma)                      | Globale, EU, Solo nella regione |
| `eu-south-1`     | Europa (Milano)                         | Globale, EU                     |
| `eu-south-2`     | Europa (Spagna)                         | Globale, EU                     |
| `eu-west-1`      | Europa (Irlanda)                        | Globale, EU, Solo nella regione |
| `eu-west-2`      | Europa (Londra)                         | Globale, EU                     |
| `eu-west-3`      | Europa (Parigi)                         | Globale, EU                     |
| `il-central-1`   | Israele (Tel Aviv)                      | Globale                         |
| `me-central-1`   | Medio Oriente (EAU)                     | Globale                         |
| `sa-east-1`      | Sud America (San Paolo)                 | Globale                         |
| `us-east-1`      | Stati Uniti Est (Virginia del Nord)     | Globale, US, Solo nella regione |
| `us-east-2`      | Stati Uniti Est (Ohio)                  | Globale, US, Solo nella regione |
| `us-west-1`      | Stati Uniti Ovest (California del Nord) | Globale, US                     |
| `us-west-2`      | Stati Uniti Ovest (Oregon)              | Globale, US, Solo nella regione |

## Quote

La quota predefinita è di 2 milioni di token di input al minuto (TPM). Puoi richiedere fino a 5 milioni di TPM di input e 500.000 TPM di output senza ulteriore approvazione da parte di Anthropic. AWS applica limiti di richieste al minuto (RPM) sul lato Bedrock; contatta il supporto AWS per modifiche agli RPM.

## Conservazione dei dati

La gestione dei dati per questa offerta è regolata da Amazon Bedrock. Per i dettagli, consulta [Data protection in Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/data-protection.html).

## Monitoraggio e logging

Claude in Amazon Bedrock emette log sia su CloudWatch che su CloudTrail. Anthropic consiglia di conservare i log delle attività su base continuativa di almeno 30 giorni per comprendere i modelli di utilizzo e indagare su potenziali problemi.

## Supporto

Per il supporto, contatta **[bedrock-ant-eap@amazon.com](mailto:bedrock-ant-eap@amazon.com)**. Includi l'ID del tuo account AWS e il `request-id` di eventuali risposte API non riuscite.

<Note>
  **Claude Mythos Preview** è un modello in anteprima di ricerca disponibile per i clienti invitati su Amazon Bedrock. Per maggiori informazioni, consulta [Project Glasswing](https://anthropic.com/glasswing).
</Note>
