---
title: Claude Models on Google Cloud (Google managed)
url: https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed
description: Google gestisce Claude Models on Google Cloud (Google managed) come parte di Google Cloud's Agent Platform. Puoi chiamare Claude con gli SDK client di Anthropic.
---

[Claude Models on Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/overview) confronta le due offerte di Google Cloud. Mostra anche come capire quale delle due utilizzi.

## Prima di effettuare chiamate API

Per usare Claude Models on Google Cloud (Google managed), hai bisogno di:

1. Un progetto Google Cloud che possa usare Agent Platform. Per i passaggi di configurazione, consulta la pagina di Google Cloud [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude).
2. La [gcloud CLI](https://cloud.google.com/sdk/docs/install) installata, per lo sviluppo locale.
3. Per l'identità che effettua le chiamate, un ruolo IAM che includa l'autorizzazione `aiplatform.endpoints.predict`, come Agent Platform User (`roles/aiplatform.user`). Per i dettagli, consulta la pagina di Google Cloud [Agent Platform partner models](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/use-partner-models).
4. Credenziali Google Cloud per quell'identità. Per gli esempi con gli SDK, potrebbe essere necessario eseguire `gcloud auth application-default login` per autenticarti con Google Cloud. Gli esempi cURL per Claude Models on Google Cloud (Google managed) ottengono il loro token con `gcloud auth print-access-token`. Quel comando usa il login proprio della gcloud CLI, non le Application Default Credentials. Per quegli esempi, esegui prima `gcloud auth login` o `gcloud init`.

### Installa un SDK

Gli [SDK client](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) di Anthropic supportano Claude Models on Google Cloud (Google managed) tramite `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). Installa il pacchetto che lo fornisce:

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

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

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

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

  <Tab title="Java">
    <CodeGroup exclude="shell, python, typescript, csharp, go, php, ruby">
      ```groovy Gradle
      implementation("com.anthropic:anthropic-java:3.1.0")
      implementation("com.anthropic:anthropic-java-vertex:3.1.0")
      ```

      ```xml Maven
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java</artifactId>
          <version>3.1.0</version>
      </dependency>
      <dependency>
          <groupId>com.anthropic</groupId>
          <artifactId>anthropic-java-vertex</artifactId>
          <version>3.1.0</version>
      </dependency>
      ```
    </CodeGroup>
  </Tab>

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

  <Tab title="Ruby">
    ```bash
    # Gemfile
    gem "anthropic"
    gem "googleauth"
    ```
  </Tab>
</Tabs>

La CLI `ant` non supporta Claude Models on Google Cloud (Google managed).

## Effettuare richieste

Le richieste a Claude Models on Google Cloud (Google managed) vengono inviate a un URL di endpoint di Agent Platform che termina con `:rawPredict`. Le richieste in streaming usano invece `:streamRawPredict`.

Una richiesta è quasi identica a una richiesta della [Messages API](https://platform.claude.com/docs/it/api/messages/create). Differisce principalmente in due modi:

* **Modello:** L'URL dell'endpoint specifica il modello. In una richiesta cURL, ometti `model` dal corpo.
* **Versione:** In una richiesta cURL, passa `anthropic_version` nel corpo, non come header. Impostalo su `vertex-2023-10-16`, oppure sulla [versione API `2026-10-21`](https://platform.claude.com/docs/it/api/migration-2026-10-21).

Gli esempi seguenti usano l'endpoint globale. Per gli altri tipi di endpoint, consulta [Endpoint globali, multi-regione e regionali](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  curl https://aiplatform.googleapis.com/v1/projects/MY_PROJECT_ID/locations/global/publishers/anthropic/models/claude-opus-5-5:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "anthropic_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Claude!"}],
      "max_tokens": 100
    }'
  ```

  <CodeGroupItem language="CLI">
    La CLI `ant` non supporta Claude Models on Google Cloud (Google managed).
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "global"

  client = AnthropicVertex(project_id=project_id, region=region)

  message = client.messages.create(
      model="claude-opus-5-5",
      max_tokens=100,
      messages=[
          {
              "role": "user",
              "content": "Hey Claude!",
          }
      ],
  )
  print(message)
  ```

  ```typescript TypeScript
  import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "global";

  // Segue il flusso standard di `google-auth-library`.
  const client = new AnthropicVertex({
    projectId,
    region
  });

  const result = await client.messages.create({
    model: "claude-opus-5-5",
    max_tokens: 100,
    messages: [
      {
        role: "user",
        content: "Hey Claude!"
      }
    ]
  });
  console.log(JSON.stringify(result, null, 2));
  ```

  ```csharp C#
  using Anthropic.Models.Messages;
  using Anthropic.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "global";

  var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));

  var parameters = new MessageCreateParams
  {
      Model = Model.ClaudeOpus5_5,
      MaxTokens = 100,
      Messages = [new UserMessageParam { Content = "Hey Claude!" }]
  };

  var message = await client.Messages.Create(parameters);
  Console.WriteLine(message);
  ```

  ```go Go
  import (
  	"context"
  	"fmt"

  	"github.com/anthropics/anthropic-sdk-go"
  	"github.com/anthropics/anthropic-sdk-go/vertex"
  )
  // ...
  	// Usa le credenziali predefinite di Google Cloud
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
  	)

  	message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
  		Model:     anthropic.ModelClaudeOpus5_5,
  		MaxTokens: 100,
  		Messages: []anthropic.MessageParam{
  			anthropic.NewUserMessage(anthropic.NewTextBlock("Hey Claude!")),
  		},
  	})
  	if err != nil {
  		panic(err)
  	}
  	fmt.Printf("%+v\n", message)
  ```

  ```java Java
  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;
  import com.anthropic.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("global")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();

      Message message = client
          .messages()
          .create(
              MessageCreateParams.builder()
                  .model(Model.CLAUDE_OPUS_5_5)
                  .maxTokens(100)
                  .addUserMessage("Hey Claude!")
                  .build()
          );

      IO.println(message);
  }
  ```

  ```php PHP
  <?php

  use Anthropic\Messages\TextBlock;
  use Anthropic\Vertex;

  $client = Vertex\Client::fromEnvironment(
      region: 'global',
      projectId: 'MY_PROJECT_ID',
  );

  $message = $client->messages->create(
      maxTokens: 100,
      messages: [
          ['role' => 'user', 'content' => 'Hey Claude!']
      ],
      model: 'claude-opus-5-5',
  );

  foreach ($message->content as $block) {
      if ($block instanceof TextBlock) {
          echo $block->text . PHP_EOL;
      }
  }
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "global",
    project_id: "MY_PROJECT_ID"
  )

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

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

