SSD Nodes Learn Hosting plans →
Guides Matt ConnorPar Matt Connor

Comment authentifier l’API Claude sur un VPS

Choisissez entre clé Anthropic, IAM AWS, Google ADC ou Microsoft Entra pour authentifier Claude sur un VPS et stocker les identifiants serveur en sécurité.

Les méthodes d’authentification de l’API Claude

L’authentification de l’API Claude repose sur une décision : quelle information d’identification votre client envoie sur le réseau. Anthropic répertorie l’API Claude directe et cinq plateformes cloud : Amazon Bedrock, Claude Platform on AWS, Claude Models on Google Cloud (Google managed), Claude Models on Google Cloud (Anthropic managed) et Microsoft Foundry. L’API Anthropic directe accepte une clé API ou un token à durée de vie courte dans un en-tête Authorization: Bearer. Elle accepte encore les clés API dans l’en-tête historique x-api-key. Amazon Bedrock prend en charge la signature des requêtes AWS et les clés API Bedrock. Aucune clé Anthropic n’intervient dans cette configuration. Google Cloud envoie un token d’accès Google à durée de vie courte. Microsoft Foundry utilise une clé émise par Azure ou un token Microsoft Entra. Les quatre sections suivantes décrivent ces configurations d’identification. Les offres AWS et Google Cloud gérées par Anthropic sont expliquées avec leurs équivalents cloud.

Ce guide explique comment intégrer un SDK (kit de développement logiciel) à un service exécuté sur un serveur Linux. Si vous configurez plutôt l’outil en ligne de commande Claude Code, les variables et le fonctionnement sont différents : consultez configurer Claude Code pour Bedrock ou Vertex. Si le service n’existe pas encore, commencez par le créer avec une première application Claude API sur un VPS, puis revenez ici pour configurer l’identification.

Tout ce qui suit a été vérifié dans la documentation de la plateforme Anthropic en août 2026, puis revérifié dans la documentation de chaque fournisseur le 16 octobre 2026. Les informations sur l’accès aux modèles Bedrock ont été revérifiées dans la documentation AWS le 19 octobre 2026. Les pages Anthropic consacrées aux quatre méthodes, aux clés API et aux versions d’API ont été revérifiées le 27 octobre 2026. Les pages Anthropic consacrées à Microsoft Foundry, aux deux endpoints Bedrock, à la méthode Google managed, à Claude Platform on AWS, à l’authentification, à Workload Identity Federation et aux versions d’API ont été revérifiées le 10 novembre 2026, ainsi que le changelog du SDK Ruby. Les identifiants de modèles, les prix, les versions des SDK et la structure des endpoints évoluent régulièrement. Ce guide renvoie donc vers les pages des fournisseurs au lieu d’imprimer des valeurs qui deviennent obsolètes.

Route 1 : une clé API Anthropic

C’est la méthode directe, et la seule dans laquelle Anthropic émet le secret. Les requêtes sont envoyées au endpoint Messages sur l’hôte API d’Anthropic, et chaque requête contient trois en-têtes.

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{"model": "MODEL_ID", "max_tokens": 64, "messages": [{"role": "user", "content": "Hello"}]}'

Remplacez MODEL_ID par un identifiant actuel provenant de la vue d’ensemble des modèles d’Anthropic. Une réponse valide est un objet JSON contenant un tableau content et un objet usage. Une clé incorrecte ou expirée renvoie HTTP 401 avec authentication_error. L’absence de l’en-tête anthropic-version entraîne une erreur distincte, car cet en-tête est obligatoire pour chaque requête ; les SDK le définissent pour vous. En octobre 2026, la documentation d’Anthropic présente Authorization: Bearer comme la méthode principale pour envoyer la clé et qualifie x-api-key de legacy, mais les deux méthodes sont acceptées, donc la commande ci-dessus fonctionne toujours. Les versions majeures actuelles des SDK envoient également la clé sous la forme Authorization: Bearer ; un proxy ou une gateway qui lit X-Api-Key doit donc être modifié lors de la mise à niveau. La version 2023-06-01 utilisée dans la commande est toujours acceptée ; la version API la plus récente d’Anthropic est 2026-10-21. Ces versions des SDK l’envoient par défaut et elle refuse certains paramètres de requête plus anciens, comme temperature.

La construction du client est la plus courte de ces configurations, car il n’y a rien à construire. Chaque SDK officiel lit automatiquement ANTHROPIC_API_KEY dans l’environnement.

import os
from anthropic import Anthropic

