SpyBara
Go Premium

claude-apps-gateway-config.md 2026-10-01 23:59 UTC to 2026-10-02 18:00 UTC

This page contains 225 additions and 162 deletions.

2026
Thu 1 23:59 Fri 2 18:59

Configuration de la passerelle Claude apps

Référence pour chaque option gateway.yaml : écouteur et TLS, OIDC, session, magasin Postgres, amonts Amazon Bedrock, Claude Platform sur AWS, Agent Platform de Google Cloud et Microsoft Foundry, routage des modèles, politiques gérées et télémétrie.

Un déploiement de passerelle Claude apps est configuré par un fichier YAML, conventionnellement gateway.yaml. Le fichier définit tout ce que fait la passerelle : où elle écoute, comment les développeurs se connectent, où va l'inférence et quelles politiques et télémétrie s'appliquent. Cette page est la référence pour chaque option de ce fichier.

Pour écrire votre première, commencez par le démarrage rapide, qui crée une configuration minimale fonctionnelle et l'exécute. Une fois que vous avez une configuration avec laquelle vous êtes satisfait, le guide de déploiement couvre la conteneurisation et l'hébergement sur Kubernetes, Cloud Run ou votre propre plateforme.

La passerelle lit le fichier une fois, au démarrage, avec claude gateway --config /path/to/gateway.yaml. Chaque option est validée par rapport à un schéma au démarrage, donc une configuration mal formée échoue au démarrage avec une erreur au niveau du champ plutôt qu'à la première utilisation.

L'exemple complet à la fin de cette page exerce chaque section.

Structure du fichier

Cinq sections sont requises. Chaque autre section est optionnelle, et une section omise prend ses valeurs par défaut. Les clés inconnues échouent au démarrage, donc une faute de frappe apparaît comme une erreur nommée plutôt qu'un paramètre silencieusement ignoré.

Sections requises :

  • listen : adresse de liaison, URL publique, terminaison TLS
  • oidc : votre fournisseur d'identité (IdP), y compris l'émetteur, le client, le mappage des réclamations et qui peut se connecter
  • session : les jetons porteurs que la passerelle émet, avec secret et durée de vie
  • store : PostgreSQL, pour les subventions d'appareils et les compteurs de limite de débit
  • upstreams : où l'inférence va, qu'il s'agisse d'Anthropic, Amazon Bedrock, Claude Platform sur AWS, Agent Platform de Google Cloud ou Microsoft Foundry

Sections optionnelles :

  • admin : authentification de l'API Admin et rétention pour les limites de dépenses
  • enforcement : comportement de limite de dépenses fail-open ou fail-closed
  • pricing : tarifs contractuels et multiplicateur de remise pour le compteur de dépenses et pour les chiffres de coût que les développeurs voient
  • models et auto_include_builtin_models : liste de modèles curée par l'administrateur et IDs par upstream
  • managed : politiques de paramètres gérés par groupe IdP
  • telemetry : transfert OTLP vers votre pile d'observabilité
  • access_control, limits, timeouts, rate_limits : autorisation/refus IP, plafonds de taille de requête, time-to-first-byte upstream et limites de connexion par IP
  • load_test_mode : tester en charge la passerelle sans appeler un fournisseur de modèle

Expansion des secrets

N'écrivez pas de secrets tels que client_secret, jwt_secret ou postgres_url directement dans gateway.yaml. Référencez-les avec l'une des formes ci-dessous, et la passerelle résout la valeur au démarrage à partir d'une variable d'environnement ou d'un fichier :

Forme Résout à Utiliser pour
${VAR} La variable d'environnement VAR. Le démarrage échoue si non défini. Variables d'environnement de conteneur, AWS Secrets Manager via injection env
${file:/path} Contenu du fichier à ce chemin absolu, coupé. La référence doit être la valeur entière du champ : contrairement à ${VAR}, elle n'est pas développée à l'intérieur d'une chaîne plus longue, donc pour un mot de passe de base de données, définissez store.password plutôt que de l'intégrer dans postgres_url. Montages de volume Kubernetes Secret, Vault Agent, SOPS

Sections obligatoires

`listen`

Le bloc listen contrôle où la passerelle est servie : l'adresse de liaison et le port, l'origine visible de l'extérieur, et la terminaison TLS optionnelle.

Champ Obligatoire Description
host Non Adresse de liaison. Par défaut 0.0.0.0.
port Non Port de liaison. Par défaut 8080.
public_url Sauf si host est loopback L'origine https:// visible de l'extérieur, utilisée pour construire le redirect_uri du fournisseur d'identité et les métadonnées de découverte. Obligatoire chaque fois que host n'est pas une adresse loopback, que la terminaison TLS se fasse à un proxy tel qu'un ALB, Ingress, ou Cloud Run ou à la passerelle elle-même via tls, car la passerelle ne dérive jamais sa propre origine à partir des en-têtes X-Forwarded-* ; ils peuvent être usurpés par le client. Le démarrage échoue sans lui. trusted_proxies ci-dessous régit uniquement la résolution de l'adresse IP du client. Également obligatoire pour activer la télémétrie, car la passerelle construit le point de terminaison OTLP qu'elle pousse aux clients à partir de cette URL.
tls.cert / tls.key Non Chemins PEM si la passerelle termine TLS elle-même
trusted_proxies Non CIDR ou adresses IP des équilibreurs de charge devant la passerelle. Lorsqu'il est défini, la passerelle fait confiance à X-Forwarded-For uniquement à partir de ces pairs et enregistre l'adresse IP réelle du client pour la limitation de débit par adresse IP et l'audit. Équivalent à set_real_ip_from de nginx. Les entrées X-Forwarded-For écrites comme ipv4:port ou [ipv6]:port, comme certains équilibreurs de charge le font, sont lues avec le port supprimé. Une adresse IPv6 avec un port ajouté et sans crochets peut être lue comme une adresse différente ou ne pas être lue du tout, donc désactivez l'option de port sur tout proxy qui écrit cette forme.

`oidc`

Le bloc oidc connecte la passerelle à votre fournisseur d'identité et décide qui peut se connecter. Il nomme l'émetteur et le client OAuth, mappe les revendications qui portent l'e-mail et les groupes, et restreint la connexion par domaine d'e-mail ou groupe.

OpenID Connect (OIDC) est le protocole SSO que la passerelle utilise avec votre fournisseur d'identité ; voir Configuration du fournisseur d'identité pour savoir ce qu'il faut enregistrer du côté du fournisseur d'identité.

Champ Obligatoire Description
issuer Oui Base de découverte OIDC. Doit servir la découverte à /.well-known/openid-configuration. Utilisez HTTPS en production ; la passerelle accepte un émetteur http://. Un émetteur loopback tel que http://localhost:8081 est rejeté par la protection SSRF sauf si CLAUDE_GATEWAY_ALLOW_LOOPBACK=1 est défini dans l'environnement de la passerelle.
client_id / client_secret Oui À partir de votre enregistrement de client OAuth
allowed_email_domains Non Rejeter les id_tokens dont la revendication email n'est pas dans l'un de ces domaines, insensible à la casse. Défense en profondeur contre les erreurs de configuration du fournisseur d'identité multi-locataire. Indépendamment de ce paramètre, un id_token dont la revendication email_verified est explicitement false est toujours rejeté.
allowed_groups Non Restreindre la connexion aux membres de ces groupes du fournisseur d'identité, comparés à groups_claim. Un utilisateur dans un domaine d'e-mail autorisé mais dans aucun de ces groupes est rejeté. Nécessite que le fournisseur d'identité émette la revendication de groupes. La correspondance est une comparaison de chaîne exacte et sensible à la casse par rapport aux valeurs de cette revendication, et la passerelle n'étend pas les groupes imbriqués : pour admettre les membres d'un sous-groupe, listez le sous-groupe ici ou configurez le fournisseur d'identité pour émettre l'appartenance aplatie.
groups_claim Non Quelle revendication id_token porte l'appartenance au groupe. Par défaut groups. Microsoft Entra émet les rôles d'application sous roles. Accepte une clé plate ou un pointeur JSON RFC 6901 tel que /resource_access/gateway/roles pour les revendications imbriquées.
google_groups Non Rechercher les groupes de l'utilisateur connecté via l'API Google Workspace Admin SDK Directory, car le id_token de Google ne porte aucune revendication de groupes. Définissez service_account_json_path sur un fichier de clé de compte de service avec délégation à l'échelle du domaine sur la portée https://www.googleapis.com/auth/admin.directory.group.readonly, et admin_email sur un administrateur Workspace que le compte de service usurpe ; l'API Directory nécessite un sujet administrateur réel. Les adresses e-mail de groupe de chaque utilisateur deviennent sa revendication de groupes, donc allowed_groups et managed.policies.match.groups correspondent sur les e-mails de groupe.
email_claim Non Quelle revendication id_token porte l'e-mail de l'utilisateur. Par défaut email. Certains fournisseurs d'identité, tels que ADFS et Entra B2C, émettent upn ou preferred_username à la place. Accepte une clé plate, un pointeur JSON, ou une liste de clés de secours où la première clé présente est utilisée.
scopes Non Remplacement complet des portées OIDC que la passerelle demande. Par défaut [openid, profile, email, offline_access]. Définissez lorsque votre fournisseur d'identité rejette les portées qu'il ne reconnaît pas, ou nécessite une portée personnalisée pour émettre des groupes ou un e-mail. Doit inclure openid. Supprimer offline_access désactive les jetons d'actualisation, donc les développeurs réexécutent la connexion au navigateur tous les session.ttl_hours. Voir Configuration du fournisseur d'identité pour les recettes de portée par fournisseur d'identité telles que le flux de jeton d'actualisation de Google.
scope_on_refresh Non Envoyer également scope, avec la même liste que la demande de connexion, lorsque la passerelle échange un jeton d'actualisation. Par défaut false : la demande d'actualisation omet scope. La plupart des fournisseurs d'identité retournent un id_token à chaque actualisation et n'en ont pas besoin. Définissez true lorsque votre fournisseur d'identité retourne un id_token lors de l'actualisation uniquement s'il est demandé à nouveau openid, ce qu'Okta documente pour sa subvention d'actualisation. Sans id_token, chaque actualisation dépend du point de terminaison userinfo du fournisseur d'identité acceptant le jeton d'accès actualisé. Si vous limitez la connexion ou les politiques de correspondance sur les groupes et que le id_token du fournisseur d'identité au moment de l'actualisation les omet, définissez également userinfo_fallback: true pour que la passerelle les remplisse à partir du point de terminaison userinfo. Un fournisseur d'identité qui a accordé moins de portées que demandé peut rejeter l'actualisation avec invalid_scope, y compris pour les sessions existantes si vous ajoutez des entrées à scopes pendant que ceci est activé. Décochez la clé si les actualisations commencent à échouer à token_endpoint après l'avoir définie. Nécessite Claude Code v2.1.260 ou ultérieur sur le serveur de la passerelle.
extra_auth_params Non Paramètres de requête supplémentaires ajoutés à la demande d'autorisation du fournisseur d'identité, textuellement. C'est le mécanisme de remplacement pour le comportement spécifique au fournisseur d'identité, tel que access_type: offline pour les jetons d'actualisation Google, domain_hint pour certains locataires Entra, ou acr_values pour les flux d'escalade. Ne peut pas remplacer les paramètres de protocole gérés par la passerelle : state, nonce, redirect_uri, PKCE, scope, response_type, response_mode, et client_id.
userinfo_fallback Non Lorsque le id_token omet l'e-mail ou les groupes, les récupérer à partir de /userinfo. Nécessaire pour les jetons d'accès légers Keycloak, le serveur org Okta, et les jetons minimaux ADFS. Le id_token reste faisant autorité ; userinfo remplit uniquement les lacunes. Par défaut false.
use_pkce Non Envoyer un défi PKCE (S256) sur la demande d'autorisation. Par défaut true. Définissez false uniquement si votre fournisseur d'identité rejette PKCE pour ce client confidentiel.
clock_skew_seconds Non Tolérer la dérive d'horloge lors de la validation des revendications de temps id_token. Par défaut 0, ce qui est strict. Augmentez si vous voyez des erreurs « token expired / not yet valid » juste après la connexion en raison d'une dérive d'horloge hôte/fournisseur d'identité.
token_endpoint_auth_method Non Remplacer la méthode d'authentification du point de terminaison de jeton. Accepte client_secret_basic ou client_secret_post. Négocié automatiquement par défaut.
id_token_signed_response_alg Non Algorithme de signature id_token attendu. Par défaut RS256. Définissez pour les fournisseurs d'identité qui signent avec ES256, PS256, ou EdDSA.
additional_authorized_parties Non Valeurs azp supplémentaires à accepter au-delà de client_id, pour les flux de courtier Keycloak et d'échange de jetons
discovery_url Non Récupérer le document de découverte à partir de cette URL au lieu de le dériver de issuer, pour les fournisseurs d'identité derrière un proxy qui réécrit l'hôte émetteur. Le chemin doit contenir /.well-known/.
use_proxy Non Envoyer les propres demandes du fournisseur d'identité de la passerelle via le proxy avant dans HTTPS_PROXY ou HTTP_PROXY, en honorer NO_PROXY. false garde ces demandes directes. Nécessite v2.1.227 ou ultérieur ; voir Demandes du fournisseur d'identité via un proxy avant ci-dessous.
form_action_origins Non Origines supplémentaires pour la directive Content-Security-Policy: form-action de la page /device. La passerelle autorise déjà 'self' et l'origine authorization_endpoint découverte, mais Chrome applique form-action à toute la chaîne de redirection. Si votre fournisseur d'identité redirige via un deuxième hôte, tel qu'Azure AD fédéré à ADFS, Okta hub-spoke, ou un intercepteur SSO d'entreprise, listez chaque origine par laquelle la demande d'autorisation peut rediriger.
ca_cert_pem Non Le certificat CA codé en PEM lui-même, pas un chemin vers un fichier. Il remplace le magasin de confiance du système pour les demandes du fournisseur d'identité uniquement. Pour charger un fichier monté, écrivez ${file:/etc/gateway/idp-ca.pem}. Utilisez pour Keycloak ou Dex derrière une PKI d'entreprise.

Demandes du fournisseur d'identité via un proxy avant

Les upstreams d'inférence honorent HTTPS_PROXY et HTTP_PROXY sur chaque version. Les propres demandes de la passerelle au fournisseur d'identité, découverte, JWKS, jeton, et userinfo, vont directes sauf si vous définissez oidc.use_proxy: true, ce qui nécessite v2.1.227 ou ultérieur. Lorsqu'une variable de proxy est définie, use_proxy n'est pas défini, et l'émetteur n'est pas couvert par NO_PROXY, la passerelle garde ces demandes directes et enregistre un avis au démarrage vous demandant de choisir ; use_proxy: false les garde directes et fait taire l'avis.

Avec use_proxy: true, le pod résout lui-même le nom d'hôte de chaque point de terminaison du fournisseur d'identité et demande au proxy de CONNECT à l'adresse IP résolue, donc le proxy doit accepter CONNECT à l'adresse IP de chaque hôte que le document de découverte nomme, pas seulement l'émetteur. Utilisez une URL de proxy http://. ca_cert_pem et la protection SSRF s'appliquent également sur le chemin proxifié.

