---
title: Claude Platform on AWS
url: https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws
description: Accédez à l'ensemble des fonctionnalités de la plateforme Claude via AWS, avec une infrastructure gérée par Anthropic.
---
Claude Platform on AWS vous offre l'expérience complète de la plateforme Anthropic, accessible depuis votre compte AWS : Messages API, Agent Skills, exécution de code et fonctionnalités bêta. Avec [Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock), c'est AWS qui exploite la pile d'inférence. Claude Platform on AWS est au contraire exploitée par Anthropic. AWS fournit la couche d'authentification (SigV4 ou clé API), le contrôle d'accès basé sur IAM et l'intégration de la facturation via AWS Marketplace.
Les SDK Anthropic prennent en charge Claude Platform on AWS.
## Fonctionnement de l'intégration de la plateforme
Les modèles Claude s'exécutent sur une infrastructure gérée par Anthropic. Il s'agit d'une intégration commerciale qui assure la facturation et l'accès via AWS. Anthropic est le sous-traitant des données pour les entrées et sorties d'inférence. AWS traite les métadonnées de facturation et d'identité selon le modèle de la marketplace. Les clients qui utilisent Claude via Claude Platform on AWS sont soumis aux [conditions d'utilisation des données](https://www.anthropic.com/legal) d'Anthropic.
Anthropic utilise l'infrastructure AWS pour traiter vos requêtes API, exécuter l'inférence des modèles et stocker le contenu de votre espace de travail (prompts, sorties, fichiers, Skills et lots, par exemple). Pour les espaces de travail créés avant le 18 septembre 2026, 00:00 UTC, Anthropic peut traiter les requêtes, stocker les données et exécuter l'inférence en dehors d'AWS. Dans les deux cas, les sous-services peuvent changer sans préavis. Définissez le paramètre [`inference_geo`](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#data-residency) pour chaque requête afin de limiter l'inférence à une zone géographique spécifique.
Claude Platform on AWS applique la même politique de conservation des données que la Claude API propriétaire. La « Zero Data Retention » (conservation zéro des données), ou ZDR, est disponible sur demande. Contactez votre représentant de compte Anthropic pour l'activer pour votre organisation.
## Claude Platform on AWS par rapport à Amazon Bedrock
Les deux offres vous permettent d'utiliser Claude via AWS, mais elles diffèrent par leur architecture, leur surface d'API et la disponibilité des fonctionnalités.
| Aspect | Claude Platform on AWS | [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock) | [Amazon Bedrock (Opus 4.6 et versions antérieures)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy) |
| ----------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------ |
| **Qui exploite la pile** | Anthropic | AWS | AWS |
| **Surface d'API** | Claude API (`/v1/{endpoint}`) | Messages API à `/anthropic/v1/messages` | Bedrock Converse / InvokeModel |
| **Disponibilité des fonctionnalités** | Généralement le même jour que la Claude API (voir les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported)) | Selon le calendrier de publication d'Amazon Bedrock | Selon le calendrier de publication d'Amazon Bedrock |
| **Agent Skills** | Disponible | Non disponible (nécessite l'exécution de code) | Non disponible |
| **Fonctionnalités bêta** | Transmises avec les en-têtes `anthropic-beta` (voir les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported)) | Les fonctionnalités bêta prises en charge par Amazon Bedrock, via l'en-tête `anthropic-beta` | Les fonctionnalités bêta prises en charge par Amazon Bedrock, via le champ `anthropic_beta` du corps de la requête InvokeModel |
| **Authentification** | AWS IAM / SigV4 ou clé API | AWS IAM / SigV4 | AWS IAM / SigV4 ou jeton bearer |
| **Facturation** | AWS Marketplace | AWS (service natif) | AWS (service natif) |
| **URL de base** | `aws-external-anthropic.{region}.api.aws` | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` |
| **Client SDK** | `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), en bêta | `AnthropicBedrockMantle` | `AnthropicBedrock` / SDK Bedrock |
| **Console** | Claude Console (`platform.claude.com`, accès via la console AWS) | Console Bedrock | Console Bedrock |
| **Limites de débit et quotas** | Gérés par Anthropic | Gérés par AWS | Gérés par AWS |
| **Sous-traitant des données d'inférence** | Anthropic | AWS | AWS |
Si vous avez besoin d'un Claude exploité par AWS, consultez [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock). Claude Platform on AWS utilise un pool de capacité distinct de celui de la Claude API propriétaire et de celui d'Amazon Bedrock. Vous pouvez exécuter des charges de travail sur plusieurs plateformes et basculer de l'une à l'autre.
[AWS PrivateLink](https://docs.aws.amazon.com/vpc/latest/privatelink/what-is-privatelink.html) est pris en charge pour connecter votre VPC au point de terminaison de Claude Platform on AWS.
**Quand choisir Bedrock :** les organisations des secteurs réglementés qui exigent une conformité FedRAMP High, IL4, IL5 ou HIPAA, ou qui ont besoin qu'AWS soit le seul sous-traitant des données, doivent utiliser [Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock). Bedrock s'exécute entièrement sur une infrastructure contrôlée par AWS, AWS étant la partie exploitante.
**Quelle offre utilisez-vous ?** Claude est disponible via plusieurs produits distincts :
* **Claude Platform on AWS** (cette page) : la plateforme Claude API facturée via AWS Marketplace. Gérée dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console) et la console AWS.
* **[Claude dans Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock) :** un service natif AWS. Géré dans la console Amazon Bedrock et facturé comme utilisation de service AWS.
* **Claude Enterprise acquis via AWS Marketplace :** un forfait [claude.ai](https://claude.ai) (le produit de chat Claude), et non une plateforme API. Géré sur claude.ai ; son comportement en matière de compte et de migration diffère de ce que décrit cette page. Consultez le [Centre d'aide Claude](https://support.claude.com).
* **Comptes Anthropic directs :** la Claude API propriétaire et les forfaits claude.ai facturés par Anthropic. Gérés dans la Claude Console et sur claude.ai.
## Configurer votre compte
La configuration de Claude Platform on AWS se déroule en quatre phases :
1. Inscrivez-vous sur la page du service dans la console AWS.
2. Finalisez la configuration de votre organisation Anthropic.
3. Notez l'ID de votre espace de travail.
4. Connectez-vous à la Claude Console.
L'inscription via la console AWS provisionne une nouvelle organisation Anthropic liée à votre compte AWS. Cette organisation est distincte de toute organisation existante de votre entreprise chez Anthropic, y compris les organisations Claude Enterprise acquises via AWS Marketplace. Les clés API, les espaces de travail et les paramètres de la Claude Console d'une organisation Anthropic propriétaire ne sont pas transférés.
Si vous disposez d'une offre privée Amazon Bedrock existante, contactez votre représentant de compte Anthropic ou AWS avant de vous inscrire. Votre remise s'appliquera ainsi dès votre première requête. Les remises ne peuvent pas être appliquées rétroactivement à l'utilisation antérieure à l'acceptation de votre offre privée. Consultez [Offres privées](https://platform.claude.com/docs/fr/about-claude/pricing#private-offers).
1. Ouvrez la [console AWS](https://console.aws.amazon.com/) et accédez à la page du service **Claude Platform on AWS**.
2. Choisissez **Sign up**.
3. Sur la page d'inscription, lisez les conditions : le contrat de licence utilisateur final d'Anthropic, l'avis de confidentialité AWS et le contrat client AWS. Cochez ensuite la case d'acceptation.
4. Choisissez **Continue**.
La page affiche une bannière **Sign-up in progress**. Restez sur la page. L'inscription prend quelques minutes, le temps qu'AWS gère pour vous l'abonnement AWS Marketplace. Vous êtes ensuite redirigé automatiquement.
Si votre organisation dispose d'une offre privée d'Anthropic, la console la recherche et vous invite à l'accepter dans AWS Marketplace. Consultez [Offres privées](https://platform.claude.com/docs/fr/about-claude/pricing#private-offers) pour plus de détails.
Lorsque vous utilisez Claude Platform on AWS, Anthropic traite et stocke votre contenu (prompts et sorties, par exemple) sur l'infrastructure AWS. Pour les espaces de travail créés avant le 18 septembre 2026, 00:00 UTC, Anthropic peut traiter et stocker ce contenu en dehors d'AWS. Les [politiques d'utilisation des données](https://www.anthropic.com/legal) d'Anthropic décrivent comment le contenu et les métadonnées sont traités et stockés.
Une fois l'inscription terminée, vous êtes redirigé vers `platform.claude.com/partner-signup`.
1. Saisissez l'adresse e-mail du propriétaire de votre organisation et choisissez **Get started**.
2. Consultez cette boîte de réception pour trouver le lien de configuration, puis suivez-le. Si votre navigateur affiche une page **Signed in as a different account**, choisissez **Log out and continue**.
3. Remplissez le formulaire de détails de l'organisation (nom de l'organisation, type d'entité, pays, utilisation prévue) et choisissez **Complete setup**.
La finalisation de la configuration crée votre organisation Anthropic et vaut acceptation des conditions commerciales d'utilisation et de la politique d'utilisation d'Anthropic. La page du service dans la console AWS affiche désormais une navigation à gauche avec **Home**, **API keys**, **Quickstart** et **Workspaces**.
Une fois la configuration terminée, la console AWS vous invite à créer un espace de travail. Consultez [Espaces de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#workspaces) pour en savoir plus sur l'association à une région, la portée des ressources IAM et la création d'espaces de travail supplémentaires.
L'ID de l'espace de travail se trouve sous **Workspaces**, sur la page du service **Claude Platform on AWS** de la console AWS ou dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console). Les ID d'espace de travail utilisent le format `wrkspc_` suivi d'un identifiant alphanumérique.
L'accès à la Claude Console est fédéré via AWS IAM :
1. Assumez un rôle IAM disposant de l'autorisation `aws-external-anthropic:AssumeConsole`. Consultez [Actions IAM pour Claude Platform on AWS](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#console-access).
2. Depuis la page du service **Claude Platform on AWS**, choisissez **Open Claude Console**. La console AWS émet un JWT et vous redirige vers `platform.claude.com`.
3. Lors de la première connexion, une adresse e-mail vous est demandée. Saisissez votre adresse e-mail professionnelle. La plateforme provisionne votre utilisateur de la Claude Console à la volée.
Lorsque vous êtes connecté via la console AWS, la Claude Console est limitée à votre organisation Claude Platform on AWS. Un indicateur **Account managed by AWS** apparaît en bas à gauche de la barre latérale de la Claude Console.
### Migrer depuis une organisation Anthropic existante
L'inscription à Claude Platform on AWS provisionne toujours une nouvelle organisation Anthropic liée à votre compte AWS. Aucune conversion sur place n'est possible. Une organisation existante, comme une organisation Claude API propriétaire, ne peut pas devenir une organisation Claude Platform on AWS.
Planifiez la migration depuis une organisation existante comme une bascule vers une nouvelle organisation :
* **Créez d'abord la nouvelle organisation.** Inscrivez-vous via la console AWS (voir [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#set-up-your-account)). Si votre migration implique une offre privée, terminez l'inscription avant l'acceptation de l'offre. Les remises s'appliquent à partir de l'acceptation, et non rétroactivement. Consultez [Offres privées](https://platform.claude.com/docs/fr/about-claude/pricing#private-offers).
* **Recréez les 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 depuis une organisation existante. Créez des espaces de travail dans la nouvelle organisation et faites passer vos applications à l'[authentification Claude Platform on AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#authentication).
* **Mettez à jour votre intégration.** Claude Platform on AWS sert la Claude API (`/v1/{endpoint}`). Les formats des requêtes et des réponses sont donc identiques à ceux de la Claude API propriétaire. Trois éléments changent : l'URL de base, la méthode d'authentification et l'en-tête `anthropic-workspace-id` sur les requêtes d'inférence et de ressources. Consultez [Effectuer des requêtes](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#making-requests). Certaines fonctionnalités de la plateforme diffèrent. Consultez [Fonctionnalités non prises en charge](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Basculez à votre propre rythme.** La nouvelle organisation est indépendante de l'existante, et les deux peuvent traiter du trafic en parallèle. Une bascule brutale n'est pas nécessaire. Transférez progressivement les charges de travail jusqu'à ce que tout votre trafic passe par la nouvelle organisation.
Une fois la nouvelle organisation opérationnelle, les différences portent surtout sur la facturation et l'authentification, qui sont gérées via AWS :
* **La facturation** passe à AWS Marketplace. L'utilisation est facturée en « Claude Consumption Units » (unités de consommation Claude) plutôt qu'en crédits prépayés (voir [Facturation](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#billing)). Vous définissez les limites de dépenses sur la page Billing (voir [Limites de dépenses](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#spend-limits)). Pendant la transition, les facturations restent séparées : l'organisation existante continue d'être facturée comme aujourd'hui.
* **L'authentification et les accès** passent à AWS. Les requêtes s'authentifient avec des identifiants AWS ou avec des clés API générées dans la console AWS, et non dans la Claude Console (voir [Authentification](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#authentication)). L'appartenance à l'organisation est gérée via AWS IAM plutôt que via la Claude Console (voir [Pages disponibles](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#available-pages)). Les SDK clients d'Anthropic fournissent des classes clientes propres à la plateforme (voir [Installer un SDK](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#install-an-sdk)).
* **L'utilisation quotidienne de l'API** fonctionne comme sur la Claude API propriétaire, sauf exceptions indiquées dans les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported). Avant de transférer le trafic de production, vérifiez vos « rate limits » (limites de débit). Les nouvelles organisations sont placées au niveau Start, et les augmentations de limites passent par votre représentant de compte Anthropic (voir [Limites de débit et quotas](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Les organisations Claude Enterprise (claude.ai) se comportent différemment. Pour ces organisations, consultez la [comparaison des offres](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock).
### Dépannage de la configuration du compte
* **« Sign-up failed: Failed to enable OutboundWebIdentityFederation » :** si cette bannière s'affiche lors de la première soumission, choisissez à nouveau **Continue**. L'activation IAM peut mettre un moment à prendre effet.
* **Aucun indicateur de progression pendant l'inscription :** l'inscription prend quelques minutes. Pendant qu'AWS provisionne votre compte, la page affiche une bannière statique **Sign-up in progress**, sans barre de progression.
* **« Signed in as a different account » après avoir suivi le lien de configuration :** choisissez **Log out and continue**. La page vous authentifie à nouveau avec l'adresse e-mail que vous avez saisie.
* **Message « Not found » pendant la connexion :** ce message peut apparaître brièvement pendant la redirection. Vous pouvez l'ignorer.
* **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.
* **« Outbound web identity federation is disabled » lors de votre premier appel API :** activez la fédération une fois par compte. Consultez [Activer la fédération d'identité web sortante](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation).
## Avant d'effectuer des appels API
Assurez-vous de disposer des éléments suivants :
1. Un compte AWS actif avec un abonnement à Claude Platform on AWS (voir [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#set-up-your-account)).
2. L'[AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html), installée et configurée.
3. **La fédération d'identité web sortante activée** sur votre compte AWS, une étape de configuration unique (voir [Activer la fédération d'identité web sortante](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation)).
4. L'ID de votre espace de travail (voir [Obtenir l'ID de votre espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id)).
5. L'autorisation IAM d'appeler l'API : l'action `aws-external-anthropic:CreateInference` sur votre espace de travail. Si vous vous authentifiez avec une clé API, il vous faut aussi `aws-external-anthropic:CallWithBearerToken` (voir [Politiques IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#iam-policies)).
### Activer la fédération d'identité web sortante
La passerelle Claude Platform on AWS appelle `sts:GetWebIdentityToken` côté serveur pour générer un JWT qu'elle transmet à Anthropic. Cette capacité STS est **désactivée par défaut** sur chaque compte AWS. Activez-la une fois par compte :
```bash CLI
aws iam enable-outbound-web-identity-federation
```
Si la réponse est `[ERROR] (FeatureEnabled) ... already enabled`, le paramètre est déjà activé pour votre compte et vous pouvez passer à la suite. Vérifiez le paramètre et récupérez l'URL de l'émetteur de votre compte :
```bash CLI
aws iam get-outbound-web-identity-federation-info
```
Sans cette étape, chaque requête renvoie `"Outbound web identity federation is disabled for your account"`. Il s'agit de l'erreur de configuration la plus courante.
### Obtenir l'ID de votre espace de travail
Vous créez un espace de travail depuis la console AWS après avoir terminé la configuration du compte (voir [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#set-up-your-account)). Les espaces de travail sont liés à une seule région AWS. Vous pouvez trouver l'ID de l'espace de travail dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console) sous **Workspaces** ou dans la section **Workspaces** de la page du service dans la console AWS.
Définissez les variables d'environnement `ANTHROPIC_AWS_WORKSPACE_ID` et `AWS_REGION` afin que les clients SDK les lisent automatiquement :
```bash CLI
export ANTHROPIC_AWS_WORKSPACE_ID='wrkspc_01AbCdEf23GhIj'
export AWS_REGION='us-west-2' # Your workspace's AWS region
```
La région est obligatoire. Le client SDK génère une erreur si aucune région n'est définie. Passez `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) lors de la création du client, ou définissez `AWS_REGION` (ou `AWS_DEFAULT_REGION`). Toutes les régions commerciales AWS sont prises en charge.
## Authentification
Claude Platform on AWS prend en charge deux méthodes d'authentification :
* AWS IAM avec signature des requêtes Signature Version 4 (SigV4), la méthode principale.
* L'authentification par clé API.
Les deux utilisent la même URL de base et le même format de requête.
### Authentification SigV4
SigV4 est la méthode native pour les entreprises. Elle s'intègre à vos politiques, rôles et audits AWS IAM existants. Configurez les identifiants AWS avec n'importe quelle méthode prise en charge par la [chaîne de fournisseurs d'identifiants AWS par défaut](https://docs.aws.amazon.com/sdkref/latest/guide/standardized-credentials.html) :
* Variables d'environnement (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, `AWS_SESSION_TOKEN`)
* Fichier d'identifiants partagé (`~/.aws/credentials`)
* Fichier de configuration partagé (`~/.aws/config`), y compris SSO et `credential_process`
* Identité web (`AWS_WEB_IDENTITY_TOKEN_FILE` et `AWS_ROLE_ARN`) pour IRSA et GitHub Actions
* Identifiants de conteneur ECS
* Service de métadonnées d'instance EC2 (IMDS)
Vérifiez que vos identifiants fonctionnent :
```bash CLI
aws sts get-caller-identity
```
### Authentification par clé API
Pour des intégrations plus simples (développement local et scripts), vous pouvez vous authentifier avec une clé API au lieu de SigV4. Définissez la variable d'environnement `ANTHROPIC_AWS_API_KEY` ou passez `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) lors de la création du client.
Générez des clés API dans la **console AWS** sous **Claude Platform on AWS → API keys**. Choisissez **Generate a key**, puis copiez la valeur de la clé. Accordez l'action IAM `aws-external-anthropic:CallWithBearerToken` aux principaux qui doivent être autorisés à utiliser l'authentification par clé API.
Les clés API pour Claude Platform on AWS sont gérées dans la console AWS, et non dans la Claude Console. Les clés créées dans la [Claude Console](https://platform.claude.com/) standard (pour l'accès à l'API propriétaire) ne fonctionnent pas avec le point de terminaison Claude Platform on AWS.
#### Clés API à court terme
Certaines charges de travail doivent transmettre un identifiant à un processus distinct. C'est le cas, par exemple, d'une passerelle pour « large language models » (grands modèles de langage), ou LLM, d'une fonction serverless ou d'un outil qui prend en charge l'authentification par jeton bearer mais pas SigV4. Pour ces charges de travail, générez une clé API à court terme à partir de vos identifiants AWS plutôt que de provisionner une clé de longue durée dans la console AWS.
AWS publie des bibliothèques de génération de jetons pour [JavaScript](https://github.com/aws/token-generator-for-aws-external-anthropic-js), [Python](https://github.com/aws/token-generator-for-aws-external-anthropic-python) et [Java](https://github.com/aws/token-generator-for-aws-external-anthropic-java). Chaque bibliothèque lit vos identifiants AWS via la chaîne de fournisseurs standard. Elle renvoie un jeton à durée limitée qui fonctionne avec l'en-tête `x-api-key`. La durée de vie du jeton est de 12 heures par défaut. Elle est plafonnée à la plus courte des trois durées suivantes : la durée demandée, l'expiration de vos identifiants AWS et 12 heures. Consultez les README des dépôts liés pour l'installation et toutes les options de configuration.
Passez le jeton généré au SDK de la même manière qu'une clé API générée dans la console AWS :
```python Python
from token_generator_for_aws_external_anthropic import TokenGenerator
from anthropic import AnthropicAWS
token = TokenGenerator(region="us-west-2").get_token()
client = AnthropicAWS(api_key=token, aws_region="us-west-2")
```
```typescript TypeScript
import { getTokenProvider } from "@aws/token-generator-for-aws-external-anthropic";
import AnthropicAws from "@anthropic-ai/aws-sdk";
const tokenProvider = getTokenProvider({ region: "us-west-2" });
const token = await tokenProvider();
const client = new AnthropicAws({ apiKey: token, awsRegion: "us-west-2" });
```
```java Java
import software.amazon.awsexternalanthropic.TokenGenerator;
import software.amazon.awssdk.regions.Region;
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
void main() {
String token = TokenGenerator.builder().region(Region.US_WEST_2).build().getToken();
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.builder()
.apiKey(token)
.region(Region.US_WEST_2)
.workspaceId(System.getenv("ANTHROPIC_AWS_WORKSPACE_ID"))
.build())
.build();
}
```
Si vous pouvez générer le jeton localement, votre processus dispose déjà d'identifiants SigV4. L'authentification SigV4 est alors généralement le choix le plus simple. Utilisez les clés à court terme lorsque le processus qui effectue les appels API est distinct de celui qui détient les identifiants AWS.
Le SDK ne renouvelle pas automatiquement les clés à court terme. Lorsqu'un jeton expire, générez-en un nouveau et créez un nouveau client. Le principal qui utilise le jeton doit toujours disposer de l'action IAM `aws-external-anthropic:CallWithBearerToken`.
### Priorité des identifiants
Le client spécifique à la plateforme résout l'authentification dans l'ordre suivant, en commençant par ce que vous passez lors de sa création :
1. `api_key` (typescript, php: `apiKey`; go: `APIKey`; java: `.apiKey()`; csharp: `AwsClientOptions.ApiKey`) → en-tête `x-api-key`
2. `aws_access_key` (typescript, php: `awsAccessKey`; go: `AWSAccessKey`; java: `.awsAccessKey()`; csharp: `AwsClientOptions.AwsAccessKey`) + `aws_secret_key` (ruby: `aws_secret_access_key`; typescript, php: `awsSecretAccessKey`; go: `AWSSecretAccessKey`; java: `.awsSecretAccessKey()`; csharp: `AwsClientOptions.AwsSecretAccessKey`) → AWS SigV4
3. `aws_profile` (typescript, php: `awsProfile`; go: `AWSProfile`; java: `.awsProfile()`; csharp: `AwsClientOptions.AwsProfile`) → AWS SigV4 avec profil nommé
4. Variable d'environnement `ANTHROPIC_AWS_API_KEY` → en-tête `x-api-key`
5. Chaîne de fournisseurs d'identifiants AWS par défaut → AWS SigV4
### Résolution de la région
Le client lit `AWS_REGION` depuis l'environnement si vous ne définissez pas `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`), et se rabat sur `AWS_DEFAULT_REGION` pour assurer la compatibilité avec les SDK AWS standard. La région est obligatoire et il n'existe pas de valeur par défaut : `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`) génère une erreur si ni l'argument du constructeur ni une variable d'environnement n'est défini.
## Installer un SDK
Les [SDK clients](https://platform.claude.com/docs/fr/cli-sdks-libraries/overview) d'Anthropic prennent en charge Claude Platform on AWS. Votre SDK fournit `AnthropicAWS` (typescript: `AnthropicAws`; csharp: `AnthropicAwsClient`; go: `anthropicaws.NewClient`; java: `AwsBackend`; php: `Anthropic\Aws\Client`; ruby: `Anthropic::AWSClient`), qui gère la signature SigV4, la construction de l'URL de base en fonction de la région et l'en-tête `anthropic-workspace-id`.
```bash
pip install -U "anthropic[aws]"
```
Sur macOS avec Python installé via Homebrew ou d'autres environnements Python gérés en externe, `pip install` peut échouer avec une erreur PEP 668 `externally-managed-environment`. Créez et activez d'abord un environnement virtuel : `python3 -m venv .venv && source .venv/bin/activate`.
```bash
npm install @anthropic-ai/aws-sdk
```
```bash
dotnet add package Anthropic.Aws
```
```bash
go get github.com/anthropics/anthropic-sdk-go
```
```kotlin Gradle
implementation("com.anthropic:anthropic-java:2.73.0")
implementation("com.anthropic:anthropic-java-aws:2.73.0")
```
```xml Maven
com.anthropic
anthropic-java
2.73.0
com.anthropic
anthropic-java-aws
2.73.0
```
```bash
composer require anthropic-ai/sdk aws/aws-sdk-php
```
```bash
gem install anthropic aws-sdk-core
```
Les clients SDK pour Claude Platform on AWS sont en bêta.
## Modèles disponibles
Les modèles suivants sont disponibles sur Claude Platform on AWS :
| Model | Model ID |
| :---------------------------------------------------------------------------------------------------- | :------------------ |
| Claude Fable 5.1 | `claude-fable-5-1` |
| Claude Fable 5 | `claude-fable-5` |
| Claude Opus 5.5 | `claude-opus-5-5` |
| Claude Opus 5 | `claude-opus-5` |
| Claude Opus 4.8 | `claude-opus-4-8` |
| Claude Opus 4.7 | `claude-opus-4-7` |
| Claude Opus 4.6 | `claude-opus-4-6` |
| Claude Opus 4.5 | `claude-opus-4-5` |
| Claude Sonnet 5.5 | `claude-sonnet-5-5` |
| Claude Sonnet 5 | `claude-sonnet-5` |
| Claude Sonnet 4.6 | `claude-sonnet-4-6` |
| Claude Sonnet 4.5 ([deprecated](https://platform.claude.com/docs/fr/about-claude/model-deprecations)) | `claude-sonnet-4-5` |
| Claude Haiku 5.5 | `claude-haiku-5-5` |
| Claude Haiku 4.5 | `claude-haiku-4-5` |
Les ID de modèles sont identiques à ceux de la Claude API propriétaire. Il n'y a ni ARN de type Bedrock ni préfixe `anthropic.`.
Les nouveaux modèles sont généralement lancés sur Claude Platform on AWS le même jour que sur la Claude API propriétaire.
Vous passez à un modèle Claude plus récent ? Dans Claude Code, exécutez `/claude-api migrate` pour appliquer les remplacements d'identifiants de modèle et les changements de paramètres non rétrocompatibles dans l'ensemble de votre base de code. La skill détecte la plateforme cloud ciblée par votre code et ajuste les formats d'identifiants de modèle ainsi que les changements de fonctionnalités pour cette plateforme. Consultez [Migrer vers un modèle Claude plus récent](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/claude-api-skill#migrating-to-a-newer-claude-model).
## Effectuer des requêtes
Claude Platform on AWS utilise les mêmes points de terminaison d'API que la Claude API propriétaire. Les différences sont l'URL de base, la méthode d'authentification et l'en-tête `anthropic-workspace-id`, qui identifie l'[espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#workspaces) ciblé par une requête. L'en-tête est obligatoire sur les requêtes d'inférence et de ressources, comme les appels à la Messages API, à la Models API, à la Files API et aux points de terminaison Claude Managed Agents. Les requêtes vers l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api) n'en ont pas besoin.
Avant d'exécuter ces exemples, effectuez les étapes décrites dans [Avant d'effectuer des appels API](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#before-making-api-calls).
```bash cURL
# Remplacez us-west-2 par votre région AWS dans l'URL et dans --aws-sigv4.
# Omettez l'en-tête x-amz-security-token si vous utilisez des identifiants d'utilisateur IAM à long terme.
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Remplacez us-west-2 par votre région AWS.
# ant lit ANTHROPIC_API_KEY et l'envoie en tant que x-api-key. Générez une clé dans la
# console AWS (voir Authentification par clé API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}' \
--transform content
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new() { Role = Role.User, Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Le client lit `AWS_REGION` (ou `AWS_DEFAULT_REGION`) et `ANTHROPIC_AWS_WORKSPACE_ID` depuis l'environnement. Vous pouvez remplacer l'une ou l'autre valeur en passant `aws_region` (typescript, php: `awsRegion`; go: `AWSRegion`; java: `.region()`; csharp: `AwsClientOptions.AwsRegion`) ou `workspace_id` (typescript, php: `workspaceId`; go: `WorkspaceID`; java: `.workspaceId()`; csharp: `AwsClientOptions.WorkspaceId`) lors de la création du client. La région et l'ID de l'espace de travail sont tous deux obligatoires. Le constructeur génère une erreur si l'un ou l'autre ne peut pas être résolu.
L'en-tête `x-amz-security-token` (cURL) n'est requis que pour les identifiants temporaires tels que les rôles IAM, SSO ou STS. Omettez-le lorsque vous utilisez des identifiants d'utilisateur IAM à long terme. Les clients SDK gèrent cela automatiquement en fonction de la source des identifiants.
La valeur `--aws-sigv4` suit le format `aws:amz::`. Le nom du service SigV4 est `aws-external-anthropic`, et la région doit correspondre à la région de l'URL de votre point de terminaison. Une incohérence dans l'un ou l'autre produit une erreur générique de rejet de signature plutôt qu'un diagnostic spécifique.
### Fenêtre de contexte
Les tailles de « context window » (fenêtre de contexte) sur Claude Platform on AWS sont identiques à celles de la Claude API propriétaire. Consultez [Fenêtres de contexte](https://platform.claude.com/docs/fr/build-with-claude/context-windows) pour connaître les limites de chaque modèle.
## Prise en charge des fonctionnalités
Claude Platform on AWS utilise directement les points de terminaison de la Claude API. Vous bénéficiez donc d'une parité fonctionnelle complète avec la Claude API propriétaire, sauf exceptions indiquées dans les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported) :
* **Accès aux fonctionnalités :** comme Anthropic exploite les deux plateformes, la plupart des nouvelles fonctionnalités et des en-têtes bêta deviennent disponibles sur Claude Platform on AWS sans étape d'intégration distincte. Consultez les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported) pour les exceptions.
* **Fonctionnalités bêta :** passez l'en-tête standard `anthropic-beta` pour accéder aux fonctionnalités bêta, exactement comme vous le feriez avec la Claude API.
* **Agent Skills :** utilisez des [Agent Skills](https://platform.claude.com/docs/fr/agents-and-tools/agent-skills/overview) prédéfinies et personnalisées avec le même paramètre `container.skills` que la Claude API. Toutes les Skills prédéfinies (PowerPoint, Excel, Word, PDF) fonctionnent immédiatement.
* **Exécution de code :** exécutez du code dans le bac à sable géré par Anthropic à l'aide de l'[outil d'exécution de code](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/code-execution-tool).
* **Utilisation d'outils :** toutes les [capacités de « tool use » (utilisation d'outils)](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/overview) sont disponibles, à l'exception des ensembles d'outils d'utilisation de l'ordinateur et du navigateur ; consultez [Fonctionnalités non prises en charge](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported).
* **Réflexion :** la [réflexion adaptative](https://platform.claude.com/docs/fr/build-with-claude/thinking), le [paramètre effort](https://platform.claude.com/docs/fr/build-with-claude/effort) et, sur les modèles qui la prennent en charge, l'[« extended thinking » (réflexion étendue)](https://platform.claude.com/docs/fr/build-with-claude/extended-thinking) fonctionnent avec les mêmes paramètres que la Claude API.
* **Streaming :** prise en charge complète du streaming SSE pour des réponses en temps réel.
* **Traitement par lots :** soumettez des requêtes par lots pour les charges de travail à haut débit.
* **Mise en cache des prompts :** mettez en cache les outils, les invites système et l'historique des messages pour réduire la latence et les coûts. Toutes les capacités de « prompt caching » (mise en cache des prompts) sont disponibles : TTL de 5 minutes, TTL d'une heure et mise en cache automatique.
* **Files API :** téléversez des fichiers et référencez-les d'une requête à l'autre.
* **Clés de chiffrement gérées par le client (CMEK) :** [CMEK](https://platform.claude.com/docs/fr/manage-claude/cmek) est disponible uniquement avec des clés [AWS KMS](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms). Les clés Google Cloud KMS et Azure Key Vault ne peuvent pas être enregistrées. La clé doit être une clé KMS mono-région située dans le même compte AWS et la même région que l'espace de travail auquel elle est associée, et sa politique de clé doit accorder l'accès au principal de service `aws-external-anthropic.amazonaws.com` ; consultez [Configurer CMEK sur Claude Platform on AWS](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#claude-platform-on-aws). Enregistrez et associez les clés dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console) ; les points de terminaison de clés externes sont également disponibles, autorisés via des [actions IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#encryption-keys). Il n'y a pas d'étape de validation distincte : la clé est implicitement validée lorsque vous l'associez à un espace de travail (l'appel d'association effectue un cycle de chiffrement/déchiffrement), de sorte qu'un problème de politique de clé apparaît au moment de l'association plutôt qu'à l'enregistrement.
* **Compliance API :** la [Compliance API](https://platform.claude.com/docs/fr/manage-claude/compliance-api) est disponible. L'accès est autorisé via l'[action `ListComplianceActivities`](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#compliance) d'AWS IAM.
Consultez le [tableau comparatif](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#claude-platform-on-aws-vs-amazon-bedrock) pour connaître les différences de disponibilité des fonctionnalités par rapport à Amazon Bedrock.
### Claude Managed Agents
[Claude Managed Agents](https://platform.claude.com/docs/fr/managed-agents/overview) est disponible sur Claude Platform on AWS, y compris les [agents](https://platform.claude.com/docs/fr/managed-agents/agent-setup), les [environnements](https://platform.claude.com/docs/fr/managed-agents/environments), les [sessions](https://platform.claude.com/docs/fr/managed-agents/sessions), les [déploiements planifiés](https://platform.claude.com/docs/fr/managed-agents/scheduled-deployments), les [coffres d'identifiants](https://platform.claude.com/docs/fr/managed-agents/vaults), les [magasins de mémoire](https://platform.claude.com/docs/fr/managed-agents/memory), les [webhooks](https://platform.claude.com/docs/fr/managed-agents/webhooks), l'[orchestration multi-agents](https://platform.claude.com/docs/fr/managed-agents/multiagent-orchestration) et les [sandboxes auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes).
Les sessions et les workers auto-hébergés sur Claude Platform on AWS diffèrent de Claude Managed Agents propriétaire sur trois points :
* **Réauthentification des sessions autonomes :** une session peut s'exécuter de manière autonome, sans aucun [événement utilisateur](https://platform.claude.com/docs/fr/managed-agents/reference#event-types), pendant 6 heures au maximum. Au-delà de 6 heures, la session nécessite une réauthentification avant de continuer. Pour vous réauthentifier, envoyez n'importe quel événement de rôle utilisateur à la session (voir [Événements et streaming](https://platform.claude.com/docs/fr/managed-agents/events-and-streaming)). Claude Managed Agents propriétaire n'impose aucune limite de durée d'exécution aux sessions autonomes.
* **[Magasins de mémoire sur les environnements auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes-memory) :** une session qui s'exécute sur un environnement auto-hébergé ne peut pas attacher de magasins de mémoire ; une session qui en inclut un est rejetée lors de sa création. Les sessions sur les environnements cloud attachent les magasins de mémoire comme d'habitude. Sur Claude Managed Agents propriétaire, les sessions sur les environnements cloud comme auto-hébergés peuvent attacher des magasins de mémoire.
* **[Authentification des workers sur les environnements auto-hébergés](https://platform.claude.com/docs/fr/managed-agents/self-hosted-sandboxes#prerequisites) :** un worker s'authentifie avec AWS IAM (SigV4) ou une [clé API générée dans la console AWS](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#api-key-authentication), et non avec une clé d'environnement. Les clés d'environnement générées dans la Claude Console ne fonctionnent pas avec le point de terminaison Claude Platform on AWS.
### Fonctionnalités non prises en charge
Les fonctionnalités suivantes ne sont actuellement pas disponibles sur Claude Platform on AWS :
* **Conformité HIPAA :** le programme de conformité HIPAA d'Anthropic n'est pas disponible. Consultez [API et conservation des données](https://platform.claude.com/docs/fr/manage-claude/api-and-data-retention).
* **Ensembles d'outils d'utilisation de l'ordinateur et du navigateur :** `computer_toolset_20260801` et `browser_toolset_20260801` ne sont actuellement pas disponibles sur Claude Platform on AWS. Les versions bêta de l'outil d'utilisation de l'ordinateur restent disponibles pour les modèles répertoriés sous [Versions antérieures de l'outil](https://platform.claude.com/docs/fr/agents-and-tools/tool-use/computer-use-tool#earlier-tool-versions).
- **Admin API :** les points de terminaison des espaces de travail (création, récupération, liste, mise à jour et archivage sur `/v1/organizations/workspaces`), les points de terminaison des clés externes (enregistrement, récupération, liste, mise à jour et suppression sur `/v1/organizations/external_keys`, pour [CMEK](https://platform.claude.com/docs/fr/manage-claude/cmek) ; les clés sont validées lorsqu'elles sont associées à un espace de travail plutôt que via un point de terminaison de validation) et les [points de terminaison des destinations de télémétrie](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#telemetry-destinations) sont disponibles. Les autres points de terminaison de l'Admin API (membres de l'organisation, membres des espaces de travail, invitations, clés API, rapports d'utilisation, rapports de coûts et rapports de limites de débit) ne sont actuellement pas disponibles. Consultez plutôt les données d'utilisation et de coûts dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console). AWS IAM gère l'appartenance à l'organisation.
- **Gestion des membres des espaces de travail :** l'ajout ou la suppression d'utilisateurs dans des espaces de travail individuels n'est pas disponible. Les politiques AWS IAM sur les ARN des espaces de travail contrôlent l'accès.
- **Espace de travail Claude Code et Analytics API :** l'espace de travail Claude Code avec limites de débit automatiques n'est pas disponible. L'utilisation de Claude Code apparaît dans la vue d'utilisation générale plutôt que dans un écran dédié.
- **Authentification OAuth :** non prise en charge. Utilisez l'authentification SigV4 ou par clé API.
- **Mode rapide :** non disponible sur Claude Platform on AWS.
- **Points de terminaison d'API compatibles OpenAI :** non disponibles sur Claude Platform on AWS.
- **Tunnels MCP :** seuls les serveurs MCP exposés sur l'internet public sont pris en charge.
## Résidence des données
Claude Platform on AWS prend en charge les zones géographiques d'inférence suivantes :
* **US :** l'inférence reste dans des centres de données situés aux États-Unis. Un multiplicateur tarifaire de 1,1x s'applique.
* **Global :** l'inférence peut être acheminée vers n'importe quel centre de données exploité par Anthropic dans le monde. La tarification standard s'applique.
La région AWS à laquelle votre espace de travail est lié détermine le point de terminaison de passerelle que vous appelez et la portée des ressources côté AWS (IAM, CloudTrail, facturation). Elle ne fixe pas l'endroit où s'exécute l'inférence du modèle. Pour fixer l'inférence dans une zone géographique spécifique, définissez `inference_geo` sur chaque requête ou configurez une valeur par défaut pour l'espace de travail.
Définissez la zone géographique d'inférence par requête avec le paramètre `inference_geo` :
Le paramètre `inference_geo` est pris en charge sur Claude 4.6 et les modèles ultérieurs. Les requêtes avec `inference_geo` sur Claude Opus 4.5, Claude Sonnet 4.5 (déprécié) ou Claude Haiku 4.5 renvoient une erreur 400. Consultez [Résidence des données](https://platform.claude.com/docs/fr/manage-claude/data-residency) pour plus de détails sur la disponibilité des modèles.
```bash cURL
# Remplacez us-west-2 par votre région AWS dans l'URL et dans --aws-sigv4.
# Omettez l'en-tête x-amz-security-token si vous utilisez des identifiants d'utilisateur IAM à long terme.
curl "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"inference_geo": "us",
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Remplacez us-west-2 par votre région AWS.
# ant lit ANTHROPIC_API_KEY et l'envoie en tant que x-api-key. Générez une clé dans la
# console AWS (voir Authentification par clé API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
ant messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--inference-geo us \
--message '{role: user, content: "Hello!"}' \
--transform content
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
message = client.messages.create(
model="claude-sonnet-5-5",
max_tokens=1024,
inference_geo="us",
messages=[{"role": "user", "content": "Hello!"}],
)
print(message)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const message = await client.messages.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
});
console.log(message);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var message = await client.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
InferenceGeo = "us",
Messages = [new() { Role = Role.User, Content = "Hello!" }]
});
Console.WriteLine(message);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
message, err := client.Messages.New(context.Background(), anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
InferenceGeo: anthropic.String("us"),
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
})
if err != nil {
panic(err)
}
fmt.Println(message)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
Message message = client.messages().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.inferenceGeo("us")
.addUserMessage("Hello!")
.build()
);
IO.println(message);
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$message = $client->messages->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
inferenceGeo: 'us',
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $message;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
inference_geo: "us",
messages: [{ role: "user", content: "Hello!" }]
)
puts message
```
Si vous omettez `inference_geo`, la requête utilise la valeur `default_inference_geo` de l'espace de travail si elle est configurée, sinon `global`.
Les contrôles de zone géographique d'inférence au niveau de l'espace de travail (`allowed_inference_geos` et `default_inference_geo`) sont également disponibles sur Claude Platform on AWS. Consultez [Restrictions au niveau de l'espace de travail](https://platform.claude.com/docs/fr/manage-claude/data-residency#workspace-level-restrictions).
## Espaces de travail
Les requêtes d'inférence et de ressources sur Claude Platform on AWS ciblent un espace de travail. Vous transmettez l'ID de l'espace de travail dans l'en-tête `anthropic-workspace-id` lors de ces appels d'API. Les ID d'espace de travail utilisent le format balisé `wrkspc_` suivi d'un identifiant alphanumérique (par exemple, `wrkspc_01AbCdEf23GhIj`). Consultez [Obtenir l'ID de votre espace de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#obtain-your-workspace-id) si vous ne l'avez pas encore.
### Portée des espaces de travail
Les espaces de travail sont liés à une seule région AWS. Un espace de travail créé dans `us-west-2` n'est accessible que via l'endpoint `us-west-2`. L'utilisation, les quotas, les coûts, les fichiers, les lots et les Skills sont tous agrégés par espace de travail, ce qui vous donne des ventilations par région dans la Claude Console.
Les espaces de travail servent également de ressource IAM principale pour Claude Platform on AWS. Vous accordez ou refusez l'accès à des espaces de travail spécifiques via des politiques AWS IAM en utilisant l'ARN de l'espace de travail. Le segment de ressource de l'ARN est le même ID préfixé par `wrkspc_` que celui que vous transmettez dans l'en-tête `anthropic-workspace-id` :
```text wrap
arn:aws:aws-external-anthropic:{region}:{account-id}:workspace/{workspace-id}
```
Par exemple :
```text wrap
arn:aws:aws-external-anthropic:us-west-2:123456789012:workspace/wrkspc_01AbCdEf23GhIj
```
Consultez [Politiques IAM](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#iam-policies) pour des exemples de politiques.
### Gérer les espaces de travail
Créez des espaces de travail supplémentaires, renommez un espace de travail ou archivez un espace de travail depuis la page **Workspaces** de la console AWS ou avec les endpoints d'espace de travail de l'[Admin API](https://platform.claude.com/docs/fr/manage-claude/admin-api). Ces endpoints ne nécessitent pas l'en-tête `anthropic-workspace-id`. La création et le listage agissent sur l'organisation ; la récupération, la mise à jour et l'archivage prennent l'ID de l'espace de travail dans le chemin de l'URL. Un nouvel espace de travail est lié à la région AWS de l'endpoint que vous appelez pour le créer (voir [Portée des espaces de travail](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#workspace-scoping)). Avec le rôle Admin, vous pouvez également créer, renommer et archiver des espaces de travail depuis la page **Workspaces** de la Claude Console.
## Utiliser la Claude Console
Claude Platform on AWS utilise la Claude Console standard à l'adresse [platform.claude.com](https://platform.claude.com). Lorsque vous vous connectez depuis la console AWS, un indicateur **Account managed by AWS** apparaît en bas à gauche de la barre latérale de la Claude Console, et la Console se limite à votre organisation Claude Platform on AWS. Elle fournit des analyses d'utilisation, des ventilations des coûts, une visibilité sur les « rate limits » (limites de débit), la gestion des espaces de travail, ainsi que des pages pour gérer les fichiers, les Agent Skills, les tâches par lots et les ressources Claude Managed Agents (agents, sessions, environnements, coffres d'identifiants, magasins de mémoire et webhooks).
### Connexion
L'accès à la Claude Console est fédéré via AWS IAM. Consultez [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#set-up-your-account) pour le processus complet de première connexion. En résumé :
1. Endossez un rôle IAM disposant de l'autorisation `aws-external-anthropic:AssumeConsole`. Consultez [Actions IAM pour Claude Platform on AWS](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#console-access).
2. Accédez à la page Claude Platform on AWS dans la [console AWS](https://console.aws.amazon.com/).
3. Choisissez **Open Claude Console**. La console AWS émet un JWT et vous redirige vers `platform.claude.com`.
4. Lors de la première connexion, une adresse e-mail vous est demandée. Saisissez votre adresse e-mail professionnelle. La plateforme provisionne votre utilisateur Claude Console à la volée (just-in-time).
Deux rôles Claude Console sont disponibles : **Admin** et **Developer**. Le rôle Admin donne accès à toutes les pages et à tous les paramètres de la Claude Console disponibles pour Claude Platform on AWS. Le rôle Developer donne un accès en lecture aux informations d'utilisation, de coûts, de limites de débit et d'espaces de travail. Contactez votre représentant de compte Anthropic pour attribuer le rôle Admin ou Developer à un principal.
### Pages disponibles
La colonne **Via la passerelle AWS** indique si la page lit et écrit des données via la passerelle AWS (et est donc régie par les [actions IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions)). Les pages marquées **Non** lisent les métadonnées au niveau de l'organisation directement depuis Anthropic et contournent les vérifications des actions IAM.
| Page | Disponible | Via la passerelle AWS | Remarques |
| --------------------- | ------------ | ---------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Usage** | Oui | Non | Consultez l'utilisation des tokens par modèle, espace de travail et dimension. Les données peuvent mettre quelques minutes à apparaître après une requête. |
| **Cost** | Oui | Non | Consultez les ventilations des coûts par modèle et par espace de travail. AWS Cost Explorer affiche la ligne agrégée [Claude Consumption Unit (CCU)](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#billing). |
| **Rate limits** | Oui | Non | Consultez les limites de débit (lecture seule). Les augmentations de niveau passent par votre représentant de compte Anthropic ; consultez [Limites de débit et quotas](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas). |
| **Workspaces** | Oui | Oui (sauf les limites de dépenses) | Consultez les espaces de travail par région. Avec le rôle Admin, vous pouvez également créer, renommer et archiver des espaces de travail, et définir des [limites de dépenses](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#spend-limits) par espace de travail. |
| **Encryption keys** | Oui | Oui | Une section de la page [Data retention](https://platform.claude.com/settings/privacy#encryption-keys) (`platform.claude.com/settings/privacy`) de la Claude Console, affichée lorsque **Organization** est sélectionné dans le menu déroulant en haut de la page. Enregistrez-y des clés AWS KMS pour [CMEK](https://platform.claude.com/docs/fr/manage-claude/cmek-aws-kms#claude-platform-on-aws) (rôle Admin). Pour associer une clé enregistrée à un espace de travail, sélectionnez l'espace de travail dans ce menu déroulant, puis sélectionnez la clé sous **Encryption key**. |
| **Files** | Oui | Oui | Consultez et gérez les fichiers téléversés. |
| **Skills** | Oui | Oui | Consultez et gérez les Agent Skills. |
| **Batches** | Oui | Oui | Consultez et gérez les tâches de traitement par lots. |
| **Agents** | Oui | Oui | Consultez et gérez les définitions d'agents. |
| **Sessions** | Oui | Oui | Consultez les sessions d'agents et l'historique des événements. |
| **Environments** | Oui | Oui | Consultez et gérez les configurations de sandbox cloud pour les sessions. |
| **Credential vaults** | Oui | Oui | Consultez et gérez les coffres d'identifiants pour l'authentification des sessions. |
| **Memory stores** | Oui | Oui | Consultez et gérez la mémoire persistante des agents. |
| **Webhooks** | Oui | Oui | Consultez et gérez les points de terminaison de webhooks. |
| **API keys** | Non | N/A | Gérez les clés API dans la console AWS (**Claude Platform on AWS → API keys**). Consultez [Authentification par clé API](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#api-key-authentication). |
| **Members** | Non | N/A | Non applicable. AWS IAM gère l'accès. |
| **Billing** | Oui (limité) | Non | Définissez une limite de dépenses mensuelle pour l'organisation ; consultez [Limites de dépenses](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#spend-limits). AWS Marketplace gère la facturation. Consultez les ventilations des coûts sur la page Cost. |
| **Claude Code** | Non | N/A | Consultez l'utilisation de Claude Code sur la page Usage. |
### Changer d'organisation
La Claude Console ne prend pas en charge le changement d'organisation pour Claude Platform on AWS. Pour accéder à une autre organisation, déconnectez-vous et authentifiez-vous à nouveau via la console AWS en utilisant le rôle IAM du compte AWS de cette organisation.
## Limites de débit et quotas
Les organisations sur Claude Platform on AWS sont placées au niveau Start. Anthropic gère directement les limites de débit, et non via les systèmes de quotas AWS.
Les organisations sur Claude Platform on AWS peuvent passer automatiquement à un « usage tier » (niveau d'utilisation) supérieur à mesure qu'elles constituent un historique de factures AWS Marketplace payées. Le processus en libre-service **Request tier increase** de la Claude Console n'est pas disponible : la page Rate limits vous oriente plutôt vers votre représentant de compte Anthropic.
Pour demander des limites plus élevées, contactez votre représentant de compte Anthropic ou le [support Anthropic](https://support.claude.com). Incluez les éléments suivants dans votre demande :
* Les modèles pour lesquels vous avez besoin de limites plus élevées
* Les pics de tokens d'entrée par minute et de tokens de sortie par minute pour chaque modèle (et non les totaux quotidiens)
* La part approximative de vos entrées constituée de contexte mis en cache ou répété (les lectures du cache ne sont pas comptabilisées dans les limites de tokens d'entrée pour la plupart des modèles ; consultez [ITPM tenant compte du cache](https://platform.claude.com/docs/fr/api/rate-limits#cache-aware-itpm))
Les niveaux d'utilisation sont des paliers fixes : chaque niveau associe des limites de débit à un [plafond de dépenses mensuel](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#spend-limits), et passer à un niveau supérieur augmente les deux. Pour les détails des niveaux et les limites par modèle, consultez [Limites de débit](https://platform.claude.com/docs/fr/api/rate-limits).
## Facturation
Claude Platform on AWS est facturé via [AWS Marketplace](https://aws.amazon.com/marketplace). L'utilisation est libellée en Claude Consumption Units (CCU), mesurée toutes les heures et facturée mensuellement à terme échu sur votre facture AWS. Les CCU ne sont pas des crédits prépayés. Il n'y a ni solde de CCU ni engagement.
Pour le prix des CCU, les mécanismes de conversion, l'application des remises et les tarifs des tokens par modèle, consultez [Tarification de Claude Platform on AWS](https://platform.claude.com/docs/fr/about-claude/pricing#claude-platform-on-aws-pricing).
### Limites de dépenses
Les niveaux d'utilisation Start, Build et Scale comportent chacun un « spend cap » (plafond de dépenses) mensuel ; consultez les [plafonds de dépenses par niveau](https://platform.claude.com/docs/fr/api/rate-limits#spend-limits) pour les valeurs actuelles. Lorsque l'utilisation de votre organisation pour le mois civil atteint le plafond de son niveau, les requêtes API échouent avec l'[erreur de plafond de dépenses](https://platform.claude.com/docs/fr/api/rate-limits#reaching-your-spend-cap) jusqu'à 00:00 UTC le premier jour du mois suivant, et les nouvelles tentatives effectuées avant cette échéance n'aboutissent pas. Le plafond de dépenses et les limites de débit appartiennent au même niveau. Pour relever le plafond, ou pour rétablir l'accès après l'avoir atteint, demandez une augmentation de niveau auprès de votre représentant de compte Anthropic ou du [support Anthropic](https://support.claude.com) (consultez [Limites de débit et quotas](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#rate-limits-and-quotas)).
Vous pouvez également définir vos propres « spend limits » (limites de dépenses) mensuelles en dessous du plafond, après avoir ajouté au moins un destinataire sous **Email recipients** sur la page Billing :
* **Limite de dépenses de l'organisation :** Accédez à [Settings > Billing](https://platform.claude.com/settings/billing) dans la [Claude Console](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#using-the-claude-console) pour définir une limite de dépenses mensuelle.
* **Limites de dépenses des espaces de travail :** Sur la page [Workspaces](https://platform.claude.com/settings/workspaces) (`platform.claude.com/settings/workspaces`) de la Claude Console, sélectionnez un espace de travail. Dans le panneau qui s'ouvre, cliquez sur **Spend limits**.
Lorsque l'utilisation atteint une limite que vous avez définie, les requêtes échouent avec une erreur HTTP 400 (consultez l'[erreur de limite de dépenses](https://platform.claude.com/docs/fr/api/rate-limits#setting-your-own-spend-limit)) jusqu'à 00:00 UTC le premier jour du mois suivant, ou jusqu'à ce que vous releviez ou supprimiez la limite.
Les dépenses sont calculées aux prix catalogue et peuvent mettre environ 2 heures à refléter l'utilisation récente ; l'utilisation peut donc dépasser le plafond ou une limite avant que les requêtes ne commencent à échouer. Le dépassement est facturé. Lorsque le plafond du niveau ou une limite de dépenses de l'organisation bloque vos requêtes, une notification par e-mail est envoyée aux destinataires répertoriés sous **Email recipients** sur la page Billing. Les destinataires basés sur les rôles, comme l'ensemble des administrateurs, ne sont pas disponibles sur Claude Platform on AWS. La notification de plafond de niveau est également envoyée à l'adresse e-mail utilisée lors de l'inscription sur AWS Marketplace.
## Surveillance et journalisation
AWS CloudTrail peut capturer toutes les requêtes adressées à Claude Platform on AWS. Les opérations sur les espaces de travail, les clés externes, les destinations de télémétrie, la conformité, les coffres et les webhooks sont journalisées par défaut en tant qu'événements de gestion (Management events). Les opérations d'inférence, de lots, de fichiers, de skills, de modèles, de profils utilisateur et de Claude Managed Agents (autres que les coffres et les webhooks) sont classées comme événements de données (Data events) et nécessitent une configuration explicite de la journalisation des événements de données, ce qui entraîne des frais CloudTrail supplémentaires. Consultez la [référence des actions IAM](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#route-to-action-mapping) pour la classification complète des types d'événements et la [documentation AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/) pour les détails de configuration.
### ID de requête
Chaque réponse inclut deux ID de requête dans les en-têtes de réponse :
* **ID de requête AWS (`x-amzn-requestid`) :** L'ID principal, indexé dans CloudTrail. Utilisez-le lorsque vous examinez des requêtes via les outils AWS ou lorsque vous contactez le support AWS.
* **ID de requête Anthropic (`request-id`) :** L'ID secondaire. Utilisez-le lorsque vous contactez le support Anthropic.
```bash cURL
# Remplacez us-west-2 par votre région AWS dans l'URL et dans --aws-sigv4.
# -i inclut les en-têtes de la réponse dans la sortie.
# Omettez l'en-tête x-amz-security-token si vous utilisez des identifiants d'utilisateur IAM à long terme.
curl -i "https://aws-external-anthropic.us-west-2.api.aws/v1/messages" \
--aws-sigv4 "aws:amz:us-west-2:aws-external-anthropic" \
--user "$AWS_ACCESS_KEY_ID:$AWS_SECRET_ACCESS_KEY" \
-H "x-amz-security-token: $AWS_SESSION_TOKEN" \
-H "content-type: application/json" \
-H "anthropic-version: 2023-06-01" \
-H "anthropic-workspace-id: $ANTHROPIC_AWS_WORKSPACE_ID" \
-d '{
"model": "claude-sonnet-5-5",
"max_tokens": 1024,
"messages": [
{"role": "user", "content": "Hello!"}
]
}'
```
```bash CLI
# Remplacez us-west-2 par votre région AWS
# ant lit ANTHROPIC_API_KEY et l'envoie en tant que x-api-key. Générez une clé dans la
# console AWS (voir Authentification par clé API).
export ANTHROPIC_API_KEY="YOUR_AWS_API_KEY"
# --debug affiche la réponse HTTP, y compris les en-têtes X-Amzn-Requestid et
# Request-Id, sur stderr
ant --debug messages create \
--base-url https://aws-external-anthropic.us-west-2.api.aws \
--workspace-id "$ANTHROPIC_AWS_WORKSPACE_ID" \
--model claude-sonnet-5-5 \
--max-tokens 1024 \
--message '{role: user, content: "Hello!"}'
```
```python Python
from anthropic import AnthropicAWS
client = AnthropicAWS()
response = client.messages.with_raw_response.create(
model="claude-sonnet-5-5",
max_tokens=1024,
messages=[{"role": "user", "content": "Hello!"}],
)
print(response.headers.get("x-amzn-requestid")) # AWS request ID
print(response.headers.get("request-id")) # Anthropic request ID
message = response.parse()
print(message.content)
```
```typescript TypeScript
import AnthropicAws from "@anthropic-ai/aws-sdk";
const client = new AnthropicAws();
const { data: message, response } = await client.messages
.create({
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }]
})
.withResponse();
console.log(response.headers.get("x-amzn-requestid")); // AWS request ID
console.log(response.headers.get("request-id")); // Anthropic request ID
console.log(message.content);
```
```csharp C#
using Anthropic;
using Anthropic.Aws;
var client = new AnthropicAwsClient();
var response = await client.WithRawResponse.Messages.Create(new()
{
Model = Model.ClaudeSonnet5_5,
MaxTokens = 1024,
Messages = [new() { Role = Role.User, Content = "Hello!" }]
});
Console.WriteLine(response.Headers.GetValues("x-amzn-requestid").First()); // AWS request ID
Console.WriteLine(response.Headers.GetValues("request-id").First()); // Anthropic request ID
Console.WriteLine(response.Value.Content);
```
```go Go
client, err := anthropicaws.NewClient(context.Background(), anthropicaws.ClientConfig{})
if err != nil {
panic(err)
}
var response *http.Response
message, err := client.Messages.New(
context.Background(),
anthropic.MessageNewParams{
Model: anthropic.ModelClaudeSonnet5_5,
MaxTokens: 1024,
Messages: []anthropic.MessageParam{
anthropic.NewUserMessage(anthropic.NewTextBlock("Hello!")),
},
},
option.WithResponseInto(&response),
)
if err != nil {
panic(err)
}
fmt.Println(response.Header.Get("x-amzn-requestid")) // AWS request ID
fmt.Println(response.Header.Get("request-id")) // Anthropic request ID
fmt.Println(message.Content)
```
```java Java
import com.anthropic.aws.backends.AwsBackend;
import com.anthropic.client.AnthropicClient;
import com.anthropic.client.okhttp.AnthropicOkHttpClient;
import com.anthropic.core.http.HttpResponseFor;
import com.anthropic.models.messages.Message;
import com.anthropic.models.messages.MessageCreateParams;
import com.anthropic.models.messages.Model;
void main() {
AnthropicClient client = AnthropicOkHttpClient.builder()
.backend(AwsBackend.fromEnv())
.build();
HttpResponseFor response = client.messages().withRawResponse().create(
MessageCreateParams.builder()
.model(Model.CLAUDE_SONNET_5_5)
.maxTokens(1024)
.addUserMessage("Hello!")
.build()
);
IO.println(response.headers().values("x-amzn-requestid").get(0)); // AWS request ID
IO.println(response.requestId().orElse(null)); // Anthropic request ID
IO.println(response.parse().content());
}
```
```php PHP
use Anthropic\Aws\Client;
$client = new Client();
$response = $client->messages->raw->create(
model: 'claude-sonnet-5-5',
maxTokens: 1024,
messages: [['role' => 'user', 'content' => 'Hello!']],
);
echo $response->getHeaderLine('x-amzn-requestid') . "\n"; // AWS request ID
echo $response->getHeaderLine('request-id') . "\n"; // Anthropic request ID
echo $response->parse()->content;
```
```ruby Ruby
require "anthropic"
client = Anthropic::AWSClient.new
# Lisez les en-têtes de réponse dans un middleware par requête, qui reçoit la
# réponse HTTP brute avant que le SDK ne l'analyse.
aws_request_id = nil
anthropic_request_id = nil
read_request_ids = lambda do |request, call_next|
response = call_next.call(request)
# Les clés de response.headers sont en minuscules.
aws_request_id = response.headers["x-amzn-requestid"]
anthropic_request_id = response.headers["request-id"]
response
end
message = client.messages.create(
model: "claude-sonnet-5-5",
max_tokens: 1024,
messages: [{ role: "user", content: "Hello!" }],
request_options: { middleware: [read_request_ids] }
)
puts aws_request_id # AWS request ID
puts anthropic_request_id # Anthropic request ID
puts message.content
```
Anthropic recommande de journaliser votre activité sur une période glissante d'au moins 30 jours afin de comprendre les schémas d'utilisation et d'examiner les problèmes.
AWS CloudTrail est configuré au sein de votre compte AWS. L'activation de la journalisation ne donne pas à AWS ou à Anthropic accès à votre contenu au-delà de ce qui est nécessaire à la facturation et au fonctionnement du service.
## Migrer depuis Amazon Bedrock
Si vous utilisez actuellement Claude sur Bedrock, la migration vers Claude Platform on AWS nécessite des modifications dans l'ensemble de votre intégration. La signature SigV4 reste prise en charge, mais le contexte de signature, l'URL de base, le format de l'API, les ID de modèle, le client et le package SDK, le format de streaming, les en-têtes de requête et la disponibilité régionale changent tous. Claude Platform on AWS provisionne également une nouvelle organisation Anthropic. Le tableau suivant résume les différences.
### Ce qui change
L'ampleur de la migration dépend de l'intégration Bedrock dont vous provenez. Le tableau suivant présente à la fois l'[intégration Bedrock actuelle](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock) (Messages API sur `bedrock-mantle.{region}.api.aws`) et l'[ancienne intégration InvokeModel](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy).
| Aspect | Depuis [Claude in Amazon Bedrock](https://platform.claude.com/docs/fr/build-with-claude/claude-in-amazon-bedrock) | Depuis [Amazon Bedrock (Opus 4.6 et versions antérieures)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy) | Vers Claude Platform on AWS |
| ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **URL de base** | `bedrock-mantle.{region}.api.aws` | `bedrock-runtime.{region}.amazonaws.com` | `aws-external-anthropic.{region}.api.aws` |
| **Format de l'API** | Messages API sur `/anthropic/v1/messages` | Bedrock Converse / InvokeModel | Claude API (`/v1/{endpoint}`) |
| **ID de modèles** | anthropic.claude-haiku-4-5 | anthropic.claude-haiku-4-5-20251001-v1:0(avec un préfixe de profil d'inférence `us.` ou `global.`) | claude-haiku-4-5 |
| **Client SDK** | `AnthropicBedrockMantle` | `AnthropicBedrock` / SDK Bedrock | Client spécifique à la plateforme (consultez [Installer un SDK](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#install-an-sdk)), en bêta |
| **Package SDK** | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`) | `anthropic[bedrock]` (typescript: `@anthropic-ai/bedrock-sdk`; csharp: `Anthropic.Bedrock`; go: `github.com/anthropics/anthropic-sdk-go/bedrock`; java: `com.anthropic:anthropic-java-bedrock`; php: `anthropic-ai/sdk`; ruby: `anthropic`), ou le SDK AWS | `anthropic[aws]` (typescript: `@anthropic-ai/aws-sdk`; csharp: `Anthropic.Aws`; go: `github.com/anthropics/anthropic-sdk-go/aws`; java: `com.anthropic:anthropic-java-aws`; php: `anthropic-ai/sdk`; ruby: `anthropic`) (consultez [Installer un SDK](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#install-an-sdk)) |
| **Nom de service SigV4** | `bedrock-mantle` | `bedrock` | `aws-external-anthropic` |
| **Format de streaming** | SSE | AWS EventStream | SSE (identique à la Claude API) |
| **En-tête d'espace de travail** | Non applicable | Non applicable | `anthropic-workspace-id`, requis sur les requêtes d'inférence et de ressources |
| **Disponibilité régionale** | Consultez [Régions Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Consultez [Régions Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/bedrock-regions.html) | Toutes les régions commerciales AWS |
| **Organisation Anthropic** | Aucune requise | Aucune requise | Nouvelle organisation créée lors de l'inscription. Les organisations existantes ne peuvent pas être converties (consultez [Migrer depuis une organisation Anthropic existante](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#moving-from-an-existing-anthropic-organization)) |
Si vous utilisez l'intégration Bedrock actuelle, le format du corps de requête est déjà celui de la Messages API. Les changements portent sur l'URL de base, le nom de service SigV4, les ID de modèles et l'ajout de l'en-tête `anthropic-workspace-id`. Si vous utilisez l'ancienne API InvokeModel ou Converse, vous devrez également réécrire les structures de requête et de réponse au format de la Messages API. Consultez [Claude sur Amazon Bedrock (Opus 4.6 et versions antérieures)](https://platform.claude.com/docs/fr/build-with-claude/claude-on-amazon-bedrock-legacy) pour la correspondance des structures de requête.
### Ce que vous gagnez
* Un accès généralement le jour même aux nouveaux modèles et fonctionnalités (consultez les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported))
* Les Agent Skills pour la génération de documents (PowerPoint, Excel, Word, PDF)
* L'exécution de code dans le bac à sable géré par Anthropic
* Les fonctionnalités bêta de la Claude API qu'Amazon Bedrock ne propose pas, via l'en-tête `anthropic-beta` (consultez les [limitations des fonctionnalités](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#features-not-supported))
* La Claude Console pour la visibilité sur les quotas et les analyses d'utilisation
* Le support direct d'Anthropic
* L'authentification par clé API comme alternative à SigV4 (consultez [Authentification par clé API](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#api-key-authentication))
### Ce qui reste identique
* L'authentification AWS IAM (SigV4)
* AWS en tant qu'entité de facturation. Le canal de facturation passe du service AWS natif à AWS Marketplace (voir [Considérations commerciales](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#commercial-considerations)).
* L'imputation sur les engagements AWS
### Pièges de la migration
**Activez d'abord la fédération d'identité web sortante.** Si votre compte AWS n'a jamais utilisé Claude Platform on AWS, vous devez [activer la fédération d'identité web sortante](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) une fois par compte avant d'effectuer des requêtes. Sans cette étape, toutes les requêtes échouent avec une erreur de fédération (consultez [Activer la fédération d'identité web sortante](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#enable-outbound-web-identity-federation) pour l'erreur exacte et la solution). Cette étape n'est pas requise pour Bedrock.
**La « Zero Data Retention » (conservation zéro des données), ou ZDR, est optionnelle (opt-in) sur Claude Platform on AWS.** Sur Bedrock, AWS est le sous-traitant des données et Anthropic ne conserve pas les entrées ni les sorties d'inférence. Le programme ZDR d'Anthropic ne s'y applique pas. Sur Claude Platform on AWS, Anthropic traite les données d'inférence en tant que sous-traitant indépendant, et la ZDR suit le modèle de l'API Claude propriétaire : elle est disponible sur demande auprès de votre représentant de compte Anthropic. Confirmez votre inscription à la ZDR avant de migrer des charges de travail de production qui dépendent de garanties de conservation des données.
### Considérations commerciales
* **Conditions d'utilisation d'Anthropic :** L'utilisation de Claude Platform on AWS nécessite l'acceptation des Conditions commerciales d'utilisation et de la Politique d'utilisation d'Anthropic. Si votre organisation ne les a pas encore acceptées (par exemple, si vous n'avez utilisé Claude que via Bedrock), elles vous sont présentées lors de la configuration du compte. Consultez [Configurer votre compte](https://platform.claude.com/docs/fr/build-with-claude/claude-platform-on-aws#set-up-your-account).
* **Remises et offres privées :** Les remises négociées et les offres privées AWS Marketplace ne sont pas transférées automatiquement entre Bedrock et Claude Platform on AWS. Collaborez avec votre représentant de compte Anthropic pour établir les conditions commerciales de Claude Platform on AWS.
## Politiques IAM
Claude Platform on AWS s'intègre à AWS IAM pour le contrôle d'accès. Vous accordez ou refusez l'accès à des actions d'API spécifiques sur des espaces de travail spécifiques en utilisant la syntaxe standard des politiques IAM.
Le nom de service SigV4 et l'espace de noms des actions IAM est `aws-external-anthropic`. Les actions suivent le modèle `aws-external-anthropic:` (par exemple, `aws-external-anthropic:CreateInference`).
### Exemple : refuser l'inférence par lots
La politique suivante autorise l'inférence en temps réel tout en bloquant le traitement par lots :
```json
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"aws-external-anthropic:CreateInference",
"aws-external-anthropic:CountTokens",
"aws-external-anthropic:GetModel",
"aws-external-anthropic:ListModels",
"aws-external-anthropic:GetWorkspace"
],
"Resource": "arn:aws:aws-external-anthropic:*:*:workspace/*"
},
{
"Effect": "Allow",
"Action": "aws-external-anthropic:ListWorkspaces",
"Resource": "*"
},
{
"Effect": "Deny",
"Action": [
"aws-external-anthropic:CreateBatchInference",
"aws-external-anthropic:GetBatchInference",
"aws-external-anthropic:ListBatchInferences"
],
"Resource": "*"
}
]
}
```
L'action `GetBatchInference` autorise à la fois la route des métadonnées de lot et la route des résultats de lot. La refuser bloque ces deux lectures. Pour une politique composée uniquement de refus (Deny) adaptée aux charges de travail sensibles à la ZDR, consultez [Verrouillage des fonctionnalités pour un espace de travail sensible à la ZDR](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#feature-lockdown-for-a-zdr-sensitive-workspace).
`ListWorkspaces` a une portée au niveau du compte ; elle apparaît donc dans une instruction Allow distincte avec `"Resource": "*"`. Spécifier un ARN d'espace de travail sur une action de portée compte n'a aucun effet (voir [Automatisation du provisionnement](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#provisioning-automation)).
Cette politique suppose une authentification AWS SigV4. Si le principal s'authentifie avec une clé API, ajoutez également `aws-external-anthropic:CallWithBearerToken` à l'instruction Allow `"Resource": "*"`. `CallWithBearerToken` est une action de la couche d'authentification sans route qui n'est pas liée à un ARN d'espace de travail. Consultez [Isolation des espaces de travail par client](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#per-customer-workspace-isolation) pour le modèle à deux instructions.
### Politiques gérées
AWS fournit cinq politiques gérées (`AnthropicFullAccess`, `AnthropicReadOnlyAccess`, `AnthropicInferenceAccess`, `AnthropicLimitedAccess` et `AnthropicSelfHostedEnvironmentAccess`) pour les modèles d'accès courants. Pour les actions accordées par chaque politique, la liste complète des actions IAM, la correspondance entre routes et actions et des exemples de politiques supplémentaires, consultez [Actions IAM pour Claude Platform on AWS](https://platform.claude.com/docs/fr/api/claude-platform-on-aws-iam-actions#managed-policies).
## Prochaines étapes
Explorez les fonctionnalités et capacités avancées de Claude.
Découvrez la tarification de Claude Platform on AWS et les tarifs des Claude Consumption Units.
À 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.
## Ressources supplémentaires
Consultez l'utilisation, les coûts et les espaces de travail dans la Claude Console. Connectez-vous via la console AWS.
Utilisez Claude exploité par AWS si vous avez besoin qu'AWS soit le seul sous-traitant des données.
Gérez votre abonnement et votre facturation AWS Marketplace.