---
title: Claude Models on Google Cloud (Anthropic managed)
url: https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed
description: Claude Models on Google Cloud (Anthropic managed) est l'API Claude, exploitée par Anthropic et accessible via votre projet Google Cloud.
---
Google Cloud gère l'accès et la facturation pour Claude Models on Google Cloud (Anthropic managed). Pour comparer les deux offres Google Cloud, ou pour vérifier laquelle vous utilisez, consultez [Claude Models on Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/overview).
## Configurer votre compte
Pour configurer votre compte pour Claude Models on Google Cloud (Anthropic managed), vous avez besoin des éléments suivants :
* L'autorisation d'effectuer des achats dans Google Cloud Marketplace sur votre compte de facturation
* L'autorisation d'activer des services sur le projet
* Un [rôle IAM qui vous permet d'ouvrir la Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), dont vous avez besoin pour l'étape 4
Ces étapes créent une nouvelle organisation Anthropic pour votre projet Google Cloud. Elle est distincte de toute organisation Anthropic dont votre entreprise dispose déjà. Cela inclut une organisation Claude Enterprise. Pour migrer depuis une organisation existante, consultez [Migrer depuis une organisation Anthropic existante](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#moving-from-an-existing-anthropic-organization).
Si vous bénéficiez d'une remise existante, contactez votre représentant de compte Anthropic ou Google Cloud avant de commencer ces étapes. Les remises ne peuvent pas être appliquées à l'utilisation passée.
1. Ouvrez [Google Cloud Marketplace](https://console.cloud.google.com/marketplace) et trouvez la fiche **Claude Models on Google Cloud (Anthropic managed)**.
2. Choisissez **Subscribe** et terminez le processus d'achat.
3. Revenez à la fiche et choisissez **Manage on Console**. Cela ouvre la page Claude dans la console Google Cloud.
Pour revenir ultérieurement à la page Claude, sélectionnez votre projet dans la console Google Cloud. Ensuite, accédez à **Agent Platform > Models > Claude Platform** et choisissez **Anthropic managed**.
Activez deux services sur chaque projet qui appelle Claude Models on Google Cloud (Anthropic managed) :
* `claude.googleapis.com` sert l'API pour Claude Models on Google Cloud (Anthropic managed). Ce service définit également les autorisations IAM. Les appels échouent sans lui.
* `anthropic-managed-claude.cloudpartnerservices.goog` est le service Marketplace qui attribue l'utilisation du projet à votre abonnement.
```bash CLI
gcloud services enable claude.googleapis.com \
anthropic-managed-claude.cloudpartnerservices.goog \
--project=my-project-id
```
Remplacez `my-project-id` par l'ID de votre projet.
Vous pouvez également activer les deux depuis la page Claude ou depuis **APIs & Services**. L'activation est une étape unique pour chaque projet. Pour vérifier que les deux services sont activés, exécutez `gcloud services list --enabled --project=my-project-id` et recherchez les deux noms.
1. Sur la page Claude, choisissez **Activate**.
2. Dans le processus de configuration Anthropic, saisissez une adresse e-mail de contact.
3. Ouvrez le lien de configuration envoyé à cette adresse.
4. Renseignez le nom de l'organisation, le type d'entité, le pays et l'utilisation prévue.
5. Acceptez les Conditions commerciales d'utilisation et la Politique d'utilisation d'Anthropic.
L'adresse de contact est utilisée uniquement pour la configuration et les avis de service. Pour savoir comment les utilisateurs ouvrent la Claude Console après la configuration, consultez [Utiliser la Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Lorsque votre organisation Anthropic est active, le bouton de la page Claude devient **Open Claude Console**. Choisissez-le. Google Cloud vérifie votre accès IAM. Ensuite, il redirige votre navigateur vers `platform.claude.com`. Vous êtes connecté à la nouvelle organisation.
Pendant que vous êtes dans la Claude Console, [trouvez l'ID de votre espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id) et copiez-le. Toute personne qui appelle Claude Models on Google Cloud (Anthropic managed) en a besoin. Transmettez-le à vos développeurs.
Pour ajouter un autre projet, répétez ces étapes dans ce projet, à partir de l'étape 2.
### Dépannage de la configuration du compte
Si vous rencontrez l'un des problèmes suivants lors de la configuration de Claude Models on Google Cloud (Anthropic managed), appliquez la solution correspondante :
* **`gcloud services enable` ne trouve pas `anthropic-managed-claude.cloudpartnerservices.goog` :** Exécutez la commande avec le compte qui a effectué l'achat dans Marketplace, ou contactez votre représentant de compte Anthropic.
* **Une erreur d'autorisation lors de votre premier appel API :** Vérifiez que `claude.googleapis.com` est activé sur le projet que vous appelez. Vérifiez que l'appelant dispose de `roles/claude.user` ou `roles/claude.admin` sur ce projet. Pour savoir ce que chaque rôle autorise, consultez [Rôles IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles). Une nouvelle attribution ou un service nouvellement activé peut mettre un moment à prendre effet.
* **« Signed in as a different account » après avoir suivi le lien de configuration :** Choisissez **Log out and continue**. Ensuite, utilisez l'adresse e-mail que vous avez saisie à l'étape 3.
* **Le bouton indique « Finish Setup » au lieu de « Open Claude Console » :** Votre organisation Anthropic existe, mais sa configuration n'est pas terminée. Un administrateur doit compléter le formulaire des détails de l'organisation.
* **La page Usage n'affiche aucune donnée après votre premier appel API :** Les données d'utilisation peuvent mettre quelques minutes à apparaître dans la Claude Console.
## Gérer l'accès
### Rôles IAM
Claude Models on Google Cloud (Anthropic managed) dispose de trois rôles IAM prédéfinis. Attribuez les rôles sur le projet.
| Rôle | Nom d'affichage | Ce qu'il autorise |
| --------------------- | --------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `roles/claude.viewer` | Claude Viewer | Toutes les autorisations `get` et `list` sur les ressources de l'espace de travail
Ce rôle est en lecture seule. |
| `roles/claude.user` | Claude User | Tout ce que `roles/claude.viewer` autorise, plus la création et la modification des ressources de l'espace de travail
Cela inclut l'envoi de messages et le comptage des tokens. Cela inclut également la gestion des lots, des fichiers, des skills et des ressources Claude Managed Agents. |
| `roles/claude.admin` | Claude Admin | Tout ce que `roles/claude.user` autorise, plus les autorisations vérifiées sur votre organisation Anthropic
Les routes au niveau de l'organisation agissent sur votre organisation Anthropic dans son ensemble, et non sur un seul espace de travail. |
Par exemple, la commande suivante permet à un compte de service d'appeler 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"
```
Pour les autorisations, les rôles prédéfinis et les types de journaux d'audit, consultez [Autorisations IAM pour Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
L'activation de `claude.googleapis.com` crée un agent de service pour le projet. Ne supprimez pas ses attributions de rôles. Les supprimer empêche Claude Models on Google Cloud (Anthropic managed) de fonctionner dans le projet.
### Utiliser la Claude Console
Avec Claude Models on Google Cloud (Anthropic managed), vous ne pouvez pas utiliser une adresse e-mail pour vous connecter à votre organisation Anthropic. Choisissez plutôt **Open Claude Console** sur la [page Claude](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) dans la console Google Cloud. Google Cloud IAM contrôle qui peut ouvrir la Claude Console. Parmi les trois [rôles IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) prédéfinis, seul `roles/claude.admin` sur le projet vous permet d'ouvrir la Claude Console.
### Espaces de travail
Dans Claude Models on Google Cloud (Anthropic managed), la configuration crée votre organisation Anthropic avec un seul espace de travail, le Default Workspace. Pour créer d'autres espaces de travail, [ouvrez la Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) et accédez à **Settings > Workspaces**. Sur la même page, vous pouvez renommer ou archiver n'importe quel espace de travail, à l'exception du Default Workspace. Chaque espace de travail possède son propre [ID d'espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Les fichiers, les skills, les lots, les sessions Claude Managed Agents et les autres ressources de l'espace de travail appartiennent à l'espace de travail dont vous [définissez l'ID pour la requête](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Vous attribuez les [rôles IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) sur le projet, de sorte qu'un rôle s'applique à chaque espace de travail de ce projet. Lorsque des équipes ont besoin d'accès distincts, attribuez à chaque équipe son propre projet Google Cloud. Chaque projet possède sa propre organisation Anthropic ; répétez donc les [étapes de configuration](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account) dans chaque projet, à partir de l'étape 2.
## Avant d'effectuer des appels API
Pour appeler Claude Models on Google Cloud (Anthropic managed), vous avez besoin des éléments suivants :
1. Un projet Google Cloud avec un abonnement actif et une organisation Anthropic dont la configuration est terminée. Consultez [Configurer votre compte](https://platform.claude.com/docs/fr/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) installée, pour le développement local.
3. Le rôle `roles/claude.user`, attribué sur le projet à l'identité qui effectue les appels.
4. Des Application Default Credentials pour cette identité. Consultez [Authentification](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#authentication).
5. L'ID de votre projet et l'[ID de votre espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id).
Pour attribuer le rôle à votre propre compte pour le développement local, exécutez la commande suivante. Vous devez disposer de l'autorisation de modifier la stratégie IAM du projet.
```bash CLI
gcloud projects add-iam-policy-binding my-project-id \
--member="user:you@example.com" \
--role="roles/claude.user"
```
Remplacez `my-project-id` par l'ID de votre projet. Remplacez `you@example.com` par l'adresse e-mail de votre compte Google. Pour voir le projet utilisé par gcloud, exécutez `gcloud config get-value project`. Pour les comptes de service et les autres rôles, consultez [Rôles IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
### Trouver l'ID de votre espace de travail
Pour trouver l'ID de votre espace de travail pour Claude Models on Google Cloud (Anthropic managed), [ouvrez la Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console) et accédez à **Settings > Workspaces**. L'ID commence par `wrkspc_`. Si vous ne pouvez pas ouvrir la Claude Console, demandez à une personne qui peut l'ouvrir de vous envoyer l'ID.
Définissez le projet et l'espace de travail comme variables d'environnement afin que les clients SDK et la [CLI `ant`](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/quickstart) les prennent en compte :
```bash CLI
export ANTHROPIC_GOOGLE_CLOUD_PROJECT="my-project-id"
export ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID="wrkspc_01AbCdEf23GhIj"
```
### Installer un SDK
Le [client SDK](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) pour Claude Models on Google Cloud (Anthropic managed) est `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`). Le client résout vos identifiants Google. Il construit également l'URL de base à partir de votre projet, de votre emplacement et de l'ID de votre espace de travail.
Les clients SDK pour Claude Models on Google Cloud (Anthropic managed) sont en bêta.
Installez le package qui fournit le 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
```
Pour utiliser plutôt la CLI `ant`, [installez-la ou mettez-la à jour](https://platform.claude.com/docs/fr/cli-sdks-libraries/cli/quickstart#installation) vers la dernière version. Une version sans prise en charge de Claude Models on Google Cloud (Anthropic managed) ignore les variables `ANTHROPIC_GOOGLE_CLOUD_*`. Elle effectue alors l'une des actions suivantes :
* Envoie la requête à l'API Claude avec tout autre identifiant que vous avez configuré
* Échoue avec une erreur d'authentification
## Effectuer des requêtes
Claude Models on Google Cloud (Anthropic managed) sert les endpoints de l'API Claude sous une URL de base qui nomme votre projet, un emplacement et votre espace de travail :
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/workspaces/{workspace}/invoke
```
Les [routes au niveau de l'organisation](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles), dont les chemins commencent par `/v1/organizations/`, utilisent une URL de base sans l'espace de travail :
```text wrap
https://claude.googleapis.com/v1/projects/{project}/locations/global/claudeOrganization/invoke
```
Si vous ne [définissez pas l'URL de base](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution), les clients SDK choisissent entre ces deux URL pour chaque requête.
Ajoutez le chemin de l'API Claude à l'URL de base. Par exemple, l'[API Messages](https://platform.claude.com/docs/fr/api/messages/create) se trouve à `.../invoke/v1/messages`. Trois éléments diffèrent d'une requête à l'API Claude :
* **URL de base :** Les URL limitées au projet présentées précédemment, à la place de `https://api.anthropic.com`.
* **Authentification :** Un en-tête `Authorization: Bearer` avec un jeton d'accès Google. N'envoyez pas d'en-tête `x-api-key`.
* **Espace de travail :** L'ID de l'espace de travail fait partie de l'URL. N'envoyez pas d'en-tête `anthropic-workspace-id`.
Tout le reste est identique à l'API Claude, notamment les éléments suivants :
* Les en-têtes `anthropic-version` et `anthropic-beta`
* Le corps de la requête
* Le streaming
* La réponse
Les exemples de code ailleurs dans cette documentation créent le client de l'API Claude et lisent une clé API. Pour en exécuter un avec Claude Models on Google Cloud (Anthropic managed), remplacez son import et son constructeur de client par ceux des exemples suivants. Pour un exemple cURL, appliquez les trois différences énumérées précédemment.
Avant d'exécuter ces exemples, effectuez les étapes de [Avant d'effectuer des appels API](https://platform.claude.com/docs/fr/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'exemple cURL demande à gcloud un jeton Application Default Credentials. Les jetons d'accès ont une durée de vie courte. Générez-en un pour chaque session au lieu de le stocker.
### ID de modèles de l'API
Claude Models on Google Cloud (Anthropic managed) utilise les mêmes ID de modèles que l'API Claude, par exemple `claude-opus-5-5`. Pour les modèles et leurs ID, consultez [Vue d'ensemble des modèles](https://platform.claude.com/docs/fr/models/overview).
Dans Claude Models on Google Cloud (Anthropic managed), une requête pour un modèle qui n'est pas disponible pour votre organisation Anthropic renvoie une erreur. Le message d'erreur indique `Model {model} is not available for this organization's inference configuration.`
## Résolution du projet, de l'emplacement et de l'espace de travail
Les clients pour Claude Models on Google Cloud (Anthropic managed) acceptent les paramètres du tableau suivant. Une valeur que vous transmettez lors de la création du client prévaut sur la variable d'environnement. Pour définir explicitement le projet et l'ID de l'espace de travail, transmettez `project` (go: `Project`; java: `.project()`; csharp: `GoogleCloudClientOptions.Project`; cli: `--google-cloud-project`) et `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `GoogleCloudClientOptions.WorkspaceId`; cli: `--google-cloud-workspace-id`).
| Paramètre | Variable d'environnement | Si non défini |
| ------------------------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| ID du projet | `ANTHROPIC_GOOGLE_CLOUD_PROJECT`, puis `GOOGLE_CLOUD_PROJECT` | Le projet que signalent les Application Default Credentials, lorsque le type d'identifiant en comporte un |
| ID de l'espace de travail | `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID` | Le client génère une erreur, sauf si vous définissez l'URL de base. Les [routes au niveau de l'organisation](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) n'ont pas besoin d'ID d'espace de travail. |
| Emplacement | `ANTHROPIC_GOOGLE_CLOUD_LOCATION` | `global` |
| URL de base | `ANTHROPIC_GOOGLE_CLOUD_BASE_URL` | Dérivée du projet, de l'emplacement et de l'ID de l'espace de travail |
Laissez l'emplacement sur `global`. L'emplacement est distinct du lieu où s'exécute l'inférence ; pour une inférence limitée aux États-Unis, définissez donc `inference_geo: "us"` sur chaque requête, comme décrit dans [Résidence des données](https://platform.claude.com/docs/fr/manage-claude/data-residency#inference-geo).
La CLI `ant` accepte les mêmes paramètres sous forme d'options :
* **ID du projet :** `--google-cloud-project`
* **ID de l'espace de travail :** `--google-cloud-workspace-id`
* **Emplacement :** `--google-cloud-location`
* **URL de base :** `--google-cloud-base-url`
La CLI utilise Claude Models on Google Cloud (Anthropic managed) lorsque le projet, l'ID de l'espace de travail ou l'emplacement est défini. Définir `GOOGLE_CLOUD_PROJECT`, l'URL de base, ou les deux, ne suffit pas.
## Authentification
Chaque requête à Claude Models on Google Cloud (Anthropic managed) comporte un jeton d'accès Google OAuth 2.0 dans un en-tête `Authorization: Bearer`. Le jeton possède la portée `https://www.googleapis.com/auth/cloud-platform`.
Google Cloud gère l'accès. Sa passerelle à `claude.googleapis.com` effectue les opérations suivantes pour chaque requête :
1. Vérifie vos identifiants Google Cloud.
2. Vérifie que l'appelant détient l'autorisation IAM dont la requête a besoin. Si ce n'est pas le cas, Google Cloud renvoie une erreur HTTP 403.
3. Transmet la requête à Anthropic. Anthropic valide la requête.
Pour attribuer des autorisations, consultez [Rôles IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles).
Les clients SDK obtiennent le jeton à partir des [Application Default Credentials](https://cloud.google.com/docs/authentication/application-default-credentials) (ADC). Toute source d'identifiants prise en charge par ADC fonctionne :
* **Développement local :** Exécutez `gcloud auth application-default login`.
* **Sur Google Cloud :** Le client utilise automatiquement le compte de service associé à la charge de travail, par exemple sur Compute Engine, GKE ou Cloud Run.
* **Un fichier de clé de compte de service :** Définissez `GOOGLE_APPLICATION_CREDENTIALS` sur son chemin.
* **Workload Identity Federation et emprunt d'identité de compte de service :** Configurez-les comme vous le feriez pour n'importe quelle API Google Cloud.
Vérifiez qu'ADC fonctionne :
```bash CLI
gcloud auth application-default print-access-token
```
Claude Models on Google Cloud (Anthropic managed) n'utilise pas de clés API. Dans la Claude Console, vous ne pouvez pas créer de clés API pour l'organisation Anthropic créée par la configuration. Les clients SDK pour Claude Models on Google Cloud (Anthropic managed) ignorent ces variables d'environnement :
* `ANTHROPIC_API_KEY`
* `ANTHROPIC_AUTH_TOKEN`
* `ANTHROPIC_BASE_URL`
### Priorité des identifiants
Le client SDK pour Claude Models on Google Cloud (Anthropic managed) recherche les identifiants dans l'ordre suivant. Le client utilise le premier qu'il trouve :
1. Un fournisseur de jetons que vous transmettez en tant que `token_provider` (typescript: `bearerTokenProvider`; csharp: `GoogleCloudClientOptions.TokenProvider`; go: `TokenSource`; java: `.bearerTokenSupplier()`; php: `tokenProvider`) lors de la création du client. Il s'agit d'une fonction ou d'une source de jetons qui renvoie un jeton d'accès. Le client lui demande un jeton à chaque requête. La mise en cache et l'actualisation du jeton sont à votre charge.
2. Un objet d'identifiants Google que vous transmettez en tant que `credentials` (typescript: `googleAuth`; csharp: `GoogleCloudClientOptions.GoogleCredential`; java: `.googleCredentials()`; php: `googleCredentials`; ruby: `google_credentials`) lors de la création du client. Le SDK Go ne dispose pas de cette option.
3. Les Application Default Credentials.
Go et Java diffèrent des autres SDK :
* **Go :** Pour l'option 1, le client accepte un `oauth2.TokenSource`. Il met le jeton en cache jusqu'à son expiration.
* **Java :** Utilisez `GoogleCloudBackend.fromEnv()` pour lire les Application Default Credentials et les variables d'environnement de [Résolution du projet, de l'emplacement et de l'espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Le client ne dispose d'aucune variable d'environnement propre pour l'identifiant. Utilisez plutôt la variable `GOOGLE_APPLICATION_CREDENTIALS` d'ADC.
Si vos requêtes passent par un proxy qui ajoute le jeton pour vous, définissez `skip_auth` (typescript, php: `skipAuth`; go: `SkipAuth`; java: `.skipAuth()`; csharp: `GoogleCloudClientOptions.SkipAuth`). Le client n'envoie alors aucun en-tête `Authorization`. Vous ne pouvez pas combiner ce paramètre avec les options d'identifiants précédentes.
Lorsque la CLI `ant` utilise Claude Models on Google Cloud (Anthropic managed), elle obtient toujours le jeton à partir des Application Default Credentials. Elle n'accepte ni fournisseur de jetons, ni objet d'identifiants, ni paramètre skip-auth.
Avant d'utiliser `ant` avec Claude Models on Google Cloud (Anthropic managed), assurez-vous qu'aucun des éléments suivants n'est défini :
* Une clé API
* Un jeton d'authentification
* `--profile` ou `ANTHROPIC_PROFILE`, s'il désigne un [profil de configuration](https://platform.claude.com/docs/fr/manage-claude/wif-reference#profile-configuration-file) avec lequel la CLI peut s'authentifier
* L'une des variables de fédération d'Anthropic :
* `ANTHROPIC_FEDERATION_RULE_ID`
* `ANTHROPIC_ORGANIZATION_ID`
* `ANTHROPIC_SERVICE_ACCOUNT_ID`
* `ANTHROPIC_IDENTITY_TOKEN`
* `ANTHROPIC_IDENTITY_TOKEN_FILE`
Si l'un d'eux est défini, la CLI utilise cet identifiant au lieu des paramètres Google Cloud de [Trouver l'ID de votre espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Si seules certaines des variables de fédération sont définies, la CLI s'arrête avec une erreur. Lorsque plusieurs identifiants sont définis, la CLI affiche une note indiquant celui qu'elle utilise.
Laissez également `ANTHROPIC_WORKSPACE_ID` et l'option `--workspace-id` non définis. La CLI envoie quand même cette valeur sous forme d'en-tête `anthropic-workspace-id`. Les requêtes à Claude Models on Google Cloud (Anthropic managed) ne doivent pas comporter cet en-tête. Définissez plutôt l'espace de travail avec `--google-cloud-workspace-id` ou `ANTHROPIC_GOOGLE_CLOUD_WORKSPACE_ID`.
Comme les clients SDK, la CLI n'envoie pas les requêtes destinées à Claude Models on Google Cloud (Anthropic managed) vers `--base-url` ou `ANTHROPIC_BASE_URL`.
## Prise en charge des fonctionnalités
Cette section répertorie les fonctionnalités qui fonctionnent sur Claude Models on Google Cloud (Anthropic managed) et celles qui n'y sont pas prises en charge. Elle ne répertorie pas toutes les fonctionnalités de l'API Claude et n'indique pas si une fonctionnalité non répertoriée fonctionne.
Les fonctionnalités suivantes fonctionnent sur Claude Models on Google Cloud (Anthropic managed) comme sur l'API Claude :
* **Mode rapide :** [« Fast mode » (mode rapide)](https://platform.claude.com/docs/fr/build-with-claude/fast-mode) pour Claude Opus 5.5.
- **Fonctionnalités bêta :** Si une bêta est limitée à certaines organisations sur l'API Claude, l'organisation Anthropic créée par la configuration a besoin du même accès.
- **Outils :** L'[utilisation d'outils](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview) (« tool use »), notamment :
* La recherche web
* La récupération web
* L'exécution de code
* L'outil de mémoire
* L'outil advisor
* Le connecteur MCP
- **Skills et fichiers :** Les [Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview) et l'[API Files](https://platform.claude.com/docs/fr/build-with-claude/files).
- **Capacités des modèles :**
* La [mise en cache des prompts](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) (« prompt caching »)
* La [réflexion étendue](https://platform.claude.com/docs/fr/build-with-claude/thinking) (« extended thinking »)
* Le [repli côté serveur](https://platform.claude.com/docs/fr/build-with-claude/refusals-and-fallback#server-side-fallback)
* Le [streaming](https://platform.claude.com/docs/fr/build-with-claude/streaming)
* Les [sorties structurées](https://platform.claude.com/docs/fr/build-with-claude/structured-outputs)
* Le [comptage des tokens](https://platform.claude.com/docs/fr/build-with-claude/token-counting)
- **Lots et modèles :** L'[API Message Batches](https://platform.claude.com/docs/fr/build-with-claude/batch-processing) et l'API Models.
Pour activer ou désactiver l'[API Compliance](https://platform.claude.com/docs/fr/manage-claude/compliance-api) pour l'organisation Anthropic créée par la configuration, [ouvrez la Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), accédez à **Settings > Compliance** et utilisez le bouton **Compliance API**.
Les clés de chiffrement gérées par le client (CMEK) sont disponibles avec les clés Google Cloud KMS. Pour activer CMEK pour l'organisation Anthropic créée par la configuration, consultez [Clés de chiffrement gérées par le client](https://platform.claude.com/docs/fr/manage-claude/cmek). Pour configurer une clé, suivez [Configurer Google Cloud KMS pour CMEK](https://platform.claude.com/docs/fr/manage-claude/cmek-google-cloud-kms). Ensuite, enregistrez, vérifiez et associez la clé dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console), comme le décrit l'onglet **Claude Console** de la page de configuration.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview) est disponible via Claude Models on Google Cloud (Anthropic managed), notamment les éléments suivants :
* [Agents](https://platform.claude.com/docs/fr/managed-agents/agent-setup)
* [Environnements](https://platform.claude.com/docs/fr/managed-agents/environments)
* [Sessions](https://platform.claude.com/docs/fr/managed-agents/sessions)
* [Coffres d'identifiants](https://platform.claude.com/docs/fr/managed-agents/vaults)
* [Magasins de mémoire](https://platform.claude.com/docs/fr/managed-agents/memory)
* [Déploiements planifiés](https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments)
* [Sandboxes auto-hébergées](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes)
L'accès est vérifié lors de la création d'une session ou d'un déploiement, et non pendant son exécution :
* **Les sessions en cours continuent de s'exécuter.** Si vous révoquez l'accès Google Cloud de l'identité qui a créé une session, la session ne s'arrête pas. Pour l'arrêter, envoyez-lui un [événement `user.interrupt`](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming#integrating-events) seul. Une fois la session à l'état `idle`, vous pouvez l'archiver ou la supprimer.
* **Les déploiements planifiés continuent de s'exécuter.** Un déploiement ne revérifie pas l'accès de son créateur à chaque exécution planifiée. Pour l'arrêter, mettez-le en pause, mettez-le à jour ou archivez-le.
Lorsque vous supprimez un utilisateur ou effectuez la rotation d'un compte de service, examinez les sessions et les déploiements créés par cette identité.
### Fonctionnalités non prises en charge
Les éléments suivants ne sont pas pris en charge sur Claude Models on Google Cloud (Anthropic managed) :
* **Clés API :** L'authentification se fait uniquement via les identifiants Google Cloud.
* **Tunnels MCP :** Les [tunnels MCP](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/overview) ne sont pas disponibles sur Claude Models on Google Cloud (Anthropic managed).
* **[Magasins de mémoire sur des environnements auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory) :** Les magasins de mémoire ne sont pas pris en charge pour les sessions sur des environnements auto-hébergés.
* **Workers de sandbox auto-hébergée préconstruits :** Les [workers auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-workers) de la CLI `ant` et des SDK Python, TypeScript et Go ne prennent pas en charge Claude Models on Google Cloud (Anthropic managed). Implémentez plutôt votre propre worker qui appelle directement les [endpoints Environments Work](https://platform.claude.com/docs/fr/api/beta/environments/work). Pour connaître les rôles et les autorisations dont votre worker a besoin, consultez [Autorisations IAM pour les environnements](https://platform.claude.com/docs/fr/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions#environments).
### Fenêtre de contexte
Les tailles de la « context window » (fenêtre de contexte) sur Claude Models on Google Cloud (Anthropic managed) sont les mêmes que sur l'API Claude. Pour la limite de chaque modèle, consultez [Fenêtres de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-windows).
## Facturation, limites de débit et journalisation
### Limites de débit
Anthropic gère les « rate limits » (limites de débit) pour Claude Models on Google Cloud (Anthropic managed). Pour demander des limites plus élevées, contactez votre représentant de compte Anthropic ou [contactez l'équipe commerciale](https://claude.com/contact-sales). Pour savoir comment les limites de débit sont mesurées et signalées, consultez [Limites de débit](https://platform.claude.com/docs/fr/api/rate-limits).
### Facturation
Claude Models on Google Cloud (Anthropic managed) est facturé via Google Cloud Marketplace. Anthropic mesure votre utilisation. Il la signale à Google Cloud en Claude Consumption Units. Les frais apparaissent sur votre facture Google Cloud. Anthropic n'envoie pas de facture distincte.
Consultez les données d'utilisation et de coût sur les pages **Usage** et **Cost** de la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#using-the-claude-console).
Si vous avez un engagement de dépenses Google Cloud, l'utilisation est prise en compte dans celui-ci de la même manière que les autres achats Marketplace.
### Conservation des données
Anthropic est le sous-traitant des données pour Claude Models on Google Cloud (Anthropic managed). Certains services de support, tels que les systèmes de confiance et de sécurité d'Anthropic, traitent des données en dehors de Google Cloud.
Claude Models on Google Cloud (Anthropic managed) suit la même politique de conservation des données que l'API Claude. Consultez [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention). La Zero Data Retention (ZDR) est disponible sur demande. Contactez votre représentant de compte Anthropic.
Un accord ZDR sur une autre organisation Anthropic ne s'applique pas à votre organisation pour Claude Models on Google Cloud (Anthropic managed).
### Surveillance et journalisation
[Cloud Audit Logs](https://cloud.google.com/logging/docs/audit) enregistre l'activité de l'API pour Claude Models on Google Cloud (Anthropic managed) dans votre projet. Les entrées apparaissent sous le service `claude.googleapis.com`. Chaque route de l'API appartient à l'un des deux types de journaux :
* **Journaux Data Access :** Ils couvrent la plupart des routes, notamment les messages, les lots, les fichiers, les skills, les modèles et la plupart des ressources Claude Managed Agents. Ils sont désactivés par défaut.
* **Journaux Admin Activity :** Ils couvrent les autres routes, notamment les routes des clés de chiffrement et la plupart des routes des coffres d'identifiants. L'exception est la route pour `vaults.verify`, qui relève de Data Access. Les journaux Admin Activity sont toujours activés.
Pour conserver un enregistrement des requêtes, activez les journaux Data Access pour `claude.googleapis.com` dans les paramètres des journaux d'audit de votre projet.
Pour les types de journaux d'audit par route, consultez [Autorisations IAM pour Claude Models on Google Cloud (Anthropic managed)](https://platform.claude.com/docs/fr/api/claude-models-on-google-cloud-anthropic-managed-iam-permissions).
#### ID de requête
Les réponses réussies de Claude Models on Google Cloud (Anthropic managed) comportent l'en-tête [`request-id`](https://platform.claude.com/docs/fr/api/errors#request-id).
## Migrer depuis une organisation Anthropic existante
Vous ne pouvez pas convertir une organisation Anthropic existante en organisation pour Claude Models on Google Cloud (Anthropic managed). Cela inclut une organisation que vous utilisez directement avec l'API Claude.
Planifiez la migration comme un basculement vers une nouvelle organisation :
* **Créez d'abord la nouvelle organisation.** Suivez [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
* **Recréez l'accès et la configuration.** Les clés API, les espaces de travail et les paramètres de la Claude Console ne sont pas transférés. Attribuez des [rôles IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#iam-roles) sur le projet au lieu de créer des clés API. Pour recréer vos espaces de travail, consultez [Espaces de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#workspaces). Pour les accords ZDR, consultez [Conservation des données](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention).
* **Planifiez le sort des ressources stockées.** Les fichiers, les skills, les lots et les ressources Claude Managed Agents restent dans l'organisation existante.
* **Mettez à jour votre intégration.** Pour savoir ce qui change et ce qui reste identique, consultez [Effectuer des requêtes](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests). Pour les fonctionnalités non prises en charge, consultez [Fonctionnalités non prises en charge](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#features-not-supported).
* **Basculez selon votre propre calendrier.** Les deux organisations sont indépendantes et peuvent servir du trafic en parallèle. Vous pouvez migrer les charges de travail progressivement. L'organisation existante conserve sa facturation actuelle. Avant de transférer le trafic de production, vérifiez les [limites de débit](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Migrer depuis Claude Models on Google Cloud (Google managed)
Pour passer à Claude Models on Google Cloud (Anthropic managed), effectuez les étapes suivantes. Avant de déplacer des charges de travail qui reposent sur un accord ZDR, consultez [Conservation des données](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#data-retention). Pour savoir ce qui change lors de la migration, consultez [Différences entre les deux offres Google Cloud](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/overview#how-the-two-google-cloud-offerings-differ).
Effectuez chaque étape de [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#set-up-your-account).
Accordez `roles/claude.user` à chaque identité qui appelle Claude Models on Google Cloud (Anthropic managed). Définissez votre projet et votre ID d'espace de travail comme variables d'environnement. Pour ces deux points, consultez [Avant d'effectuer des appels API](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#before-making-api-calls).
Installez le paquet qui fournit le client pour Claude Models on Google Cloud (Anthropic managed). Consultez [Installer un SDK](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#install-an-sdk).
Modifiez le code qui importe et crée votre client. Utilisez `AnthropicGoogleCloud` (csharp: `AnthropicGoogleCloudClient`; go: `googlecloud.NewClient`; java: `GoogleCloudBackend`; php: `Anthropic\GoogleCloud\Client`; ruby: `Anthropic::GoogleCloudClient`) à la place de `AnthropicVertex` (csharp: `AnthropicVertexClient`; go: `vertex.WithGoogleAuth`; java: `VertexBackend`; php: `Anthropic\Vertex\Client`; ruby: `Anthropic::VertexClient`). Dans une requête cURL, modifiez l'URL, les en-têtes et le corps. Votre code actuel crée un client pour Claude Models on Google Cloud (Google managed). Par exemple, le code suivant crée ce client avec le point de terminaison global :
```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` ne prend pas en charge 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"
)
// ...
// Utilise les identifiants Google Cloud par défaut.
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"
)
```
Le code suivant crée le client pour 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
```
Le nouveau client lit votre projet et votre ID d'espace de travail à partir des variables d'environnement que vous avez définies dans [Trouver votre ID d'espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#find-your-workspace-id). Vous ne les transmettez pas lors de la création du client. Vos appels à l'API Messages restent inchangés, à l'exception des ID de modèle et des fonctionnalités abordés à l'étape suivante.
* **ID de modèle :** si vous utilisez un modèle antérieur à Claude 4.6, remplacez le `@` situé avant la date de l'instantané dans son ID par un trait d'union. Par exemple, `claude-haiku-4-5@20251001` devient `claude-haiku-4-5-20251001`. Pour connaître les modèles et leurs ID, consultez [ID de modèle de l'API](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#api-model-ids).
* **Fonctionnalités :** consultez [Prise en charge des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#feature-support) pour chaque fonctionnalité utilisée par votre code.
* **Emplacement :** si vous utilisez actuellement un point de terminaison multirégional ou régional, vérifiez quel emplacement Claude Models on Google Cloud (Anthropic managed) utilise. Consultez [Résolution du projet, de l'emplacement et de l'espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#project-location-and-workspace-resolution).
Exécutez la requête de [Effectuer des requêtes](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#making-requests) pour vérifier que votre configuration fonctionne. Exécutez ensuite votre propre code. Si un appel échoue avec une erreur d'autorisation, consultez [Dépannage de la configuration du compte](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#troubleshooting-account-setup). Avant de migrer le trafic de production, vérifiez les [limites de débit](https://platform.claude.com/docs/fr/build-with-claude/claude-models-on-google-cloud/anthropic-managed#rate-limits).
## Étapes suivantes
Explorez les fonctionnalités de Claude.
Consultez les autorisations, les rôles et les types de journaux d'audit.
À mesure que des modèles plus sûrs et plus performants sont lancés, Anthropic retire régulièrement les plus anciens. Consultez toutes les dépréciations de l'API, ainsi que les remplacements recommandés.
Gérez votre abonnement et votre facturation.