Sortie proxy uniquement change les deux : pendant qu'il est actif, les demandes du fournisseur d'identité suivent le proxy sauf si vous définissez use_proxy: false, et la passerelle remet au proxy chaque nom d'hôte du fournisseur d'identité sans le résoudre d'abord.

Sortie proxy uniquement

Définissez CLAUDE_GATEWAY_PROXY_IS_EGRESS_BOUNDARY=1 dans l'environnement de la passerelle, à côté de HTTPS_PROXY, lorsque le pod atteint d'autres hôtes uniquement via ce proxy avant et ne peut pas résoudre les noms DNS publics lui-même, ou lorsque le proxy refuse CONNECT à une adresse IP. Nécessite v2.1.277 ou ultérieur. C'est une variable d'environnement plutôt qu'une clé gateway.yaml pour que rien dans le fichier de configuration ne puisse assouplir la vérification d'adresse de la passerelle.

export HTTPS_PROXY=http://proxy.corp.example.com:3128
export NO_PROXY=
export no_proxy=
export CLAUDE_GATEWAY_PROXY_IS_EGRESS_BOUNDARY=1

La passerelle enregistre une ligne network: au démarrage pendant que la sortie proxy uniquement est active.

Chaque ligne ci-dessous est une classe de demande sortante sur une passerelle avec HTTPS_PROXY défini, par défaut et pendant que la sortie proxy uniquement est active.

Demande sortante Par défaut Sortie proxy uniquement active
Upstreams provider: anthropic, échange de jeton Workload Identity Federation, exports telemetry.forward_to Résolus et vérifiés localement, puis CONNECT à l'adresse IP vérifiée via le proxy. Un collecteur de télémétrie listé dans NO_PROXY est atteint directement à la place Nom d'hôte remis au proxy
Découverte du fournisseur d'identité, JWKS, jeton, et userinfo Direct sauf si oidc.use_proxy: true, puis CONNECT à l'adresse IP vérifiée Nom d'hôte remis au proxy, sauf si oidc.use_proxy: false garde un fournisseur d'identité interne direct
Upstreams Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, et Microsoft Foundry ; recherches de groupes Google Nom d'hôte remis au proxy Inchangé

La sortie proxy uniquement reste désactivée sauf si l'environnement de la passerelle répond à ces trois conditions :

  • HTTPS_PROXY ou HTTP_PROXY est défini.
  • NO_PROXY et no_proxy sont vides. Si votre plateforme injecte l'un ou l'autre dans les pods, définissez les deux sur une valeur vide sur le conteneur de la passerelle. Lister un collecteur de télémétrie dans NO_PROXY garde la sortie proxy uniquement désactivée.
  • CLAUDE_GATEWAY_ALLOW_LOOPBACK n'est pas activé. Un collecteur ou un fournisseur d'identité sur la propre boucle locale du pod ne peut pas être combiné avec la sortie proxy uniquement, car une adresse loopback remise au proxy serait la propre boucle locale de l'hôte proxy, donc donnez à ces services une adresse que le proxy peut atteindre à la place. Pour la même raison, la passerelle refuse les noms de style localhost directement pendant que la sortie proxy uniquement est active.

Lorsque l'une de ces conditions n'est pas remplie, la passerelle enregistre un avertissement au démarrage nommant la variable qui l'a arrêtée et conserve le comportement par défaut.

Une fois que la sortie proxy uniquement est active, autorisez chaque destination dans le proxy, y compris un collecteur interne et tout hôte configuré par adresse IP. Vous pouvez toujours garder un fournisseur d'identité interne direct avec oidc.use_proxy: false.

`session`

Le bloc session façonne les jetons porteurs que la passerelle émet après la connexion : le secret qui les signe et combien de temps ils vivent.

Champ Obligatoire Description
jwt_secret Oui Au moins 32 octets d'entropie, par exemple à partir de openssl rand -base64 32. Signe les jetons porteurs HS256 de la passerelle. Accepte une chaîne unique ou un tableau pour la rotation : l'index 0 signe et toutes les entrées vérifient. Pour faire tourner, prépendez un nouveau secret, attendez ttl_hours, puis supprimez l'ancien.
ttl_hours Non Durée de vie du jeton porteur de la passerelle. Par défaut 1. Le CLI s'actualise silencieusement avant l'expiration lorsque le fournisseur d'identité émet des jetons d'actualisation. Une durée de vie plus courte déprovisionne plus rapidement ; une plus longue fait moins d'allers-retours du fournisseur d'identité. Si votre fournisseur d'identité ne peut pas émettre de jetons d'actualisation car offline_access n'est pas disponible, il n'y a pas d'actualisation silencieuse, donc augmentez ceci à 8 ou 12 pour éviter de renvoyer les développeurs à la connexion au navigateur toutes les heures.

`store`

Le bloc store pointe la passerelle vers sa base de données PostgreSQL, qui contient les subventions d'appareil et les compteurs de limitation de débit.

Champ Obligatoire Description
postgres_url Oui URL postgres:// ou postgresql://. Obligatoire : le rendez-vous de subvention d'appareil, où le rappel du navigateur écrit et le CLI d'interrogation lit, a besoin d'un état entre répliques. La passerelle exécute ses propres migrations de schéma au démarrage et à la mise à niveau, donc le rôle a besoin de droits pour créer et modifier les tables sur le schéma cible. Voir Mises à niveau et Postgres.
username Non Remplace l'utilisateur dans postgres_url
password Non Identifiant de base de données. Définissez-le ici plutôt que dans postgres_url pour que l'identifiant reste hors de l'URL. Accepte n'importe quel caractère et prend précédence sur les identifiants d'URL.
max_connections Non Taille du pool de connexions Postgres par réplique. Par défaut 5, ce qui est conservateur et convivial pour les bases de données partagées. Avec les limites de dépenses activées, le chemin chaud effectue quelques opérations par demande d'inférence, donc augmentez-le pour une base de données dédiée sous charge, et gardez répliques × ceci en dessous du max_connections de la base de données.
connect_timeout_seconds Non Secondes que la passerelle attend lorsqu'elle ouvre une connexion Postgres. Un nombre entier de 1 à 60, par défaut 5. Augmentez-le si les tentatives de connexion expirent lorsqu'une nouvelle instance de passerelle démarre. Nécessite Claude Code v2.1.274 ou ultérieur sur le serveur de la passerelle. Les versions antérieures refusent de démarrer lorsque la clé est définie.
readiness_grace_seconds Non Combien de secondes /readyz continue de signaler prêt après que Postgres cesse de répondre. Un nombre entier de 0 à 3600, par défaut 0. Voir Comportement de panne pour savoir comment choisir une valeur. Nécessite Claude Code v2.1.282 ou ultérieur sur le serveur de la passerelle. Les versions antérieures refusent de démarrer lorsque la clé est définie.

Pour le développement local, pointez postgres_url vers un conteneur Postgres jetable, par exemple docker run --rm -p 5432:5432 -e POSTGRES_HOST_AUTH_METHOD=trust postgres.

`upstreams`

upstreams est une liste ordonnée. La passerelle transfère l'inférence au premier upstream qui résout le modèle demandé.

Sur 5xx, 429, 401, 403, 404, ou timeout, la passerelle bascule vers l'upstream suivant ; les autres 4xx ne le font pas, car ces erreurs sont attribuables à la demande plutôt qu'à l'upstream. Un 401 ou 403 signifie que l'identifiant que la passerelle a utilisé contre cet upstream a échoué. Un 404 signifie que cet upstream ne sert pas le modèle demandé, donc un upstream ultérieur dans la liste peut toujours le faire.

Si vous définissez forward_user_identity: true sur un upstream, un 429 qu'il retourne à une demande qui portait l'e-mail du développeur ne bascule pas. Voir comment un refus de limite par utilisateur atteint le développeur.

Le basculement sur 404 nécessite la passerelle v2.1.198 ou ultérieur. Les versions antérieures retournaient le premier 404 au client même lorsqu'un upstream ultérieur dans la liste servait le modèle.

Plusieurs upstreams du même fournisseur doivent définir un name: distinct.

Les clients Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, et Microsoft Foundry sont construits une fois au démarrage, et leurs SDK actualisent les identifiants en interne, donc la rotation des identifiants cloud ne nécessite pas un redémarrage. Les clés API Anthropic statiques et les porteurs sont lus au démarrage ; voir Anthropic API.

Messages d'erreur Upstream

La passerelle retourne la réponse d'erreur d'un upstream, ou son propre 502, selon la façon dont les upstreams ont répondu :

  • Un upstream a retourné un statut sur lequel la passerelle ne bascule pas : la réponse de cet upstream. La passerelle n'essaie pas d'autres upstreams.
  • Chaque upstream que la passerelle a essayé a échoué d'une manière sur laquelle elle bascule : le dernier 429. Lorsqu'aucun n'a retourné un 429, la passerelle préfère, dans l'ordre, le dernier 401 ou 403, le dernier 404, et le dernier 501. Lorsqu'aucun n'a retourné l'un de ceux-ci, le propre 502 de la passerelle, all upstreams failed (N attempted), où N compte chaque entrée dans upstreams, y compris les entrées que la passerelle a ignorées car elles ne servent pas le modèle demandé.

Lorsque la passerelle retourne la réponse d'un upstream, elle conserve le code de statut de l'upstream. Qu'elle conserve le message de l'upstream dépend du fournisseur. Le corps d'erreur d'un upstream Anthropic API atteint le développeur inchangé.

Les upstreams Amazon Bedrock, Claude Platform on AWS, Google Cloud's Agent Platform, et Microsoft Foundry peuvent nommer vos ID de compte, ARN de rôle, et ID de projet dans leur texte d'erreur. La passerelle enregistre ce texte complet dans le journal opérationnel. Ce que le développeur voit de ces upstreams dépend du refus :

  • 400 ou 413 dans l'enveloppe d'erreur standard d'Anthropic : le message propre de l'upstream, tel que prompt is too long. Claude Platform on AWS, Agent Platform, et Microsoft Foundry retournent cette enveloppe pour les rejets d'API de modèle.
  • 400 ou 413 dans la propre forme du fournisseur : un jeton capability_rejected:. Lorsque la passerelle ne peut pas classer le refus, upstream rejected the request sur un 400 ou request too large for this upstream sur un 413.
  • N'importe quel autre statut : copie générique par statut, telle que upstream rate limit exceeded sur un 429.

Par exemple, la passerelle remplace le Input is too long for requested model. d'Amazon Bedrock par capability_rejected: prompt_too_long. Claude Code se compacte automatiquement sur ce jeton, comme il le fait sur prompt is too long.

Garder le message 400 ou 413 d'un upstream cloud, ou le remplacer par un jeton capability_rejected:, nécessite la passerelle v2.1.233 ou ultérieur.

Anthropic API

L'upstream Anthropic minimal est une clé API de la Console Claude :

upstreams:
  - provider: anthropic
    auth:
      api_key: ${ANTHROPIC_API_KEY}
    # OU un porteur OAuth (par exemple, un jeton échangé Workload-Identity-Federation) :
    #   oauth_token: ${file:/var/run/secrets/anthropic-oauth-token}
    # base_url: https://api.anthropic.com   # par défaut ; remplacez pour un proxy avant

Les deux formes d'identifiant diffèrent dans l'en-tête qu'elles envoient :

  • api_key : envoie x-api-key. Faites-la tourner dans la Console Claude et mettez à jour la variable d'environnement.
  • oauth_token : envoie Authorization: Bearer. Utilisez la forme porteur lorsque votre organisation émet des jetons de courte durée au lieu de clés API de longue durée. Le porteur est lu une fois au démarrage, donc actualisez en remontant le secret et en redémarrant.

Au lieu d'une clé statique ou d'un porteur, vous pouvez utiliser Workload Identity Federation. Créez une règle de fédération en suivant le guide Workload Identity Federation, puis montez le JWT OIDC de votre charge de travail en tant que fichier, tel qu'un jeton de compte de service projeté Kubernetes ou un id-token de plateforme CI. La passerelle échange le JWT pour un porteur de courte durée et l'actualise automatiquement. Le fichier de jeton est relui à chaque échange, donc les jetons projetés en rotation sont récupérés sans redémarrage.

upstreams:
  - provider: anthropic
    auth:
      federation_rule_id: ${ANTHROPIC_FEDERATION_RULE_ID}
      organization_id: ${ANTHROPIC_ORGANIZATION_ID}
      identity_token_file: /var/run/secrets/anthropic/id-token
      # workspace_id: wrkspc_...       # obligatoire si la règle couvre >1 espace de travail
      # service_account_id: svac_...   # vérification de cible attendue optionnelle
En-têtes d'identité par utilisateur pour un proxy que vous exécutez

Vous pouvez pointer le base_url d'un upstream provider: anthropic vers un proxy que vous exécutez au lieu de l'API Anthropic. Pour dire à ce proxy quel développeur a envoyé chaque demande, définissez forward_user_identity: true sur cet upstream. Le proxy peut alors attribuer les dépenses par développeur. Nécessite une passerelle exécutant Claude Code v2.1.233 ou ultérieur.

Par exemple, pour un proxy à upstream-gateway.internal.example.com :

upstreams:
  - provider: anthropic
    base_url: https://upstream-gateway.internal.example.com
    auth:
      api_key: ${PROXY_KEY}
    forward_user_identity: true        # par défaut false

La passerelle ajoute ces en-têtes à chaque demande qu'elle transfère à cet upstream.

En-tête Valeur
x-litellm-end-user-id L'e-mail du développeur, lorsque le fournisseur d'identité en a fourni un.
x-claude-gateway-user-id Le sujet du fournisseur d'identité du développeur, à partir de la revendication sub du jeton.
x-claude-gateway-user-email L'e-mail du développeur, lorsque le fournisseur d'identité en a fourni un.

Lorsque le jeton du fournisseur d'identité ne porte pas d'e-mail, la passerelle envoie uniquement x-claude-gateway-user-id et omet les deux en-têtes d'e-mail. Si votre fournisseur d'identité met l'e-mail dans une revendication différente, définissez oidc.email_claim sur cette revendication.

Lorsque votre proxy répond 429 à une demande qui portait l'e-mail du développeur, la passerelle retourne cette réponse au développeur tel quel au lieu de basculer vers l'upstream suivant, donc votre budget par utilisateur du proxy ou votre limite de débit tient. Les autres réponses du proxy suivent les règles de basculement ordinaires. Si le jeton du fournisseur d'identité d'un développeur ne porte pas d'e-mail, la passerelle transfère ses demandes sans les en-têtes d'e-mail, donc un 429 à l'une de ces demandes compte comme capacité upstream et bascule. Avant v2.1.267 sur le serveur de la passerelle, chaque 429 basculait.

Définissez forward_user_identity uniquement sur un upstream dont le base_url est un proxy que vous exploitez. La passerelle envoie les e-mails des développeurs à quel que soit le serveur que ce base_url nomme. Si le base_url est l'API Anthropic, qui est la valeur par défaut, la passerelle refuse de démarrer.

Amazon Bedrock

Pour le déploiement côté client d'Amazon Bedrock que la passerelle remplace ou précède, voir Claude Code on Amazon Bedrock. L'upstream côté passerelle :