client = Anthropic()  # reads ANTHROPIC_API_KEY from the environment

message = client.messages.create(
    model=os.environ["CLAUDE_MODEL"],
    max_tokens=64,
    messages=[{"role": "user", "content": "Hello"}],
)
print(message.usage)

Il est préférable de conserver l’identifiant du modèle dans l’environnement, à côté de la clé. Les noms des modèles évoluent selon un calendrier que vous ne contrôlez pas, et redéployer le code pour modifier une seule chaîne est un travail évitable.

Les clés sont créées dans la Console, où vous choisissez leur expiration au moment de la création : des durées prédéfinies de 3 heures, 1 jour, 7 jours ou 30 jours, une durée personnalisée, ou Never, sous réserve de la politique d’expiration maximale de votre organisation. L’expiration est définitive après la création et ne peut pas être modifiée. Anthropic envoie un e-mail au créateur de la clé avant l’expiration d’une clé à longue durée, mais une clé à courte durée expire sans aucun e-mail d’avertissement. Une clé expirée renvoie 401 et ne peut pas être réactivée ; il faut donc toujours créer une nouvelle clé.

Aucune région n’est à choisir pour l’API directe, et la facturation est directement rattachée à votre organisation Anthropic. Les workspaces limitent une clé à un projet, ce qui permet le plus facilement de suivre les dépenses d’un service donné. Limitez la clé d’un serveur à son workspace lors de sa création : une clé personnelle ou de compte de service qui n’est pas limitée à un workspace doit envoyer un en-tête anthropic-workspace-id pour chaque requête, faute de quoi l’API renvoie 400 avec invalid_request_error. Pour un service, choisissez une clé de compte de service, car une clé personnelle cesse de fonctionner lorsque la personne qui l’a créée quitte l’organisation. Pour le calcul correspondant à cette facture, consultez la comparaison entre la tarification de l’API par token et un abonnement.

Une autre option a sa place ici, car elle supprime entièrement le secret statique. Workload Identity Federation permet à une charge de travail d’échanger un token OpenID Connect (OIDC) provenant d’un fournisseur d’identité auquel vous faites déjà confiance contre un token Anthropic de courte durée auprès de POST /v1/oauth/token, puis le SDK renouvelle ce token avant son expiration. Aucune chaîne sk-ant-api... n’est jamais générée ni copiée. Cette solution convient à Kubernetes, GitHub Actions et aux VM cloud, qui disposent déjà d’une identité de plateforme. Un VPS classique ne dispose généralement d’aucun émetteur de ce type ; sur ce serveur, une clé API stockée dans un fichier est donc la solution réaliste, et c’est ainsi que le reste de ce guide la traite.

Route 2 : identifiants AWS sur Amazon Bedrock

Sur Bedrock, vous n’avez aucune clé Anthropic. Avec des identifiants AWS, le SDK signe chaque requête HTTP avec AWS Signature Version 4 (SigV4), et AWS détermine si l’appelant peut invoquer le modèle.

pip install -U "anthropic[bedrock]"
aws sts get-caller-identity

aws sts get-caller-identity affiche le numéro de compte et l’ARN (Amazon Resource Name) de l’identité résolue par vos identifiants. Exécutez cette commande avant toute autre opération lorsque vous utilisez SigV4. Pour SigV4, le SDK résout les identifiants du constructeur, les identifiants de l’environnement et la chaîne d’identifiants AWS standard. La sélection de la région est indépendante. Dans le client Python AnthropicBedrock, une clé API Bedrock fournie via api_key ou AWS_BEARER_TOKEN_BEDROCK génère ValueError si vous transmettez également aws_access_key, aws_secret_key, aws_session_token ou aws_profile. Sans ces arguments explicites, la clé sélectionne l’authentification bearer au lieu de la chaîne d’identifiants AWS. Le client TypeScript donne la priorité à la clé API Bedrock par rapport aux identifiants AWS explicites. La commande STS ne teste pas l’authentification bearer.

La construction du client ne change que sur la classe et sur un argument.

from anthropic import AnthropicBedrock

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

AnthropicBedrock pilote l’intégration InvokeModel de Bedrock. En octobre 2026, Anthropic documente également Claude dans Amazon Bedrock, avec un endpoint Messages API à https://bedrock-mantle.{region}.api.aws/anthropic/v1/messages pour Claude Opus 4.7 et les modèles ultérieurs, accessible via un client AnthropicBedrockMantle du même package. Il prend en charge les identifiants AWS et les bearer tokens Bedrock. Les conditions d’accès aux modèles diffèrent entre les deux endpoints, comme expliqué ci-dessous.