### ID dei modelli API

| Model                                                                                                 | Agent Platform API model ID  |
| :---------------------------------------------------------------------------------------------------- | :--------------------------- |
| Claude Fable 5.1                                                                                      | `claude-fable-5-1`           |
| Claude Mythos 5.1 ([limited availability](https://support.claude.com/en/articles/14604842))           | `claude-mythos-5-1`          |
| Claude Fable 5                                                                                        | `claude-fable-5`             |
| Claude Mythos 5 ([limited availability](https://support.claude.com/en/articles/14604842))             | `claude-mythos-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@20251101`   |
| Claude Opus 4.1 ([deprecated](https://platform.claude.com/docs/it/about-claude/model-deprecations))   | `claude-opus-4-1@20250805`   |
| Claude Opus 4 ([deprecated](https://platform.claude.com/docs/it/about-claude/model-deprecations))     | `claude-opus-4@20250514`     |
| 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@20250929` |
| Claude Sonnet 4 ([deprecated](https://platform.claude.com/docs/it/about-claude/model-deprecations))   | `claude-sonnet-4@20250514`   |
| Claude Haiku 5.5                                                                                      | `claude-haiku-5-5`           |
| Claude Haiku 4.5                                                                                      | `claude-haiku-4-5@20251001`  |
| Claude Haiku 3.5 ([deprecated](https://platform.claude.com/docs/it/about-claude/model-deprecations))  | `claude-3-5-haiku@20241022`  |

Claude Models on Google Cloud (Google managed) offre modelli Claude diversi in regioni diverse. Per verificare quali modelli offre una regione, cerca "Claude" in [Model Garden](https://cloud.google.com/model-garden) oppure consulta la pagina di Google Cloud [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude).

Google stabilisce le date del ciclo di vita dei modelli serviti da Claude Models on Google Cloud (Google managed). Queste date possono differire dal calendario della Claude API. Per la data di ritiro attuale di un modello, consulta la pagina di Google Cloud [Anthropic Claude models on Agent Platform](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude). Per il significato di Deprecated e Retired, consulta [Deprecazioni dei modelli](https://platform.claude.com/docs/it/about-claude/model-deprecations).

<Note>
  Claude Mythos Preview è una research preview. Claude Models on Google Cloud (Google managed) la offre ai clienti invitati. Per maggiori informazioni, consulta [Project Glasswing](https://anthropic.com/glasswing).
</Note>

<Tip>
  Stai passando a un modello Claude più recente? La [skill Claude API](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model) in Claude Code applica le sostituzioni degli ID dei modelli e le modifiche incompatibili ai parametri in tutta la tua base di codice:

  Lascia che Claude Code migri il tuo codice per te

  ```text
  /claude-api migrate questo progetto all'ultimo modello Claude Opus
  ```

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

## Endpoint globali, multi-regione e regionali

Claude Models on Google Cloud (Google managed) offre tre tipi di endpoint. Ne scegli uno con il valore di regione che passi quando crei il client. In una richiesta cURL, il tipo di endpoint determina l'host e il segmento `locations` dell'URL.

| Tipo di endpoint          | Valore di regione              | Host                                                                       |
| ------------------------- | ------------------------------ | -------------------------------------------------------------------------- |
| **Globale** (consigliato) | `"global"`                     | `aiplatform.googleapis.com`                                                |
| **Multi-regione**         | `"us"` o `"eu"`                | `aiplatform.us.rep.googleapis.com`<br />`aiplatform.eu.rep.googleapis.com` |
| **Regionale**             | Una regione, come `"us-east5"` | `{region}-aiplatform.googleapis.com`                                       |

I tipi di endpoint differiscono per la destinazione a cui inviano le richieste:

* **Globale:** Le richieste vengono inviate a qualsiasi regione con capacità disponibile. Usalo quando desideri la massima disponibilità e la residenza dei dati è flessibile.
* **Multi-regione:** Le richieste vengono inviate a qualsiasi regione negli Stati Uniti (`"us"`) o nell'Unione Europea (`"eu"`). Usalo quando hai bisogno della residenza dei dati all'interno di un'ampia area geografica e di una disponibilità maggiore rispetto a una singola regione.
* **Regionale:** Le richieste vengono inviate solo alla regione che specifichi, come `"us-east5"` o `"europe-west1"`. Usalo quando hai bisogno della residenza dei dati in una singola regione o devi rispettare requisiti di conformità rigorosi.

Gli endpoint multi-regione e regionali costano il 10% in più rispetto agli endpoint globali. Tutti e tre i tipi di endpoint accettano traffico pay-as-you-go, mentre il throughput con provisioning richiede un endpoint regionale.

Gli endpoint regionali servono solo Claude Sonnet 4.6 e i modelli precedenti. Per i modelli più recenti, usa un endpoint globale o multi-regione.

<Note>
  Il sovrapprezzo per gli endpoint multi-regione e regionali si applica solo a Claude Sonnet 4.5 (deprecato) e ai modelli successivi. Per i modelli che mantengono i prezzi precedenti, consulta [Prezzi delle piattaforme cloud](https://platform.claude.com/docs/it/about-claude/pricing#cloud-platform-pricing). Per gli endpoint regionali, il sovrapprezzo riflette i costi infrastrutturali della capacità regionale dedicata.
</Note>

Gli esempi seguenti usano l'endpoint multi-regione `us`. Le righe evidenziate impostano la regione. Per una richiesta completa sull'endpoint globale, consulta [Effettuare richieste](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#accessing-vertex-ai).

<CodeGroup exclude="shell:CLI">
  ```bash cURL
  # L'identificatore multi-regione, "us" o "eu", compare nel nome host e nel percorso
  curl https://aiplatform.us.rep.googleapis.com/v1/projects/MY_PROJECT_ID/locations/us/publishers/anthropic/models/claude-opus-5-5:rawPredict \
    -H "Authorization: Bearer $(gcloud auth print-access-token)" \
    -H "Content-Type: application/json" \
    -d '{
      "anthropic_version": "vertex-2023-10-16",
      "messages": [{"role": "user", "content": "Hey Claude!"}],
      "max_tokens": 100
    }'
  ```

  <CodeGroupItem language="CLI">
    La CLI `ant` non supporta Claude Models on Google Cloud (Google managed).
  </CodeGroupItem>

  ```python Python
  from anthropic import AnthropicVertex

  project_id = "MY_PROJECT_ID"
  region = "us"  # Multi-region identifier: "us" or "eu"

  client = AnthropicVertex(project_id=project_id, region=region)
  ```

  ```typescript TypeScript
  import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

  const projectId = "MY_PROJECT_ID";
  const region = "us"; // Multi-region identifier: "us" or "eu"

  const client = new AnthropicVertex({
    projectId,
    region
  });
  ```

  ```csharp C#
  using Anthropic.Vertex;

  var projectId = "MY_PROJECT_ID";
  var region = "us"; // Multi-region identifier: "us" or "eu"

  var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));
  ```

  ```go Go
  import (
  	"context"

  	"github.com/anthropics/anthropic-sdk-go"
  	"github.com/anthropics/anthropic-sdk-go/vertex"
  )
  // ...
  	// Identificatore multi-regione: "us" o "eu"
  	client := anthropic.NewClient(
  		vertex.WithGoogleAuth(context.Background(), "us", "MY_PROJECT_ID"),
  	)
  ```

  ```java Java
  import com.anthropic.client.AnthropicClient;
  import com.anthropic.client.okhttp.AnthropicOkHttpClient;
  import com.anthropic.vertex.backends.VertexBackend;
  import com.google.auth.oauth2.GoogleCredentials;

  void main() throws Exception {
      // Identificatore multi-regione: "us" o "eu"
      AnthropicClient client = AnthropicOkHttpClient.builder()
          .backend(
              VertexBackend.builder()
                  .googleCredentials(GoogleCredentials.getApplicationDefault())
                  .region("us")
                  .project("MY_PROJECT_ID")
                  .build()
          )
          .build();
  }
  ```

  ```php PHP
  use Anthropic\Vertex;

  $client = Vertex\Client::fromEnvironment(
      region: 'us', // Multi-region identifier: "us" or "eu"
      projectId: 'MY_PROJECT_ID',
  );
  ```

  ```ruby Ruby
  require "anthropic"

  client = Anthropic::VertexClient.new(
    region: "us", # Multi-region identifier: "us" or "eu"
    project_id: "MY_PROJECT_ID"
  )
  ```
</CodeGroup>

## Funzionalità supportate

Le funzionalità supportate su Claude Models on Google Cloud (Google managed) includono le seguenti:

* [Messages API](https://platform.claude.com/docs/it/api/messages/create)

* ["Prompt caching" (cache dei prompt)](https://platform.claude.com/docs/it/build-with-claude/prompt-caching)

* ["Thinking" (ragionamento)](https://platform.claude.com/docs/it/build-with-claude/thinking)

* ["Tool use" (uso degli strumenti)](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview), inclusi questi strumenti:

  * [Strumento Bash](https://platform.claude.com/docs/it/agents-and-tools/tool-use/bash-tool)
  * [Strumento di uso del browser](https://platform.claude.com/docs/it/agents-and-tools/tool-use/browser-use-tool)
  * [Strumento di uso del computer](https://platform.claude.com/docs/it/agents-and-tools/tool-use/computer-use-tool)
  * [Strumento di memoria](https://platform.claude.com/docs/it/agents-and-tools/tool-use/memory-tool)
  * [Strumento editor di testo](https://platform.claude.com/docs/it/agents-and-tools/tool-use/text-editor-tool)
  * [Strumento di ricerca web](https://platform.claude.com/docs/it/agents-and-tools/tool-use/web-search-tool)

* [Citazioni](https://platform.claude.com/docs/it/build-with-claude/citations)

* [Output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs)

La [panoramica delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/overview) elenca ogni funzionalità e indica se Claude Models on Google Cloud (Google managed) la supporta.

### Funzionalità non supportate

Claude Models on Google Cloud (Google managed) non supporta quanto segue:

* **Sorgenti di input:** Sorgenti URL per immagini e documenti, e la Files API
* **Strumenti lato server:** Esecuzione di codice, web fetch e advisor
* **Infrastruttura per agenti:** Agent Skills, connettore MCP e chiamata programmatica degli strumenti
* **Endpoint API:** Message Batches API, Models API, Admin API, Compliance API e Usage and Cost API
* **Claude Managed Agents**
* **Fallback lato server:** Il [parametro `fallbacks`](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback)

Invece del fallback lato server, usa il [pattern di fallback lato client](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#client-side-fallback).

### Finestra di contesto

Claude Models on Google Cloud (Google managed) offre una ["context window" (finestra di contesto) da 1M di token](https://platform.claude.com/docs/it/build-with-claude/context-windows) per questi modelli:

* Claude Fable 5.1
* Claude Fable 5
* Claude Opus 5.5
* Claude Opus 5
* Claude Opus 4.8
* Claude Opus 4.7
* Claude Opus 4.6
* Claude Sonnet 5.5
* Claude Sonnet 5
* Claude Sonnet 4.6
* Claude Haiku 5.5

Gli altri modelli Claude hanno una finestra di contesto da 200k token. Tra questi ci sono Claude Sonnet 4.5 (deprecato) e Claude Sonnet 4 (deprecato).

Agent Platform limita i payload delle richieste a 30 MB. Quando invii documenti di grandi dimensioni o molte immagini, potresti raggiungere questo limite prima del limite di token.

## Fatturazione, limiti di velocità e logging

### Limiti di velocità

Google Cloud gestisce i "rate limits" (limiti di velocità) e le quote per Claude Models on Google Cloud (Google managed). Per i dettagli, incluso come richiedere un aumento della quota, consulta la pagina di Google Cloud [Quotas for Anthropic Claude models](https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude/quotas).

### Fatturazione

Google Cloud ti fattura per Claude Models on Google Cloud (Google managed). Per i prezzi, consulta la pagina di Google Cloud [Generative AI pricing](https://cloud.google.com/vertex-ai/generative-ai/pricing#claude-models). I prezzi dipendono anche dal tipo di endpoint. Consulta [Endpoint globali, multi-regione e regionali](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

### Conservazione dei dati

Google Cloud regola la gestione dei dati per Claude Models on Google Cloud (Google managed). Per i dettagli, consulta [Agent Platform and zero data retention](https://cloud.google.com/vertex-ai/generative-ai/docs/data-governance).

### Monitoraggio e logging

Per registrare prompt e completamenti per Claude Models on Google Cloud (Google managed), usa il [servizio di logging di richieste e risposte](https://cloud.google.com/vertex-ai/generative-ai/docs/multimodal/request-response-logging) di Agent Platform.

Anthropic consiglia di conservare almeno gli ultimi 30 giorni di log. I log ti aiutano a comprendere la tua attività e a indagare su possibili usi impropri.

<Note>
  L'attivazione di questo servizio non concede a Google o ad Anthropic alcun accesso ai tuoi contenuti.
</Note>

## Migrazione da Claude Models on Google Cloud (Anthropic managed)

Per sapere cosa cambia con il passaggio, consulta [In cosa differiscono le due offerte di Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/overview#how-the-two-google-cloud-offerings-differ). Per passare a Claude Models on Google Cloud (Google managed), segui questi passaggi:

<Steps>
  <Step title="Configura l'accesso">
    Verifica che il tuo progetto e l'identità che effettua le chiamate soddisfino i requisiti indicati in [Prima di effettuare chiamate API](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#before-making-api-calls).
  </Step>

  <Step title="Installa il pacchetto SDK">
    Installa il pacchetto che fornisce il client per Claude Models on Google Cloud (Google managed). Consulta [Installa un SDK](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#install-an-sdk-for-accessing-vertex-ai).
  </Step>

  <Step title="Sostituisci l'import e il client">
    Modifica il codice che importa e crea il tuo client. Usa `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`) al posto di `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). Una richiesta cURL richiede un nuovo URL, nuovi header e un nuovo corpo. Il codice seguente crea il client per Claude Models on Google Cloud (Anthropic managed) che usi oggi:

    <CodeGroup>
      ```bash cURL
      curl "https://claude.googleapis.com/v1/projects/$ANTHROPIC_GOOGLE_CLOUD_PROJECT/locations/global/workspaces/$ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID/invoke/v1/messages" \
        -H "Authorization: Bearer $(gcloud auth application-default print-access-token)" \
        -H "content-type: application/json" \
        -H "anthropic-version: 2023-06-01" \
        -d '{
          "model": "claude-opus-5-5",
          "max_tokens": 1024,
          "messages": [
            {"role": "user", "content": "Hello, Claude"}
          ]
        }'
      ```

      ```bash CLI
      ant messages create \
        --model claude-opus-5-5 \
        --max-tokens 1024 \
        --message '{role: user, content: "Hello, Claude"}'
      ```

      ```python Python
      from anthropic import AnthropicGoogleCloud

      client = AnthropicGoogleCloud()
      ```

      ```typescript TypeScript
      import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";

      const client = new AnthropicGoogleCloud();
      ```

      ```csharp C#
      using Anthropic.GoogleCloud;

      var client = new AnthropicGoogleCloudClient();
      ```

      ```go Go
      import (
      	"context"

      	"github.com/anthropics/anthropic-sdk-go"
      	"github.com/anthropics/anthropic-sdk-go/googlecloud"
      )
      // ...
      	client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
      	if err != nil {
      		panic(err)
      	}
      ```

      ```java Java
      import com.anthropic.client.AnthropicClient;
      import com.anthropic.client.okhttp.AnthropicOkHttpClient;
      import com.anthropic.googlecloud.backends.GoogleCloudBackend;

      void main() {
          AnthropicClient client = AnthropicOkHttpClient.builder()
              .backend(GoogleCloudBackend.fromEnv())
              .build();
      }
      ```

      ```php PHP
      use Anthropic\GoogleCloud\Client;

      $client = new Client();
      ```

      ```ruby Ruby
      require "anthropic"

      client = Anthropic::GoogleCloudClient.new
      ```
    </CodeGroup>

    Il codice seguente crea il client per Claude Models on Google Cloud (Google managed). Usa l'endpoint globale. Per gli altri tipi di endpoint, consulta [Endpoint globali, multi-regione e regionali](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#global-multi-region-and-regional-endpoints).

    <CodeGroup exclude="shell:CLI">
      ```bash cURL
      curl https://aiplatform.googleapis.com/v1/projects/MY_PROJECT_ID/locations/global/publishers/anthropic/models/claude-opus-5-5:rawPredict \
        -H "Authorization: Bearer $(gcloud auth print-access-token)" \
        -H "Content-Type: application/json" \
        -d '{
          "anthropic_version": "vertex-2023-10-16",
          "messages": [{"role": "user", "content": "Hey Claude!"}],
          "max_tokens": 100
        }'
      ```

      <CodeGroupItem language="CLI">
        La CLI `ant` non supporta Claude Models on Google Cloud (Google managed). Usa invece cURL o un SDK.
      </CodeGroupItem>

      ```python Python
      from anthropic import AnthropicVertex

      project_id = "MY_PROJECT_ID"
      region = "global"

      client = AnthropicVertex(project_id=project_id, region=region)
      ```

      ```typescript TypeScript
      import { AnthropicVertex } from "@anthropic-ai/vertex-sdk";

      const projectId = "MY_PROJECT_ID";
      const region = "global";

      const client = new AnthropicVertex({
        projectId,
        region
      });
      ```

      ```csharp C#
      using Anthropic.Vertex;

      var projectId = "MY_PROJECT_ID";
      var region = "global";

      var client = new AnthropicVertexClient(new AnthropicVertexCredentials(region, projectId));
      ```

      ```go Go
      import (
      	"context"

      	"github.com/anthropics/anthropic-sdk-go"
      	"github.com/anthropics/anthropic-sdk-go/vertex"
      )
      // ...
      	// Usa le credenziali predefinite di Google Cloud
      	client := anthropic.NewClient(
      		vertex.WithGoogleAuth(context.Background(), "global", "MY_PROJECT_ID"),
      	)
      ```

      ```java Java
      import com.anthropic.client.AnthropicClient;
      import com.anthropic.client.okhttp.AnthropicOkHttpClient;
      import com.anthropic.vertex.backends.VertexBackend;
      import com.google.auth.oauth2.GoogleCredentials;

      void main() throws Exception {
          AnthropicClient client = AnthropicOkHttpClient.builder()
              .backend(
                  VertexBackend.builder()
                      .googleCredentials(GoogleCredentials.getApplicationDefault())
                      .region("global")
                      .project("MY_PROJECT_ID")
                      .build()
              )
              .build();
      }
      ```

      ```php PHP
      use Anthropic\Vertex;

      $client = Vertex\Client::fromEnvironment(
          region: 'global',
          projectId: 'MY_PROJECT_ID',
      );
      ```

      ```ruby Ruby
      require "anthropic"

      client = Anthropic::VertexClient.new(
        region: "global",
        project_id: "MY_PROJECT_ID"
      )
      ```
    </CodeGroup>

    Questo codice passa l'ID del tuo progetto e una regione quando crea il client. Sostituisci `MY_PROJECT_ID` con l'ID del tuo progetto. Le chiamate alla Messages API che effettui con il client restano invariate. Le eccezioni sono gli ID dei modelli e le funzionalità indicati nel passaggio successivo.
  </Step>

  <Step title="Verifica gli ID dei modelli e le funzionalità">
    * **ID dei modelli:** Se usi un modello precedente a Claude 4.6, sostituisci il trattino prima della data dello snapshot nel suo ID con `@`. Ad esempio, `claude-haiku-4-5-20251001` diventa `claude-haiku-4-5@20251001`. Per i modelli e i relativi ID, consulta [ID dei modelli API](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#api-model-ids).
    * **Funzionalità:** Verifica che le funzionalità usate dal tuo codice non siano elencate in [Funzionalità non supportate](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#features-not-supported).
  </Step>

  <Step title="Esegui una richiesta di prova">
    Esegui la richiesta in [Effettuare richieste](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#accessing-vertex-ai) per verificare che la tua configurazione funzioni. Poi esegui il tuo codice. Prima di spostare il traffico di produzione, leggi le informazioni sui [limiti di velocità per Claude Models on Google Cloud (Google managed)](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/google-managed#rate-limits).
  </Step>
</Steps>

## Passaggi successivi

<CardGroup cols={2}>
  <Card title="Panoramica delle funzionalità" icon="stack" href="https://platform.claude.com/docs/it/build-with-claude/overview">
    Esplora le funzionalità di Claude.
  </Card>

  <Card title="Modelli Anthropic Claude su Agent Platform" icon="book" href="https://docs.cloud.google.com/gemini-enterprise-agent-platform/models/partner-models/claude">
    Verifica quali modelli Claude offre ciascuna regione e le relative date di ritiro.
  </Card>

  <Card title="Documentazione di Agent Platform" icon="book" href="https://cloud.google.com/vertex-ai/docs">
    Leggi la documentazione di Google Cloud's Agent Platform.
  </Card>

  <Card title="Endpoint globale per i modelli Claude" icon="link" href="https://cloud.google.com/blog/products/ai-machine-learning/global-endpoint-for-claude-models-generally-available-on-vertex-ai">
    Leggi il post del blog di Google Cloud sull'endpoint globale per i modelli Claude.
  </Card>
</CardGroup>