upstreams:
  - provider: bedrock
    region: us-east-1
    auth: {}                           # chaîne d'identifiants AWS par défaut préférée
    # OU identifiants explicites :
    # auth:
    #   aws_access_key_id: ${AWS_AKID}
    #   aws_secret_access_key: ${AWS_SK}
    #   aws_session_token: ${AWS_ST}
    # OU un jeton porteur Bedrock API :
    # auth:
    #   aws_bearer_token: ${AWS_BEARER_TOKEN}
    # Remplacez le point de terminaison bedrock-runtime pour les déploiements FIPS ou VPC-endpoint :
    # base_url: https://bedrock-runtime-fips.us-east-1.amazonaws.com

Un bloc auth vide utilise la chaîne d'identifiants par défaut du SDK AWS : variables d'environnement, ~/.aws/credentials, rôle de tâche ECS, métadonnées d'instance EC2, ou IRSA sur EKS. En production, donnez au pod de la passerelle un rôle IAM au lieu d'intégrer des clés statiques dans une image de conteneur.

Les identifiants explicites doivent être complets : la passerelle échoue au démarrage lorsque aws_access_key_id et aws_secret_access_key ne sont pas définis ensemble, ou lorsque aws_session_token est défini sans eux. Avant v2.1.207, un bloc auth: partiel passait la validation.

Configuration Comment
Permissions IAM Accordez au principal de la passerelle bedrock:InvokeModel et bedrock:InvokeModelWithResponseStream sur les ARN de profil d'inférence et les ARN de modèle de fondation sous-jacents. Pour le catalogue intégré dans les régions US : arn:aws:bedrock:<region>:<account>:inference-profile/us.anthropic.* et arn:aws:bedrock:*::foundation-model/anthropic.*. Accordez également bedrock:CountTokens sur les ARN de modèle de fondation. La passerelle l'utilise, sans frais, pour compter les jetons d'entrée d'une demande que le client a abandonnée, donc les limites de dépenses restent exactes. Sans cela, la passerelle revient à une demande Bedrock d'un jeton pour ce compte.
Accès au modèle Amazon Bedrock active l'accès au modèle par défaut dans les régions commerciales. La porte au niveau du compte restante est celle d'Anthropic : un formulaire de cas d'utilisation unique ; si personne dans votre compte AWS ne l'a soumis, ouvrez la console Amazon Bedrock, sélectionnez un modèle Anthropic dans le catalogue de modèles, et complétez le formulaire. Voir Soumettre les détails du cas d'utilisation pour le formulaire AWS Organizations et les permissions dont le soumetteur a besoin.
EKS (IRSA) Créez un rôle IAM avec la politique ci-dessus et une politique de confiance pour le fournisseur OIDC de votre cluster limité au compte de service de la passerelle. Annotez le compte de service avec eks.amazonaws.com/role-arn: arn:aws:iam::<acct>:role/claude-gateway. auth: {} le récupère.
ECS / EC2 Attachez le rôle IAM à la définition de tâche ou au profil d'instance. auth: {} le récupère.
N'importe où ailleurs Passez les identifiants via les variables d'environnement AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY, et AWS_SESSION_TOKEN, ou définissez-les explicitement dans auth: avec l'expansion ${VAR}
Région region: est la région du point de terminaison API. Les profils d'inférence inter-régions acheminent à travers la géographie (US, EU, APAC) indépendamment de celui que vous choisissez. Pour les régions non-US ou les ARN de débit provisionné, ajoutez un bloc models: avec les bons ID par upstream.
Appliquer une protection Amazon Bedrock

Pour appliquer une protection Amazon Bedrock à chaque demande d'inférence que la passerelle envoie via un upstream Bedrock, ajoutez un bloc guardrail à cet upstream. Nécessite Claude Code v2.1.281 ou ultérieur sur le serveur de la passerelle.

upstreams:
  - provider: bedrock
    region: us-east-1
    auth: {}
    guardrail:
      id: gr-abc123                    # ID de protection ou ARN complet
      version: "1"                     # un numéro de version publié, ou DRAFT
 # gardez les guillemets : un 1 nu échoue au démarrage

Accordez également bedrock:ApplyGuardrail sur la protection au principal qui signe les demandes de cet upstream : le principal AWS de la passerelle, ou avec assume_role le rôle nommé dans role_arn.

Définissez guardrail sur chaque upstream bedrock ou sur aucun. La passerelle refuse de démarrer sur un mélange, car le basculement pourrait autrement envoyer une demande à un upstream Bedrock qui n'a pas de protection.

La protection couvre les upstreams Bedrock uniquement. Si vous listez un autre fournisseur dans upstreams, la passerelle envoie les demandes à ce fournisseur sans la protection.

Lorsqu'une demande /v1/messages dont le corps porte un champ amazon-bedrock-*, tel que amazon-bedrock-guardrailConfig, atteint un upstream Bedrock qui a guardrail défini, la passerelle répond 400 au lieu de la transférer.

Bedrock dans un autre compte AWS

Définissez assume_role sur un upstream Bedrock et la passerelle utilise sa propre identité AWS uniquement pour appeler sts:AssumeRole sur un rôle que vous nommez, qui peut être dans un compte AWS différent de la passerelle. Chaque demande Bedrock de cet upstream est signée avec les identifiants d'une heure que STS retourne, donc aucune clé d'accès de longue durée ne traverse les comptes.

Nécessite une passerelle exécutant Claude Code v2.1.281 ou ultérieur. Une passerelle antérieure refuse de démarrer lorsqu'elle trouve la clé.

upstreams:
  - name: bedrock-isolated
    provider: bedrock
    region: us-east-1
    auth: {}                           # le rôle propre de la passerelle : il appelle uniquement STS
    assume_role:
      role_arn: arn:aws:iam::222222222222:role/claude-gateway-bedrock
      # external_id: ${BEDROCK_ROLE_EXTERNAL_ID}   # lorsque la politique de confiance du rôle en exige une

Le bloc assume_role prend trois clés :

Clé Signification
role_arn Le rôle IAM que la passerelle assume, comme un ARN arn:aws:iam:: ou arn:aws-us-gov:iam::. Donnez-lui les permissions Bedrock que cet upstream a besoin, bedrock:CountTokens inclus, plus bedrock:ApplyGuardrail lorsque l'upstream définit guardrail.
external_id Optionnel. Envoyé comme ID externe à chaque appel sts:AssumeRole. Définissez-le lorsque la politique de confiance du rôle en exige un, et citez-le s'il est composé uniquement de chiffres.
session_name Optionnel. email ou sub donne à chaque développeur sa propre session : voir Attribution des coûts AWS par développeur. Non défini, chaque demande utilise une session nommée claude-apps-gateway.

La politique de confiance du rôle nomme le principal propre de la passerelle, tel que son IRSA ou son rôle de tâche ECS. Ce principal a besoin de sts:AssumeRole sur le rôle et aucune permission Bedrock de sa propre. Supprimez la Condition si vous ne définissez pas external_id.

{
  "Version": "2012-10-17",
  "Statement": [{
    "Effect": "Allow",
    "Principal": { "AWS": "arn:aws:iam::111111111111:role/claude-gateway" },
    "Action": "sts:AssumeRole",
    "Condition": { "StringEquals": { "sts:ExternalId": "your-external-id" } }
  }]
}
  • Si STS refuse ou est inaccessible, la passerelle n'envoie pas la demande avec les identifiants propres de l'upstream. Elle enregistre l'erreur STS avec ce qu'il faut vérifier, puis essaie l'upstream suivant que vous avez listé. Messages d'erreur Upstream couvre ce que le client reçoit lorsqu'aucun upstream ne réussit. Un upstream ultérieur sans assume_role servirait la demande avec ses propres identifiants, donc listez-en un uniquement si c'est ce que vous voulez.
  • La passerelle appelle le point de terminaison STS régional sts.<region>.amazonaws.com, que son réseau doit atteindre. Pour le point de terminaison FIPS, définissez AWS_USE_FIPS_ENDPOINT=true dans l'environnement de la passerelle plutôt que use_fips_endpoint dans un fichier de configuration AWS.
  • assume_role s'applique à provider: bedrock uniquement et a besoin d'identifiants source SigV4 : la passerelle refuse de démarrer lorsqu'il est défini à côté de aws_bearer_token.
  • Chaque développeur que la passerelle admet peut utiliser cet upstream ; managed régit quels développeurs peuvent utiliser quels modèles. Pour garder un modèle servi via le rôle d'être également servi à partir d'un autre compte, donnez-lui un id personnalisé dont la carte upstream_model n'a que le nom de cet upstream. Pour un tel id, la passerelle ignore chaque autre upstream, donc ni la demande ni le compte de jetons pour une demande abandonnée ne peuvent basculer vers un autre compte. Les noms de modèles intégrés sont toujours essayés sur chaque upstream dans l'ordre, celui-ci inclus, et une demande qui l'atteint est signée avec le même rôle, donc listez cet upstream en dernier sauf si son compte devrait également les servir.

Cet exemple donne à un modèle un id personnalisé que seul l'upstream isolé sert :

models:
  - id: claude-opus-restricted          # un id personnalisé, pas un nom de modèle intégré
    upstream_model:
      bedrock-isolated: us.anthropic.claude-opus-4-8   # le seul upstream qui le sert
Attribution des coûts AWS par développeur

Par défaut, la passerelle signe chaque demande Bedrock avec un identifiant, donc AWS voit toutes les demandes des développeurs sous un seul principal IAM. Ajoutez session_name: email à assume_role et la passerelle appelle sts:AssumeRole une fois par développeur par heure, avec le nom de session défini sur l'e-mail de ce développeur, et signe ses demandes avec les identifiants retournés, donc les demandes de chaque développeur atteignent AWS sous leur propre session de rôle assumé. Le rôle peut être dans le compte propre de la passerelle.

Nécessite une passerelle exécutant Claude Code v2.1.281 ou ultérieur. Attribution des coûts sur AWS couvre le rôle IAM et où la facturation AWS affiche les sessions.

upstreams:
  - provider: bedrock
    region: us-east-1
    auth: {}                           # le rôle propre de la passerelle : il appelle uniquement STS
    assume_role:
      role_arn: arn:aws:iam::123456789012:role/claude-gateway-bedrock-user
      session_name: email              # ou sub

session_name sélectionne quelle revendication vérifiée devient le RoleSessionName AWS : email ou sub. La passerelle écrit tout caractère autre que les lettres ASCII, les chiffres, et _+,.@- comme =XX hex par octet UTF-8, et raccourcit un résultat plus long que 64 caractères à un préfixe plus un hash, donc le nom de session de chaque développeur reste valide et unique. Une demande d'un développeur dont le jeton manque la revendication n'est pas envoyée via cet upstream, et le journal de l'opérateur dit de basculer vers sub ou de définir oidc.email_claim.

Un développeur actif coûte un appel STS par heure par réplique de passerelle, et les demandes premières concurrentes partagent un appel.

La passerelle fait également un appel de sa propre sur ce rôle : le compte de jetons pour une demande que le client a abandonnée, donc les limites de dépenses restent exactes. Ce compte et sa demande de secours d'un jeton sont signés par la session partagée claude-apps-gateway, donc AWS attribue le secours à claude-apps-gateway plutôt qu'au développeur.

Pour une attribution stricte par développeur, définissez assume_role avec session_name sur chaque upstream Bedrock que vous listez. Un upstream sans lui signe les demandes qu'il sert avec ses propres identifiants.

Claude Platform on AWS

Claude Platform on AWS sert l'API Anthropic propriétaire sur l'infrastructure AWS à aws-external-anthropic.<region>.api.aws. Il utilise les ID de modèle propriétaires, honore les en-têtes anthropic-beta tels qu'envoyés, et sert count_tokens, donc aucune traduction spécifique à Bedrock ne s'applique. Le fournisseur anthropicAws nécessite Claude Code v2.1.198 ou ultérieur ; les versions antérieures de la passerelle le rejettent au démarrage.

Pour le déploiement côté client de la même plateforme, voir Claude Code on Claude Platform on AWS. L'upstream côté passerelle :

upstreams:
  - provider: anthropicAws
    region: us-east-1
    workspace_id: wrkspc_...
    auth:
      api_key: ${ANTHROPIC_AWS_API_KEY}   # envoyé comme x-api-key
    # OU SigV4 via la chaîne d'identifiants AWS par défaut :
    # auth: {}
    # OU identifiants SigV4 explicites :
    # auth:
    #   aws_access_key_id: ${AWS_ACCESS_KEY_ID}
    #   aws_secret_access_key: ${AWS_SECRET_ACCESS_KEY}
    # Remplacez le point de terminaison dérivé :
    # base_url: https://aws-external-anthropic.us-east-1.api.aws

La plateforme s'exécute dans un compte AWS séparé d'Amazon Bedrock et signe les demandes SigV4 pour son propre nom de service, aws-external-anthropic, donc un rôle IAM limité à Bedrock ne l'autorise pas. Une clé API dans auth.api_key prend précédence lorsque les identifiants SigV4 sont également définis. Un bloc auth vide utilise la chaîne d'identifiants par défaut du SDK AWS, la même chaîne que l'upstream Amazon Bedrock utilise.

Champ Obligatoire Description
region Oui Région AWS, lettres minuscules, chiffres, et traits d'union. La passerelle dérive le point de terminaison à partir de lui comme https://aws-external-anthropic.<region>.api.aws.
workspace_id Oui Envoyé comme en-tête à chaque demande ; la plateforme l'exige
auth.api_key Non Clé API pour la plateforme, envoyée comme x-api-key. Pas un jeton porteur : les deux modes d'authentification sont une clé API ou SigV4.
auth.aws_access_key_id / auth.aws_secret_access_key Non Identifiants SigV4 explicites. Définir l'un sans l'autre échoue au démarrage. auth.aws_session_token est accepté à côté d'eux.
base_url Non Remplacez le point de terminaison dérivé

Parce que la plateforme résout les ID de modèle propriétaires, le catalogue intégré achemine vers elle sans bloc models:. Lorsque vous organisez une liste models:, clé l'entrée anthropicAws: avec l'ID propriétaire.

Google Cloud Agent Platform

Pour la configuration côté client équivalente, voir Claude Code on Google Cloud. L'upstream côté passerelle :

upstreams:
  - provider: vertex
    region: us-east5
    project_id: example-prod
    auth: {}                           # identifiants par défaut d'application préférés
    # OU un fichier de clé de compte de service :
    # auth: { service_account_json: /secrets/sa.json }
    # Remplacez le point de terminaison aiplatform pour Private Service Connect :
    # base_url: https://us-east5-aiplatform.p.googleapis.com

Un bloc auth vide utilise les identifiants par défaut d'application : GOOGLE_APPLICATION_CREDENTIALS, métadonnées GCE, ou Workload Identity GKE. Les fichiers de clé JSON de compte de service sont supportés mais déconseillés ; utilisez Workload Identity ou attachez un compte de service à l'instance GCE ou Cloud Run.

Définissez region: global pour utiliser le point de terminaison global pour Google Cloud's Agent Platform au lieu d'un régional. Google achemine ensuite chaque demande vers une région disponible, donc vous ne suivez pas la disponibilité du modèle par région. Définir une région spécifique épingle chaque demande à elle.

