---
title: Claude Models on Google Cloud (Anthropic managed)
url: https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed
description: Claude Models on Google Cloud (Anthropic managed) è la Claude API, gestita da Anthropic e raggiungibile tramite il tuo progetto Google Cloud.
---
Google Cloud gestisce l'accesso e la fatturazione per Claude Models on Google Cloud (Anthropic managed). Per confrontare le due offerte Google Cloud, o per verificare quale utilizzi, consulta [Claude Models on Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/overview).
## Configura il tuo account
Per configurare il tuo account per Claude Models on Google Cloud (Anthropic managed), ti serve quanto segue:
* L'autorizzazione ad acquistare in Google Cloud Marketplace sul tuo account di fatturazione
* L'autorizzazione ad abilitare i servizi sul progetto
* Un [ruolo IAM che ti consenta di aprire la Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), necessario per il passaggio 4
Questi passaggi creano una nuova organizzazione Anthropic per il tuo progetto Google Cloud. È separata da qualsiasi organizzazione Anthropic già esistente nella tua azienda, inclusa un'organizzazione Claude Enterprise. Per passare da un'organizzazione esistente, consulta [Passare da un'organizzazione Anthropic esistente](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#moving-from-an-existing-anthropic-organization).
Se disponi di uno sconto esistente, contatta il tuo referente Anthropic o Google Cloud prima di iniziare questi passaggi. Gli sconti non possono essere applicati all'utilizzo passato.
1. Apri [Google Cloud Marketplace](https://console.cloud.google.com/marketplace) e trova l'inserzione **Claude Models on Google Cloud (Anthropic managed)**.
2. Scegli **Subscribe** e completa il flusso di acquisto.
3. Torna all'inserzione e scegli **Manage on Console**. Si apre la pagina Claude nella console Google Cloud.
Per tornare alla pagina Claude in seguito, seleziona il tuo progetto nella console Google Cloud. Poi vai su **Agent Platform > Models > Claude Platform** e scegli **Anthropic managed**.
Abilita due servizi su ogni progetto che chiama Claude Models on Google Cloud (Anthropic managed):
* `claude.googleapis.com` fornisce l'API per Claude Models on Google Cloud (Anthropic managed). Questo servizio definisce anche le autorizzazioni IAM. Senza di esso le chiamate falliscono.
* `anthropic-managed-claude.cloudpartnerservices.goog` è il servizio Marketplace che attribuisce l'utilizzo del progetto al tuo abbonamento.
```bash CLI
gcloud services enable claude.googleapis.com \
anthropic-managed-claude.cloudpartnerservices.goog \
--project=my-project-id
```
Sostituisci `my-project-id` con l'ID del tuo progetto.
Puoi anche abilitarli entrambi dalla pagina Claude o da **APIs & Services**. L'abilitazione è un passaggio da eseguire una sola volta per ogni progetto. Per verificare che entrambi i servizi siano abilitati, esegui `gcloud services list --enabled --project=my-project-id` e cerca entrambi i nomi.
1. Nella pagina Claude, scegli **Activate**.
2. Nel flusso di configurazione di Anthropic, inserisci un indirizzo email di contatto.
3. Apri il link di configurazione inviato a quell'indirizzo.
4. Compila il nome dell'organizzazione, il tipo di entità, il paese e l'uso previsto.
5. Accetta i Termini di servizio commerciali e la Politica di utilizzo di Anthropic.
L'indirizzo di contatto viene utilizzato solo per la configurazione e per le comunicazioni di servizio. Per sapere come le persone aprono la Claude Console dopo la configurazione, consulta [Usare la Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Quando la tua organizzazione Anthropic è attiva, il pulsante nella pagina Claude diventa **Open Claude Console**. Sceglilo. Google Cloud verifica il tuo accesso IAM. Poi reindirizza il browser a `platform.claude.com`. Hai effettuato l'accesso alla nuova organizzazione.
Mentre sei nella Claude Console, [trova l'ID del tuo workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id) e copialo. Serve a chiunque chiami Claude Models on Google Cloud (Anthropic managed). Comunicalo ai tuoi sviluppatori.
Per aggiungere un altro progetto, ripeti questi passaggi in quel progetto, a partire dal passaggio 2.
### Risoluzione dei problemi di configurazione dell'account
Se riscontri uno dei seguenti problemi durante la configurazione di Claude Models on Google Cloud (Anthropic managed), applica la relativa soluzione:
* **`gcloud services enable` non trova `anthropic-managed-claude.cloudpartnerservices.goog`:** Esegui il comando con l'account che ha completato l'acquisto in Marketplace, oppure contatta il tuo referente Anthropic.
* **Un errore di autorizzazione alla prima chiamata API:** Verifica che `claude.googleapis.com` sia abilitato sul progetto che stai chiamando. Verifica che il chiamante abbia `roles/claude.user` o `roles/claude.admin` su quel progetto. Per sapere cosa consente ciascun ruolo, consulta [Ruoli IAM](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles). Una nuova concessione o un servizio appena abilitato possono richiedere qualche istante per essere applicati.
* **"Signed in as a different account" dopo aver seguito il link di configurazione:** Scegli **Log out and continue**. Poi usa l'indirizzo email che hai inserito nel passaggio 3.
* **Il pulsante indica "Finish Setup" invece di "Open Claude Console":** La tua organizzazione Anthropic esiste, ma la sua configurazione non è completa. Un amministratore deve completare il modulo con i dettagli dell'organizzazione.
* **La pagina Usage non mostra dati dopo la prima chiamata API:** I dati di utilizzo possono richiedere alcuni minuti per comparire nella Claude Console.
## Gestisci l'accesso
### Ruoli IAM
Claude Models on Google Cloud (Anthropic managed) dispone di tre ruoli IAM predefiniti. Concedi i ruoli sul progetto.
| Ruolo | Nome visualizzato | Cosa consente |
| --------------------- | ----------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `roles/claude.viewer` | Claude Viewer | Ogni autorizzazione `get` e `list` sulle risorse del workspace
Questo ruolo è di sola lettura. |
| `roles/claude.user` | Claude User | Tutto ciò che consente `roles/claude.viewer`, più la creazione e la modifica delle risorse del workspace
Ciò include l'invio di messaggi e il conteggio dei token. Include anche la gestione di batch, file, skill e risorse di Claude Managed Agents. |
| `roles/claude.admin` | Claude Admin | Tutto ciò che consente `roles/claude.user`, più le autorizzazioni verificate sulla tua organizzazione Anthropic
Le route a livello di organizzazione agiscono sulla tua organizzazione Anthropic nel suo complesso, non su un singolo workspace. |
Ad esempio, il seguente comando consente a un service account di chiamare Claude Models on Google Cloud (Anthropic managed):
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="serviceAccount:my-app@my-project-id.iam.gserviceaccount.com" \
--role="roles/claude.user"
```
Per autorizzazioni, ruoli predefiniti e tipi di audit log, consulta [Autorizzazioni IAM per Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
L'abilitazione di `claude.googleapis.com` crea un service agent per il progetto. Non rimuovere le sue concessioni di ruolo. Rimuoverle impedisce a Claude Models on Google Cloud (Anthropic managed) di funzionare nel progetto.
### Usare la Claude Console
Con Claude Models on Google Cloud (Anthropic managed), non puoi usare un indirizzo email per accedere alla tua organizzazione Anthropic. Scegli invece **Open Claude Console** nella [pagina Claude](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) della console Google Cloud. Google Cloud IAM controlla chi può aprire la Claude Console. Dei tre [ruoli IAM](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) predefiniti, solo `roles/claude.admin` sul progetto ti consente di aprire la Claude Console.
### Workspace
In Claude Models on Google Cloud (Anthropic managed), la configurazione crea la tua organizzazione Anthropic con un solo workspace, il Default Workspace. Per creare altri workspace, [apri la Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) e vai su **Settings > Workspaces**. Nella stessa pagina puoi rinominare o archiviare qualsiasi workspace tranne il Default Workspace. Ogni workspace ha il proprio [ID workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). File, skill, batch, sessioni di Claude Managed Agents e altre risorse del workspace appartengono al workspace il cui ID [imposti per la richiesta](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Concedi i [ruoli IAM](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) sul progetto, quindi un ruolo si applica a ogni workspace di quel progetto. Quando i team necessitano di accessi separati, assegna a ciascun team il proprio progetto Google Cloud. Ogni progetto ha la propria organizzazione Anthropic, quindi ripeti i [passaggi di configurazione](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) in ciascun progetto, a partire dal passaggio 2.
## Prima di effettuare chiamate API
Per chiamare Claude Models on Google Cloud (Anthropic managed), ti serve quanto segue:
1. Un progetto Google Cloud con un abbonamento attivo e un'organizzazione Anthropic la cui configurazione sia completa. Consulta [Configura il tuo account](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
2. La [gcloud CLI](https://cloud.google.com/sdk/docs/install) installata, per lo sviluppo locale.
3. Il ruolo `roles/claude.user`, concesso sul progetto all'identità che effettua le chiamate.
4. Le Application Default Credentials per quell'identità. Consulta [Autenticazione](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#authentication).
5. L'ID del tuo progetto e l'[ID del tuo workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id).
Per concedere il ruolo al tuo account per lo sviluppo locale, esegui il seguente comando. Ti serve l'autorizzazione a modificare la policy IAM del progetto.
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="user:you@example.com" \
--role="roles/claude.user"
```
Sostituisci `my-project-id` con l'ID del tuo progetto. Sostituisci `you@example.com` con l'indirizzo email del tuo account Google. Per vedere il progetto che gcloud sta usando, esegui `gcloud config get-value project`. Per i service account e gli altri ruoli, consulta [Ruoli IAM](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
### Trova l'ID del tuo workspace
Per trovare l'ID del tuo workspace per Claude Models on Google Cloud (Anthropic managed), [apri la Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) e vai su **Settings > Workspaces**. L'ID inizia con `wrkspc_`. Se non puoi aprire la Claude Console, chiedi a qualcuno che può aprirla di inviarti l'ID.
Imposta il progetto e il workspace come variabili d'ambiente in modo che i client SDK e la [CLI `ant`](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/quickstart) li rilevino:
```bash CLI
export ANTHROPIC_GOOGLE_CLOUD_PROJECT="my-project-id"
export ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID="wrkspc_01AbCdEf23GhIj"
```
### Installa un SDK
Il [client SDK](https://platform.claude.com/docs/it/cli-sdks-libraries/overview) per Claude Models on Google Cloud (Anthropic managed) è `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). Il client risolve le tue credenziali Google. Costruisce inoltre l'URL di base a partire dal tuo progetto, dalla location e dall'ID del workspace.
I client SDK per Claude Models on Google Cloud (Anthropic managed) sono in beta.
Installa il pacchetto che fornisce il client:
```bash
pip install -U "anthropic[google_cloud]"
```
```bash
npm install @anthropic-ai/google-cloud-sdk
```
```bash
dotnet add package Anthropic.GoogleCloud
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:3.1.0")
implementation("com.anthropic:anthropic-java-google-cloud:3.1.0")
```
```xml Maven
com.anthropic
anthropic-java
3.1.0
com.anthropic
anthropic-java-google-cloud
3.1.0
```
```bash
composer require anthropic-ai/sdk google/auth
```
```bash
gem install anthropic googleauth
```
Per usare invece la CLI `ant`, [installala o aggiornala](https://platform.claude.com/docs/it/cli-sdks-libraries/cli/quickstart#installation) all'ultima versione. Una versione senza supporto per Claude Models on Google Cloud (Anthropic managed) ignora le variabili `ANTHROPIC_GOOGLE_CLOUD_*`. In tal caso esegue una delle seguenti azioni:
* Invia la richiesta alla Claude API con qualsiasi altra credenziale che hai configurato
* Fallisce con un errore di autenticazione
## Effettuare richieste
Claude Models on Google Cloud (Anthropic managed) fornisce gli endpoint della Claude API sotto un URL di base che indica il tuo progetto, una location e il tuo workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/workspaces/{workspace}/invoke
```
Le [route a livello di organizzazione](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles), i cui percorsi iniziano con `/v1/organizations/`, usano un URL di base senza il workspace:
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/claudeOrganization/invoke
```
Se non [imposti l'URL di base](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution), i client SDK scelgono tra questi due per ogni richiesta.
Aggiungi il percorso della Claude API all'URL di base. Ad esempio, la [Messages API](https://platform.claude.com/docs/it/api/messages/create) si trova in `.../invoke/v1/messages`. Tre aspetti differiscono da una richiesta alla Claude API:
* **URL di base:** Gli URL con ambito di progetto mostrati in precedenza, al posto di `https://api.anthropic.com`.
* **Autenticazione:** Un header `Authorization: Bearer` con un token di accesso Google. Non inviare un header `x-api-key`.
* **Workspace:** L'ID del workspace fa parte dell'URL. Non inviare un header `anthropic-workspace-id`.
Tutto il resto è uguale alla Claude API, incluso quanto segue:
* Gli header `anthropic-version` e `anthropic-beta`
* Il corpo della richiesta
* Lo streaming
* La risposta
Gli esempi di codice presenti altrove in questa documentazione creano il client della Claude API e leggono una chiave API. Per eseguirne uno con Claude Models on Google Cloud (Anthropic managed), sostituisci il relativo import e il costruttore del client con quelli degli esempi seguenti. Per un esempio cURL, applica le tre differenze elencate in precedenza.
Prima di eseguire questi esempi, completa i passaggi in [Prima di effettuare chiamate API](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
```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()
message = client.messages.create(
model="claude-opus-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello, Claude"}],
)
print(message)
```
```typescript TypeScript
import { AnthropicGoogleCloud } from "@anthropic-ai/google-cloud-sdk";
const client = new AnthropicGoogleCloud();
const message = await client.messages.create({
model: "claude-opus-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
});
console.log(message);
```
```csharp C#
using Anthropic.GoogleCloud;
using Anthropic.Models.Messages;
var client = new AnthropicGoogleCloudClient();
var parameters = new MessageCreateParams
{
Model = Model.ClaudeOpus5_5,
MaxTokens = 1024,
Messages = [new UserMessageParam { Content = "Hello, 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/googlecloud"
)
func main() {
client, err := googlecloud.NewClient(context.Background(), googlecloud.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeOpus5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello, Claude")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
}
```
```java Java
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.googlecloud.backends.GoogleCloudBackend;
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(GoogleCloudBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_OPUS_5_5)
.maxTokens(1024)
.addUserMessage("Hello, Claude")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\GoogleCloud\Client;
use Anthropic\Messages\Model;
$client = new Client();
$message = $client->messages->create(
model: Model::CLAUDE_OPUS_5_5,
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello, Claude']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::GoogleCloudClient.new
message = client.messages.create(
model: Anthropic::Model::CLAUDE_OPUS_5_5,
max_tokens: 1024,
messages: [{ role: "user", content: "Hello, Claude" }]
)
puts message
```
L'esempio cURL chiede a gcloud un token delle Application Default Credentials. I token di accesso hanno una durata breve. Generane uno per ogni sessione invece di memorizzarlo.
### ID dei modelli API
Claude Models on Google Cloud (Anthropic managed) usa gli stessi ID dei modelli della Claude API, ad esempio `claude-opus-5-5`. Per i modelli e i relativi ID, consulta [Panoramica dei modelli](https://platform.claude.com/docs/it/models/overview).
In Claude Models on Google Cloud (Anthropic managed), una richiesta per un modello non disponibile per la tua organizzazione Anthropic restituisce un errore. Il messaggio di errore è `Model {model} is not available for this organization's inference configuration.`
## Risoluzione di progetto, location e workspace
I client per Claude Models on Google Cloud (Anthropic managed) accettano le impostazioni della tabella seguente. Un valore che passi quando crei il client ha la precedenza sulla variabile d'ambiente. Per impostare esplicitamente il progetto e l'ID del workspace, passa `project` (go: `Project`; java: `.project()`; csharp: `GoogleCloudClientOptions.Project`; cli: `--google-cloud-project`) e `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `GoogleCloudClientOptions.WorkspaceId`; cli: `--google-cloud-workspace-id`).
| Impostazione | Variabile d'ambiente | Se non impostata |
| ------------ | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ID progetto | `ANTHROPIC_GOOGLE_CLOUD_PROJECT`, poi `GOOGLE_CLOUD_PROJECT` | Il progetto indicato dalle Application Default Credentials, quando il tipo di credenziale ne include uno |
| ID workspace | `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` | Il client genera un errore a meno che tu non imposti l'URL di base. Le [route a livello di organizzazione](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) non necessitano di un ID workspace. |
| Location | `ANTHROPIC_GOOGLE_CLOUD_LOCATION` | `global` |
| URL di base | `ANTHROPIC_GOOGLE_CLOUD_BASE_URL` | Derivato dal progetto, dalla location e dall'ID del workspace |
Lascia la location su `global`. La location è distinta dal luogo in cui viene eseguita l'inferenza, quindi per un'inferenza solo negli Stati Uniti imposta `inference_geo: "us"` su ogni richiesta, come descritto in [Residenza dei dati](https://platform.claude.com/docs/it/manage-claude/data-residency#inference-geo).
La CLI `ant` accetta le stesse impostazioni come flag:
* **ID progetto:** `--google-cloud-project`
* **ID workspace:** `--google-cloud-workspace-id`
* **Location:** `--google-cloud-location`
* **URL di base:** `--google-cloud-base-url`
La CLI usa Claude Models on Google Cloud (Anthropic managed) quando sono impostati il progetto, l'ID del workspace o la location. Impostare `GOOGLE_CLOUD_PROJECT`, l'URL di base o entrambi non è sufficiente.
## Autenticazione
Ogni richiesta a Claude Models on Google Cloud (Anthropic managed) include un token di accesso Google OAuth 2.0 in un header `Authorization: Bearer`. Il token ha lo scope `https://www.googleapis.com/auth/cloud-platform`.
Google Cloud gestisce l'accesso. Il suo gateway su `claude.googleapis.com` esegue le seguenti operazioni per ogni richiesta:
1. Verifica le tue credenziali Google Cloud.
2. Verifica che il chiamante disponga dell'autorizzazione IAM richiesta dalla richiesta. In caso contrario, Google Cloud restituisce un errore HTTP 403.
3. Inoltra la richiesta ad Anthropic. Anthropic convalida la richiesta.
Per concedere le autorizzazioni, consulta [Ruoli IAM](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
I client SDK ottengono il token dalle [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials) (ADC). Funziona qualsiasi origine di credenziali supportata da ADC:
* **Sviluppo locale:** Esegui `gcloud auth application-default login`.
* **Su Google Cloud:** Il client usa automaticamente il service account associato al carico di lavoro, ad esempio su Compute Engine, GKE o Cloud Run.
* **Un file di chiave del service account:** Imposta `GOOGLE_APPLICATION_CREDENTIALS` sul suo percorso.
* **Workload Identity Federation e impersonificazione del service account:** Configurali come faresti per qualsiasi API Google Cloud.
Verifica che ADC funzioni:
```bash CLI
gcloud auth application-default print-access-token
```
Claude Models on Google Cloud (Anthropic managed) non usa chiavi API. Nella Claude Console non puoi creare chiavi API per l'organizzazione Anthropic creata dalla configurazione. I client SDK per Claude Models on Google Cloud (Anthropic managed) ignorano queste variabili d'ambiente:
* `ANTHROPIC_API_KEY`
* `ANTHROPIC_AUTH_TOKEN`
* `ANTHROPIC_BASE_URL`
### Precedenza delle credenziali
Il client SDK per Claude Models on Google Cloud (Anthropic managed) cerca le credenziali nel seguente ordine. Il client usa la prima che trova:
1. Un token provider che passi come `token_provider` (typescript: `bearerTokenProvider`; csharp: `GoogleCloudClientOptions.TokenProvider`; go: `TokenSource`; java: `.bearerTokenSupplier()`; php: `tokenProvider`) quando crei il client. È una funzione o un'origine di token che restituisce un token di accesso. Il client gli chiede un token a ogni richiesta. La memorizzazione nella cache e l'aggiornamento del token sono a tuo carico.
2. Un oggetto di credenziali Google che passi come `credentials` (typescript: `googleAuth`; csharp: `GoogleCloudClientOptions.GoogleCredential`; java: `.googleCredentials()`; php: `googleCredentials`; ruby: `google_credentials`) quando crei il client. L'SDK Go non dispone di questa opzione.
3. Le Application Default Credentials.
Go e Java differiscono dagli altri SDK:
* **Go:** Per l'opzione 1, il client accetta un `oauth2.TokenSource`. Memorizza il token nella cache fino alla sua scadenza.
* **Java:** Usa `GoogleCloudBackend.fromEnv()` per leggere le Application Default Credentials e le variabili d'ambiente indicate in [Risoluzione di progetto, location e workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Il client non ha una propria variabile d'ambiente per la credenziale. Usa invece `GOOGLE_APPLICATION_CREDENTIALS` di ADC.
Se le tue richieste passano attraverso un proxy che allega il token per te, imposta `skip_auth` (typescript, php: `skipAuth`; go: `SkipAuth`; java: `.skipAuth()`; csharp: `GoogleCloudClientOptions.SkipAuth`). Il client non invia quindi alcun header `Authorization`. Non puoi combinare questa impostazione con le opzioni di credenziali precedenti.
Quando la CLI `ant` usa Claude Models on Google Cloud (Anthropic managed), ottiene sempre il token dalle Application Default Credentials. Non accetta token provider, oggetti di credenziali né impostazioni skip-auth.
Prima di usare `ant` con Claude Models on Google Cloud (Anthropic managed), assicurati che nessuno dei seguenti elementi sia impostato:
* Una chiave API
* Un token di autenticazione
* `--profile` o `ANTHROPIC_PROFILE`, se indica un [profilo di configurazione](https://platform.claude.com/docs/it/manage-claude/wif-reference#profile-configuration-file) con cui la CLI può autenticarsi
* Una qualsiasi delle variabili di federazione di Anthropic:
* `ANTHROPIC_FEDERATION_RULE_ID`
* `ANTHROPIC_ORGANIZATION_ID`
* `ANTHROPIC_SERVICE_ACCOUNT_ID`
* `ANTHROPIC_IDENTITY_TOKEN`
* `ANTHROPIC_IDENTITY_TOKEN_FILE`
Se uno di questi è impostato, la CLI usa quella credenziale invece delle impostazioni Google Cloud indicate in [Trova l'ID del tuo workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Se sono impostate solo alcune delle variabili di federazione, la CLI si interrompe con un errore. Quando è impostata più di una credenziale, la CLI stampa una nota che indica quella che utilizza.
Lascia inoltre non impostati `ANTHROPIC_WORKSPACE_ID` e il flag `--workspace-id`. La CLI invia comunque quel valore come header `anthropic-workspace-id`. Le richieste a Claude Models on Google Cloud (Anthropic managed) non devono includere quell'header. Imposta invece il workspace con `--google-cloud-workspace-id` o `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID`.
Come i client SDK, la CLI non invia le richieste per Claude Models on Google Cloud (Anthropic managed) a `--base-url` o `ANTHROPIC_BASE_URL`.
## Supporto delle funzionalità
Questa sezione elenca le funzionalità che funzionano su Claude Models on Google Cloud (Anthropic managed) e quelle che non sono supportate. Non elenca tutte le funzionalità della Claude API e non indica se una funzionalità non elencata funziona.
Le seguenti funzionalità funzionano su Claude Models on Google Cloud (Anthropic managed) come sulla Claude API:
* **Modalità veloce:** la [modalità veloce](https://platform.claude.com/docs/it/build-with-claude/fast-mode) ("fast mode") per Claude Opus 5.5.
- **Funzionalità beta:** Se una beta è limitata a organizzazioni selezionate sulla Claude API, l'organizzazione Anthropic creata dalla configurazione necessita dello stesso accesso.
- **Strumenti:** L'[uso degli strumenti](https://platform.claude.com/docs/it/agents-and-tools/tool-use/overview), inclusi:
* Ricerca web
* Recupero web
* Esecuzione di codice
* Lo strumento di memoria
* Lo strumento advisor
* Il connettore MCP
- **Skill e file:** [Agent Skills](https://platform.claude.com/docs/it/agents-and-tools/agent-skills/overview) e la [Files API](https://platform.claude.com/docs/it/build-with-claude/files).
- **Capacità dei modelli:**
* [Cache dei prompt](https://platform.claude.com/docs/it/build-with-claude/prompt-caching)
* [Ragionamento esteso](https://platform.claude.com/docs/it/build-with-claude/thinking)
* [Fallback lato server](https://platform.claude.com/docs/it/build-with-claude/refusals-and-fallback#server-side-fallback)
* [Streaming](https://platform.claude.com/docs/it/build-with-claude/streaming)
* [Output strutturati](https://platform.claude.com/docs/it/build-with-claude/structured-outputs)
* [Conteggio dei token](https://platform.claude.com/docs/it/build-with-claude/token-counting)
- **Batch e modelli:** La [Message Batches API](https://platform.claude.com/docs/it/build-with-claude/batch-processing) e la Models API.
Per attivare o disattivare la [Compliance API](https://platform.claude.com/docs/it/manage-claude/compliance-api) per l'organizzazione Anthropic creata dalla configurazione, [apri la Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), vai su **Settings > Compliance** e usa l'interruttore **Compliance API**.
Le chiavi di crittografia gestite dal cliente (CMEK) sono disponibili con le chiavi Google Cloud KMS. Per attivare CMEK per l'organizzazione Anthropic creata dalla configurazione, consulta [Chiavi di crittografia gestite dal cliente](https://platform.claude.com/docs/it/manage-claude/cmek). Per configurare una chiave, segui [Configurare Google Cloud KMS per CMEK](https://platform.claude.com/docs/it/manage-claude/cmek-google-cloud-kms). Poi registra, verifica e associa la chiave nella [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), come descritto nella scheda **Claude Console** della pagina di configurazione.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/it/managed-agents/overview) è disponibile tramite Claude Models on Google Cloud (Anthropic managed), inclusi i seguenti elementi:
* [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)
* [Vault delle credenziali](https://platform.claude.com/docs/it/managed-agents/vaults)
* [Archivi di memoria](https://platform.claude.com/docs/it/managed-agents/memory)
* [Deployment pianificati](https://platform.claude.com/docs/it/managed-agents/scheduled-deployments)
* [Sandbox self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes)
L'accesso viene verificato quando viene creata una sessione o un deployment, non durante la sua esecuzione:
* **Le sessioni in esecuzione continuano a funzionare.** Se revochi l'accesso Google Cloud all'identità che ha creato una sessione, la sessione non si interrompe. Per interromperla, inviale un [evento `user.interrupt`](https://platform.claude.com/docs/it/managed-agents/events-and-streaming#integrating-events) da solo. Dopo che la sessione è `idle`, puoi archiviarla o eliminarla.
* **I deployment pianificati continuano a funzionare.** Un deployment non ricontrolla l'accesso del suo creatore a ogni esecuzione pianificata. Per interromperlo, mettilo in pausa, aggiornalo o archivialo.
Quando rimuovi un utente o ruoti un service account, esamina le sessioni e i deployment creati da quell'identità.
### Funzionalità non supportate
I seguenti elementi non sono supportati su Claude Models on Google Cloud (Anthropic managed):
* **Chiavi API:** L'autenticazione avviene solo tramite credenziali Google Cloud.
* **Tunnel MCP:** I [tunnel MCP](https://platform.claude.com/docs/it/agents-and-tools/mcp-tunnels/overview) non sono disponibili su Claude Models on Google Cloud (Anthropic managed).
* **[Memory store su ambienti self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-memory):** I memory store non sono supportati per le sessioni su ambienti self-hosted.
* **Worker predefiniti per sandbox self-hosted:** I [worker self-hosted](https://platform.claude.com/docs/it/managed-agents/self-hosted-sandboxes-workers) nella CLI `ant` e negli SDK Python, TypeScript e Go non supportano Claude Models on Google Cloud (Anthropic managed). Implementa invece un tuo worker che chiami direttamente gli [endpoint Environments Work](https://platform.claude.com/docs/it/api/beta/environments/work). Per i ruoli e le autorizzazioni di cui il tuo worker ha bisogno, consulta [Autorizzazioni IAM per gli ambienti](https://platform.claude.com/docs/it/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions#environments).
### Finestra di contesto
Le dimensioni della "context window" (finestra di contesto) su Claude Models on Google Cloud (Anthropic managed) sono le stesse della Claude API. Per il limite di ciascun modello, consulta [Finestre di contesto](https://platform.claude.com/docs/it/build-with-claude/context-windows).
## Fatturazione, limiti di velocità e logging
### Limiti di velocità
Anthropic gestisce i "rate limit" (limiti di velocità) per Claude Models on Google Cloud (Anthropic managed). Per richiedere limiti più elevati, contatta il tuo referente Anthropic o [contatta il reparto vendite](https://claude.com/contact-sales). Per sapere come vengono misurati e riportati i limiti di velocità, consulta [Limiti di velocità](https://platform.claude.com/docs/it/api/rate-limits).
### Fatturazione
Claude Models on Google Cloud (Anthropic managed) viene fatturato tramite Google Cloud Marketplace. Anthropic misura il tuo utilizzo e lo riporta a Google Cloud in Claude Consumption Units. Gli addebiti compaiono nella tua fattura Google Cloud. Anthropic non invia una fattura separata.
Visualizza i dati di utilizzo e di costo nelle pagine **Usage** e **Cost** della [Claude Console](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Se hai un impegno di spesa Google Cloud, l'utilizzo viene conteggiato ai fini di tale impegno come gli altri acquisti in Marketplace.
### Conservazione dei dati
Anthropic è il responsabile del trattamento dei dati per Claude Models on Google Cloud (Anthropic managed). Alcuni servizi di supporto, come i sistemi di trust and safety di Anthropic, elaborano i dati al di fuori di Google Cloud.
Claude Models on Google Cloud (Anthropic managed) segue la stessa politica di conservazione dei dati della Claude API. Consulta [API e conservazione dei dati](https://platform.claude.com/docs/it/manage-claude/api-and-data-retention). La Zero Data Retention (ZDR) è disponibile su richiesta. Contatta il tuo referente Anthropic.
Un accordo ZDR su un'altra organizzazione Anthropic non si estende alla tua organizzazione per Claude Models on Google Cloud (Anthropic managed).
### Monitoraggio e logging
[Cloud Audit Logs](https://cloud.google.com/logging/docs/audit) registra l'attività API per Claude Models on Google Cloud (Anthropic managed) nel tuo progetto. Le voci compaiono sotto il servizio `claude.googleapis.com`. Ogni route API appartiene a uno di due tipi di log:
* **Log Data Access:** Coprono la maggior parte delle route, inclusi messaggi, batch, file, skill, modelli e la maggior parte delle risorse di Claude Managed Agents. Sono disattivati per impostazione predefinita.
* **Log Admin Activity:** Coprono le altre route, incluse le route delle chiavi di crittografia e la maggior parte delle route dei vault delle credenziali. L'eccezione è la route per `vaults.verify`, che è di tipo Data Access. I log Admin Activity sono sempre attivi.
Per conservare un registro delle richieste, attiva i log Data Access per `claude.googleapis.com` nelle impostazioni degli audit log del tuo progetto.
Per i tipi di audit log per route, consulta [Autorizzazioni IAM per Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/it/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
#### ID delle richieste
Le risposte riuscite di Claude Models on Google Cloud (Anthropic managed) includono l'header [`request-id`](https://platform.claude.com/docs/it/api/errors#request-id).
## Passare da un'organizzazione Anthropic esistente
Non puoi convertire un'organizzazione Anthropic esistente in un'organizzazione per Claude Models on Google Cloud (Anthropic managed). Ciò include un'organizzazione che usi direttamente con la Claude API.
Pianifica il passaggio come una migrazione a una nuova organizzazione:
* **Crea prima la nuova organizzazione.** Segui [Configura il tuo account](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
* **Ricrea accessi e configurazione.** Chiavi API, workspace e impostazioni della Claude Console non vengono trasferiti. Concedi i [ruoli IAM](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) sul progetto invece di creare chiavi API. Per ricreare i tuoi workspace, consulta [Workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#workspaces). Per gli accordi ZDR, consulta [Conservazione dei dati](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention).
* **Pianifica la gestione delle risorse archiviate.** File, skill, batch e risorse di Claude Managed Agents rimangono nell'organizzazione esistente.
* **Aggiorna la tua integrazione.** Per sapere cosa cambia e cosa rimane uguale, consulta [Effettuare richieste](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests). Per le funzionalità non supportate, consulta [Funzionalità non supportate](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#features-not-supported).
* **Esegui la migrazione secondo i tuoi tempi.** Le due organizzazioni sono indipendenti e possono gestire il traffico in parallelo. Puoi spostare i carichi di lavoro gradualmente. L'organizzazione esistente mantiene la sua fatturazione attuale. Prima di spostare il traffico di produzione, verifica i [limiti di velocità](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Migrazione da Claude Models on Google Cloud (Google managed)
Per passare a Claude Models on Google Cloud (Anthropic managed), completa i seguenti passaggi. Prima di spostare carichi di lavoro che si basano su un accordo ZDR, consulta [Conservazione dei dati](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention). Per sapere cosa cambia con il passaggio, consulta [Differenze tra le due offerte Google Cloud](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/overview#how-the-two-google-cloud-offerings-differ).
Completa ogni passaggio in [Configura il tuo account](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
Concedi `roles/claude.user` a ogni identità che chiama Claude Models on Google Cloud (Anthropic managed). Imposta il tuo progetto e l'ID del workspace come variabili d'ambiente. Per entrambi, consulta [Prima di effettuare chiamate API](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
Installa il pacchetto che fornisce il client per Claude Models on Google Cloud (Anthropic managed). Consulta [Installa un SDK](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#install-an-sdk).
Modifica il codice che importa e crea il tuo client. Usa `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`) al posto di `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). In una richiesta cURL, modifica l'URL, gli header e il body. Il tuo codice attuale crea un client per Claude Models on Google Cloud (Google managed). Ad esempio, il codice seguente crea quel client con l'endpoint globale:
```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
}'
```
La CLI `ant` non supporta Claude Models on Google Cloud (Google managed).
```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"
)
```
Il codice seguente crea il client per Claude Models on Google Cloud (Anthropic managed):
```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
```
Il nuovo client legge il tuo progetto e l'ID del workspace dalle variabili d'ambiente che hai impostato in [Trova l'ID del tuo workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Non devi passarli quando crei il client. Le tue chiamate alla Messages API restano invariate, ad eccezione degli ID dei modelli e delle funzionalità indicati nel passaggio successivo.
* **ID dei modelli:** Se usi un modello precedente a Claude 4.6, sostituisci la `@` prima della data dello snapshot nel suo ID con un trattino. 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/anthropic-managed#api-model-ids).
* **Funzionalità:** Controlla [Supporto delle funzionalità](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#feature-support) per ogni funzionalità utilizzata dal tuo codice.
* **Località:** Se oggi usi un endpoint multi-regione o regionale, verifica quale località utilizza Claude Models on Google Cloud (Anthropic managed). Consulta [Risoluzione di progetto, località e workspace](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Esegui la richiesta in [Effettuare richieste](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) per verificare che la tua configurazione funzioni. Poi esegui il tuo codice. Se una chiamata non riesce con un errore di autorizzazione, consulta [Risoluzione dei problemi di configurazione dell'account](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#troubleshooting-account-setup). Prima di spostare il traffico di produzione, controlla i [limiti di velocità](https://platform.claude.com/docs/it/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Passaggi successivi
Esplora le funzionalità di Claude.
Consulta autorizzazioni, ruoli e tipi di log di controllo.
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.
Gestisci il tuo abbonamento e la fatturazione.