Surveillez la mise à niveau dans la ligne pip install -U. Au 27 octobre 2026, le dernier SDK envoie par défaut la version d’API 2026-10-21, y compris via Bedrock. Anthropic précise que les model IDs versionnés avec un ARN qu’il répertorie pour Claude Opus 4.6 et les versions antérieures ne prennent pas en charge cette version sur Bedrock et peuvent renvoyer une erreur 400. Si un service appelle l’un de ces modèles, conservez le SDK dans la version qu’il utilise actuellement et verrouillez-la, ou migrez d’abord le service vers un modèle Claude 4.7 ou ultérieur.

La région n’est pas un simple paramètre décoratif. Les endpoints Bedrock sont propres à chaque région, les modèles Claude disponibles varient selon la région, et la région entre dans la signature SigV4. Une signature calculée pour une région est donc rejetée par une autre. Définissez explicitement AWS_REGION dans l’environnement du service, car les SDK ne réagissent pas tous de la même façon lorsqu’il est absent. Comme indiqué en octobre 2026, le client Python AnthropicBedrock lit AWS_REGION ou AWS_DEFAULT_REGION, puis la région de votre session boto3 ou de votre profil AWS, notamment ~/.aws/config, et génère ValueError si aucune région n’est résolue. Le client TypeScript lit AWS_REGION, utilise us-east-1 comme valeur de repli lorsqu’il n’est pas défini, et ne lit pas ~/.aws/config pour déterminer la région. C’est pourquoi AWS CLI peut répertorier les modèles Claude avec succès sur la même machine où un processus Node appelle la mauvaise région : la CLI a lu votre fichier de configuration, contrairement au client.

Sur une instance EC2, vous associez un rôle IAM (identity and access management) et aucun secret n’est écrit sur le disque, car le service de métadonnées de l’instance fournit des identifiants temporaires au SDK. Un VPS situé en dehors d’AWS ne dispose ni d’un rôle d’instance ni d’un service de métadonnées. Vous devez alors choisir entre une paire de clés d’accès longue durée d’un utilisateur IAM stockée sur la machine, qui constitue le même type de secret qu’une clé Anthropic, et la fédération : authentifiez-vous auprès de votre fournisseur d’identité, appelez AWS STS (security token service), puis utilisez les identifiants temporaires renvoyés. Bedrock accepte également les clés API Bedrock, c’est-à-dire des bearer tokens transmis via AWS_BEARER_TOKEN_BEDROCK. AWS en documente deux types. Une clé à court terme est valide pendant 12 heures au maximum, ou pendant la durée de la session qui l’a générée si celle-ci est plus courte. Elle hérite des permissions de l’identité IAM qui l’a générée. C’est le type recommandé par AWS pour la production. Une clé à long terme reste valide jusqu’à la date d’expiration choisie lors de sa création, par exemple 30 ou 90 jours avec --credential-age-days, ou n’expire pas si ce paramètre d’API est omis. La Console crée un utilisateur IAM associé et AWS recommande ce type uniquement pour l’exploration. Une clé à long terme ne fonctionne que dans la région où elle a été générée. Son utilisation dans une autre région renvoie Credential should be scoped to a valid region.

La facturation est portée par votre compte AWS et non par Anthropic, ce qui constitue généralement la raison principale de ce choix. Les endpoints régionaux appliquent une majoration de 10 % par rapport à l’endpoint global, comme indiqué en octobre 2026. Claude Platform on AWS est un produit distinct : Anthropic l’exploite, AWS le facture via AWS Marketplace et l’authentification utilise SigV4 ou une clé API générée dans AWS Console. Les clés de la Claude Console ne fonctionnent pas avec ce produit. L’accès s’effectue via un client AnthropicAWS qu’Anthropic indique comme beta. Une erreur Bedrock mérite d’être reconnue, car elle ressemble à un problème de permissions alors que ce n’en est pas un : Invocation of model ID ... with on-demand throughput isn't supported. Retry your request with the ID or ARN of an inference profile that contains this model. Il s’agit du routage du modèle. Aucun changement d’identifiants ne résoudra ce problème.

Route 3 : Identifiants Google sur Vertex AI

La documentation d’Anthropic appelle désormais cette route Claude Models on Google Cloud (Google managed), que Google exécute dans le cadre de son Agent Platform, le nouveau nom donné par Google à ce qui vient de Vertex AI. L’hôte aiplatform.googleapis.com, l’extra anthropic[vertex] et la classe AnthropicVertex présentés ci-dessous restent inchangés.