Configuration Comment
Permissions IAM Accordez au compte de service de la passerelle roles/aiplatform.user sur le projet, ou un rôle personnalisé avec aiplatform.endpoints.predict. Activez l'API Google Cloud's Agent Platform (aiplatform.googleapis.com).
Accès au modèle Dans Model Garden, activez les modèles Claude pour votre projet. Ils publient vers des régions spécifiques ; vérifiez la fiche du modèle pour les régions supportées.
GKE (Workload Identity) Liez un compte de service GCP au compte de service Kubernetes de la passerelle et annotez le KSA avec iam.gke.io/gcp-service-account: claude-gateway@<proj>.iam.gserviceaccount.com. auth: {} le récupère.
Cloud Run / GCE Définissez le compte de service du service sur un avec roles/aiplatform.user. auth: {} le récupère.
N'importe où ailleurs auth: { service_account_json: /secrets/sa.json }, le chemin vers un fichier de clé JSON monté en tant que secret. Le champ prend un chemin de fichier, pas le contenu de la clé, donc aucune expansion ${file:…} n'est impliquée.

Microsoft Foundry

Pour le déploiement côté client de Microsoft Foundry, voir Claude Code on Microsoft Foundry. L'upstream côté passerelle :

upstreams:
  - provider: foundry
    resource: example-foundry              # https://example-foundry.services.ai.azure.com
    auth: { use_azure_ad: true }        # préféré : DefaultAzureCredential / Managed Identity
    # OU une clé API :
    # auth:
    #   api_key: ${FOUNDRY_API_KEY}

use_azure_ad: true résout via DefaultAzureCredential : Managed Identity sur AKS, ACI, ou App Service ; l'Azure CLI ; ou les identifiants d'environnement. Les clés API fonctionnent mais sont au niveau du projet et ne tournent pas automatiquement. Le point de terminaison de Microsoft Foundry est dérivé de resource: ; définissez le base_url optionnel pour le remplacer pour les clouds souverains tels qu'Azure Government.

Configuration Comment
RBAC Accordez à l'identité de la passerelle Azure AI User ou Cognitive Services User sur la ressource Microsoft Foundry
Déploiements Microsoft Foundry utilise les noms de déploiement choisis par l'administrateur, pas les ID de modèle canoniques. Ajoutez un bloc models: mappant chaque ID canonique à votre nom de déploiement.
AKS (workload identity) Fédérez une identité gérée attribuée par l'utilisateur avec l'émetteur OIDC du cluster et liez-la au compte de service de la passerelle. use_azure_ad: true la récupère via WorkloadIdentityCredential.
ACI / App Service Activez l'identité gérée attribuée par le système ou l'utilisateur sur la ressource. use_azure_ad: true la récupère.
N'importe où ailleurs auth: { api_key: "${FOUNDRY_API_KEY}" }. Citez ${…} à l'intérieur de { }.

En-têtes statiques sur les demandes upstream

Pour ajouter des en-têtes fixes aux demandes que la passerelle envoie à un upstream, définissez headers: sur cet upstream. Utilisez-le lorsqu'un proxy que vous exécutez devant le fournisseur achemine ou attribue le trafic par un en-tête.

headers: nécessite Claude Code v2.1.277 ou ultérieur sur le serveur de la passerelle. Une passerelle antérieure refuse de démarrer lorsqu'elle trouve la clé. Mettez à niveau chaque réplique avant d'ajouter la clé, et supprimez la clé avant de revenir à une version antérieure.

Les en-têtes vont au serveur que base_url nomme, ou au point de terminaison propre du fournisseur lorsque base_url n'est pas défini. Le fournisseur les reçoit également sauf si votre proxy les supprime.

Cet exemple atteint un upstream provider: vertex via un proxy à upstream-proxy.internal.example.com. Il définit l'en-tête x-source que le proxy lit, et envoie un jeton de la variable d'environnement PROXY_TOKEN comme x-proxy-token :

upstreams:
  - provider: vertex
    region: us-east5
    project_id: example-prod
    base_url: https://upstream-proxy.internal.example.com
    auth: {}
    headers:
      x-source: claude-apps-gateway
      x-proxy-token: ${PROXY_TOKEN}

Les valeurs sont du texte ASCII imprimable sans espace à chaque extrémité. Citez un nombre, true, ou false pour que YAML le lise comme texte.

Pour garder un secret hors du fichier de configuration, utilisez l'expansion de secret pour charger la valeur à partir d'une variable d'environnement avec ${VAR} ou à partir d'un fichier avec ${file:/path}. Un ${VAR} qui se résout en une valeur vide arrête le démarrage de la passerelle.

headers: fonctionne sur chaque fournisseur, et chaque upstream envoie uniquement le sien.

Pas chaque demande que la passerelle envoie à un upstream les porte :

Demande que la passerelle envoie à cet upstream Porte headers:
/v1/messages, streaming ou non, et /v1/messages/count_tokens Oui
Une demande qui a basculé à partir d'un autre upstream Oui, uniquement le headers: de cet upstream
Appel CountTokens d'Amazon Bedrock pour une demande que le client a abandonnée Non
L'échange de jeton Workload Identity Federation Non

Sur un upstream Amazon Bedrock ou Claude Platform on AWS qui signe les demandes avec AWS SigV4, ces en-têtes font partie de la signature, donc votre proxy doit les transmettre inchangés.

Si vous utilisez un nom que la passerelle réserve, elle refuse de démarrer, et l'erreur de démarrage nomme l'en-tête. Les noms réservés incluent :

  • authorization et x-api-key
  • host, content-type, et user-agent
  • N'importe quel nom commençant par anthropic-, x-goog-, x-amz-, ou x-amzn-

Plusieurs upstreams

Le même fournisseur peut apparaître plus d'une fois avec un name: distinct. Cela couvre différentes régions, différents comptes via différentes chaînes d'identifiants, débit provisionné par rapport à la demande, et basculement inter-fournisseur.

La passerelle essaie les upstreams dans l'ordre. 5xx, 429, 401, 403, 404, timeouts, et point de terminaison manquant (501) basculer ; les autres 4xx ne le font pas.

429 est par capacité upstream, donc l'épuisement du débit provisionné (PT) bascule vers la demande. Si vous définissez forward_user_identity: true sur un upstream, un 429 à une demande qui portait l'e-mail du développeur est un refus par utilisateur à la place et ne bascule pas.

Chaque demande commence au premier upstream. Une demande atteint un upstream ultérieur uniquement lorsque chaque upstream devant lui a échoué ou ne sert pas le modèle demandé.

La passerelle ne garde aucun enregistrement des upstreams échoués, donc pendant qu'un upstream est en panne, chaque demande qui l'atteint l'essaie toujours et attend qu'il échoue avant de passer au suivant.

Pour un upstream Anthropic API, timeouts.upstream_ttfb_ms limite l'attente sur un upstream en panne. Ce paramètre ne s'applique pas aux autres fournisseurs, où la passerelle attend jusqu'à une heure pour qu'un upstream commence à répondre.

404 est par disponibilité du modèle upstream, donc un upstream qui n'a pas activé un modèle ne bloque pas un upstream ultérieur qui le sert. Un upstream qui ne peut pas résoudre le modèle demandé est ignoré sans un aller-retour réseau.

Cet exemple achemine une allocation de débit provisionné Amazon Bedrock en premier, déborde vers la demande et un deuxième compte, et revient à l'API Anthropic en dernier :

upstreams:
  # Primaire : débit provisionné dans votre région d'accueil.
  - name: bedrock-pt
    provider: bedrock
    region: us-east-1
    auth: {}
  # Débordement : demande inter-régions.
  - name: bedrock-od
    provider: bedrock
    region: us-west-2
    auth: {}
  # Compte différent : une allocation Bedrock séparée via des clés statiques.
  - name: bedrock-acct2
    provider: bedrock
    region: us-east-1
    auth:
      aws_access_key_id: ${ACCT2_AKID}
      aws_secret_access_key: ${ACCT2_SK}
  # Dernier recours : API Anthropic directe.
  - name: anthropic-fallback
    provider: anthropic
    auth:
      api_key: ${ANTHROPIC_API_KEY}

# Les ID de modèle par upstream sont clés sur le `name:` de l'upstream.
models:
  - id: claude-opus-4-8
    label: Claude Opus 4.8
    upstream_model:
      bedrock-pt: arn:aws:bedrock:us-east-1:111111111111:provisioned-model/abcdef
      bedrock-od: us.anthropic.claude-opus-4-8
      bedrock-acct2: us.anthropic.claude-opus-4-8
      anthropic-fallback: claude-opus-4-8
Levier Comment
Régions différentes Un upstream Amazon Bedrock par région, chacun avec sa propre region:. Avec auto_include_builtin_models: true, les profils d'inférence inter-régions acheminent automatiquement ; pour les déploiements épinglés à la région, utilisez un bloc models:.
Comptes différents Un upstream Amazon Bedrock par compte. La chaîne par défaut (auth: {}) utilise l'identité du pod ; pour un deuxième compte, ajoutez assume_role pour l'atteindre avec des identifiants de courte durée, ou définissez des identifiants explicites ou un jeton porteur dans auth:.
Débit provisionné Mappez le modèle à l'ARN de débit provisionné dans models: pour le nom de cet upstream. Les autres upstreams gardent l'ID à la demande, donc la capacité PT est épuisée avant de basculer.
Points de terminaison VPC / FIPS Définissez base_url: sur l'upstream à votre URL de point de terminaison VPC ou FIPS
Acheminement limité au modèle Uniquement un id de modèle personnalisé, un qui n'est pas un nom de modèle Claude intégré, ignore les upstreams absents de sa carte upstream_model:. La passerelle essaie les modèles intégrés sur chaque upstream dans l'ordre et utilise l'ID par défaut du fournisseur où la carte n'a pas d'entrée, donc pour les modèles intégrés, la carte change quel ID un upstream reçoit plutôt que s'il est essayé ; un upstream qui rejette l'ID suit les mêmes règles de basculement que n'importe quelle autre erreur upstream.

Le basculement entre les fournisseurs cloud, ou vers l'API Anthropic directe, change quel accord, géographie, et autres conditions régissent la demande.

Le CLI applique la même limitation de fonctionnalité aux passerelles indépendamment de quel upstream sert une demande donnée, donc le basculement n'envoie pas un champ de corps qu'un upstream rejetterait.

Sections optionnelles

`admin`

Optionnel. Active /v1/organizations/spend_limits, qui reflète l'API Admin publique d'Anthropic, et l'application des dépenses par développeur sur /v1/messages. Consultez Limites de dépenses pour savoir comment les plafonds sont définis et appliqués ; cette section couvre les clés gateway.yaml qui activent la fonctionnalité et l'ajustent.

admin:
  # Named static API keys for the admin endpoints, sent as x-api-key.
  # The id appears in the audit log as admin-key:<id> so each key is
  # attributable. Array for rotation: add the new key, roll clients,
  # remove the old.
  write_keys:
    - { id: terraform, key: "${GATEWAY_ADMIN_WRITE_KEY_TF}" }
    - { id: ci,        key: "${GATEWAY_ADMIN_WRITE_KEY_CI}" }
  read_keys:
    - { id: reporting, key: "${GATEWAY_ADMIN_READ_KEY}" }
  # IdP groups granted full admin via the normal gateway JWT (no API key).
  admin_groups: [platform-finops]
  blocked_message: request an increase at https://go.example.com/claude-limits
Champ Requis Description
write_keys Non Tableau de {id, key}. Une x-api-key correspondant à l'une de ces clés peut lister, définir et supprimer les limites de dépenses. Les valeurs de clé doivent comporter au moins 32 caractères ; les id doivent être uniques dans read_keys et write_keys.
read_keys Non Tableau de {id, key}. Lecture seule : tous les endpoints GET, y compris la liste des plafonds, la récupération d'un plafond par ID, et la lecture de /effective et /audit.
admin_groups Non Noms de groupes IdP. Un JWT de passerelle dont la revendication groups inclut l'un de ces groupes dispose d'un accès administrateur complet, en lecture et en écriture, et est audité en tant que oidc:<sub>. Utilisez ceci pour les administrateurs humains ; utilisez les clés API pour les machines. Une entrée vide dans cette liste arrête la passerelle au démarrage. Consultez Valeurs de matcher qui arrêtent la passerelle au démarrage.
blocked_message Non Ajouté textuellement à l'erreur 429 billing_error qu'un développeur bloqué voit. Écrivez l'instruction complète, comme une URL ou un canal Slack. Lorsqu'il n'est pas défini, la passerelle envoie uniquement le message par défaut. Consultez Comment l'application fonctionne.
audit_retention_days Non Par défaut 365. Les lignes admin_audit plus anciennes sont supprimées.
spend_retention_months Non Par défaut 13. Les lignes du compteur spend plus anciennes que cela sont supprimées. La valeur par défaut conserve une année complète plus le mois partiel actuel pour les rapports d'une année sur l'autre.
identity_retention_days Non Par défaut 90. TTL de dernière consultation pour les lignes principal_emails, qui contiennent l'e-mail, le nom d'affichage et les groupes de chaque développeur (PII). Délibérément plus court que la rétention des dépenses afin qu'une identité déprovisionnée expire tandis que ses compteurs de dépenses anonymes restent.
group_limit_mode Non min (par défaut) ou max. Lorsqu'un développeur se trouve dans plusieurs groupes avec des plafonds, min applique le plus restrictif et max le moins restrictif. Utilisé à la fois par l'application et par /effective.

`enforcement`

Le bloc enforcement contrôle le comportement des vérifications de limite de dépenses lorsque le magasin est indisponible.

Champ Requis Description
fail_closed_on_error Non Par défaut false. L'application des dépenses échoue en mode ouvert en cas de panne Postgres, afin que l'inférence reste active. Définissez true pour échouer en mode fermé : les développeurs au-delà du plafond sont bloqués, mais tout le monde l'est aussi si le magasin est inaccessible. Nécessite un bloc admin: : l'application des dépenses ne s'exécute que lorsque admin est configuré, et la passerelle refuse de démarrer si vous définissez ceci à true sans ce bloc.

`pricing`

Le bloc pricing indique au compteur de dépenses quoi facturer au lieu du prix catalogue en USD, afin que les plafonds et /effective reflètent vos tarifs contractuels. Les montants restent en USD et restent une estimation, pas une facture. Deux prérequis :

  • Claude Code v2.1.227 ou ultérieur sur le serveur de passerelle. Les versions antérieures rejettent la clé inconnue au démarrage.
  • Un bloc admin: ou, dans v2.1.268 ou ultérieur, un bloc managed: avec au moins une politique. La passerelle refuse de démarrer avec pricing défini et aucun de ces blocs, car rien ne le lirait.
pricing:
  multiplier: 0.85
  overrides:
    - upstream: bedrock-eu
      model: claude-sonnet-4-6
      input: 3.30
      output: 16.50
      cache_read: 0.33
      cache_write: 4.125
Champ Requis Description
multiplier Non Par défaut 1. Le compteur multiplie chaque montant mesuré par cette valeur, qu'il soit au prix catalogue ou remplacé, donc 0.85 facture 85 % du prix. Doit être supérieur à 0 et au maximum 10, et une valeur supérieure à 1 est une majoration.
overrides Non Lignes de {upstream, model, input, output, cache_read, cache_write} en USD par million de tokens. Les quatre tarifs sont requis. Chacun doit être supérieur à 0 et au maximum 10000.