Google Cloud utilise les Application Default Credentials (ADC), avec un ordre de recherche fixe que les bibliothèques d’authentification Google suivent pour trouver un identifiant sans que vous ayez à en indiquer un. ADC vérifie d’abord GOOGLE_APPLICATION_CREDENTIALS, puis le fichier écrit par gcloud auth application-default login, et enfin le compte de service associé via le metadata server.

pip install -U "anthropic[vertex]"
gcloud auth application-default login

Sur un poste de travail, cette connexion écrit $HOME/.config/gcloud/application_default_credentials.json et vous avez terminé. Sur un serveur, évitez de stocker les identifiants d’un utilisateur humain ; la commande prend également en charge l’usurpation d’identité d’un compte de service. En dehors de Google Cloud, le metadata server Google n’est pas disponible non plus. Utilisez donc GOOGLE_APPLICATION_CREDENTIALS pour indiquer à ADC un fichier de configuration Workload Identity Federation ou un fichier de clé de compte de service. Un fichier JSON de clé de compte de service est un secret à longue durée de vie et doit être protégé exactement comme décrit plus loin dans ce guide. Dans Google Cloud, associez un compte de service à la VM : aucun fichier n’a alors besoin d’être protégé. L’identité trouvée par ADC doit disposer d’un rôle IAM incluant l’autorisation aiplatform.endpoints.predict, par exemple Agent Platform User (roles/aiplatform.user).

from anthropic import AnthropicVertex

client = AnthropicVertex(project_id="my-project", region="global")

Deux éléments changent si vous descendez au niveau HTTP brut au lieu d’utiliser le SDK. L’identifiant du modèle sort du corps de la requête et passe dans le chemin de l’URL, tandis que anthropic_version sort de l’en-tête et passe dans le corps. Au 27 octobre 2026, la documentation d’Anthropic accepte soit vertex-2023-10-16, soit la nouvelle version d’API 2026-10-21 à cet emplacement. L’identifiant d’authentification est un jeton d’accès Google ordinaire. Dans la commande ci-dessous, gcloud auth print-access-token utilise la connexion propre au gcloud CLI au lieu d’ADC. Exécutez donc d’abord gcloud auth login ou gcloud init sur la machine où vous effectuez le test.

curl https://aiplatform.googleapis.com/v1/projects/${PROJECT_ID}/locations/global/publishers/anthropic/models/${MODEL_ID}:rawPredict \
  -H "Authorization: Bearer $(gcloud auth print-access-token)" \
  -H "Content-Type: application/json" \
  -d '{"anthropic_version": "vertex-2023-10-16", "max_tokens": 64, "messages": [{"role": "user", "content": "Hello"}]}'

La région est un argument à part entière. global effectue un routage dynamique selon la disponibilité, us et eu sont des identifiants multirégion, et un nom tel que us-east5 impose une région unique. En octobre 2026, Anthropic documente des endpoints à région unique uniquement pour Claude Sonnet 4.6 et les versions antérieures ; les modèles plus récents utilisent les endpoints globaux ou multirégion. Les endpoints multirégion et régionaux coûtent 10 % de plus que les endpoints globaux, comme indiqué dans la documentation d’octobre 2026. La facturation passe par le projet Google Cloud ; les quotas et les factures sont donc gérés par Google.

Au 27 octobre 2026, Anthropic documente également une seconde offre Google Cloud, dont le format de requête est différent. Dans Claude Models on Google Cloud (Anthropic managed), Anthropic exploite directement l’API Claude à l’adresse claude.googleapis.com, accessible via un client AnthropicGoogleCloud. L’authentification utilise toujours des identifiants Google Cloud, notamment ADC, mais la requête ressemble à celle de l’API directe : model reste dans le corps et la version est transmise dans l’en-tête anthropic-version. L’accès repose sur ses propres rôles IAM (roles/claude.user et rôles associés), la configuration crée une nouvelle organisation Anthropic pour le projet, et l’utilisation est facturée par Google Cloud Marketplace. Si les URL de vos requêtes contiennent aiplatform et se terminent par :rawPredict, vous utilisez la route gérée par Google décrite dans cette section.

Méthode 4 : Microsoft Foundry est la méthode Azure