Comment le compteur fait correspondre une ligne de remplacement :

  • Une ligne remplace le prix catalogue pour les requêtes que upstream, un upstreams[].name, traite pour model. Cela inclut le tarif mode rapide plus élevé, donc les requêtes en mode rapide et standard sont mesurées aux mêmes quatre tarifs.
  • Un ID intégré tel que claude-sonnet-4-6, mis en correspondance comme models[].id, couvre chaque forme datée, forme Amazon Bedrock régionale, ou forme Google Cloud Agent Platform que le compteur évalue comme ce modèle. Toute autre chaîne, comme un alias ou un ARN de profil d'inférence, correspond à l'ID que le client a envoyé ou à la chaîne envoyée en amont, sans tenir compte de la casse.
  • Lorsque les lignes se chevauchent, le compteur choisit la ligne la plus spécifique plutôt que la première ligne : une ligne dont model est la chaîne de modèle exacte envoyée en amont, puis une ligne correspondant à l'ID exact que le client a envoyé, puis une ligne nommant le modèle intégré.
  • Un nom d'upstream inconnu fait échouer le démarrage, tout comme deux lignes pour un upstream qui nomment le même modèle, y compris deux orthographes d'un modèle intégré. La passerelle avertit au démarrage à propos d'une ligne qu'aucun modèle demandable ne peut utiliser.
  • Les requêtes de recherche Web restent au prix catalogue de $0,01 ; le multiplicateur s'y applique toujours.

Pour les tarifs par région, donnez à chaque région son propre upstream nommé et une ligne par upstream.

Majorer les prix

Avec v2.1.271 ou ultérieur sur le serveur de passerelle, vous pouvez définir multiplier au-dessus de 1, jusqu'à 10, pour mesurer plus que ce que le fournisseur facture, par exemple un tarif de refacturation interne. Cet exemple mesure chaque requête à 120 % du prix :

pricing:
  multiplier: 1.2

Avec un bloc admin:, la majoration s'applique également aux limites de dépenses. Le compteur compte 120 % du prix, afin que les développeurs atteignent leurs plafonds plus tôt. La passerelle journalise un avertissement au démarrage qui le signale.

Le multiplicateur ne change pas ce que le fournisseur en amont facture pour les requêtes.

Si la passerelle envoie également les tarifs aux clients connectés, les développeurs ont besoin de Claude Code v2.1.271 ou ultérieur pour voir la majoration. Les clients antérieurs ignorent un multiplier supérieur à 1 et affichent les coûts sans lui.

Un serveur de passerelle antérieur à v2.1.271 refuse de démarrer si vous définissez un multiplier supérieur à 1.

Envoyer les tarifs aux clients connectés

Avec v2.1.268 ou ultérieur sur le serveur de passerelle, la passerelle place également les tarifs de pricing dans les politiques managed qu'elle sert, en tant que paramètre géré modelPricing. Les développeurs correspondant à une politique voient alors les tarifs pricing pour le premier upstream qui sert chaque ID de modèle dans /usage, la barre de statut et OpenTelemetry. Un développeur qui ne correspond à aucune politique ne reçoit aucun paramètre géré, afin que ses chiffres restent au prix catalogue. Les clients appliquent le paramètre dans Claude Code v2.1.242 ou ultérieur.

  • Ce que la passerelle ajoute : à moins que le bloc cli d'une politique ne définisse déjà modelPricing, la passerelle ajoute le multiplier et, pour chaque ID de modèle qu'un client peut demander, la ligne de remplacement du premier upstream qui sert cet ID. Un tarif que seul un upstream de basculement facture reste sur la passerelle.
  • Exclure une politique : définissez modelPricing à {} dans le bloc cli de cette politique, et ses développeurs restent au prix catalogue.
  • Conserver les tarifs propres d'une politique : une politique dont le bloc cli définit modelPricing avec son propre multiplier ou overrides conserve ce modelPricing entièrement, et la passerelle n'y ajoute aucun de ses propres tarifs.

`models`

Le bloc models est une liste de modèles optionnelle organisée par l'administrateur, servie à /v1/models et utilisée pour traduire les ID de modèles par upstream. Elle est requise pour les régions Amazon Bedrock hors US, les ARN de débit provisionné Amazon Bedrock et les noms de déploiement Microsoft Foundry.

auto_include_builtin_models: true   # false: expose only the list below
models:
  - id: claude-opus-4-8
    label: Claude Opus 4.8
    # description: optional text shown in clients that surface it
    upstream_model:
      anthropic: claude-opus-4-8
      bedrock: us.anthropic.claude-opus-4-8   # or an inference-profile ARN
      foundry: your-opus-deployment-name

Chaque clé sous upstream_model doit correspondre au name d'un upstream configuré, qui par défaut est le nom du fournisseur. Une clé qui ne correspond à aucun upstream fait échouer le démarrage, donc omettez les lignes pour les fournisseurs que vous n'utilisez pas.

`managed`

Le bloc managed définit des politiques d'accès basées sur les rôles, indexées sur les groupes IdP ou le domaine de messagerie. Les politiques sont évaluées dans l'ordre ; la première correspondance est sélectionnée, puis fusionnée sur la base fourre-tout match: {}. Elles sont servies par utilisateur à GET /managed/settings avec mise en cache ETag/304.

managed:
  policies:
    # Specific groups first.
    - match: { groups: [eng-contractors] }
      cli:
        availableModels: [claude-sonnet-4-6]
        permissions: { deny: ["WebFetch", "WebSearch"] }
    # Default catch-all last: matches everyone who authenticated.
    - match: {}
      cli:
        availableModels: [claude-opus-4-8, claude-sonnet-4-6, claude-haiku-4-5]

Un fourre-tout match: {}, conventionnellement listé en dernier, est traité comme une couche de base. Chaque autre politique hérite du fourre-tout toute clé qu'elle ne définit pas, afin que les entrées par rôle n'aient besoin de lister que ce qui diffère de la valeur par défaut de l'organisation. Les règles de fusion dépendent du type de clé :

  • Listes d'autorisation : availableModels et permissions.allow. La liste d'une politique spécifique remplace complètement celle de la base.
  • Listes de refus et tableaux de hooks : permissions.deny, permissions.ask, disabledMcpjsonServers, deniedMcpServers, blockedMarketplaces et chaque tableau de type d'événement hooks. Ceux-ci prennent l'union de la base et de la politique, afin qu'un hook de refus ou d'audit à l'échelle de l'organisation ne puisse pas être accidentellement supprimé par un remplacement par rôle.
  • Clés de type enregistrement : env, modelOverrides et skillOverrides. Celles-ci fusionnent superficiellement, afin qu'un bloc env par rôle remplace les clés qu'il définit et hérite du reste de la base.

availableModels est également appliqué côté serveur à /v1/messages, afin qu'un modèle refusé retourne 400 indépendamment de ce que le client envoie.

La passerelle valide elle-même la valeur model avant de relayer une requête, afin qu'une valeur mal formée n'atteigne jamais un upstream. Elle rejette la requête avec un 400 dans deux cas :

  • Lorsque la valeur est manquante ou vide, la passerelle rejette la requête avec le message model is required. Cette vérification nécessite une passerelle exécutant Claude Code v2.1.228 ou ultérieur.
  • Lorsque la valeur est présente mais n'est pas une chaîne, la passerelle rejette la requête avec le message model must be a string. Nécessite une passerelle exécutant Claude Code v2.1.221 ou ultérieur.
Matcher Comportement
match: {} Correspond à chaque utilisateur authentifié. Commencez par l'un de ceux-ci et ajoutez plus tard des politiques limitées à des groupes au-dessus.
match: { groups: [a, b] } Correspond si la revendication groups du JWT contient l'un des groupes listés. Sensible à la casse : les groupes doivent correspondre à la casse exacte de l'IdP.
match: { email_domain: example.com } Correspond à la partie après le dernier @ dans la revendication email du JWT, sans tenir compte de la casse. Accepte un domaine par politique.
match: { groups: [a], email_domain: example.com } Les deux conditions doivent correspondre

Un utilisateur authentifié qui ne correspond à aucune politique obtient les valeurs par défaut de la passerelle, ce qui signifie chaque modèle du catalogue et aucun paramètre géré. Ajoutez un fourre-tout match: {} en dernier si vous voulez une politique par défaut garantie.

Valeurs de matcher qui arrêtent la passerelle au démarrage

Au démarrage, la passerelle vérifie le bloc match de chaque politique et la liste admin_groups. L'une de ces valeurs arrête la passerelle avec une erreur qui nomme le champ :

  • Une liste groups vide
  • Une entrée vide dans groups ou dans admin_groups
  • Un email_domain vide
  • Un email_domain qui contient @, un espace ou une virgule. La passerelle supprime les espaces autour de la valeur et retire un @ initial avant cette vérification. Écrivez un domaine nu, comme example.com.

Avant v2.1.232, la passerelle démarrait avec ces valeurs. Chaque valeur avait cet effet :

  • Un email_domain vide : la passerelle ignorait la vérification du domaine, de sorte qu'une politique avec un email_domain vide et sans liste groups correspondait à chaque utilisateur authentifié
  • Une liste groups vide : la politique ne correspondait à personne
  • Un email_domain contenant @, un espace ou une virgule : la politique ne correspondait à personne
  • Une entrée vide dans groups ou dans admin_groups : l'entrée correspondait à un utilisateur uniquement lorsque la revendication groups IdP de cet utilisateur contenait également une entrée vide. Dans admin_groups, cette correspondance accordait l'accès administrateur. Si votre liste admin_groups n'a jamais contenu d'entrée vide, personne n'a obtenu l'accès administrateur de cette façon.

Ce qui va dans `cli`

Chaque valeur cli est un document Claude Code managed-settings.json complet, le même schéma que vous déploieriez via MDM ou /etc/claude-code/managed-settings.json, exprimé ici en YAML. Le CLI applique le document livré au niveau géré, au-dessus des paramètres utilisateur et projet, à la place des paramètres gérés par le serveur. Il ignore donc les paramètres restreints aux sources de politique au niveau du système d'exploitation, comme policyHelper et wslInheritsWindowsSettings.

La passerelle valide chaque document par rapport au schéma de paramètres du CLI au démarrage, afin qu'une clé de niveau supérieur non reconnue fasse échouer le démarrage avec une erreur nommant chaque clé fautive. Les parties délibérément ouvertes du schéma acceptent toujours des valeurs arbitraires, car les clients plus récents peuvent reconnaître des entrées que le schéma de la passerelle ne reconnaît pas. Ces clés ouvertes incluent env, pluginConfigs et les clés imbriquées sous permissions.

Comme la validation utilise le schéma fourni avec la version installée de la passerelle, placer dans la configuration gérée une clé de paramètres de niveau supérieur introduite par une version plus récente de Claude Code nécessite de mettre d'abord à niveau la passerelle. Testez une nouvelle politique sur un client avant de la déployer.

La référence complète des clés se trouve dans Paramètres Claude Code. Les clés que les opérateurs utilisent en premier :

managed:
  policies:
    - match: {}
      cli:
        # Model access (also enforced server-side at /v1/messages)
        availableModels: [claude-opus-4-8, claude-sonnet-4-6, claude-haiku-4-5]

        # Permission policy
        permissions:
          deny:
            - "WebFetch"
            - "Read(./.env)"
            - "Read(./secrets/**)"
          disableBypassPermissionsMode: disable   # blocks --dangerously-skip-permissions
        allowManagedPermissionRulesOnly: true     # ignore user/project permission rules

        # Environment pushed into the CLI process. DISABLE_UPDATES blocks
        # background and manual updates; DISABLE_AUTOUPDATER stops only
        # background updates.
        env:
          DISABLE_UPDATES: "1"                    # pin versions via your own distribution

        # Org-wide hooks. Hook commands run on developer machines, not the
        # gateway, so the path must exist on every client OS in the policy.
        hooks:
          PostToolUse:
            - matcher: "Edit|Write"
              hooks:
                - { type: command, command: /usr/local/bin/audit-edit.sh }
Clé Appliquée par Effet
availableModels Passerelle + CLI Liste d'autorisation des modèles. Également vérifiée à /v1/messages, afin qu'un client modifié ne puisse pas la contourner.
permissions.allow / .deny CLI Règles d'outils et de commandes. Consultez Permissions.
permissions.disableBypassPermissionsMode CLI Définissez à disable pour bloquer bypassPermissions, le mode qui ignore les demandes de permission, et le flag --dangerously-skip-permissions
allowManagedPermissionRulesOnly CLI Lorsque true, les paramètres gérés deviennent la seule source de paramètres des règles de permission. L'entrée allowManagedPermissionRulesOnly liste chaque source que Claude Code ignore alors.
env CLI Variables d'environnement fusionnées dans le processus CLI. Utilisez-les pour la télémétrie, la mise à jour automatique et les remplacements de noms de modèles.
hooks CLI Hooks à l'échelle de l'organisation
managedMcpServers CLI Serveurs MCP distants fournis à chaque développeur correspondant aux côtés des serveurs qu'il ajoute lui-même, http et sse uniquement. Consultez Serveurs MCP dans une politique. Nécessite Claude Code v2.1.259 ou ultérieur sur le serveur de passerelle et sur les clients. Les clients antérieurs ignorent la clé.

Comme ces paramètres arrivent par le réseau, le CLI affiche à chaque développeur une boîte de dialogue d'approbation de sécurité avant d'appliquer les paramètres listés ci-dessous :

  • hooks
  • Les variables env qui nécessitent l'approbation du développeur, comme les variables de proxy et d'URL de base
  • Les paramètres d'exécution de shell comme apiKeyHelper et statusLine
  • Les paramètres binaires du sandbox sandbox.bwrapPath, sandbox.socatPath et sandbox.ripgrep
  • Les paramètres du sandbox qui interceptent le trafic, injectent des identifiants ou affaiblissent l'isolation, comme sandbox.network.tlsTerminate et les paramètres de port du proxy. Boîtes de dialogue d'approbation de sécurité les liste tous.

Mémoire d'approbation explique combien de temps dure une approbation et quand la boîte de dialogue réapparaît.

Claude Code applique certaines variables env livrées sans afficher la boîte de dialogue d'approbation au développeur, comme les paramètres de sélection de modèle et les limites numériques. D'autres variables livrées peuvent nécessiter l'approbation du développeur avant de prendre effet ; une valeur non vide de proxy, d'URL de base ou de OTEL_EXPORTER_OTLP_ENDPOINT la nécessite toujours. Lorsqu'une variable livrée nécessite une approbation, la boîte de dialogue la nomme.

Variables d'environnement et boîte de dialogue d'approbation donne les détails, y compris quatre options de confidentialité dont la valeur livrée détermine si elles nécessitent une approbation. Avant v2.1.218, Claude Code appliquait moins de variables sans demander au développeur, de sorte que davantage de variables livrées déclenchaient la boîte de dialogue.

La configuration de télémétrie de la passerelle pousse OTEL_EXPORTER_OTLP_ENDPOINT, donc définir telemetry.forward_to déclenche la boîte de dialogue sur chaque client interactif. La boîte de dialogue protège la machine du développeur contre une passerelle compromise ou hostile, et non l'organisation contre le développeur.

Une exécution non interactive, comme claude -p ou une session Agent SDK, ne peut pas afficher la boîte de dialogue. Elle applique les paramètres poussés pour cette exécution uniquement et ne les enregistre pas comme approuvés, de sorte que la prochaine session interactive du développeur affiche toujours la boîte de dialogue. Avant v2.1.207, une exécution non interactive enregistrait les paramètres comme approuvés et aucune session interactive ultérieure n'affichait la boîte de dialogue pour eux.