Si vous avez recherché Claude sur Azure, vous êtes au bon endroit. Cette méthode est prise en charge. Claude s’exécute dans Microsoft Foundry (anciennement Azure AI Foundry) et est facturé via Azure Marketplace en Claude Consumption Units. Vous créez une ressource Foundry, vous y déployez un modèle Claude, puis vous appelez un endpoint hébergé par Azure à l’adresse https://{resource}.services.ai.azure.com/anthropic/v1/*.

Deux types d’identification fonctionnent. Le premier est une clé émise par Azure dans l’onglet Details du déploiement, dans le portail Foundry. Elle est envoyée dans un en-tête api-key ou x-api-key. Le second est un token Microsoft Entra. C’est le meilleur choix sur un serveur, car le contrôle d’accès en fonction des rôles d’Azure détermine alors qui peut appeler l’endpoint.

ACCESS_TOKEN=$(az account get-access-token --resource https://ai.azure.com --query accessToken -o tsv)

curl https://${RESOURCE}.services.ai.azure.com/anthropic/v1/messages \
  -H "content-type: application/json" \
  -H "Authorization: Bearer $ACCESS_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -d '{"model": "DEPLOYMENT_NAME", "max_tokens": 64, "messages": [{"role": "user", "content": "Hello"}]}'

Le champ model contient le nom du déploiement, et non un identifiant de modèle. Les deux valeurs sont identiques par défaut. Elles cessent de l’être dès que vous définissez vous-même le nom du déploiement. C’est la cause habituelle d’une erreur Deployment not found sur une requête pourtant correcte. Les SDK Python et TypeScript lisent ANTHROPIC_FOUNDRY_API_KEY et ANTHROPIC_FOUNDRY_RESOURCE dans l’environnement. D’après la documentation du 10 novembre 2026, Foundry prend en charge les sept SDK officiels : C#, Go, Java, PHP, Python, Ruby et TypeScript. Go utilise un package dédié foundry (go get github.com/anthropics/anthropic-sdk-go/v2/foundry). Ruby a obtenu un Anthropic::FoundryClient dédié dans la version 2.5.0 du gem, publiée le 4 novembre 2026. Avant cette version, le code Ruby devait pointer le client générique vers l’URL de base Foundry.

Pointer un client générique vers l’URL de base Foundry présente toujours un risque, que ce soit dans du code Ruby écrit avant la version 2.5.0 ou avec la CLI ant, que les exemples Foundry d’Anthropic utilisent eux-mêmes de cette manière. Si vous ne transmettez pas explicitement les identifiants au client générique et que ANTHROPIC_API_KEY ou ANTHROPIC_AUTH_TOKEN est encore défini dans l’environnement, le client le récupère et envoie votre identifiant Anthropic à un endpoint Microsoft. Supprimez la variable ou transmettez explicitement la clé ou le token Foundry au client. En Ruby, passer à Anthropic::FoundryClient, qui accepte la clé Foundry ou un fournisseur de tokens Entra, est la solution la plus propre. La durée de vie par défaut d’un token d’accès Entra est choisie aléatoirement entre 60 et 90 minutes. Un processus de longue durée doit donc le renouveler au lieu de conserver celui obtenu au démarrage.

Combien de temps les identifiants présents sur votre serveur restent-ils valides ?

GraphiqueDocumented credential lifetime by route, hours
Les données de ce graphique
[
  {
    "label": "Anthropic key, 30-day preset",
    "max_lifetime_hours": 720
  },
  {
    "label": "Anthropic key, 7-day preset",
    "max_lifetime_hours": 168
  },
  {
    "label": "AWS STS assumed role",
    "max_lifetime_hours": 12
  },
  {
    "label": "Bedrock short-term API key",
    "max_lifetime_hours": 12
  },
  {
    "label": "Entra ID access token, default upper bound",
    "max_lifetime_hours": 1.5
  },
  {
    "label": "Federated Anthropic token, default",
    "max_lifetime_hours": 1
  }
]

Il s’agit des plafonds et des valeurs par défaut publiés par chaque fournisseur et relevés en octobre 2026, pas de mesures effectuées. Ils sont importants pour une seule raison : ils indiquent pendant combien de temps un identifiant compromis continue de fonctionner alors que vous cherchez encore à déterminer qu’il a été divulgué. Le token Anthropic fédéré au bas du graphique reste valide pendant au plus 1 heure par défaut. Sa durée est également limitée à deux fois la durée restante du token du fournisseur d’identité. Un token d’accès Microsoft Entra n’a pas une valeur par défaut unique : Microsoft attribue à chacun une durée aléatoire comprise entre 60 et 90 minutes, soit 75 minutes en moyenne. Le graphique l’affiche à sa limite supérieure de 1.5 heure. Cette valeur par défaut varie également selon le client, la ressource et l’activation ou non de Conditional Access dans le tenant. Lorsque le client et la ressource prennent tous deux en charge Continuous Access Evaluation, Entra peut prolonger la durée jusqu’à 24 à 28 heures et révoquer le token presque en temps réel en cas d’événements tels que la désactivation du compte. Une policy de durée de vie des tokens du tenant peut définir cette durée entre 10 minutes et 23:59:59. Les SDK actualisent automatiquement les tokens Anthropic fédérés. Sur Foundry, configurez un fournisseur de tokens Entra pour actualiser les tokens au lieu de transmettre une chaîne de token fixe. Une règle de fédération peut définir sa propre durée de vie des tokens entre une minute et 24 heures. L’assistant Connect workload de la Console préremplit 10 minutes. Consultez donc la règle au lieu de supposer la valeur par défaut. Un rôle assumé et une clé API courte durée Bedrock restent tous deux valides pendant 12 heures. Une clé API longue durée Bedrock n’apparaît pas dans le graphique, car elle n’a pas de plafond fixe : elle reste valide jusqu’à l’expiration choisie lors de sa création, ou n’expire pas si CredentialAgeDays a été omis de l’appel API. C’est pourquoi AWS la recommande uniquement pour l’exploration. Une clé créée avec la valeur prédéfinie de 30 jours reste valide pendant 720 heures. C’est cet identifiant qui reste dans un fichier sur votre serveur pendant un mois.

Emplacement de l’identifiant sur un VPS

Placez le secret dans un fichier que seul root peut lire, puis laissez systemd le transmettre au processus. Cette méthode reste valable quelle que soit la version du SDK : il vaut donc la peine de la mettre en place correctement une fois pour toutes.

sudo useradd --system --home /opt/claude-app --shell /usr/sbin/nologin claudeapp
sudo install -d -m 700 -o root -g root /etc/claude-app
sudo install -m 600 -o root -g root /dev/null /etc/claude-app/env
sudoedit /etc/claude-app/env

Le fichier contient des lignes KEY=value brutes. Pas de export, pas de guillemets ni de syntaxe shell, car systemd l’analyse directement au lieu de le transmettre à un shell.

ANTHROPIC_API_KEY=sk-ant-api03-REPLACE-ME
CLAUDE_MODEL=REPLACE-ME
[Unit]
Description=Claude API service
After=network-online.target

[Service]
User=claudeapp
EnvironmentFile=/etc/claude-app/env
ExecStart=/opt/claude-app/venv/bin/python -m claude_app
Restart=on-failure

[Install]
WantedBy=multi-user.target

systemd lit EnvironmentFile= en tant que root, avant de basculer vers User=claudeapp. Le compte de service n’a donc jamais besoin d’un accès en lecture au fichier. Le mode 600 avec root comme propriétaire suffit, et c’est pourquoi la commande install ci-dessus le configure ainsi. Démarrez-le avec sudo systemctl enable --now claude-app, puis vérifiez avec systemctl status claude-app que l’unité a atteint active (running) au lieu de redémarrer en boucle.

Voici quatre choses à éviter, chacune pour une raison que vous pouvez vérifier vous-même :

  • N’écrivez pas la clé avec Environment= dans le fichier d’unité. Une unité située sous /etc/systemd/system est lisible par tous les utilisateurs, et systemctl cat claude-app affiche donc le secret à n’importe quel utilisateur local.
  • Ne la committez pas. .gitignore exclut un nouveau fichier d’un commit, mais ne fait rien pour un fichier déjà committé, car l’historique git conserve tout ce qui lui a été fourni.
  • N’intégrez pas la clé dans une image de conteneur. Les valeurs ENV persistent dans la configuration de l’image, et les arguments de build sont visibles dans l’historique de l’image ou dans les métadonnées de provenance. Supprimer le fichier dans une couche ultérieure ne le supprime pas de la couche précédente. Transmettez plutôt les secrets au moment de l’exécution avec --env-file ou avec un fichier monté.
  • Ne considérez pas l’environnement du processus comme privé vis-à-vis de root. sudo cat /proc/$(pgrep -u claudeapp -f claude_app | head -1)/environ | tr '\0' '\n' réaffiche la clé. La commande qui lit le fichier nécessite elle-même sudo ; une redirection d’entrée shell est exécutée avant sudo et utilise les permissions du compte courant. L’objectif est de tenir le secret éloigné de tous les autres comptes du serveur, pas de root, qui peut le lire quoi que vous fassiez.

Ce dernier point définit la limite de ce que cette conception vous apporte. Le fichier réservé à root protège la clé stockée, mais tout code exécuté par le compte de service peut lire l’environnement du processus, et les processus enfants en héritent. Ce n’est pas le bon conteneur lorsque le processus exécute du code que vous n’avez pas écrit, car tout ce que le processus peut exécuter peut lire son propre environnement. Garder les secrets hors de portée d’un agent IA traite ce cas, qui correspond à un problème différent et nécessite une autre solution.

Comment faire tourner la clé sans interruption de service ?

Effectuez la rotation vers l’avant, puis révoquez l’ancienne clé en dernier. Le redémarrage du service unique ci-dessous interrompt brièvement le service. Une disponibilité ininterrompue nécessite une autre instance pour traiter les requêtes pendant le redémarrage.

  1. Créez la nouvelle clé dans la Console, dans le même workspace que l’ancienne.
  2. Écrivez-la dans /etc/claude-app/env avec sudoedit.
  3. Exécutez sudo systemctl restart claude-app.
  4. Vérifiez que le service répond aux requêtes, puis révoquez l’ancienne clé dans la Console.

EnvironmentFile est lu au démarrage de l’unité. Un processus en cours d’exécution conserve donc la valeur qui lui a été transmise lors de son lancement. systemctl daemon-reload relit les fichiers d’unité, mais ne modifie pas l’environnement d’un processus en cours d’exécution. Seul un redémarrage prend donc en compte la nouvelle clé. Révoquer la clé à l’étape 1 au lieu de l’étape 4 vous garantit une interruption de service jusqu’à l’étape 3.

Les routes cloud effectuent leur rotation chez le fournisseur. Un utilisateur IAM peut avoir deux access keys actives simultanément. Créez donc la seconde, déployez-la, puis supprimez la première. Une clé de service account Google se renouvelle de la même manière. Une ressource Foundry contient deux clés. La régénération de l’une d’elles désactive immédiatement son ancienne valeur. Faites donc passer le service sur l’autre clé avant de régénérer celle qu’il utilisait. Les tokens Entra et les tokens fédérés Anthropic ne nécessitent aucune rotation manuelle. C’est l’argument le plus solide pour les utiliser lorsque c’est possible.

Pendant que vous êtes dans la Console, définissez une limite de dépenses sur le workspace. Une clé divulguée coûte cher avant toute autre conséquence, et limiter ce qu’un agent sur un VPS peut dépenser présente les contrôles disponibles.

Pourquoi mon client renvoie-t-il 401 ou 403 ?

401 avec authentication_error sur l’API directe. La clé est incorrecte, révoquée ou expirée. L’expiration est souvent oubliée, car le code n’a pas changé et la requête fonctionnait hier. Vérifiez la colonne d’expiration de la clé dans la Console, ou lisez expires_at depuis l’Admin API, où sa valeur est null pour les clés sans expiration. Une clé personnelle cesse également de fonctionner lorsque son propriétaire quitte l’organisation.

Le SDK ignore votre configuration de fédération et utilise une clé à la place. ANTHROPIC_API_KEY et ANTHROPIC_AUTH_TOKEN ont priorité sur la fédération dans l’ordre de priorité des identifiants, donc l’un ou l’autre la masque. Le cas le plus trompeur est le suivant : une variable exportée avec une chaîne vide occupe tout de même son emplacement. Ainsi, ANTHROPIC_API_KEY="" amène le SDK à s’authentifier avec une clé vide au lieu de poursuivre avec la méthode suivante. Utilisez unset ANTHROPIC_API_KEY.

401 avec le message brut Authentication failed sur la fédération. Ce message est volontairement identique pour toutes les causes possibles, afin qu’un appelant ne puisse pas déduire la configuration de vos règles en lisant le texte de l’erreur. La cause réelle est enregistrée sur la page de l’historique d’authentification dans la Console. Commencez par cette page au lieu de supposer que le problème vient du JWT.

403 sur Foundry. Le jeton a été authentifié, mais votre compte Azure ne possède pas de rôle autorisant l’appel. Attribuez à l’identité qui effectue la requête un rôle Azure RBAC tel que Foundry User (anciennement Azure AI User) ou Cognitive Services User.

Tout problème sur Bedrock. Pour l’authentification SigV4, exécutez d’abord aws sts get-caller-identity avec l’utilisateur de service. Cette commande indique si la machine possède des identifiants AWS utilisables. Elle permet de distinguer un problème d’identifiants d’un problème d’accès au modèle ou de région. Au 29 octobre 2026, AWS active l’accès à de nombreux modèles lors de la première utilisation dans les régions commerciales lorsque les autorisations AWS Marketplace requises sont présentes, mais certains modèles nécessitent un accès distinct au niveau du compte. Les modèles Anthropic appelés via la route InvokeModel nécessitent d’abord un formulaire de cas d’utilisation à remplir une fois par compte (ou une seule fois pour toute une AWS Organization, mais les régions avec opt-in le nécessitent de nouveau). Tant que cette étape n’est pas validée, l’appel renvoie AccessDeniedException. AWS précise que le formulaire ne s’applique pas au endpoint bedrock-mantle. Le premier appel à un modèle dans un compte amène également Bedrock à démarrer en arrière-plan l’abonnement AWS Marketplace. Cet abonnement nécessite une identité disposant des autorisations aws-marketplace:Subscribe, aws-marketplace:Unsubscribe et aws-marketplace:ViewSubscriptions. L’absence de ces autorisations ne fait pas forcément échouer le premier appel : AWS précise que les appels peuvent réussir pendant 15 minutes maximum, le temps de configurer l’abonnement. Une fois l’abonnement échoué, les appels suivants renvoient le même AccessDeniedException. Si un service fonctionne pendant ses premières minutes, puis commence à échouer, cherchez plutôt le problème de ce côté que du côté des identifiants. Après l’attribution des autorisations, AWS prévoit jusqu’à 2 minutes pour terminer l’abonnement. Un modèle qui n’est pas proposé dans la région appelée échoue, même si les identifiants sont valides.

FAQ

Ai-je besoin d’une clé API Anthropic pour utiliser Claude sur Bedrock ou Vertex ?

Non. Sur Amazon Bedrock, le SDK signe les requêtes avec les identifiants AWS à l’aide de SigV4 ou envoie une clé API Bedrock. Sur Google Cloud, il envoie un jeton d’accès Google obtenu via Application Default Credentials. Aucun secret fourni par Anthropic n’existe dans l’une ou l’autre configuration, et l’utilisation est facturée au compte cloud, pas à Anthropic. C’est également pourquoi une clé Anthropic laissée dans ANTHROPIC_API_KEY constitue un risque sur ces hôtes : un client générique configuré pour un endpoint cloud l’y enverra sans difficulté.

Claude est-il disponible sur Azure ?

Oui, via Microsoft Foundry, anciennement Azure AI Foundry. Vous créez une ressource Foundry, y déployez un modèle Claude, puis appelez https://{resource}.services.ai.azure.com/anthropic/v1/messages avec une clé fournie par Azure dans un en-tête api-key ou avec un jeton bearer Microsoft Entra. L’utilisation est facturée via Azure Marketplace en Claude Consumption Units. Le champ model du corps de la requête doit contenir le nom de votre déploiement. Ce nom ne correspond à l’identifiant du modèle que si vous avez conservé le nom par défaut lors de la création du déploiement. Il ne peut plus être modifié ensuite.

Où dois-je stocker la clé API Claude sur un serveur Linux ?

Dans un fichier appartenant à root et doté du mode 600, chargé via EnvironmentFile= dans une unité systemd. systemd lit ce fichier en tant que root avant de basculer vers le User= de l’unité. Le compte de service n’a donc pas besoin d’y accéder. Conservez cette clé hors du dépôt, hors du fichier d’unité lui-même, qui est lisible par tous et affiché par systemctl cat, ainsi que hors de la configuration, des layers et des métadonnées de build de l’image de conteneur.

Pourquoi ma requête API Claude renvoie-t-elle désormais 401 alors que rien n’a changé ?

Une clé arrivée à la date d’expiration définie lors de sa création renvoie 401. L’expiration est définie lors de la création et ne peut plus être modifiée ensuite. Les clés à durée de vie courte expirent sans avertissement par e-mail. Une clé expirée ne peut pas être réactivée. Créez donc une clé de remplacement, écrivez-la dans le fichier d’environnement, redémarrez le service, puis révoquez l’ancienne clé. Si la clé est bien à jour, vérifiez qu’un identifiant obsolète ne la masque pas : ANTHROPIC_API_KEY défini sur une chaîne vide reste prioritaire sur les sources de federation et de profil qui suivent.

Cet article vous a-t-il été utile ?

#claude#api#authentication#bedrock#vertex#secrets-management