Si un développeur refuse, Claude Code quitte cette session plutôt que d'appliquer la politique. Lorsque vous poussez un nouveau hook, ou toute variable env qui déclenche la boîte de dialogue, vers une politique large, chaque développeur correspondant voit donc la boîte de dialogue dans ses sessions interactives. Une session interactive en cours l'affiche lors du prochain sondage horaire, et sinon elle apparaît au prochain démarrage interactif du développeur.

La clé cli s'appelait settings dans les versions antérieures. Cette orthographe est toujours acceptée comme alias, mais les nouveaux déploiements doivent utiliser cli.

Fenêtre de contexte dans les sessions de terminal

Les sessions de terminal connectées via /login utilisent la fenêtre de contexte de 1M pour Opus 4.7 et ultérieur, Sonnet 5 et ultérieur, ainsi que les modèles Fable. L'ID de modèle n'a besoin d'aucun suffixe [1m], et les sessions se compactent à environ 967K tokens. Avant Claude Code v2.1.287 sur la machine du développeur, Claude Code considérait que les modèles Opus et Fable avaient une fenêtre de 200K, sauf si l'ID de modèle se terminait par [1m].

Pour que les sessions de terminal se compactent plutôt à la limite de 200K, définissez la fenêtre de compaction automatique dans le env de la politique :

managed:
  policies:
    - match: {}
      cli:
        env:
          CLAUDE_CODE_AUTO_COMPACT_WINDOW: "200000"

Claude Code applique cette variable sans afficher la boîte de dialogue d'approbation au développeur. La variable s'applique à chaque modèle, y compris les ID de modèles qui se terminent par [1m].

Pour désactiver plutôt le contexte 1M, définissez CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" dans le même bloc env. Claude Code considère alors que chaque modèle a une fenêtre de 200K. Dans les sessions interactives, chaque développeur approuve cette variable dans la boîte de dialogue d'approbation avant qu'elle ne prenne effet.

Serveurs MCP dans une politique

Pour fournir des serveurs MCP aux clients Claude Code auxquels une politique correspond, définissez managedMcpServers dans le bloc cli de cette politique. Vous avez besoin de Claude Code v2.1.259 ou ultérieur sur le serveur de passerelle et sur les clients.

La passerelle vérifie chaque entrée au démarrage avec les mêmes règles que Claude Code applique sur le client, et si une entrée échoue à une vérification, la passerelle refuse de démarrer et nomme l'entrée.

Si vous écrivez une référence ${VAR} dans gateway.yaml, la passerelle la résout à partir de son environnement au démarrage via l'expansion de secret avant d'exécuter les vérifications d'entrée, de sorte que chaque client correspondant reçoit la valeur littérale et peut la lire. Les recommandations sur les en-têtes pour les serveurs fournis s'appliquent à la valeur développée.

La passerelle rejette l'orthographe .mcp.json mcpServers dans un bloc cli, et son erreur de démarrage nomme managedMcpServers comme clé à utiliser. Avant v2.1.259, la passerelle rejetait toute définition de serveur MCP dans un bloc cli.

Superposition Claude Desktop

Si votre organisation déploie également Claude Desktop, la même passerelle sert les deux clients. Pointez bootstrapUrl, dans la configuration gérée de Claude Desktop, vers <listen.public_url>/user/bootstrap. Claude Desktop dérive l'émetteur OAuth de cette URL, exécute la même connexion par code d'appareil auprès de cette passerelle et récupère sa configuration à partir de la réponse.

La passerelle dérive une grande partie de la réponse du bloc cli de la politique correspondante et de la configuration de passerelle de niveau supérieur :

  • La liste des modèles, à partir de availableModels. Contexte étendu dans Claude Desktop couvre l'option de contexte 1M de chaque modèle

  • Les outils désactivés, à partir des entrées permissions.deny constituées d'un simple nom d'outil. Si vous définissez disabledBuiltinTools dans le bloc desktop de la politique, la passerelle sert l'union de votre valeur et de la liste dérivée, de sorte que vous pouvez désactiver plus d'outils de cette façon mais ne pouvez pas réactiver un outil que vous avez désactivé via permissions.deny

  • La liste d'autorisation de sortie, à partir de sandbox.network.allowedDomains. Si vous définissez coworkEgressAllowedHosts dans le bloc desktop de la politique, la passerelle utilise cette valeur à la place de la liste dérivée

  • Un endpoint OTLP qui pointe vers la passerelle elle-même, et les attributs d'identité de l'utilisateur connecté. La passerelle relaie les exportations qu'elle reçoit sur cet endpoint vers vos destinations forward_to. Elle inclut l'endpoint et les attributs lorsque vous définissez à la fois telemetry.forward_to et listen.public_url.

    Claude Desktop exporte chaque signal avec un seul encodage : http/protobuf, ou http/json lorsque vous définissez OTEL_EXPORTER_OTLP_PROTOCOL ou l'une de ses variantes par signal à http/json dans le env de la politique. Avant Claude Code v2.1.261 sur le serveur de passerelle, la réponse définissait http/json dans tous les cas, de sorte qu'un collecteur qui accepte uniquement protobuf rejetait les exportations de Claude Desktop

Pour définir disabledBuiltinTools, coworkEgressAllowedHosts ou le paramètre managedMcpServers propre à Claude Desktop dans le bloc desktop d'une politique, vous avez besoin de Claude Code v2.1.232 ou ultérieur sur le serveur de passerelle. Le managedMcpServers de Claude Desktop prend une valeur de tableau plutôt qu'un objet.

La passerelle omet de la réponse d'amorçage les clés sans équivalent Claude Desktop, comme hooks et les règles de permission ciblées comme Bash(npm *).

Ajoutez le bloc desktop optionnel aux côtés de cli pour définir directement les paramètres de Claude Desktop. Écrivez les paramètres de la référence de configuration gérée de Claude Desktop sous forme de noms de clés plats. Laissez de côté les clés que Claude Desktop lit uniquement depuis MDM ou des fichiers locaux, comme bootstrapUrl ; la passerelle les rejette au démarrage. Avant v2.1.232, la passerelle acceptait une liste fixe de 11 clés de feature flag, comme chatTabEnabled et disableAutoUpdates, et rejetait toute autre clé au démarrage. Avant v2.1.227, la passerelle rejetait également chatTabEnabled et chatAdvancedFileAnalysisEnabled au démarrage.

managed:
  policies:
    - match: { groups: [eng-contractors] }
      cli:
        availableModels: [claude-sonnet-4-6]
      desktop:
        isLocalDevMcpEnabled: false
        disableAutoUpdates: true
        banner: { text: "Contractor build: internal use only" }

Chaque clé est optionnelle ; Claude Desktop applique sa propre valeur par défaut pour toute clé que vous omettez. La passerelle valide chaque bloc desktop au démarrage par rapport au schéma de configuration que Claude Desktop utilise lui-même, de sorte qu'une erreur apparaît au démarrage de la passerelle sous la forme d'une erreur nommant la clé plutôt que d'atteindre chaque poste Desktop connecté. La passerelle échoue au démarrage lorsqu'un bloc contient :

  • Une clé inconnue
  • Une clé reconnue dont Claude Desktop rejetterait ou supprimerait silencieusement la valeur, comme une valeur vide ou une sous-clé mal orthographiée dans une entrée imbriquée. Avant v2.1.260, la passerelle supprimait silencieusement un champ mal orthographié dans un objet imbriqué d'une entrée managedMcpServers ou orgPluginSettings au lieu d'échouer au démarrage.
  • Une clé que la passerelle calcule elle-même : la connexion d'inférence, la liste des modèles et le relais OTLP. Configurez-les via upstreams, models et le forward_to de la section telemetry.
  • Un alias hérité d'une clé actuelle. Dans l'erreur de démarrage, la passerelle nomme la clé canonique à écrire.

Si vous utilisez une valeur ou une forme d'entrée dépréciée, comme une entrée managedMcpServers sans transport, la passerelle démarre et journalise un avertissement qui nomme le remplacement.

La passerelle valide un bloc desktop par rapport au schéma fourni avec sa version installée, comme elle le fait pour le bloc cli. Pour livrer un paramètre introduit par une version plus récente de Claude Desktop, mettez d'abord à niveau la passerelle. Par exemple, userPluginMarketplacesEnabled et userPluginUploadsEnabled nécessitent Claude Code v2.1.260 ou ultérieur sur le serveur de passerelle et Claude Desktop 1.37937.0 ou ultérieur sur les machines des membres.

blockReadsOutsideWorkingDirectories, disableBypassPermissionsMode, configRecheckIntervalMinutes et sshClientPath nécessitent Claude Code v2.1.281 ou ultérieur sur le serveur de passerelle. C'est aussi le cas de la valeur required de microsoftAuthBroker et du champ continuousAccessEvaluation d'une entrée managedMcpServers Microsoft 365. Les versions de Claude Desktop antérieures à la valeur required la lisent comme disabled, donc définissez required uniquement lorsque le Claude Desktop de chaque membre la prend en charge. La référence de configuration gérée de Claude Desktop indique la version qui lit chaque clé pour la première fois.

Si vous définissez orgPluginSettings dans le bloc desktop d'une politique, la passerelle le sert sous la forme de tableau que lisent Claude Desktop 1.15200.0 et ultérieur. Les versions de Desktop plus anciennes ignorent le tableau et n'appliquent aucune politique d'outil de plugin, donc mettez à jour les membres vers 1.15200.0 ou ultérieur avant de vous y fier.

La passerelle complète les clés que le bloc desktop d'une politique ne définit pas à partir du bloc desktop du fourre-tout match: {}, de la même manière qu'elle complète le bloc cli d'une politique à partir de la base. Si vous définissez disabledBuiltinTools ou builtinToolPolicy à la fois dans la base et dans une politique par rôle, la passerelle conserve la restriction de la base :

  • disabledBuiltinTools : la passerelle utilise l'union de la liste de la base et de la liste de la politique
  • builtinToolPolicy : si vous définissez un outil à une valeur autre que allow dans la base, la passerelle conserve cette valeur même si vous définissez allow pour le même outil dans une politique par rôle

Pour toute autre clé, si vous la définissez dans la politique par rôle, la passerelle utilise la valeur de la politique par rôle. La passerelle remplace entièrement un tableau ou un objet imbriqué comme banner, donc si vous définissez banner.text dans une politique par rôle, la passerelle supprime le banner.backgroundColor de la base.

Si vous ne déployez pas Claude Desktop, laissez complètement desktop hors de vos politiques ; la passerelle retourne alors 404 depuis /user/bootstrap pour chaque utilisateur.

Contexte étendu dans Claude Desktop

Si vous servez Claude Desktop depuis la passerelle, son sélecteur de modèles propose une option de contexte 1M pour chaque modèle listé pouvant s'exécuter avec une fenêtre de contexte de 1M. Cela inclut Claude Opus 4.6 et ultérieur, Claude Sonnet 4.6 et ultérieur, ainsi que les modèles Fable. L'option est la variante [1m] du modèle, décrite dans Contexte étendu. Vous avez besoin de Claude Code v2.1.284 ou ultérieur sur le serveur de passerelle.

Une entrée models n'obtient pas d'option 1M lorsque :

  • Un upstream pouvant servir l'entrée la mappe vers un modèle sans prise en charge de 1M, y compris un upstream que la passerelle n'atteint qu'en cas de basculement
  • Ni son id ni aucune de ses valeurs upstream_model ne nomme un modèle Claude, comme un alias personnalisé routé vers un ARN de profil d'inférence d'application

Pour modifier ce que propose le sélecteur, utilisez l'une de ces options :

  • Démarrer les utilisateurs sur l'option 1M : définissez modelPrefer1mContext: true dans le bloc desktop de la politique. Les utilisateurs qui n'ont pas encore choisi de modèle démarrent sur l'option 1M lorsque le premier modèle listé en possède une. Les utilisateurs qui ont déjà choisi un modèle conservent leur choix.
  • Proposer l'option manuellement : faites-le si votre serveur de passerelle exécute une version antérieure à v2.1.284, ou si une entrée ne nomme aucun modèle Claude. Listez le modèle deux fois dans models, une fois avec son ID simple et une fois avec [1m] ajouté, toutes deux avec le même mappage upstream_model. Claude Desktop affiche la paire comme un seul modèle avec une option 1M. La passerelle sert une entrée [1m] sans la vérifier, donc n'en ajoutez une que pour un modèle que vos upstreams servent en 1M.

Cet exemple propose l'option manuellement pour un alias personnalisé routé vers un profil d'inférence d'application, et y fait démarrer les nouveaux utilisateurs :

models:
  - id: corp-sonnet
    upstream_model:
      bedrock: arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/sonnet-5-prod
  - id: corp-sonnet[1m]
    upstream_model:
      bedrock: arn:aws:bedrock:us-east-2:123456789012:application-inference-profile/sonnet-5-prod

managed:
  policies:
    - match: {}
      desktop:
        modelPrefer1mContext: true
Supprimer l'option 1M

Pour supprimer l'option du sélecteur, définissez CLAUDE_CODE_DISABLE_1M_CONTEXT: "1" dans le bloc env sous la clé cli de la politique. Si vous avez également listé une entrée dont l'id se termine par [1m], la passerelle la sert toujours, donc supprimez également cette entrée.

La variable atteint aussi les sessions de terminal des développeurs auxquels correspond la politique. Pour ce qu'elle y modifie, consultez Contexte étendu.

Priorité avec d'autres sources gérées

Si un appareil dispose également d'une politique livrée par MDM ou d'un managed-settings.json local, les paramètres livrés par la passerelle sont prioritaires. Priorité au sein du niveau géré, sur la page des paramètres gérés, indique quand les sources locales s'appliquent, et présente les clés que Claude Code lit depuis chaque source d'administration quelle que soit la source sélectionnée, comme les clés de verrouillage du sandbox, forceRemoteSettingsRefresh et la fusion env par variable. Un policyHelper configuré dans un profil MDM ou dans le fichier de paramètres gérés s'exécute uniquement lorsque la passerelle ne livre aucun paramètre ; l'entrée indique ce que sa sortie remplace.

Les hôtes d'intégration tels que Claude Desktop peuvent fournir une politique via l'option SDK managedSettings. Paramètres parents des hôtes d'intégration indique quand Claude Code l'applique, et Restreindre les paramètres parents liste les paramètres de type autorisation qui s'appliquent toujours sans les verrous allowManaged*Only.

Les politiques de passerelle s'appliquent à chaque invocation de Claude Code sur la machine, y compris les exécutions non interactives claude -p et les sessions lancées par l'Agent SDK. Si la passerelle est inaccessible au démarrage, les sessions connectées se terminent avec une erreur plutôt que de s'exécuter sans leur politique.

`telemetry`

Le CLI envoie des métriques, des logs et, lorsqu'elles sont activées, des traces à la passerelle, qui les relaie textuellement à chaque destination configurée. Les exportations utilisent OpenTelemetry Protocol (OTLP) sur HTTP. Pour ignorer le relais et faire exporter les sessions directement vers votre collecteur, nommez le collecteur dans une politique. Consultez Surveillance de l'utilisation pour les métriques et événements que le CLI émet.

Dans les sessions connectées via /login, le CLI marque chaque exportation avec l'identité de l'utilisateur authentifié, lue à partir du JWT émis par la passerelle : les attributs user.id, user.email et user.groups. L'attribution des coûts et de l'utilisation par développeur fonctionne donc sans configuration côté développeur.

Claude Desktop et les sessions Cowork connectées via la passerelle marquent leur télémétrie avec user.email et user.groups aux côtés de enduser.id, afin que vous puissiez couvrir l'utilisation du terminal, de Desktop et de Cowork avec une seule requête sur user.email ou user.groups. user.groups est la liste des groupes IdP séparés par des virgules.

La télémétrie de Desktop et de Cowork porte également enduser.sub, la revendication sub que votre fournisseur d'identité émet pour l'utilisateur, qui reste la même lorsque l'e-mail d'un utilisateur change. Les sessions de terminal marquent la même valeur sous user.id, de sorte qu'une requête qui fait correspondre enduser.sub avec le user.id du terminal couvre ensemble l'utilisation du terminal, de Desktop et de Cowork d'un utilisateur. Sur les exportations de Desktop et de Cowork, user.id est un identifiant anonyme, pas le sujet.

Comme toutes les données OpenTelemetry de Claude Code, ces attributs vont uniquement aux destinations que votre organisation configure, jamais à Anthropic.

Si la liste de groupes d'un utilisateur dépasse 255 caractères une fois encodée en pourcentage, ou si un nom de groupe contient une virgule ou un signe égal, la passerelle omet user.groups de la télémétrie Desktop et Cowork de cet utilisateur plutôt que de la tronquer. Les sessions de terminal de cet utilisateur portent toujours la liste complète.

La passerelle omet enduser.sub lorsque le sujet dépasse 255 caractères une fois encodé en pourcentage, ou contient un espace, un caractère en dehors de l'ASCII imprimable, ou l'un de , ; = \ " %. La télémétrie Desktop et Cowork de cet utilisateur conserve ses autres attributs.

Vous avez besoin de Claude Code v2.1.265 ou ultérieur sur le serveur de passerelle pour user.email et user.groups sur la télémétrie Desktop et Cowork, et de Claude Desktop 1.24012 ou ultérieur sur la machine de chaque développeur pour user.groups.

Vous avez besoin de Claude Code v2.1.274 ou ultérieur sur le serveur de passerelle pour enduser.sub.

telemetry:
  forward_to:
    - url: https://otel-collector.internal.example.com
      headers:
        Authorization: ${OTLP_TOKEN}
      # Per-signal opt-in. Default: metrics only.
      metrics: true
      logs: false
      traces: false
    - url: https://api.datadoghq.com/api/v2/otlp
      headers:
        DD-API-KEY: ${DD_API_KEY}

Chaque URL forward_to doit utiliser https://, avec une exception pour un collecteur sur l'interface de bouclage de la passerelle elle-même :

  • http://localhost:<port> passe la validation de configuration, mais la protection SSRF bloque chaque exportation avec ECONNREFUSED_SSRF à moins que vous ne définissiez CLAUDE_GATEWAY_ALLOW_LOOPBACK=1 dans l'environnement de la passerelle
  • http://127.0.0.1:<port> ou http://[::1]:<port> fait échouer le démarrage à moins que cette variable ne soit définie

Pour un collecteur dans le cluster, exposez-le en HTTPS à sa propre adresse interne, ou exécutez-le en tant que sidecar avec la variable définie.

Lorsque HTTPS_PROXY est défini, la passerelle envoie les exportations via ce proxy.

Pour atteindre directement un collecteur interne, ajoutez-le à NO_PROXY par nom d'hôte ou par un domaine avec un point initial comme .internal.example.com, ce qui nécessite Claude Code v2.1.277 ou ultérieur sur le serveur de passerelle. Assurez-vous que la passerelle peut atteindre le collecteur sans le proxy. Une entrée sans point initial correspond uniquement à ce nom exact, pas aux noms situés en dessous. Les plages CIDR ne correspondent pas.

Avec la sortie uniquement via proxy activée, autorisez plutôt le collecteur dans le proxy, car toute entrée NO_PROXY désactive la sortie uniquement via proxy.

La télémétrie est désactivée par défaut dans le CLI. Lorsque vous définissez à la fois telemetry.forward_to et listen.public_url, la passerelle l'active pour les clients connectés en poussant six variables d'environnement via /managed/settings :

  • CLAUDE_CODE_ENABLE_TELEMETRY=1
  • OTEL_METRICS_EXPORTER, OTEL_LOGS_EXPORTER et OTEL_TRACES_EXPORTER, chacune définie à otlp si au moins une destination forward_to active ce signal et à none sinon
  • OTEL_EXPORTER_OTLP_ENDPOINT=<public_url>
  • OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf

Lorsque vous ajoutez vos propres étiquettes, la passerelle pousse également OTEL_RESOURCE_ATTRIBUTES.

Avant Claude Code v2.1.265 sur le serveur de passerelle, la passerelle poussait les trois sélecteurs d'exportateur avec la valeur otlp, y compris pour les signaux qu'aucune destination n'avait activés.

L'endpoint poussé est construit à partir de l'URL publique, de sorte que les métriques et les logs n'ont besoin d'aucune configuration OTEL de la part des développeurs ou des politiques.

Les développeurs connectés via /login ne peuvent pas rediriger les exportations avec leur propre configuration OTEL :

  • Variables définies localement : Claude Code applique les variables poussées au niveau géré, de sorte que chacune remplace la valeur qu'un développeur définit localement.
  • Endpoints configurés localement : avec l'exportation OTLP/HTTP activée, le CLI ignore tout endpoint configuré localement, que la passerelle ait poussé ou non les variables de télémétrie. Ses exportations vont à la passerelle, à moins qu'une politique ne nomme votre collecteur comme endpoint.

Sans destination forward_to pour un signal, la passerelle l'accepte et l'ignore. Si des développeurs exportent déjà la télémétrie Claude Code vers l'un de vos collecteurs, ajoutez-le en tant que destination forward_to, avec les logs ou les traces activés s'ils les exportent, afin qu'il continue à recevoir leurs données après leur connexion. Pour plutôt ignorer le relais, nommez le collecteur dans une politique.

Les traces nécessitent également CLAUDE_CODE_ENHANCED_TELEMETRY_BETA=1 sur chaque client. Définissez-la dans le bloc env d'une politique gérée, car la passerelle ne la pousse pas. Les développeurs l'approuvent dans la même boîte de dialogue d'approbation de sécurité que l'endpoint poussé déclenche déjà.

Définissez-la à 1 uniquement dans les politiques dont vous voulez tracer les groupes. Une politique qui ne la définit pas hérite de la valeur de votre politique fourre-tout match: {} si celle-ci en définit une, selon les règles de fusion. Pour empêcher les clients d'un groupe d'envoyer des traces même lorsqu'un développeur définit la variable localement, définissez-la à 0 dans la politique de ce groupe.

Les encodages OTLP protobuf et JSON sont tous deux relayés, et tout backend compatible OpenTelemetry fonctionne comme destination.

Ajouter vos propres étiquettes

Pour placer des étiquettes fixes comme service.namespace ou deployment.environment.name sur la télémétrie des sessions connectées via la passerelle, définissez telemetry.resource_attributes. Chaque étiquette est un attribut de ressource OpenTelemetry, et chaque destination reçoit les mêmes étiquettes.

Les sessions obtiennent les étiquettes uniquement lorsque vous définissez également telemetry.forward_to et listen.public_url. Cet exemple ajoute deux étiquettes :

telemetry:
  forward_to:
    - url: https://otel-collector.internal.example.com
  resource_attributes:
    service.namespace: claude
    deployment.environment.name: prod

La passerelle refuse de démarrer lorsqu'une étiquette enfreint l'une de ces règles, et l'erreur de démarrage nomme l'étiquette :

  • Les noms utilisent uniquement des lettres, des chiffres, ., _ et -
  • Les noms ne sont pas réservés. Comparés sans tenir compte de la casse, les noms réservés sont tout ce qui commence par user., enduser. ou identity., plus service.name, service.version, claude.deployment_mode, host.arch, os.type, os.version et wsl.version
  • Les valeurs sont en ASCII imprimable non vide, sans espace et sans aucun de , ; = \ " %
  • Les valeurs comptent au maximum 255 caractères tels que la passerelle les compte après encodage en pourcentage, donc /, : et @ comptent chacun pour trois
  • Les valeurs sont du texte, donc mettez entre guillemets un nombre, true ou false

Vous avez besoin de Claude Code v2.1.281 ou ultérieur sur le serveur de passerelle pour définir telemetry.resource_attributes. Une passerelle antérieure refuse de démarrer lorsqu'elle trouve la clé. Mettez à niveau chaque réplica avant d'ajouter la clé, et supprimez la clé avant de revenir à une version antérieure.

Les sessions de terminal connectées via /login reçoivent les étiquettes sous la forme de OTEL_RESOURCE_ATTRIBUTES, poussée avec les autres variables de télémétrie. Si vous définissez OTEL_RESOURCE_ATTRIBUTES dans le bloc env d'une politique, les sessions de terminal auxquelles correspond cette politique obtiennent cette valeur à la place des étiquettes. Claude Desktop reçoit les étiquettes de la passerelle aux côtés de user.email et des autres attributs d'identité.

Claude Code copie également chaque étiquette sur chaque point de données de métrique, afin que vous puissiez filtrer les métriques par celle-ci dans un backend qui n'indexe pas les attributs de ressource. Pour désactiver cette copie, consultez Contrôle de la cardinalité des métriques.

Exporter directement vers votre collecteur

Pour que les sessions connectées via /login envoient la télémétrie directement à votre collecteur au lieu de passer par le relais, définissez OTEL_EXPORTER_OTLP_ENDPOINT sur l'URL de base https:// du collecteur dans le bloc env d'une politique gérée. Claude Code ajoute /v1/metrics, /v1/logs ou /v1/traces à l'URL que vous définissez, comme https://otel-collector.example.com:4318, et y exporte chaque signal via OTLP/HTTP. Nécessite Claude Code v2.1.265 ou ultérieur sur la machine de chaque développeur. Les clients antérieurs exportent via le relais.

Pour vous authentifier auprès du collecteur, définissez OTEL_EXPORTER_OTLP_HEADERS dans le même bloc env. Les sessions n'envoient jamais le jeton de session de passerelle du développeur à un collecteur nommé de cette façon.

Lorsque vous ajoutez ou modifiez cet endpoint dans une politique, Claude Code demande à chaque développeur de l'approuver dans la boîte de dialogue d'approbation de sécurité avant de l'appliquer dans une session interactive.

Claude Code vérifie l'endpoint avant d'exporter directement un signal, et conserve ce signal sur le relais lorsqu'une vérification échoue. Les vérifications incluent :

  • L'endpoint provient de la passerelle elle-même. Si vous définissez la même variable dans un profil MDM ou un managed-settings.json local, les exportations restent sur le relais.
  • L'URL utilise https://, ou http:// vers une adresse de bouclage
  • L'URL se résout en un chemin se terminant par /v1/<signal>, sans chaîne de requête ni fragment. Claude Code construit lui-même ce chemin à partir de la variable générique. Il utilise telle quelle une variable par signal comme OTEL_EXPORTER_OTLP_METRICS_ENDPOINT, donc incluez-y le chemin complet.
  • L'URL n'est pas l'hôte de la passerelle elle-même. Un endpoint adressé à la passerelle conserve le chemin du relais et son jeton de session.
  • Ni vous ni le développeur n'avez configuré otelHeadersHelper dans une quelconque source de paramètres. Avec un helper configuré, chaque signal reste sur le relais.

L'endpoint que vous nommez change uniquement la destination des exportations. Vous choisissez toujours quels signaux sont exportés avec les sélecteurs OTEL_*_EXPORTER.

L'endpoint seul n'active pas l'exportation, donc définissez également les variables qui l'activent, à moins que la passerelle ne les pousse déjà :

  • Si la passerelle pousse déjà les variables de télémétrie, elles couvrent l'activation, les sélecteurs et le protocole, et votre endpoint explicite remplace la valeur <public_url> poussée. Définissez vous-même un sélecteur OTEL_*_EXPORTER à otlp uniquement pour un signal qu'aucune destination forward_to n'active.
  • Si ce n'est pas le cas, définissez également CLAUDE_CODE_ENABLE_TELEMETRY=1, les sélecteurs OTEL_*_EXPORTER et OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf.

Lorsque le développeur se déconnecte, ou se connecte à une autre passerelle, les exportations vers le collecteur s'arrêtent et Claude Code abandonne chaque lot restant plutôt que de l'envoyer.

Quand une destination échoue

La passerelle ne met pas en mémoire tampon, ne réessaie pas et ne stocke pas la télémétrie, de sorte qu'elle abandonne une exportation qui n'atteint pas une destination plutôt que de la livrer en retard. Chaque destination réussit ou échoue indépendamment, et le client exportateur reçoit une réponse de succès dans tous les cas, de sorte qu'une livraison échouée n'apparaît que dans le journal de la passerelle.

Après cinq livraisons consécutives échouées vers une destination, la passerelle suspend le transfert vers celle-ci par périodes de 30 secondes, en journalisant chaque pause, jusqu'à ce qu'une livraison réussisse. Toute réponse d'erreur, délai d'expiration ou erreur de connexion compte comme une livraison échouée, sauf 400, 413, 415, 422 et 431, qui signifient que le collecteur a refusé le payload de cette exportation comme mal formé ou trop volumineux.

Un payload refusé ne fait ni avancer ni réinitialiser le compteur d'échecs : la passerelle continue de transférer vers la destination et journalise un avertissement nommant celle-ci et le statut, au premier refus de la destination puis tous les cent refus.

Réglage HTTP

Quatre blocs optionnels de niveau supérieur, access_control, limits, timeouts et rate_limits, règlent la surface HTTP. Les valeurs par défaut conviennent à la plupart des déploiements.

Bloc Clé Par défaut Description
access_control allow_cidrs / deny_cidrs vide Autorisation/refus des IP entrantes par adresse client, après résolution de trusted_proxies. deny_cidrs est vérifié en premier ; un client auquel il correspond est rejeté même si allow_cidrs correspond également. Si allow_cidrs n'est pas vide, la passerelle refuse par défaut. /healthz et /readyz sont exemptés de allow_cidrs. Lorsqu'un proxy de confiance envoie une entrée X-Forwarded-For qui n'est pas une adresse IP, le client réel est inconnu et la passerelle journalise une fois un avertissement indiquant ce qu'il faut vérifier. Lorsque l'une ou l'autre liste s'applique à la requête, elle la refuse avec 403 et la raison d'audit xff_unparseable. Lorsqu'aucune ne s'applique, elle sert la requête et utilise l'adresse propre du proxy comme IP client pour les limites de débit par IP et l'audit.
limits max_request_bytes 32 MiB Taille max du corps de requête entrante ; les requêtes trop volumineuses obtiennent 413 avant que le corps ne soit mis en mémoire tampon. Augmentez-la pour les requêtes contenant des fichiers ou images volumineux.
limits max_request_header_bytes non défini Lorsqu'il est défini, les en-têtes trop volumineux retournent 431
limits max_url_length non défini Lorsqu'il est défini, une URL trop longue retourne 414
timeouts upstream_ttfb_ms 120000 Attente max des en-têtes de réponse de l'upstream (temps jusqu'au premier octet). Le corps de la réponse est ensuite diffusé sans limite de durée. S'applique au chemin direct vers l'upstream Anthropic ; sur tous les autres fournisseurs, la passerelle attend jusqu'à une heure que la réponse commence.
rate_limits device_authorization.max / .window_seconds 30 / 600 Limite de débit par IP sur l'endpoint d'autorisation d'appareil non authentifié. Augmentez-la pour une grande organisation derrière une IP de sortie partagée ou un NAT. Déploiements à grande échelle montre comment la dimensionner. Ces limites s'appliquent uniquement au flux de connexion par octroi d'appareil, pas à l'inférence /v1/messages. Consultez Résistance à la force brute du code utilisateur.
rate_limits device_verify.max / .window_seconds 10 / 600 Limite de débit par IP sur les soumissions de user_code à /device. C'est ce qui empêche quelqu'un de deviner le code d'un autre développeur. Déploiements à grande échelle montre jusqu'où l'augmenter.

Si vous laissez les deux listes access_control vides, ce qui est la valeur par défaut, la passerelle sert n'importe quelle adresse client, de sorte que seul votre réseau restreint qui peut l'atteindre. C'est important car une passerelle peut pousser des paramètres gérés qui exécutent des commandes sur les machines des développeurs.

Tant que allow_cidrs est vide, la passerelle avertit à deux endroits, sans changer la façon dont elle répond à une requête :

  • Au démarrage : un avertissement dans le journal opérationnel recommande d'autoriser uniquement les plages privées 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 100.64.0.0/10, 127.0.0.0/8, ::1/128 et fc00::/7, plus toute autre plage interne depuis laquelle vos développeurs se connectent. Si vous liez la passerelle à une adresse de bouclage et ne définissez ni trusted_proxies ni public_url, comme en développement local, l'avertissement n'apparaît pas.
  • À l'exécution : la première fois qu'une requête arrive d'une adresse en dehors de ces plages privées, la passerelle journalise un avertissement et émet un événement d'audit access.public_client contenant l'IP du client. Les deux se déclenchent une fois par processus. Les adresses lien-local, 169.254.0.0/16 et fe80::/10, ne comptent pas comme publiques. La passerelle répond à /healthz et /readyz avant cette vérification, de sorte que les sondes de santé depuis des plages publiques ne la déclenchent pas.

Les deux signaux utilisent l'adresse client telle que la passerelle la résout. Si un équilibreur de charge, une redirection de port ou un tunnel relaie le trafic et n'est pas listé dans listen.trusted_proxies, la passerelle voit l'adresse du relais, qui est généralement privée, de sorte que ni l'avertissement à l'exécution ni une liste d'autorisation privée ne détectent le trafic relayé par celui-ci.

Derrière un tel front-end, définissez d'abord listen.trusted_proxies afin que la passerelle voie les adresses client réelles, et gardez dans tous les cas la passerelle et tout ce qui se trouve devant elle inaccessibles depuis l'Internet public.

`load_test_mode`

Le bloc load_test_mode vous permet de tester la charge d'une passerelle sans appeler de fournisseur de modèles. Lorsqu'il est activé, la passerelle construit et signe chaque requête au fournisseur comme d'habitude, l'abandonne au lieu de l'envoyer, et diffuse une réponse préenregistrée via son chemin de réponse normal. La réponse est un texte de remplissage qui commence par une phrase indiquant qu'elle est préenregistrée.

Nécessite Claude Code v2.1.282 ou ultérieur sur le serveur de passerelle. Une passerelle antérieure refuse de démarrer lorsqu'elle trouve la clé. Mettez à niveau chaque réplica avant d'ajouter le bloc, et supprimez le bloc avant de revenir à une version antérieure.

L'exemple ci-dessous active le mode avec les valeurs par défaut, une réponse d'environ 750 tokens de texte diffusée sur environ 10 secondes :

load_test_mode:
  enabled: true
  reply_tokens: 750     # roughly how many tokens of text each canned reply carries
  reply_seconds: 9.5    # how long a streamed reply takes
Champ Requis Description
enabled Oui true active le mode. false conserve vos valeurs dans le fichier avec le mode désactivé. La passerelle refuse de démarrer si le bloc est présent sans ce champ.
reply_tokens Non Par défaut 750. Nombre approximatif de tokens de texte que contient chaque réponse préenregistrée, un nombre entier de 1 à 100000.
reply_seconds Non Par défaut 9.5. Durée d'une réponse diffusée, de 0 à 600. 0 envoie la réponse entière d'un coup. Une réponse à une requête sans streaming revient toujours d'un coup.

Un test de charge dans ce mode couvre la passerelle, votre Postgres et tout ce qui se trouve devant la passerelle. Il ne couvre pas les limites, la vitesse ni le chemin réseau du fournisseur.

Aucune requête de modèle n'est envoyée au fournisseur, de sorte que le CPU par requête d'un réplica est une estimation et apparaît inférieur à celui de la production, qui chiffre également son trafic vers le fournisseur. Confirmez un nombre de réplicas avec un petit pilote auprès du vrai fournisseur. Avant v2.1.283, l'estimation apparaissait bien plus basse.

Lorsque le mode est activé, une requête peut porter un en-tête x-load-test-user contenant un nombre entier d'au plus sept chiffres. La passerelle compte chaque nombre comme un développeur distinct, avec l'e-mail et les groupes du développeur dont le jeton accompagnait la requête.

Donnez au déploiement de test de charge sa propre base de données vide, car la passerelle refuse de démarrer avec le mode activé sur une base de données dans laquelle un développeur a déjà dépensé quoi que ce soit.

Exemple complet

Cette configuration de référence complète exerce chaque section centrale ; les blocs de tuning HTTP conservent leurs valeurs par défaut. Copiez-la, supprimez ce dont vous n'avez pas besoin, et remplissez vos valeurs. La configuration dans le Démarrage rapide est une version minimale de celle-ci.

# Exécutez avec :
#   claude gateway --config gateway.yaml
#
# La verbosité du journal opérationnel est contrôlée par la variable
# d'environnement CLAUDE_GATEWAY_LOG_LEVEL
# (debug | info | warn | error ; par défaut info). debug
# enregistre également les noms de réclamations dans chaque id_token, pour le diagnostic groups_claim.
# Cela n'affecte pas les événements d'audit, qui sont toujours émis.

listen:
  host: 0.0.0.0
  port: 8080
  public_url: https://claude-gateway.internal.example.com
  # Omettez le bloc tls lors de l'exécution derrière une entrée qui termine TLS.
  # tls:
  #   cert: /certs/gateway.crt
  #   key: /certs/gateway.key
  # trusted_proxies:
  #   - 10.0.0.0/8

oidc:
  issuer: https://example.okta.com
  client_id: 0oa1example2
  client_secret: ${OIDC_CLIENT_SECRET}
  allowed_email_domains:
    - example.com
  # Requis lorsque l'émetteur est le serveur d'organisation Okta, dont les id_tokens
  # peuvent omettre l'e-mail et les groupes ; la passerelle les remplit à partir de /userinfo.
  userinfo_fallback: true
  # allowed_groups: [claude-code-users]
  # Okta émet des groupes uniquement lorsque la portée `groups` est demandée et que
  # le filtre de réclamation de groupes de l'application les autorise. La politique
  # des entrepreneurs ci-dessous correspond aux groupes, donc la portée est demandée ici.
  scopes: [openid, profile, email, offline_access, groups]
  # extra_auth_params: { access_type: offline, prompt: consent }  # Google
  # groups_claim: groups          # Rôles d'application Entra : utilisez `roles`
  # email_claim: email

session:
  jwt_secret: ${GATEWAY_JWT_SECRET}   # openssl rand -base64 32
  # ttl_hours: 1

store:
  postgres_url: ${GATEWAY_POSTGRES_URL}
  # max_connections: 5
  # connect_timeout_seconds: 5
  # readiness_grace_seconds: 300   # continuez à passer le contrôle de disponibilité lors d'un basculement de base de données

# Active /v1/organizations/spend_limits (reflète l'API Admin Anthropic)
# et l'application des limites de dépenses par développeur sur /v1/messages. Omettez pour désactiver.
# Les plafonds eux-mêmes sont définis via l'API admin, pas ici.
# admin:
#   write_keys:
#     - { id: terraform, key: "${GATEWAY_ADMIN_WRITE_KEY_TF}" }
#   read_keys:
#     - { id: reporting, key: "${GATEWAY_ADMIN_READ_KEY}" }
#   admin_groups: [platform-finops]
#   blocked_message: request an increase at https://go.example.com/claude-limits
#   # audit_retention_days: 365
#   # spend_retention_months: 13
#   # identity_retention_days: 90
#   # group_limit_mode: min

# enforcement:
#   fail_closed_on_error: false

# Testez en charge ce déploiement sans appeler un fournisseur de modèle. Jamais sur une
# passerelle que les développeurs utilisent : chaque demande reçoit une réponse en conserve.
# load_test_mode:
#   enabled: true
#   # reply_tokens: 750
#   # reply_seconds: 9.5

# Mesurez aux tarifs contractuels au lieu du prix catalogue USD. Nécessite admin: ou une
# politique managed:. Avec managed:, les mêmes tarifs vont également aux clients connectés.
# Les tarifs ci-dessous sont des espaces réservés, pas des prix de contrat réels.
# pricing:
#   multiplier: 0.85
#   overrides:
#     - { upstream: anthropic, model: claude-sonnet-4-6, input: 3.30, output: 16.50, cache_read: 0.33, cache_write: 4.125 }

upstreams:
  - provider: anthropic
    auth:
      api_key: ${ANTHROPIC_API_KEY}

  # - provider: bedrock
  #   region: us-east-1
  #   auth: {}

  # - provider: anthropicAws
  #   region: us-east-1
  #   workspace_id: wrkspc_...
  #   auth:
  #     api_key: ${ANTHROPIC_AWS_API_KEY}

  # - provider: vertex
  #   region: us-east5
  #   project_id: example-prod
  #   auth: {}

  # - provider: foundry
  #   resource: example-foundry
  #   auth: { use_azure_ad: true }

auto_include_builtin_models: true
models:
  - id: claude-opus-4-8
    label: Claude Opus 4.8
    upstream_model:
      anthropic: claude-opus-4-8
      # bedrock: us.anthropic.claude-opus-4-8
      # anthropicAws: claude-opus-4-8
      # vertex: claude-opus-4-8
      # foundry: <your-opus-deployment-name>
  - id: claude-sonnet-4-6
    label: Claude Sonnet 4.6
    upstream_model:
      anthropic: claude-sonnet-4-6
  - id: claude-haiku-4-5
    label: Claude Haiku 4.5
    upstream_model:
      anthropic: claude-haiku-4-5

managed:
  policies:
    - match: { groups: [contractors] }
      cli:
        availableModels: [claude-haiku-4-5]
        # Limitez l'option du sélecteur par défaut à availableModels au lieu de
        # la valeur par défaut du niveau, afin que les entrepreneurs n'obtiennent pas une erreur 400 sur la valeur par défaut.
        enforceAvailableModels: true
        # allow approuve automatiquement ces outils ; il ne bloque pas le reste.
        # Ajoutez des règles de refus pour restreindre les outils.
        permissions: { allow: [Read, Grep] }
    - match: {}
      cli:
        availableModels: [claude-opus-4-8, claude-sonnet-4-6, claude-haiku-4-5]
        permissions:
          allow: [Read, Grep, Bash, Edit]
          deny: ["WebFetch"]
        env: { HTTP_PROXY: http://proxy.example.com:8080 }

telemetry:
  forward_to:
    - url: https://otel.internal.example.com:4318
      headers:
        Authorization: Bearer ${OTEL_TOKEN}

Paramètres gérés côté client

Tout ce qui précède configure le serveur de passerelle. Pointer les machines des développeurs vers celui-ci est configuré séparément, sur chaque appareil, via les paramètres gérés de Claude Code. La passerelle ne peut pas pousser les clés de connexion elle-même, car ce sont elles qui disent au client où se trouve la passerelle.

Pour le CLI, définissez ces clés dans le managed-settings.json par système d'exploitation. Les deux clés de connexion acheminent chaque /login du développeur vers votre passerelle :

{
  "forceLoginMethod": "gateway",
  "forceLoginGatewayUrl": "https://claude-gateway.internal.example.com",
  "parentSettingsBehavior": "merge"
}

parentSettingsBehavior: "merge" maintient le fonctionnement de la livraison de la liste d'autorisation de sortie de Claude Desktop vers ses sessions Claude Code intégrées ; Deliver policy to Claude Desktop sessions explique le mécanisme et où l'opt-in doit se situer.

Pour empêcher les développeurs de contourner la passerelle avec une variable de fournisseur cloud ou un ANTHROPIC_BASE_URL personnel, ajoutez "allowedProviders": ["gateway"] au même fichier. Claude Code refuse alors chaque session sur la machine qui n'est pas configurée pour une passerelle Cloud, et n'admet une passerelle que lorsqu'il s'agit de celle que forceLoginGatewayUrl nomme ou d'une dont l'URL est définie par le bloc env du fichier comme ANTHROPIC_BASE_URL. claude gateway refuse de s'exécuter sur une machine qui définit la liste, donc gardez la clé hors de l'hôte de la passerelle. Voir l'entrée allowedProviders dans la référence des paramètres. Nécessite Claude Code v2.1.285 ou ultérieur.

Déployez le fichier managed-settings.json sur chaque appareil, généralement via votre plateforme MDM. Le chemin du fichier diffère selon la plateforme. Voir où chaque mécanisme stocke la stratégie.

Par défaut, une stratégie de registre sur Windows ou un plist de préférences gérées sur macOS remplace le fichier managed-settings.json plutôt que de le fusionner avec lui, à l'exception des clés d'exception et des vérifications entre sources ci-dessus. Les trois clés de cet extrait suivent la règle de source de priorité la plus élevée, donc les flottes qui livrent la stratégie via Group Policy ou les profils de configuration doivent placer les trois dans ce mécanisme à la place.

Pour Claude Desktop, définissez la clé bootstrapUrl dans la propre configuration gérée de Claude Desktop sur <listen.public_url>/user/bootstrap. Le flux de connexion et la stratégie par groupe correspondent alors à ceux du CLI une fois qu'une stratégie opte pour le serveur avec une clé desktop ; sans l'opt-in, /user/bootstrap retourne 404. Voir Claude Desktop overlay pour la moitié côté serveur.

Claude Code honore forceLoginGatewayUrl, gatewayInternalNetworks, et la valeur "gateway" de forceLoginMethod uniquement à partir d'une source gérée sur la machine : managed-settings.json, le plist macOS ou le registre HKLM Windows, ou un assistant de stratégie. Les définir dans le ~/.claude/settings.json personnel d'un développeur ou dans la charge utile de la passerelle ne configure pas la connexion à la passerelle.

Omettez forceLoginMethod et forceLoginOrgUUID de la charge utile. Claude Code lit toujours les deux clés à partir de la charge utile pour sa vérification des identifiants au démarrage, donc un développeur qui conserve une identifiant émis par Anthropic sur la machine obtient la sortie au démarrage décrite sous Administrator policy requires a Cloud gateway sign-in même après sa connexion.