Documentation 2026-07-28 23:57 UTC to 2026-07-29 19:02 UTC

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Passerelle Claude apps pour Amazon Bedrock, Claude Platform sur AWS, Google Cloud et Microsoft Foundry

6 

7> Exécutez Claude Code via Amazon Bedrock, Claude Platform sur AWS, Google Cloud ou Microsoft Foundry derrière une passerelle auto-hébergée avec authentification SSO, accès aux modèles par groupe et télémétrie OTLP.

8 

9<Note>

10 La passerelle Claude apps est conçue pour les organisations qui doivent — ou préfèrent — acheminer l'inférence via leur propre fournisseur cloud, par exemple pour respecter les exigences de [résidence des données](/docs/fr/claude-apps-gateway-deploy#compliance-posture). Si vous n'avez pas cette exigence et souhaitez accéder à d'autres fonctionnalités telles que l'approvisionnement SCIM ou Claude Code sur web et mobile, Claude Enterprise peut être un meilleur choix. Consultez la page de [disponibilité des fonctionnalités](/docs/fr/feature-availability) pour une comparaison complète de toutes les méthodes de déploiement.

11</Note>

12 

13Claude apps gateway est un service auto-hébergé qui se situe entre les clients Claude Code de vos développeurs et votre fournisseur de modèles. Les développeurs se connectent avec votre fournisseur d'identité (IdP) d'entreprise au lieu de détenir des clés API ou des identifiants cloud. La passerelle détient les identifiants en amont, applique l'accès aux modèles et les [paramètres gérés](/docs/fr/permissions#managed-settings) par groupe IdP, et relaye la télémétrie d'utilisation vers votre propre pile d'observabilité.

14 

15Elle est incluse dans le binaire `claude`, donc le même exécutable qui exécute Claude Code sur un ordinateur portable exécute le serveur de passerelle avec `claude gateway --config gateway.yaml`.

16 

17Cette page couvre :

18 

19* [Pourquoi Claude apps gateway](#why-claude-apps-gateway), ce qu'il ajoute par rapport à l'exécution de votre propre solution, et quand quelque chose d'autre convient mieux

20* Un [démarrage rapide](#quickstart) avec les [prérequis](#prerequisites) qui fait passer une passerelle de zéro à un développeur connecté

21* [Connecter les développeurs](#connect-developers), y compris la définition de l'URL de la passerelle via les paramètres gérés

22* [Disponibilité et limitations](#availability-and-limitations) couvrant les fonctionnalités Claude Code qui fonctionnent via la passerelle et ce que le serveur supporte

23 

24Les pages complémentaires approfondissent le sujet. La [référence de configuration](/docs/fr/claude-apps-gateway-config) couvre chaque option du fichier YAML que le démarrage rapide écrit, et le [guide de déploiement](/docs/fr/claude-apps-gateway-deploy) couvre la configuration par IdP, le déploiement Kubernetes et Cloud Run, et les opérations.

25 

26<h2 id="why-claude-apps-gateway">

27 Pourquoi Claude apps gateway

28</h2>

29 

30L'[aperçu de la passerelle](/docs/fr/gateways) couvre ce qu'une passerelle fait et pourquoi vous en exécuteriez une. Claude apps gateway est la propre passerelle d'Anthropic, intégrée au binaire `claude` et testée aux côtés de chaque version de Claude Code, elle transmet donc les en-têtes et les champs de requête que Claude Code envoie sans que les opérateurs maintiennent une liste d'autorisation distincte. Une fois déployée, elle vous donne :

31 

32* **Identifiants** : la clé API en amont ou l'identifiant cloud ne vit que dans votre infrastructure. Les développeurs s'authentifient avec SSO d'entreprise et reçoivent des jetons porteurs de courte durée, donc le déprovisionnement se fait dans votre IdP. Déprovisionner un utilisateur et son accès à la passerelle expire dans la durée de vie de la session, une heure par défaut.

33* **Contrôle d'accès** : vos groupes IdP correspondent à des listes d'autorisation de modèles et à des politiques de [paramètres gérés](/docs/fr/permissions#managed-settings). La passerelle applique l'accès aux modèles côté serveur, rejetant les demandes pour les modèles non accordés, et sélectionne la politique de paramètres gérés de chaque groupe, que l'interface de ligne de commande applique au [niveau des paramètres gérés](/docs/fr/settings#settings-precedence). Différentes équipes obtiennent différents modèles, outils et permissions, et un développeur ne peut pas remplacer ce que sa politique verrouille.

34* **Livraison des paramètres** : la passerelle livre les paramètres gérés aux clients connectés elle-même, remplaçant les [paramètres gérés par le serveur](/docs/fr/server-managed-settings) de la console d'administration claude.ai.

35* **Télémétrie** : chaque destination configurée, comme Datadog, Splunk ou ClickHouse, reçoit les [métriques OpenTelemetry Protocol (OTLP)](/docs/fr/monitoring-usage) avec les nombres de jetons, le modèle, l'identité de l'utilisateur et la latence par défaut, avec les journaux et les traces comme des options par destination.

36* **Routage en amont** : les clients parlent l'API Anthropic Messages à la passerelle, et la passerelle traduit pour chaque amont, qu'il s'agisse de Bedrock, de la [plateforme Claude sur AWS](/docs/fr/claude-platform-on-aws), de la plateforme Agent de Google Cloud, de Foundry ou de l'API Anthropic, avec basculement entre eux. Vous pouvez modifier les régions, les fournisseurs ou l'ordre de basculement sans que les développeurs le remarquent ou se reconfigurent.

37 

38<Frame>

39 <img src="https://mintcdn.com/claude-code/st9_ZQOFsZa3cKFl/images/claude-gateway-architecture.svg?fit=max&auto=format&n=st9_ZQOFsZa3cKFl&q=85&s=560770d8f49bbd6f1ca7090ed1f13c03" alt="Diagramme montrant les clients Claude Code se connectant via HTTPS avec des jetons porteurs à une passerelle Claude apps auto-hébergée dans votre infrastructure, qui connecte les utilisateurs à votre IdP, stocke l'état d'authentification dans PostgreSQL, relaye la télémétrie à votre collecteur OTLP et transmet l'inférence à Amazon Bedrock, Claude Platform on AWS, Google Cloud, Microsoft Foundry ou l'API Anthropic" width="760" height="320" data-path="images/claude-gateway-architecture.svg" />

40</Frame>

41 

42<Note>

43 Le plan de données de la passerelle n'envoie rien à l'infrastructure Anthropic sauf si l'API Anthropic est un amont configuré. Vous contrôlez où la télémétrie, les journaux d'audit, les paramètres gérés et l'identité IdP de vos développeurs vont, et la passerelle ne les envoie à Anthropic. Pour le trafic restant que le processus CLI peut envoyer et comment le fermer, voir [Posture de conformité](/docs/fr/claude-apps-gateway-deploy#compliance-posture).

44</Note>

45 

46Pour les fonctionnalités Claude Code qui fonctionnent via la passerelle et ce que le serveur lui-même supporte, voir [Disponibilité et limitations](#availability-and-limitations) ci-dessous. Pour les décisions telles que le coût, le contournement, l'exécution de plusieurs passerelles et les plates-formes sans serveur, voir le [guide de déploiement](/docs/fr/claude-apps-gateway-deploy#deployment).

47 

48<h3 id="other-gateway-implementations">

49 Autres implémentations de passerelle

50</h3>

51 

52Si vous exécutez déjà une passerelle LLM ou une passerelle API qui répond à vos besoins, continuez à l'utiliser ; [Autres passerelles LLM](/docs/fr/llm-gateway) couvre la configuration de Claude Code contre elle.

53 

54La [référence du protocole de passerelle](/docs/fr/llm-gateway-protocol) documente le contrat que Claude Code attend de toute passerelle : les points de terminaison qu'elle appelle, les en-têtes et les champs de corps à transmettre, et ce qui cesse de fonctionner quand ils sont supprimés. Une passerelle Claude apps en cours d'exécution sert un sur-ensemble de ce contrat à `GET /protocol`, ajoutant les points de terminaison spécifiques à Claude apps gateway pour la connexion SSO, la livraison des paramètres gérés et la télémétrie. Récupérez-le avec `curl https://claude-gateway.internal.example.com/protocol` à partir de n'importe quelle passerelle déployée, comme celle que le [démarrage rapide](#quickstart) ci-dessous produit.

55 

56Les modifications majeures du protocole sont annoncées à l'avance, mais la compatibilité rétroactive indéfinie n'est pas garantie.

57 

58<h2 id="quickstart">

59 Démarrage rapide

60</h2>

61 

62Ce démarrage rapide parcourt le chemin minimal : enregistrez un client OAuth dans votre IdP, écrivez un `gateway.yaml`, exécutez la passerelle aux côtés de Postgres avec Docker Compose, et vérifiez la connexion de bout en bout. Il utilise un amont Amazon Bedrock ; Claude Platform on AWS, Google Cloud's Agent Platform, Microsoft Foundry, et l'API Anthropic sont également supportés en échangeant le bloc `upstreams` comme indiqué dans la [référence de configuration](/docs/fr/claude-apps-gateway-config#upstreams). À la fin, vous avez une passerelle à laquelle un développeur peut se `/login`.

63 

64<Note>

65 **Déployez sur votre réseau privé.** Claude Code ne se connecte qu'à une passerelle dont l'adresse est privée. C'est un garde de sécurité, car une passerelle de confiance peut pousser des paramètres qui exécutent des commandes sur les machines des développeurs. Mettez la passerelle derrière un équilibreur de charge interne ou un VPN et donnez-lui un nom d'hôte qui ne se résout qu'à des adresses IP privées.

66 

67 Les points de terminaison de passerelle publique exploités par Anthropic sont l'exception : `/login` les accepte sur `https://`. Il s'agit d'un petit ensemble fixe de passerelles qu'Anthropic elle-même exploite ; ce ne sont pas une option de déploiement que vous pouvez sélectionner ou configurer. La liste est compilée dans Claude Code, donc aucune configuration ne peut ajouter un nom d'hôte à celle-ci et aucune passerelle que vous hébergez ne se qualifie pour l'exemption. {/* min-version: 2.1.206 */}Avant v2.1.206, `/login` rejetait ces points de terminaison comme toute autre adresse publique.

68</Note>

69 

70<h3 id="prerequisites">

71 Prérequis

72</h3>

73 

74Ayez ceci en place avant de commencer :

75 

76| Vous avez besoin | Détails |

77| -------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

78| Claude Code v2.1.195 ou ultérieur | La sous-commande `claude gateway` et le flux de connexion de la passerelle sont livrés dans v2.1.195. Les versions publiques antérieures ne les incluent pas. La machine exécutant le serveur de passerelle et la machine de chaque développeur doivent être sur v2.1.195 ou ultérieur ; exécutez `claude update` pour obtenir la dernière version. {/* min-version: 2.1.198 */}L'[amont Claude Platform on AWS](/docs/fr/claude-apps-gateway-config#claude-platform-on-aws) nécessite Claude Code v2.1.198 ou ultérieur sur le serveur de passerelle. |

79| Fournisseur d'identité OpenID Connect (OIDC) | Okta, Microsoft Entra ID, Google Workspace, Keycloak, ou Dex, ou tout autre IdP conforme à OIDC comme PingFederate. La passerelle exécute la découverte OIDC standard et le flux de code d'autorisation contre elle. SAML et LDAP ne sont pas supportés. |

80| PostgreSQL 14 ou ultérieur | Soutient le flux de connexion d'appareil, où le rappel du navigateur écrit et l'interface de ligne de commande d'interrogation lit, plus les compteurs de limite de débit. Tout Postgres géré fonctionne, y compris le plus petit niveau. Sans limites de dépenses configurées, la passerelle stocke quelques Ko d'état d'authentification de courte durée ; avec les [limites de dépenses](/docs/fr/claude-apps-gateway-spend-limits), elle détient également des tables de dépenses durables, d'audit et d'identité qui doivent être sauvegardées. TLS via `?sslmode=require` est recommandé. |

81| Amont du modèle | Identifiants Amazon Bedrock, identifiants Claude Platform on AWS, identifiants Google Cloud, une ressource Microsoft Foundry, ou une clé API Anthropic. Plusieurs ammonts sont supportés avec basculement. |

82| HTTPS | La passerelle doit être accessible via `https://` à partir des ordinateurs portables des développeurs et de tout navigateur utilisé pour la connexion ; la passerelle sert la page de vérification d'appareil sur le même écouteur. Fournissez un certificat TLS via `listen.tls`, ou exécutez derrière un ingress qui termine TLS et définissez `listen.public_url`. Une origine `http://` simple est acceptée uniquement sur la boucle locale, pour le développement local. |

83| Adresse de réseau privé | À `/login`, Claude Code exige que le nom d'hôte ou l'adresse IP de la passerelle ne se résolve qu'à des adresses privées : RFC 1918, CGNAT `100.64.0.0/10`, ULA IPv6 `fc00::/7`, ou boucle locale pour le développement local. La vérification s'exécute sur chaque adresse IP résolue, donc si une adresse à laquelle le nom se résout est publique, `/login` rejette l'URL. Si les machines des développeurs acheminent HTTPS via un proxy d'entreprise, la connexion exige également que l'hôte proxy se résolve à des adresses privées ; s'il ne le fait pas, ajoutez l'hôte de la passerelle à `NO_PROXY` pour que l'interface de ligne de commande se connecte directement. {/* min-version: 2.1.206 */}Les points de terminaison de passerelle exploités par Anthropic sont exemptés des vérifications d'adresse privée et de proxy : `/login` les accepte sur `https://` par correspondance exacte du nom d'hôte, donc l'exigence de réseau privé s'applique uniquement à une passerelle que vous hébergez vous-même. Avant v2.1.206, `/login` rejetait un point de terminaison exploité par Anthropic comme toute autre adresse publique. |

84| Runtime Linux | Le serveur de passerelle s'exécute uniquement sur le binaire Linux natif. macOS fonctionne pour le développement local. Windows n'est pas supporté comme plate-forme serveur. |

85 

86Le serveur de passerelle nécessite le binaire `claude` natif ; téléchargez une version épinglée comme décrit dans [Installer Claude Code](/docs/fr/setup). Le serveur utilise des fonctionnalités d'exécution qui ne sont pas disponibles quand Claude Code s'exécute sous Node. Si vous voyez `requires the native binary` au démarrage, passez à l'une des méthodes d'installation autonomes.

87 

88<h3 id="steps">

89 Étapes

90</h3>

91 

92<Steps>

93 <Step title="Enregistrez un client OAuth dans votre IdP">

94 Décidez d'abord du nom d'hôte de la passerelle, car l'URI de redirection doit le correspondre. Créez une nouvelle application web OIDC et définissez l'URI de redirection sur `https://claude-gateway.<your-domain>/oauth/callback`, où l'hôte est la même valeur que vous définissez comme [`listen.public_url`](/docs/fr/claude-apps-gateway-config#listen) à l'étape 3. Notez le `client_id` et le `client_secret`. Les instructions par IdP sont dans [Configuration du fournisseur d'identité](/docs/fr/claude-apps-gateway-deploy#identity-provider-setup).

95 </Step>

96 

97 <Step title="Provisionner une base de données PostgreSQL">

98 Tout Postgres 14 ou ultérieur fonctionne, y compris le plus petit niveau géré. La passerelle exécute ses propres migrations de schéma au démarrage, donc l'utilisateur de la base de données a besoin de la permission `CREATE TABLE`. Si votre politique de sécurité interdit DDL à partir de rôles d'application, pré-créez le schéma à la place ; voir [`store`](/docs/fr/claude-apps-gateway-config#store).

99 </Step>

100 

101 <Step title="Écrivez gateway.yaml">

102 Les secrets sont lus via l'expansion `${ENV_VAR}` pour que le fichier lui-même puisse vivre dans le contrôle de version. Utilisez un nom d'hôte `public_url` qui se résout à une adresse IP privée sur votre réseau, car `/login` rejette les adresses publiques. La configuration minimale a cinq sections, et tous les autres champs ont une valeur par défaut :

103 

104 ```yaml gateway.yaml theme={null}

105 listen:

106 host: 0.0.0.0

107 port: 8080

108 # Requis derrière tout proxy qui termine TLS. Utilisé pour l'IdP

109 # redirect_uri et le document de découverte.

110 public_url: https://claude-gateway.internal.example.com

111 

112 oidc:

113 issuer: https://login.example.com # doit servir /.well-known/openid-configuration

114 client_id: 0oa1example2

115 client_secret: ${OIDC_CLIENT_SECRET}

116 allowed_email_domains: [example.com] # rejeter les id_tokens en dehors de votre org

117 userinfo_fallback: true # pour les IdPs dont l'id_token omet email/groups ; inoffensif sinon

118 

119 session:

120 jwt_secret: ${GATEWAY_JWT_SECRET} # openssl rand -base64 32

121 ttl_hours: 1 # limite également la latence de révocation lors du déprovisionnement IdP

122 

123 store:

124 postgres_url: ${GATEWAY_POSTGRES_URL} # ajouter ?sslmode=require pour Postgres géré

125 

126 upstreams:

127 - provider: bedrock

128 region: us-east-1

129 auth: {} # vide : chaîne de credentials AWS par défaut

130 # (IRSA, rôle de tâche EC2/ECS, variables d'env, ~/.aws)

131 

132 # Les modèles sont traduits par amont automatiquement. Le catalogue intégré

133 # mappe claude-opus-4-8 à us.anthropic.claude-opus-4-8 et ainsi de suite pour chaque

134 # modèle Claude supporté par Bedrock. Définissez false et ajoutez une liste `models:` pour

135 # exposer uniquement des modèles spécifiques.

136 auto_include_builtin_models: true

137 ```

138 

139 Cette configuration est suffisante pour une boucle de connexion fonctionnelle avec le catalogue de modèles Bedrock par défaut. Une fois qu'elle s'exécute, ajoutez RBAC par groupe et paramètres gérés via [`managed.policies`](/docs/fr/claude-apps-gateway-config#managed), fan-out de télémétrie via [`telemetry`](/docs/fr/claude-apps-gateway-config#telemetry), et basculement multi-amont, ARNs de débit provisionné, ou régions non-US via [`models`](/docs/fr/claude-apps-gateway-config#models).

140 

141 <Note>

142 L'amont Bedrock a besoin d'un principal AWS avec `bedrock:InvokeModel` et `bedrock:InvokeModelWithResponseStream` sur les ARNs `inference-profile/us.anthropic.*` et les ARNs `foundation-model/anthropic.*` sous-jacents, et l'accès au modèle activé dans la console Bedrock pour les modèles Claude que vous voulez. Fournissez l'identifiant avec IRSA sur EKS, un rôle de tâche ECS, ou un profil d'instance EC2 plutôt que des clés statiques. La [référence `upstreams`](/docs/fr/claude-apps-gateway-config#upstreams) a les détails IAM complets, la matrice de credentials inter-cloud, et les blocs `auth` pour les autres fournisseurs.

143 </Note>

144 </Step>

145 

146 <Step title="Exécutez-le">

147 Construisez une image de conteneur autour du binaire `claude` qui répond aux [exigences d'image](/docs/fr/claude-apps-gateway-deploy#container-image), puis exécutez-la aux côtés de Postgres :

148 

149 ```yaml docker-compose.yaml theme={null}

150 services:

151 gateway:

152 image: <your-registry>/claude-gateway:<version>

153 ports: ["8080:8080"]

154 volumes: ["./gateway.yaml:/etc/claude/gateway.yaml:ro"]

155 environment:

156 OIDC_CLIENT_SECRET: ${OIDC_CLIENT_SECRET}

157 GATEWAY_JWT_SECRET: ${GATEWAY_JWT_SECRET}

158 GATEWAY_POSTGRES_URL: postgres://gw:pw@postgres/gateway

159 # Identifiants AWS : en production, omettez ceux-ci et utilisez un rôle d'instance.

160 # Pour les tests Compose locaux, transmettez les vôtres :

161 AWS_ACCESS_KEY_ID: ${AWS_ACCESS_KEY_ID}

162 AWS_SECRET_ACCESS_KEY: ${AWS_SECRET_ACCESS_KEY}

163 AWS_SESSION_TOKEN: ${AWS_SESSION_TOKEN}

164 depends_on:

165 postgres:

166 condition: service_healthy

167 postgres:

168 image: postgres:16-alpine

169 environment: { POSTGRES_USER: gw, POSTGRES_PASSWORD: pw, POSTGRES_DB: gateway }

170 healthcheck:

171 test: ["CMD-SHELL", "pg_isready -U gw"]

172 interval: 5s

173 volumes: ["pgdata:/var/lib/postgresql/data"]

174 volumes: { pgdata: }

175 ```

176 

177 La passerelle est un binaire Linux unique qui lit la configuration, exécute la découverte OIDC contre votre IdP, applique ses migrations de schéma Postgres, construit les clients en amont, et commence à écouter. Le démarrage échoue fermé pour la configuration, la connexion Postgres avec un délai d'attente de 5 secondes, la découverte OIDC, et la construction du client en amont. Si l'un de ceux-ci est inaccessible ou mal configuré, la passerelle se termine avec une erreur plutôt que de servir le trafic dans un état dégradé.

178 

179 Un démarrage réussi ne valide pas le chemin d'inférence, car les identifiants d'instance Bedrock et Agent Platform se résolvent à la première demande, pas au démarrage.

180 

181 Regardez stderr pour la séquence de démarrage. Les lignes de journal utilisent le format `[gateway] <timestamp> <level> <message>`, les événements d'audit sont JSON sur une seule ligne avec un champ `evt`, et une bannière de démarrage, omise ci-dessous, s'imprime entre les lignes de migration et d'écoute. Vous devriez voir, dans l'ordre :

182 

183 ```text theme={null}

184 {"ts":"2026-06-10T17:03:21.114Z","evt":"config.load","path":"/etc/claude/gateway.yaml","sha256":"…"}

185 [gateway] 2026-06-10T17:03:21.408Z info migration 1 applied

186 [gateway] 2026-06-10T17:03:21.512Z info claude gateway listening on http://0.0.0.0:8080

187 ```

188 

189 Si le démarrage se termine avant la ligne `claude gateway listening on`, la dernière ligne de stderr nomme le problème :

190 

191 * un Postgres inaccessible

192 * un rôle Postgres sans permission DDL

193 * un document de découverte OIDC inaccessible ou invalide

194 * une violation de schéma de configuration avec le chemin de champ offensant

195 

196 Corrigez-le et redémarrez.

197 

198 Si vous avez déjà un ingress qui termine TLS, ignorez Compose et exécutez le binaire directement avec `claude gateway --config gateway.yaml`. Définissez `public_url` sur l'origine de l'ingress et liez `listen` à une adresse de boucle locale ou interne au cluster.

199 </Step>

200 

201 <Step title="Vérifiez la surface d'authentification">

202 Trois vérifications confirment que la passerelle peut authentifier un utilisateur réel avant de la remettre à un développeur.

203 

204 Les exemples utilisent l'URL publique de la passerelle ; pour la configuration Compose locale sans ingress, remplacez `http://localhost:8080` dans les deux premières vérifications. La troisième vérification ouvre `verification_uri_complete`, qui est construite à partir de `public_url`, donc pour Compose local définissez `public_url: http://localhost:8080` dans `gateway.yaml`, et ajoutez `http://localhost:8080/oauth/callback` comme deuxième URI de redirection sur le client OAuth de l'étape 1, car la passerelle construit l'IdP `redirect_uri` à partir de `public_url`. Le lien de vérification s'ouvre alors dans votre navigateur local.

205 

206 Dans Windows PowerShell, exécutez `curl.exe` ; le `curl` nu est un alias pour `Invoke-WebRequest` et rejette ces drapeaux.

207 

208 Tout d'abord, récupérez le document de découverte, qui confirme que la passerelle est active, la configuration est valide, et tous les contrôles de démarrage ont réussi :

209 

210 ```bash theme={null}

211 curl -s https://claude-gateway.internal.example.com/.well-known/oauth-authorization-server | jq

212 ```

213 

214 ```json theme={null}

215 {

216 "issuer": "https://claude-gateway.internal.example.com",

217 "device_authorization_endpoint": "…/oauth/device_authorization",

218 "token_endpoint": "…/oauth/token",

219 "grant_types_supported": ["urn:ietf:params:oauth:grant-type:device_code", "refresh_token"]

220 }

221 ```

222 

223 La réponse inclut des champs supplémentaires, tels que `response_types_supported` et `scopes_supported`.

224 

225 Deuxièmement, demandez une autorisation d'appareil, qui confirme que le flux de connexion d'appareil fonctionne et que Postgres est accessible et inscriptible :

226 

227 ```bash theme={null}

228 curl -s -X POST https://claude-gateway.internal.example.com/oauth/device_authorization | jq

229 ```

230 

231 ```json theme={null}

232 {

233 "device_code": "…",

234 "user_code": "WDJB-MJHT",

235 "verification_uri": "https://claude-gateway.internal.example.com/device",

236 "verification_uri_complete": "https://claude-gateway.internal.example.com/device?user_code=WDJB-MJHT",

237 "expires_in": 600,

238 "interval": 5

239 }

240 ```

241 

242 Troisièmement, testez la jambe du navigateur en ouvrant `verification_uri_complete` dans un navigateur et en confirmant le code. Vous devriez être redirigé vers la page de connexion de votre IdP, et après vous être connecté, atterrir sur la passerelle avec une confirmation de connexion.

243 

244 Utilisez la première vérification défaillante pour localiser le problème :

245 

246 * **La première vérification échoue** : le démarrage n'a pas été complété ; vérifiez stderr

247 * **La deuxième vérification échoue** : Postgres n'est pas accessible à partir de la passerelle ou le rôle ne peut pas écrire ; vérifiez la chaîne de connexion et les permissions

248 * **La troisième vérification n'atteint pas l'IdP** : vérifiez que l'URI de redirection de l'IdP correspond exactement à `https://<gateway>/oauth/callback`

249 * **La troisième vérification atteint l'IdP mais rebondit avec une erreur** : lisez le journal d'audit de la passerelle, qui enregistre chaque rejet d'authentification avec la raison, comme `email domain not allowed`

250 </Step>

251 

252 <Step title="Connectez un développeur">

253 Cette dernière étape se produit sur une machine de développeur, pas le serveur. Définissez `forceLoginMethod` sur `"gateway"` et `forceLoginGatewayUrl` sur l'URL `public_url` de votre passerelle dans le [fichier de paramètres gérés](/docs/fr/settings#settings-files) de cette machine, puis exécutez `/login`, appuyez sur Entrée sur l'écran **Cloud gateway**, et complétez la connexion du navigateur. [Définir l'URL de la passerelle](#set-the-gateway-url) ci-dessous couvre la distribution des deux clés à grande échelle.

254 </Step>

255</Steps>

256 

257<h2 id="connect-developers">

258 Connecter les développeurs

259</h2>

260 

261Les développeurs se connectent à partir de leurs propres ordinateurs portables avec une seule connexion au navigateur, en utilisant leur compte professionnel d'entreprise. Ils n'ont pas besoin d'un compte claude.ai, d'une clé API ou d'un abonnement, car les demandes au modèle passent par la passerelle en utilisant l'identifiant en amont de l'organisation. La connexion est pilotée par les [paramètres gérés côté client](/docs/fr/claude-apps-gateway-config#client-side-managed-settings) que vous poussez via MDM, il n'y a donc pas de configuration manuelle du côté du développeur ; cette section couvre ce que l'administrateur configure.

262 

263L'interface de ligne de commande empreinte le certificat feuille TLS de la passerelle à la première connexion et l'épingle par nom d'hôte. Publiez l'empreinte SHA-256 attendue aux côtés de l'URL de la passerelle pour que les développeurs aient quelque chose à comparer. Obtenez l'empreinte du fichier de certificat avec `openssl x509 -noout -fingerprint -sha256 -in cert.pem` ; l'invite `/login` affiche les 16 premiers caractères du résumé en hexadécimal minuscule sans séparateurs.

264 

265Quand le certificat tourne, chaque développeur voit à nouveau l'invite de confiance, traitez donc les rotations comme un événement planifié et republier l'empreinte.

266 

267Une fois connecté, le [sélecteur de modèle](/docs/fr/model-config) affiche les modèles dans la liste d'autorisation `availableModels` du développeur, les paramètres gérés s'appliquent au démarrage et se rafraîchissent toutes les heures, et la télémétrie s'achemine vers votre collecteur. Les sessions se rafraîchissent silencieusement avant l'expiration de `ttl_hours`, et un rafraîchissement échoué après le déprovisionnement IdP invite à une reconnexion.

268 

269<h3 id="set-the-gateway-url">

270 Définir l'URL de la passerelle

271</h3>

272 

273Définissez les deux clés dans le fichier de [paramètres gérés](/docs/fr/settings#settings-files) par système d'exploitation que vous déployez via MDM ou directement sur le disque, et `/login` s'ouvre directement sur l'écran **Cloud gateway** avec l'URL remplie :

274 

275```json theme={null}

276{

277 "forceLoginMethod": "gateway",

278 "forceLoginGatewayUrl": "https://claude-gateway.internal.example.com"

279}

280```

281 

282Le développeur appuie sur Entrée pour se connecter. L'invite d'empreinte TLS de première connexion apparaît toujours.

283 

284Il n'y a pas d'option de passerelle dans le sélecteur de connexion pour qu'un développeur sélectionne manuellement, et `forceLoginGatewayUrl` est ignoré dans les fichiers de paramètres propres d'un développeur. `forceLoginMethod` seul, sans URL, laisse le développeur à un message « Contactez votre administrateur informatique ». Les deux clés appartiennent au fichier que vous poussez vers les machines, pas au bloc `managed.policies[].cli` de la passerelle, qui ne atteint que les clients déjà connectés.

285 

286<h3 id="ci-pipelines-and-remote-machines">

287 Pipelines CI et machines distantes

288</h3>

289 

290Il n'y a pas de flux de jeton de service pour les pipelines sans surveillance. La connexion à la passerelle exécute toujours le flux d'appareil du navigateur, donc un travail CI sans développeur pour approuver la connexion ne peut pas s'authentifier ; configurez ceux-ci directement contre votre fournisseur.

291 

292Une fois qu'un développeur s'est connecté, chaque invocation de Claude Code sur cette machine utilise la session de passerelle, y compris les exécutions non-interactives `claude -p` et les sessions démarrées par le SDK Agent, et la [politique de passerelle s'applique à tous](/docs/fr/claude-apps-gateway-config#managed).

293 

294Le flux d'appareil sépare l'interface de ligne de commande d'interrogation du navigateur approbateur, donc une boîte de développement distante sans affichage fonctionne toujours : le développeur exécute `/login` via SSH sur la machine distante et ouvre le lien de vérification dans le navigateur sur son ordinateur portable.

295 

296<h3 id="what’s-enforced-on-developers">

297 Ce qui est appliqué aux développeurs

298</h3>

299 

300Ces garanties s'appliquent à chaque session de passerelle connectée.

301 

302* **Accès au modèle** : les demandes pour les modèles que la politique n'accorde pas retournent 400, et le sélecteur `/model` est filtré à la liste d'autorisation `availableModels` de la politique. Définissez [`enforceAvailableModels: true`](/docs/fr/model-config#default-model-behavior) dans la politique pour que l'option Par défaut se résolve à un modèle à l'intérieur de `availableModels` au lieu du défaut intégré de Claude Code ; sans cela, Par défaut reste sélectionnable et est rejeté au moment de la demande si ce modèle n'est pas accordé.

303* **Destination de télémétrie** : quand le [transfert de télémétrie](/docs/fr/claude-apps-gateway-config#telemetry) est configuré, le point de terminaison d'export OTLP est épinglé à la passerelle, et la configuration poussée par la passerelle remplace les variables `OTEL_*` définies localement.

304* **Identifiants** : le jeton de passerelle est le seul identifiant de la session. `ANTHROPIC_AUTH_TOKEN`, `ANTHROPIC_API_KEY`, `apiKeyHelper`, et toute connexion claude.ai antérieure sont ignorés lors de la connexion, donc les développeurs n'ont pas besoin de se déconnecter de claude.ai d'abord.

305* **Paramètres gérés** : les clés verrouillées ne peuvent pas être remplacées localement. L'interface de ligne de commande applique la politique au démarrage et à chaque sondage horaire.

306* **Démarrage** : les sessions connectées se terminent au démarrage avec une erreur après environ 10 secondes quand la passerelle est inaccessible, plutôt que de démarrer sans leurs paramètres.

307* **Déprovisionnement** : une session dont l'utilisateur est désactivé dans l'IdP expire dans `ttl_hours` quand le prochain rafraîchissement échoue.

308 

309<h3 id="what-the-organization-can-see">

310 Ce que l'organisation peut voir

311</h3>

312 

313La télémétrie d'utilisation porte l'identité du développeur, les nombres de jetons, le modèle et la latence vers le collecteur de l'organisation. La passerelle ne journalise ni ne stocke le contenu des invites ou des complétions. Que la télémétrie plus riche comme les journaux et les traces soit collectée, qui peut inclure les commandes et les chemins de fichiers, est le [choix par destination](/docs/fr/claude-apps-gateway-config#telemetry) de l'organisation.

314 

315<h2 id="availability-and-limitations">

316 Disponibilité et limitations

317</h2>

318 

319Le tableau couvre les fonctionnalités Claude Code qui fonctionnent quand les développeurs se connectent via la passerelle, et ce que le serveur de passerelle lui-même supporte. Quand quelque chose n'est pas supporté, la colonne Notes donne l'alternative.

320 

321La passerelle livre les valeurs [`anthropic-beta`](https://platform.claude.com/docs/en/api/beta-headers) que l'interface de ligne de commande envoie à chaque amont, donc les opérateurs ne maintiennent pas une liste d'autorisation bêta. Pour Amazon Bedrock, qui ignore l'en-tête, la passerelle déplace les valeurs dans le champ `anthropic_beta` du corps de la demande ; les autres ammonts reçoivent l'en-tête tel qu'envoyé.

322 

323L'ensemble bêta de session de passerelle de l'interface de ligne de commande omet les bêtas propriétaires uniquement et la bêta extended-cache-ttl, c'est pourquoi ces lignes ci-dessous s'affichent comme non disponibles.

324 

325| Fonctionnalité | Statut | Notes |

326| ---------------------------------------------------------------------------------------------------------------------------- | -------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

327| Transfert d'inférence (Amazon Bedrock, Claude Platform on AWS, Agent Platform de Google Cloud, Microsoft Foundry, Anthropic) | Disponible | Avec traduction de modèle par amont et basculement. L'amont Amazon Bedrock utilise le point de terminaison `bedrock-runtime` et la chaîne de credentials AWS par défaut ; le [point de terminaison Mantle](/docs/fr/amazon-bedrock#use-the-mantle-endpoint) d'Amazon Bedrock n'est pas un amont supporté. L'[amont Claude Platform on AWS](/docs/fr/claude-apps-gateway-config#claude-platform-on-aws) nécessite Claude Code v2.1.198 ou ultérieur sur le serveur de passerelle. |

328| Accès au modèle et paramètres gérés par groupe IdP | Disponible | L'accès au modèle est appliqué côté serveur ; les paramètres gérés sont livrés par groupe IdP et appliqués par l'interface de ligne de commande au [niveau des paramètres gérés](/docs/fr/settings#settings-precedence) |

329| Fan-out de télémétrie (OTLP/HTTP) | Disponible | Identité-estampillé par export ; encodages protobuf et JSON |

330| Fournisseurs d'identité OIDC | Disponible | Tout IdP conforme à OIDC ; la passerelle exécute la découverte OIDC standard et le flux du code d'autorisation. Voir [Configuration du fournisseur d'identité](/docs/fr/claude-apps-gateway-deploy#identity-provider-setup) pour la configuration par IdP |

331| Limites de dépenses par utilisateur et par groupe | Disponible | Voir [Limites de dépenses](/docs/fr/claude-apps-gateway-spend-limits) |

332| Recherche web côté serveur | Non disponible | L'interface de ligne de commande ne peut pas voir quel fournisseur en amont la passerelle achemine vers, donc elle ne peut pas vérifier le support de la recherche web et désactive WebSearch sur les sessions de passerelle |

333| Mise en cache des invites standard | Disponible | Les points d'arrêt `cache_control` sont transférés à chaque amont |

334| TTL de cache d'1 heure | Non disponible | L'interface de ligne de commande omet la bêta extended-cache-ttl sur les sessions de passerelle, car pas tous les ammonts vers lesquels la passerelle peut acheminer supportent le TTL d'1 heure, donc la mise en cache des invites via la passerelle utilise le TTL de 5 minutes ; voir la note sur l'en-tête bêta ci-dessus |

335| Mode Auto | Disponible | Suit les [règles du fournisseur tiers](/docs/fr/permission-modes#enable-auto-mode-on-bedrock-agent-platform-or-foundry) : seuls les modèles éligibles sur les fournisseurs tiers peuvent l'utiliser. {/* min-version: 2.1.207 */}Avant v2.1.207, le mode auto sur les sessions de passerelle nécessitait de définir `CLAUDE_CODE_ENABLE_AUTO_MODE=1`, livrable via le bloc `env` de la politique gérée |

336| Optimisations propriétaires uniquement comme la portée du cache global et les outils efficaces en jetons | Non disponible | L'interface de ligne de commande ne les active pas sur les sessions de passerelle ; voir la note sur l'en-tête bêta ci-dessus |

337| OTLP/gRPC | Non supporté | OTLP sur HTTP uniquement |

338| SAML, LDAP et autres authentifications non-OIDC | Non supporté | OIDC uniquement. Frontal avec un pont OIDC si nécessaire |

339| Multi-locataire (plusieurs émetteurs OIDC) | Non supporté | Un émetteur par passerelle. Exécutez des instances séparées |

340| Serveur Windows | Non supporté | Déployez sur Linux. macOS pour le développement local uniquement |

341| Graphique Helm | Non disponible | La passerelle s'exécute comme un Deployment sans état standard ; voir le [guide de déploiement](/docs/fr/claude-apps-gateway-deploy#kubernetes) |

342| Interface utilisateur d'administration | Non disponible | La configuration est le fichier YAML ; redéployez pour le modifier |

343 

344<h2 id="next-steps">

345 Prochaines étapes

346</h2>

347 

348Le démarrage rapide vous laisse avec une configuration minimale s'exécutant sous Docker Compose. Pour aller plus loin :

349 

350* Développez `gateway.yaml` au-delà de la configuration minimale, par exemple pour ajouter RBAC par groupe, basculement multi-amont, ou destinations de télémétrie. La [référence de configuration](/docs/fr/claude-apps-gateway-config) couvre chaque option.

351* Passez de Compose à un déploiement de production sur Kubernetes ou Cloud Run, configurez correctement votre IdP, et examinez le modèle de sécurité. Le [guide de déploiement et d'opérations](/docs/fr/claude-apps-gateway-deploy) couvre la configuration par IdP, les exigences d'image de conteneur, les sondes de santé et le dépannage.

352* Mettez des plafonds de dépenses sur les développeurs individuels ou les groupes pour qu'une charge de travail incontrôlée ne puisse pas consommer tout votre engagement. [Limites de dépenses](/docs/fr/claude-apps-gateway-spend-limits) couvre l'API d'administration et le fonctionnement de l'application.

353* Pour un exemple complet travaillé sur Google Cloud, avec Cloud Run, Cloud SQL et Secret Manager, voir [Déployer sur Google Cloud](/docs/fr/claude-apps-gateway-on-gcp).

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Exécuter Claude Code via un lanceur d'entreprise

6 

7> Acheminez les processus que Claude Code démarre à partir de son propre binaire, y compris le service d'arrière-plan et chaque session de vue agent, via un lanceur obligatoire avec CLAUDE_CODE_PROCESS_WRAPPER.

8 

9Certaines organisations exigent que chaque processus sur une station de travail démarre via un lanceur obligatoire. Le lanceur applique le bac à sable, les contrôles réseau ou l'injection de credentials dont dépend la posture de sécurité de l'entreprise, et un binaire qui démarre sans cela constitue une violation de politique.

10 

11`CLAUDE_CODE_PROCESS_WRAPPER` démarre chaque processus que Claude Code lance à partir de son propre binaire via votre lanceur : le service d'arrière-plan, chaque session qu'il héberge dans la [vue agent](/docs/fr/agent-view), et les relanceurs de Claude Code après une mise à jour. Définissez-le sur le chemin absolu de votre lanceur, et Claude Code exécute le lanceur avec la commande Claude Code comme arguments.

12 

13Un lanceur qui enveloppe la commande `claude` sur votre `PATH` ne peut pas atteindre ces processus, car ils démarrent à partir du chemin direct du binaire sans consulter `claude`.

14 

15<Note>

16 `CLAUDE_CODE_PROCESS_WRAPPER` nécessite Claude Code v2.1.208 ou ultérieur. Les versions antérieures ignorent la variable et démarrent chaque processus sans enveloppe.

17</Note>

18 

19<h2 id="what-the-launcher-covers">

20 Ce que le lanceur couvre

21</h2>

22 

23Avec `CLAUDE_CODE_PROCESS_WRAPPER` défini, Claude Code démarre chacun des processus suivants via votre lanceur :

24 

25* Le service d'arrière-plan que `claude agents` et les sessions d'arrière-plan démarrent à la demande.

26* L'hôte terminal et la session Claude Code à l'intérieur de chaque ligne de vue agent, y compris les sessions de secours à chaud que le service maintient prêtes.

27* Les sessions que le service redémarre après une mise à jour ou un plantage.

28* Le relancement que Claude Code effectue de lui-même pour terminer l'installation d'une mise à jour, y compris l'action de redémarrage pour mise à jour de la vue agent.

29 

30Sur Windows, la variable est ignorée : le contrat du lanceur dépend de `exec`, que Windows ne supporte pas. Une machine Windows avec la variable définie exécute chaque processus sans enveloppe et continue de fonctionner, et le seul signal est un avertissement dans le [journal de débogage](/docs/fr/troubleshooting). Si votre politique de lanceur couvre Windows, la variable ne la satisfait pas là : comptez les machines Windows comme non enveloppées lorsque vous planifiez le déploiement.

31 

32<h3 id="processes-that-start-outside-the-launcher">

33 Processus qui démarrent en dehors du lanceur

34</h3>

35 

36Trois processus ne démarrent jamais via le lanceur :

37 

38* Un [service d'arrière-plan installé](/docs/fr/agent-view#the-supervisor-process) : `launchd` ou `systemd` démarre ce processus à partir de son fichier d'unité. `/status` et `claude daemon status` avertissent quand cela s'applique, et les sessions que le service génère démarrent toujours via le lanceur une fois que le service redémarre avec la variable dans ses paramètres.

39* Une session que vous démarrez vous-même dans un terminal, qui s'exécute comme vous l'avez invoquée. Pour couvrir ces sessions, mettez un script nommé `claude` dans un répertoire plus tôt sur `PATH` qui exécute votre lanceur avec le vrai binaire ; ne remplacez pas le lien symbolique géré. Les auto-générations ne consultent pas `PATH`, donc les deux lanceurs ne s'empilent jamais.

40* Le premier processus d'un lien profond `claude-cli://`, que le gestionnaire de protocole du système d'exploitation démarre directement. Tout ce que cette session démarre en arrière-plan par la suite s'exécute via le lanceur. Pour fermer complètement ce chemin, [empêchez l'enregistrement du gestionnaire](/docs/fr/deep-links#registration-and-supported-platforms) avec le paramètre `disableDeepLinkRegistration`.

41 

42<h3 id="helper-process-names-in-process-monitors">

43 Noms des processus d'aide dans les moniteurs de processus

44</h3>

45 

46Avec un lanceur configuré, `ps` et Activity Monitor affichent le nom du binaire versionné pour les processus d'aide d'arrière-plan au lieu des étiquettes `claude bg-pty-host` et `claude bg-spare` de Claude Code, car le `exec` du lanceur reconstruit la liste d'arguments. Le renommage est un effet secondaire, pas une dissimulation : les processus sont autrement inchangés, et Claude Code identifie ses propres processus par chemin binaire, jamais par nom d'affichage.

47 

48<h2 id="set-up-the-launcher">

49 Configurer le lanceur

50</h2>

51 

52<Steps>

53 <Step title="Écrire le script du lanceur">

54 Créez un script exécutable à un chemin absolu, tel que `/opt/corp/launcher`. Claude Code l'exécute avec la commande Claude Code complète comme arguments, et le script doit se terminer en appelant `exec "$@"` pour qu'il se remplace par Claude Code :

55 

56 ```bash theme={null}

57 #!/bin/sh

58 # Configuration de votre organisation : entrez dans le bac à sable, appliquez

59 # les contrôles réseau ou injectez les credentials.

60 exec "$@"

61 ```

62 

63 Rendez-le exécutable avec `chmod +x`. La partie configuration est tout ce que votre lanceur doit faire avant que Claude Code s'exécute ; [le contrat du lanceur](#the-launcher-contract) ci-dessous énumère les règles que le script doit suivre.

64 

65 <Note>

66 Si vous avez précédemment remplacé le lien symbolique `~/.local/bin/claude` par votre lanceur, restaurez le lien symbolique d'origine dans le même changement. Un lien symbolique remplacé fait démarrer la première session enveloppée du service d'arrière-plan via les deux lanceurs à la fois, et cela met l'installation dans un état géré en externe : `/doctor` le signale, la mise à jour automatique laisse le fichier en place, et le nettoyage des anciennes versions reste désactivé jusqu'à ce que l'installateur gère à nouveau ce chemin.

67 </Note>

68 </Step>

69 

70 <Step title="Définir CLAUDE_CODE_PROCESS_WRAPPER dans les paramètres">

71 Définissez la variable dans le bloc `env` d'un fichier de paramètres pour que le service d'arrière-plan détaché l'hérite. Un `export` shell n'est pas suffisant : le service d'arrière-plan démarre à la demande, survit à votre shell et ne relit jamais les profils shell.

72 

73 Pour une machine, ajoutez-le à `~/.claude/settings.json`. Pour le déployer sur chaque machine de votre organisation, mettez le même bloc dans les [paramètres gérés](/docs/fr/permissions#managed-settings) :

74 

75 ```json theme={null}

76 {

77 "env": {

78 "CLAUDE_CODE_PROCESS_WRAPPER": "/opt/corp/launcher"

79 }

80 }

81 ```

82 

83 Quand plus d'une source définit la variable, la valeur des paramètres gérés remplace à la fois `~/.claude/settings.json` et une valeur exportée dans le shell, donc les utilisateurs ne peuvent pas pointer les auto-générations vers un lanceur différent.

84 

85 Les paramètres de projet et locaux ne peuvent pas définir cette variable. Un fichier validé dans un référentiel ne doit pas pouvoir mettre un binaire devant chaque processus Claude Code sur la machine, donc `CLAUDE_CODE_PROCESS_WRAPPER` dans `.claude/settings.json` ou `.claude/settings.local.json` est ignoré, avec un avertissement dans le [journal de débogage](/docs/fr/troubleshooting).

86 </Step>

87 

88 <Step title="Redémarrer le service d'arrière-plan et vos sessions">

89 Un service d'arrière-plan en cours d'exécution et toute session `claude` ouverte lisent la variable une fois au démarrage, donc ils continuent de lancer des processus sans enveloppe jusqu'au redémarrage. Exécutez `claude daemon stop --any` pour arrêter le service à la demande ; la commande suivante qui en a besoin, comme `claude agents`, en démarre un enveloppé. Un [service installé](/docs/fr/agent-view#the-supervisor-process) prend `claude daemon stop` sans `--any`. Ensuite, redémarrez vos sessions `claude` ouvertes.

90 

91 Sur les machines que vous ne pouvez pas redémarrer manuellement, la première session démarrée après le push des paramètres retire automatiquement un service à la demande sans enveloppe restant. Une machine où aucune nouvelle session ne démarre garde son service sans enveloppe jusqu'à ce qu'une le fasse, et un service installé a toujours besoin du redémarrage dans cette étape.

92 </Step>

93 

94 <Step title="Vérifier">

95 Exécutez `/status` dans une session : l'entrée Self-exec affiche la commande de lancement résolue et avertit quand le service d'arrière-plan en cours d'exécution ne correspond pas. `claude daemon status` imprime les mêmes informations depuis le shell, y compris après que vous ayez annulé la variable, quand `/status` n'affiche plus l'entrée.

96 </Step>

97</Steps>

98 

99<h2 id="the-launcher-contract">

100 Le contrat du lanceur

101</h2>

102 

103Quand le lanceur ne peut pas s'exécuter, Claude Code refuse de démarrer le processus au lieu de le démarrer sans enveloppe. Sur Windows, [la variable est ignorée](#what-the-launcher-covers) et les processus démarrent sans enveloppe. Claude Code tient le script à ces règles :

104 

105* **Terminez par `exec "$@"`**. Un lanceur qui crée un enfant et se termine laisse un processus Claude Code orphelin que le service d'arrière-plan ne peut pas suivre. La vue agent marque une telle session comme échouée avec un message nommant le lanceur, et le service récolte ce que le lanceur a laissé derrière.

106* **Ne réordonnez pas, n'absorbez pas et ne préparez pas les arguments.** Le premier argument est le binaire Claude Code et tout ce qui suit est son argv.

107* **Passez chaque variable d'environnement héritée via `exec`.** Ajouter des variables, comme les credentials injectées, est correct ; supprimer les héritées ne l'est pas.

108 * Les jetons d'authentification par session, la sélection du modèle et du fournisseur, et `CLAUDE_CODE_PROCESS_WRAPPER` lui-même voyagent tous sur l'environnement hérité, donc un lanceur qui le reconstruit à partir d'une liste d'autorisation casse les sessions qu'il démarre, et `/status` signale une non-correspondance du lanceur.

109 * Si le lanceur doit entrer dans un espace de noms ou un bac à sable qui réinitialise l'environnement, réexportez l'environnement hérité à l'intérieur verbatim.

110* **Atteignez `exec` en environ trois secondes chaque fois que le lanceur s'exécute.** Une expédition d'arrière-plan à froid exécute le lanceur deux fois en série avant le premier octet de sortie, donc faites un travail lent comme un échange d'authentification unique paresseusement ou à partir d'un cache.

111 * Un lanceur qui s'exécute bien au-delà du budget est traité comme un démarrage bloqué et redémarré.

112* **Tolérez d'être invoqué de l'intérieur de vous-même.** Claude Code applique le lanceur à chaque auto-génération imbriquée, donc un lanceur qui acquiert une ressource exclusive doit détecter qu'il la détient déjà.

113* **N'écrivez pas sur le terminal avant que Claude Code ne démarre.** Tout ce qui est imprimé avant le `exec` est signalé comme la cause du plantage si la session meurt avant l'initialisation.

114 

115<h3 id="format-of-the-claude_code_process_wrapper-value">

116 Format de la valeur `CLAUDE_CODE_PROCESS_WRAPPER`

117</h3>

118 

119Pour la plupart des lanceurs, la valeur est simplement le chemin absolu du script, comme `/opt/corp/launcher`.

120 

121Pour passer à votre lanceur ses propres arguments, écrivez-les après le chemin. Claude Code analyse la valeur comme une liste d'arguments, pas une commande shell :

122 

123* L'espace blanc sépare les jetons, et les guillemets doubles groupent un jeton qui contient des espaces.

124* Une valeur qui commence par `[` est lue comme un tableau de chaînes JSON, comme `["/opt/corp/launcher", "--profile", "cc"]`.

125* La syntaxe shell ne fonctionne pas : il n'y a pas d'expansion de variable ou de globbing, et un opérateur non cité comme `;`, `|`, `&` ou `$(` est rejeté comme une erreur de configuration plutôt que réinterprété.

126 

127Quand la valeur ne peut pas être utilisée, Claude Code refuse de démarrer le processus affecté et [signale la raison](/docs/fr/errors#claude_code_process_wrapper-launcher-errors).

128 

129<h2 id="relationship-to-claude_code_shell_prefix">

130 Relation avec `CLAUDE_CODE_SHELL_PREFIX`

131</h2>

132 

133`CLAUDE_CODE_PROCESS_WRAPPER` enveloppe les propres processus de Claude Code et passe la commande via des jetons argv séparés pour que le lanceur `exec`. [`CLAUDE_CODE_SHELL_PREFIX`](/docs/fr/env-vars) enveloppe les commandes shell que Claude Code exécute en votre nom, comme les appels d'outil Bash, les hooks et les commandes qui démarrent les serveurs MCP stdio, et passe chacun comme une seule chaîne entre guillemets shell dans `$1` pour que le wrapper la réévalue. Un lanceur écrit pour l'un ne fonctionne pas comme l'autre.

134 

135<h2 id="related-resources">

136 Ressources connexes

137</h2>

138 

139* [Vue agent](/docs/fr/agent-view) : les sessions d'arrière-plan et le processus superviseur que le lanceur couvre

140* [Variables d'environnement](/docs/fr/env-vars) : l'entrée de référence `CLAUDE_CODE_PROCESS_WRAPPER`

141* [Paramètres gérés](/docs/fr/permissions#managed-settings) : livrez le bloc `env` sur une flotte

142* [Référence d'erreur du lanceur](/docs/fr/errors#claude_code_process_wrapper-launcher-errors) : les messages de refus et comment récupérer

12 12 

13<Warning>13<Warning>

14 Bien que le dev container offre des protections substantielles, aucun système n'est complètement immunisé contre toutes les attaques.14 Bien que le dev container offre des protections substantielles, aucun système n'est complètement immunisé contre toutes les attaques.

15 Lorsqu'il est exécuté avec `--dangerously-skip-permissions`, les dev containers n'empêchent pas un projet malveillant d'exfiltrer quoi que ce soit d'accessible à l'intérieur du conteneur, y compris les identifiants Claude Code stockés dans [`~/.claude`](/fr/claude-directory).15 Lorsqu'il est exécuté avec `--dangerously-skip-permissions`, les dev containers n'empêchent pas un projet malveillant d'exfiltrer quoi que ce soit d'accessible à l'intérieur du conteneur, y compris les identifiants Claude Code stockés dans [`~/.claude`](/docs/fr/claude-directory).

16 Utilisez les dev containers uniquement lors du développement avec des référentiels de confiance, et surveillez les activités de Claude.16 Utilisez les dev containers uniquement lors du développement avec des référentiels de confiance, et surveillez les activités de Claude.

17 Évitez de monter les secrets de l'hôte tels que `~/.ssh` ou les fichiers d'identifiants cloud dans le conteneur ; préférez les jetons limités au référentiel ou à courte durée de vie.17 Évitez de monter les secrets de l'hôte tels que `~/.ssh` ou les fichiers d'identifiants cloud dans le conteneur ; préférez les jetons limités au référentiel ou à courte durée de vie.

18</Warning>18</Warning>

20<Accordion title="Comment les dev containers fonctionnent avec votre éditeur">20<Accordion title="Comment les dev containers fonctionnent avec votre éditeur">

21 <img src="https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture.svg?fit=max&auto=format&n=YvJyjZfd9yMihr0i&q=85&s=9017b1d16a446c6cc37ba562f35b9aae" className="dark:hidden" alt="Diagramme montrant un éditeur sur l'hôte se connectant à un dev container Docker. Claude Code, le terminal et les outils de compilation s'exécutent à l'intérieur du conteneur. Le référentiel hôte est monté en bind dans le conteneur en tant qu'espace de travail." width="640" height="300" data-path="images/devcontainer-architecture.svg" />21 <img src="https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture.svg?fit=max&auto=format&n=YvJyjZfd9yMihr0i&q=85&s=9017b1d16a446c6cc37ba562f35b9aae" className="dark:hidden" alt="Diagramme montrant un éditeur sur l'hôte se connectant à un dev container Docker. Claude Code, le terminal et les outils de compilation s'exécutent à l'intérieur du conteneur. Le référentiel hôte est monté en bind dans le conteneur en tant qu'espace de travail." width="640" height="300" data-path="images/devcontainer-architecture.svg" />

22 22 

23 <img src="https://mintcdn.com/claude-code/YvJyjZfd9yMihr0i/images/devcontainer-architecture-dark.svg?fit=max&auto=format&n=YvJyjZfd9yMihr0i&q=85&s=ef00c8e25b1ea7a3a152895f1488831b" className="hidden dark:block" alt="Diagramme montrant un éditeur sur l'hôte se connectant à un dev container Docker. Claude Code, le terminal et les outils de compilation s'exécutent à l'intérieur du conteneur. Le référentiel hôte est monté en bind dans le conteneur en tant qu'espace de travail." width="640" height="300" data-path="images/devcontainer-architecture-dark.svg" />23 <img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/devcontainer-architecture-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=a0a340b1f2afc6a590696102c8acaaca" className="hidden dark:block" alt="Diagramme montrant un éditeur sur l'hôte se connectant à un dev container Docker. Claude Code, le terminal et les outils de compilation s'exécutent à l'intérieur du conteneur. Le référentiel hôte est monté en bind dans le conteneur en tant qu'espace de travail." width="640" height="300" data-path="images/devcontainer-architecture-dark.svg" />

24 24 

25 Un dev container s'exécute en tant que conteneur Docker, soit sur votre machine, soit sur un hôte cloud tel que GitHub Codespaces. Un éditeur qui prend en charge la spécification Dev Containers, tel que VS Code, GitHub Codespaces, un IDE JetBrains ou Cursor, se connecte à ce conteneur : vous parcourez et modifiez les fichiers dans l'éditeur comme d'habitude, mais le terminal intégré, les serveurs de langage et les outils de compilation s'exécutent tous à l'intérieur du conteneur plutôt que sur votre hôte. Les éditeurs sans support de dev container, tels que Vim simple, ne font pas partie de ce flux de travail.25 Un dev container s'exécute en tant que conteneur Docker, soit sur votre machine, soit sur un hôte cloud tel que GitHub Codespaces. Un éditeur qui prend en charge la spécification Dev Containers, tel que VS Code, GitHub Codespaces, un IDE JetBrains ou Cursor, se connecte à ce conteneur : vous parcourez et modifiez les fichiers dans l'éditeur comme d'habitude, mais le terminal intégré, les serveurs de langage et les outils de compilation s'exécutent tous à l'intérieur du conteneur plutôt que sur votre hôte. Les éditeurs sans support de dev container, tels que Vim simple, ne font pas partie de ce flux de travail.

26 26 

27 Claude Code s'exécute à l'intérieur du conteneur, il voit donc les mêmes fichiers, dépendances et outils que le reste de la chaîne d'outils de votre projet. Dans VS Code, vous pouvez utiliser soit le [panneau d'extension Claude Code](/fr/vs-code), soit exécuter `claude` dans le terminal intégré ; les deux s'exécutent à l'intérieur du conteneur et partagent la même configuration `~/.claude`.27 Claude Code s'exécute à l'intérieur du conteneur, il voit donc les mêmes fichiers, dépendances et outils que le reste de la chaîne d'outils de votre projet. Dans VS Code, vous pouvez utiliser soit le [panneau d'extension Claude Code](/docs/fr/vs-code), soit exécuter `claude` dans le terminal intégré ; les deux s'exécutent à l'intérieur du conteneur et partagent la même configuration `~/.claude`.

28</Accordion>28</Accordion>

29 29 

30<h2 id="add-claude-code-to-your-dev-container">30<h2 id="add-claude-code-to-your-dev-container">

75Ce que vous voyez à l'invite d'authentification dépend de votre fournisseur :75Ce que vous voyez à l'invite d'authentification dépend de votre fournisseur :

76 76 

77* **Anthropic** : connectez-vous via un navigateur avec votre compte Claude ou Anthropic Console77* **Anthropic** : connectez-vous via un navigateur avec votre compte Claude ou Anthropic Console

78* **[Amazon Bedrock, Google Cloud's Agent Platform ou Microsoft Foundry](/fr/third-party-integrations)** : Claude Code utilise vos identifiants de fournisseur cloud, sans invite de navigateur78* **[Amazon Bedrock, Google Cloud's Agent Platform ou Microsoft Foundry](/docs/fr/third-party-integrations)** : Claude Code utilise vos identifiants de fournisseur cloud, sans invite de navigateur

79 79 

80Pour les fournisseurs cloud, transmettez les identifiants dans le conteneur en tant que variables d'environnement via `containerEnv`, un secret Codespaces ou l'identité de charge de travail de votre cloud plutôt que de monter les fichiers d'identifiants depuis l'hôte. Voir [Amazon Bedrock](/fr/amazon-bedrock), [Google Cloud's Agent Platform](/fr/google-vertex-ai), ou [Microsoft Foundry](/fr/microsoft-foundry) pour la chaîne d'identifiants que Claude Code lit.80Pour les fournisseurs cloud, transmettez les identifiants dans le conteneur en tant que variables d'environnement via `containerEnv`, un secret Codespaces ou l'identité de charge de travail de votre cloud plutôt que de monter les fichiers d'identifiants depuis l'hôte. Voir [Amazon Bedrock](/docs/fr/amazon-bedrock), [Google Cloud's Agent Platform](/docs/fr/google-vertex-ai), ou [Microsoft Foundry](/docs/fr/microsoft-foundry) pour la chaîne d'identifiants que Claude Code lit.

81 81 

82Voir [Choisir votre fournisseur d'API](/fr/admin-setup#choose-your-api-provider) pour décider quel chemin convient à votre organisation.82Voir [Choisir votre fournisseur d'API](/docs/fr/admin-setup#choose-your-api-provider) pour décider quel chemin convient à votre organisation.

83 83 

84<Note>84<Note>

85 Si la connexion au navigateur se termine mais le rappel n'atteint jamais le conteneur, copiez le code affiché dans le navigateur et collez-le à l'invite `Paste code here if prompted` dans le terminal. Cela peut se produire lorsque la redirection de port de l'éditeur n'achemine pas le rappel localhost.85 Si la connexion au navigateur se termine mais le rappel n'atteint jamais le conteneur, copiez le code affiché dans le navigateur et collez-le à l'invite `Paste code here if prompted` dans le terminal. Cela peut se produire lorsque la redirection de port de l'éditeur n'achemine pas le rappel localhost.

89 Persister l'authentification et les paramètres entre les reconstructions89 Persister l'authentification et les paramètres entre les reconstructions

90</h2>90</h2>

91 91 

92Par défaut, le répertoire personnel du conteneur est supprimé lors de la reconstruction, les ingénieurs doivent donc se reconnecter à chaque fois. Claude Code stocke son jeton d'authentification, les paramètres utilisateur et l'historique de session sous [`~/.claude`](/fr/claude-directory). Montez un volume nommé à ce chemin pour conserver cet état entre les reconstructions.92Par défaut, le répertoire personnel du conteneur est supprimé lors de la reconstruction, les ingénieurs doivent donc se reconnecter à chaque fois. Claude Code stocke son jeton d'authentification, les paramètres utilisateur et l'historique de session sous [`~/.claude`](/docs/fr/claude-directory). Montez un volume nommé à ce chemin pour conserver cet état entre les reconstructions.

93 93 

94L'exemple suivant monte un volume au répertoire personnel de l'utilisateur `node` :94L'exemple suivant monte un volume au répertoire personnel de l'utilisateur `node` :

95 95 

99]99]

100```100```

101 101 

102Remplacez `/home/node` par le répertoire personnel de l'utilisateur `remoteUser` de votre conteneur. Si vous montez le volume ailleurs que `~/.claude`, définissez [`CLAUDE_CONFIG_DIR`](/fr/env-vars) sur le chemin de montage afin que Claude Code y lise et écrive.102Remplacez `/home/node` par le répertoire personnel de l'utilisateur `remoteUser` de votre conteneur. Si vous montez le volume ailleurs que `~/.claude`, définissez [`CLAUDE_CONFIG_DIR`](/docs/fr/env-vars) sur le chemin de montage afin que Claude Code y lise et écrive.

103 103 

104Pour isoler l'état par projet plutôt que de partager un volume sur tous les référentiels, incluez la variable `${devcontainerId}` dans le nom de la source. La [configuration de référence](https://github.com/anthropics/claude-code/blob/main/.devcontainer/devcontainer.json) utilise `source=claude-code-config-${devcontainerId}` à cette fin.104Pour isoler l'état par projet plutôt que de partager un volume sur tous les référentiels, incluez la variable `${devcontainerId}` dans le nom de la source. La [configuration de référence](https://github.com/anthropics/claude-code/blob/main/.devcontainer/devcontainer.json) utilise `source=claude-code-config-${devcontainerId}` à cette fin.

105 105 

106Dans GitHub Codespaces, `~/.claude` persiste lors de l'arrêt et du redémarrage d'un codespace, mais est toujours effacé lorsque vous reconstruisez le conteneur, donc le montage de volume ci-dessus s'applique également là. Pour conserver l'authentification entre les codespaces, stockez `ANTHROPIC_API_KEY` ou un `CLAUDE_CODE_OAUTH_TOKEN` de [`claude setup-token`](/fr/authentication#generate-a-long-lived-token) en tant que [secret Codespaces](https://docs.github.com/en/codespaces/managing-your-codespaces/managing-your-account-specific-secrets-for-github-codespaces) ; Codespaces rend les secrets disponibles en tant que variables d'environnement à l'intérieur du conteneur automatiquement.106Dans GitHub Codespaces, `~/.claude` persiste lors de l'arrêt et du redémarrage d'un codespace, mais est toujours effacé lorsque vous reconstruisez le conteneur, donc le montage de volume ci-dessus s'applique également là. Pour conserver l'authentification entre les codespaces, stockez `ANTHROPIC_API_KEY` ou un `CLAUDE_CODE_OAUTH_TOKEN` de [`claude setup-token`](/docs/fr/authentication#generate-a-long-lived-token) en tant que [secret Codespaces](https://docs.github.com/en/codespaces/managing-your-codespaces/managing-your-account-specific-secrets-for-github-codespaces) ; Codespaces rend les secrets disponibles en tant que variables d'environnement à l'intérieur du conteneur automatiquement.

107 107 

108<h2 id="enforce-organization-policy">108<h2 id="enforce-organization-policy">

109 Appliquer la politique organisationnelle109 Appliquer la politique organisationnelle

111 111 

112Un dev container est un endroit pratique pour appliquer la politique organisationnelle, car la même image et configuration s'exécutent sur la machine de chaque ingénieur.112Un dev container est un endroit pratique pour appliquer la politique organisationnelle, car la même image et configuration s'exécutent sur la machine de chaque ingénieur.

113 113 

114Claude Code lit `/etc/claude-code/managed-settings.json` sur Linux et l'applique avec la plus haute priorité dans la [hiérarchie des paramètres](/fr/settings#how-scopes-interact), donc les valeurs là-bas remplacent tout ce qu'un ingénieur définit dans `~/.claude` ou le répertoire `.claude/` du projet. Copiez le fichier en place depuis votre Dockerfile :114Claude Code lit `/etc/claude-code/managed-settings.json` sur Linux et l'applique avec la plus haute priorité dans la [hiérarchie des paramètres](/docs/fr/settings#how-scopes-interact), donc les valeurs là-bas remplacent tout ce qu'un ingénieur définit dans `~/.claude` ou le répertoire `.claude/` du projet. Copiez le fichier en place depuis votre Dockerfile :

115 115 

116```dockerfile Dockerfile theme={null}116```dockerfile Dockerfile theme={null}

117RUN mkdir -p /etc/claude-code117RUN mkdir -p /etc/claude-code

118COPY managed-settings.json /etc/claude-code/managed-settings.json118COPY managed-settings.json /etc/claude-code/managed-settings.json

119```119```

120 120 

121Parce que le Dockerfile vit dans le référentiel, n'importe qui ayant accès en écriture peut modifier ou supprimer cette étape. Pour une politique que les ingénieurs ne peuvent pas contourner en modifiant les fichiers du référentiel, livrez les paramètres gérés via [paramètres gérés par le serveur](/fr/server-managed-settings) ou votre MDM à la place. Voir [fichiers de paramètres gérés](/fr/settings#settings-files) pour les clés disponibles et les autres chemins de livraison.121Parce que le Dockerfile vit dans le référentiel, n'importe qui ayant accès en écriture peut modifier ou supprimer cette étape. Pour une politique que les ingénieurs ne peuvent pas contourner en modifiant les fichiers du référentiel, livrez les paramètres gérés via [paramètres gérés par le serveur](/docs/fr/server-managed-settings) ou votre MDM à la place. Voir [fichiers de paramètres gérés](/docs/fr/settings#settings-files) pour les clés disponibles et les autres chemins de livraison.

122 122 

123Pour définir les [variables d'environnement](/fr/env-vars) qui s'appliquent à chaque session Claude Code dans le conteneur, ajoutez-les à `containerEnv` dans votre `devcontainer.json`. L'exemple suivant désactive la télémétrie et les rapports d'erreur et empêche Claude Code de se mettre à jour automatiquement après l'installation :123Pour définir les [variables d'environnement](/docs/fr/env-vars) qui s'appliquent à chaque session Claude Code dans le conteneur, ajoutez-les à `containerEnv` dans votre `devcontainer.json`. L'exemple suivant désactive la télémétrie et les rapports d'erreur et empêche Claude Code de se mettre à jour automatiquement après l'installation :

124 124 

125```json devcontainer.json theme={null}125```json devcontainer.json theme={null}

126"containerEnv": {126"containerEnv": {

131 131 

132La Fonctionnalité Dev Container installe toujours la dernière version de Claude Code. Pour épingler une version spécifique de Claude Code pour des builds reproductibles, installez-la depuis votre Dockerfile avec `npm install -g @anthropic-ai/claude-code@X.Y.Z` au lieu d'utiliser la fonctionnalité, et définissez `DISABLE_AUTOUPDATER` comme indiqué ci-dessus.132La Fonctionnalité Dev Container installe toujours la dernière version de Claude Code. Pour épingler une version spécifique de Claude Code pour des builds reproductibles, installez-la depuis votre Dockerfile avec `npm install -g @anthropic-ai/claude-code@X.Y.Z` au lieu d'utiliser la fonctionnalité, et définissez `DISABLE_AUTOUPDATER` comme indiqué ci-dessus.

133 133 

134Pour la liste complète des contrôles de politique incluant les règles de permission, les restrictions d'outils et les listes blanches de serveurs MCP, voir [Configurer Claude Code pour votre organisation](/fr/admin-setup).134Pour la liste complète des contrôles de politique incluant les règles de permission, les restrictions d'outils et les listes blanches de serveurs MCP, voir [Configurer Claude Code pour votre organisation](/docs/fr/admin-setup).

135 135 

136Pour rendre les [serveurs MCP](/fr/mcp) disponibles à l'intérieur du conteneur, définissez-les à [portée du projet](/fr/mcp#mcp-installation-scopes) dans un fichier `.mcp.json` à la racine du référentiel afin qu'ils soient vérifiés aux côtés de votre configuration de dev container. Installez tous les binaires sur lesquels les serveurs stdio locaux dépendent dans votre Dockerfile, et ajoutez les domaines de serveur distant à votre liste blanche réseau.136Pour rendre les [serveurs MCP](/docs/fr/mcp) disponibles à l'intérieur du conteneur, définissez-les à [portée du projet](/docs/fr/mcp#mcp-installation-scopes) dans un fichier `.mcp.json` à la racine du référentiel afin qu'ils soient vérifiés aux côtés de votre configuration de dev container. Installez tous les binaires sur lesquels les serveurs stdio locaux dépendent dans votre Dockerfile, et ajoutez les domaines de serveur distant à votre liste blanche réseau.

137 137 

138<h2 id="restrict-network-egress">138<h2 id="restrict-network-egress">

139 Restreindre la sortie réseau139 Restreindre la sortie réseau

140</h2>140</h2>

141 141 

142Vous pouvez limiter le trafic sortant du conteneur aux seuls domaines dont Claude Code a besoin. Voir [Exigences d'accès réseau](/fr/network-config#network-access-requirements) pour les domaines d'inférence et d'authentification, et [Services de télémétrie](/fr/data-usage#telemetry-services) pour les connexions de télémétrie et de rapport d'erreur optionnelles et comment les désactiver.142Vous pouvez limiter le trafic sortant du conteneur aux seuls domaines dont Claude Code a besoin. Voir [Exigences d'accès réseau](/docs/fr/network-config#network-access-requirements) pour les domaines d'inférence et d'authentification, et [Services de télémétrie](/docs/fr/data-usage#telemetry-services) pour les connexions de télémétrie et de rapport d'erreur optionnelles et comment les désactiver.

143 143 

144Le conteneur de référence inclut un script [`init-firewall.sh`](https://github.com/anthropics/claude-code/blob/main/.devcontainer/init-firewall.sh) qui bloque tout le trafic sortant sauf les domaines dont Claude Code et vos outils de développement ont besoin. L'exécution d'un pare-feu à l'intérieur d'un conteneur nécessite des permissions supplémentaires, donc la référence ajoute les capacités `NET_ADMIN` et `NET_RAW` via `runArgs`. Le script de pare-feu et ces capacités ne sont pas requis pour Claude Code lui-même : vous pouvez les laisser de côté et vous fier à vos propres contrôles réseau à la place.144Le conteneur de référence inclut un script [`init-firewall.sh`](https://github.com/anthropics/claude-code/blob/main/.devcontainer/init-firewall.sh) qui bloque tout le trafic sortant sauf les domaines dont Claude Code et vos outils de développement ont besoin. L'exécution d'un pare-feu à l'intérieur d'un conteneur nécessite des permissions supplémentaires, donc la référence ajoute les capacités `NET_ADMIN` et `NET_RAW` via `runArgs`. Le script de pare-feu et ces capacités ne sont pas requis pour Claude Code lui-même : vous pouvez les laisser de côté et vous fier à vos propres contrôles réseau à la place.

145 145 

151 151 

152Ignorer les invites de permission supprime votre opportunité d'examiner les appels d'outils avant qu'ils ne s'exécutent. Claude peut toujours modifier n'importe quel fichier dans l'espace de travail monté en bind, qui apparaît directement sur votre hôte, et atteindre tout ce que la politique réseau du conteneur permet. Associez cet indicateur aux [restrictions de sortie réseau](#restrict-network-egress) ci-dessus pour limiter ce qu'une session contournée peut atteindre.152Ignorer les invites de permission supprime votre opportunité d'examiner les appels d'outils avant qu'ils ne s'exécutent. Claude peut toujours modifier n'importe quel fichier dans l'espace de travail monté en bind, qui apparaît directement sur votre hôte, et atteindre tout ce que la politique réseau du conteneur permet. Associez cet indicateur aux [restrictions de sortie réseau](#restrict-network-egress) ci-dessus pour limiter ce qu'une session contournée peut atteindre.

153 153 

154Si vous voulez moins d'invites sans désactiver les contrôles de sécurité, envisagez plutôt le [mode auto](/fr/permission-modes#eliminate-prompts-with-auto-mode), qui a un classificateur examinant les actions avant qu'elles ne s'exécutent. Pour empêcher les ingénieurs d'utiliser `--dangerously-skip-permissions` du tout, définissez `permissions.disableBypassPermissionsMode` sur `"disable"` dans les [paramètres gérés](/fr/settings#permission-settings).154Si vous voulez moins d'invites sans désactiver les contrôles de sécurité, envisagez plutôt le [mode auto](/docs/fr/permission-modes#eliminate-prompts-with-auto-mode), qui a un classificateur examinant les actions avant qu'elles ne s'exécutent. Pour empêcher les ingénieurs d'utiliser `--dangerously-skip-permissions` du tout, définissez `permissions.disableBypassPermissionsMode` sur `"disable"` dans les [paramètres gérés](/docs/fr/settings#permission-settings).

155 155 

156<h2 id="try-the-reference-container">156<h2 id="try-the-reference-container">

157 Essayer le conteneur de référence157 Essayer le conteneur de référence

193 193 

194Une fois Claude Code en cours d'exécution dans votre dev container, les pages ci-dessous couvrent le reste d'un déploiement organisationnel : choisir un chemin d'authentification, livrer une politique gérée en dehors du référentiel, surveiller l'utilisation et comprendre ce que Claude Code stocke et envoie.194Une fois Claude Code en cours d'exécution dans votre dev container, les pages ci-dessous couvrent le reste d'un déploiement organisationnel : choisir un chemin d'authentification, livrer une politique gérée en dehors du référentiel, surveiller l'utilisation et comprendre ce que Claude Code stocke et envoie.

195 195 

196* [Configurer Claude Code pour votre organisation](/fr/admin-setup) : choisir un fournisseur d'authentification, décider comment la politique atteint les appareils et planifier le déploiement196* [Configurer Claude Code pour votre organisation](/docs/fr/admin-setup) : choisir un fournisseur d'authentification, décider comment la politique atteint les appareils et planifier le déploiement

197* [Paramètres gérés par le serveur](/fr/server-managed-settings) : livrer une politique gérée depuis la console d'administration Claude.ai afin que les ingénieurs ne puissent pas la contourner en modifiant les fichiers du référentiel197* [Paramètres gérés par le serveur](/docs/fr/server-managed-settings) : livrer une politique gérée depuis la console d'administration Claude.ai afin que les ingénieurs ne puissent pas la contourner en modifiant les fichiers du référentiel

198* [Surveiller l'utilisation et l'activité d'audit](/fr/monitoring-usage) : exporter les métriques OpenTelemetry et examiner ce que votre équipe exécute198* [Surveiller l'utilisation et l'activité d'audit](/docs/fr/monitoring-usage) : exporter les métriques OpenTelemetry et examiner ce que votre équipe exécute

199* [Exigences d'accès réseau](/fr/network-config#network-access-requirements) : la liste complète des domaines pour les proxies et les pare-feu199* [Exigences d'accès réseau](/docs/fr/network-config#network-access-requirements) : la liste complète des domaines pour les proxies et les pare-feu

200* [Services de télémétrie et désactivation](/fr/data-usage#telemetry-services) : ce que Claude Code envoie par défaut et les variables d'environnement qui le désactivent200* [Services de télémétrie et désactivation](/docs/fr/data-usage#telemetry-services) : ce que Claude Code envoie par défaut et les variables d'environnement qui le désactivent

201* [Explorer le répertoire `.claude`](/fr/claude-directory) : ce que le montage de volume contient, y compris les identifiants, les paramètres et l'historique de session201* [Explorer le répertoire `.claude`](/docs/fr/claude-directory) : ce que le montage de volume contient, y compris les identifiants, les paramètres et l'historique de session

202* [Environnements sandbox](/fr/sandbox-environments) : comparer les dev containers avec le sandbox Bash intégré, les conteneurs personnalisés et les machines virtuelles202* [Environnements sandbox](/docs/fr/sandbox-environments) : comparer les dev containers avec le sandbox Bash intégré, les conteneurs personnalisés et les machines virtuelles

203* [Modèle de sécurité](/fr/security) : comment le système de permission de Claude Code, le sandboxing et les protections contre l'injection de prompt s'assemblent203* [Modèle de sécurité](/docs/fr/security) : comment le système de permission de Claude Code, le sandboxing et les protections contre l'injection de prompt s'assemblent

204* [Modes de permission](/fr/permission-modes) : la gamme complète du mode plan au mode auto au contournement, et quand utiliser chacun204* [Modes de permission](/docs/fr/permission-modes) : la gamme complète du mode plan au mode auto au contournement, et quand utiliser chacun

1> ## Documentation Index

2> Fetch the complete documentation index at: https://code.claude.com/docs/llms.txt

3> Use this file to discover all available pages before exploring further.

4 

5# Autres passerelles LLM

6 

7> Acheminez Claude Code via une passerelle LLM que votre organisation exécute déjà. Couvre la connexion de Claude Code à une passerelle, le déploiement d'une passerelle pour votre organisation et ce que Claude Code envoie à une passerelle.

8 

9Cette section couvre l'utilisation d'un produit de passerelle que votre organisation exécute déjà, plutôt que la [passerelle Claude apps](/docs/fr/claude-apps-gateway). Pour savoir ce qu'est une passerelle, comment elle se situe entre Claude Code et votre fournisseur, et comment choisir entre la passerelle Claude apps et un autre produit, consultez l'[aperçu des passerelles](/docs/fr/gateways).

10 

11<Note>

12 * Si vous êtes un développeur se connectant à une passerelle existante : [connectez Claude Code à votre passerelle](/docs/fr/llm-gateway-connect)

13 * Si vous êtes un administrateur déployant une passerelle pour votre organisation : [déployez et distribuez une passerelle](/docs/fr/llm-gateway-rollout)

14 * Si vous configurez un produit de passerelle : la [référence du protocole de passerelle](/docs/fr/llm-gateway-protocol)

15</Note>

16 

17Toute passerelle qui expose un [format API supporté](/docs/fr/llm-gateway-protocol#api-formats) fonctionne. Anthropic n'approuve pas, ne maintient pas et n'audite pas les produits de passerelle tiers, et ne supporte pas l'acheminement de Claude Code vers des modèles non-Claude via aucune passerelle. Déployez la passerelle en suivant sa propre documentation, puis complétez le côté Claude Code avec les [étapes de déploiement ci-dessous](#roll-out-a-gateway).

18 

19<h2 id="what-a-gateway-provides">

20 Ce qu'une passerelle fournit

21</h2>

22 

23Une passerelle donne à votre organisation un seul endroit pour gérer :

24 

25* **Credentials** : la clé du fournisseur reste côté serveur ; les développeurs détiennent plutôt des credentials de passerelle

26* **Suivi de l'utilisation** : attribuez l'utilisation par développeur ou équipe, quel que soit le fournisseur qui traite la requête

27* **Contrôles des coûts** : appliquez les budgets et les limites de débit en un seul endroit

28* **Journalisation d'audit** : enregistrez chaque requête de modèle pour la conformité

29* **Changement de fournisseur** : changez le fournisseur dans la configuration de la passerelle, sans toucher aux machines des développeurs

30 

31Tous ces éléments sauf le changement de fournisseur s'appliquent que le flux amont soit l'API d'Anthropic ou un [fournisseur cloud](/docs/fr/third-party-integrations). Le changement de fournisseur sans reconfiguration des machines des développeurs dépend également de la passerelle exposant un seul [point de terminaison au format Anthropic](/docs/fr/llm-gateway-protocol#api-formats) quel que soit le flux amont ; une passerelle qui expose le propre format d'un fournisseur lie la configuration du client à ce fournisseur.

32 

33Le compromis est que la passerelle devient une infrastructure que votre organisation exploite. Claude Code ajoute des capacités à chaque version, et une passerelle qui ne les transfère pas casse les fonctionnalités correspondantes, donc le produit de passerelle doit être maintenu à jour à mesure que Claude Code évolue. La [référence du protocole de passerelle](/docs/fr/llm-gateway-protocol) couvre ce qu'il faut transférer.

34 

35<h2 id="roll-out-a-gateway">

36 Déployer une passerelle

37</h2>

38 

39Quand vous êtes prêt à déployer une passerelle LLM pour votre organisation, la séquence est la même quel que soit le produit de passerelle que vous choisissez :

40 

411. Déployez la passerelle et donnez-lui votre credential du fournisseur, afin qu'elle puisse authentifier les requêtes qu'elle transfère.

422. Émettez à chaque développeur une credential de passerelle, afin que l'utilisation soit attribuée au développeur et que l'offboarding révoque une credential.

433. Distribuez la configuration via un [fichier de paramètres gérés](/docs/fr/settings#settings-files) et votre outillage de secrets, afin que chaque machine reçoive l'URL de base et une credential. Quand les deux sont distribués, les développeurs ne configurent rien. Si vous n'avez pas de distribution de paramètres en place, les développeurs suivent la [page de connexion](/docs/fr/llm-gateway-connect) pour définir les variables eux-mêmes.

444. Faites en sorte que chaque développeur [vérifie la configuration dans Claude Code](/docs/fr/llm-gateway-connect#check-for-an-existing-configuration), afin que les problèmes de distribution fassent surface avant qu'ils ne dépendent de la passerelle.

45 

46[Déployez une passerelle LLM pour votre organisation](/docs/fr/llm-gateway-rollout) parcourt chaque étape et montre les fichiers de configuration à distribuer à chacune. La passerelle est une partie de la configuration de l'organisation ; pour l'application des politiques, la visibilité de l'utilisation et les décisions de traitement des données, consultez [Configurez Claude Code pour votre organisation](/docs/fr/admin-setup).

47 

48<h2 id="subscriptions-and-gateways">

49 Abonnements et passerelles

50</h2>

51 

52Tandis qu'une [variable de credential de passerelle](/docs/fr/llm-gateway-connect#set-the-credential-variable) ou `apiKeyHelper` est active, l'abonnement claude.ai d'un développeur n'est pas utilisé : la credential remplace la connexion à l'abonnement pour cette session, et les limites d'utilisation de l'abonnement ne s'appliquent pas. Ce trafic est facturé par token à celui qui possède la credential que la passerelle transfère, tel que le compte Anthropic Console de votre organisation, ou votre compte Amazon Bedrock, Google Cloud's Agent Platform, ou Microsoft Foundry quand la passerelle achemine là.

53 

54[`ANTHROPIC_BASE_URL`](/docs/fr/llm-gateway-connect#set-the-base-url-and-credential) est la variable qui pointe Claude Code vers la passerelle. Définir uniquement cette variable, sans credential de passerelle, ne remplace pas l'abonnement. Les requêtes acheminent toujours via la passerelle, mais une connexion claude.ai sauvegardée reste la credential active, donc ses limites d'utilisation et sa facturation s'appliquent. Les passerelles qui transmettent ce trafic à Anthropic doivent transférer la capacité OAuth dans `anthropic-beta` ; consultez la [référence des en-têtes de requête](/docs/fr/llm-gateway-protocol#request-headers).

55 

56<h2 id="related-pages">

57 Pages connexes

58</h2>

59 

60* [Aperçu des passerelles](/docs/fr/gateways) : comment une passerelle fonctionne et comment choisir entre la passerelle Claude apps et un autre produit

61* [Passerelle Claude apps](/docs/fr/claude-apps-gateway) : la passerelle auto-hébergée d'Anthropic avec connexion SSO et télémétrie OTLP

62* [Connectez Claude Code à une passerelle LLM](/docs/fr/llm-gateway-connect) : définissez l'URL de base et la credential sur votre propre machine, avec la configuration par surface et un tableau de dépannage

63* [Déployez une passerelle LLM pour votre organisation](/docs/fr/llm-gateway-rollout) : la liste de contrôle de l'administrateur pour déployer une passerelle, émettre des credentials de développeur et distribuer les paramètres gérés

64* [Référence du protocole de passerelle](/docs/fr/llm-gateway-protocol) : ce que Claude Code envoie à une passerelle, pour les opérateurs en configurant une, couvrant les points de terminaison, les en-têtes à transférer et le passage des fonctionnalités

20 20 

21<img src="https://mintcdn.com/claude-code/VbDJw--l6T9a9Wvm/images/prompt-caching-prefix.svg?fit=max&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=f2e8f0b8298a50305fe428ca3f1d1594" className="dark:hidden" alt="Quatre tours affichés sous forme de barres horizontales croissantes. La requête de chaque tour contient tout ce qui provient du tour précédent plus l'échange le plus récent ajouté à la fin. Aux tours deux et trois, le préfixe inchangé est lu à partir du cache et seul le nouvel échange est traité. Au tour quatre, le prompt système a changé, donc le préfixe ne correspond plus et la requête entière est retraitée et écrite." width="720" height="454" data-path="images/prompt-caching-prefix.svg" />21<img src="https://mintcdn.com/claude-code/VbDJw--l6T9a9Wvm/images/prompt-caching-prefix.svg?fit=max&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=f2e8f0b8298a50305fe428ca3f1d1594" className="dark:hidden" alt="Quatre tours affichés sous forme de barres horizontales croissantes. La requête de chaque tour contient tout ce qui provient du tour précédent plus l'échange le plus récent ajouté à la fin. Aux tours deux et trois, le préfixe inchangé est lu à partir du cache et seul le nouvel échange est traité. Au tour quatre, le prompt système a changé, donc le préfixe ne correspond plus et la requête entière est retraitée et écrite." width="720" height="454" data-path="images/prompt-caching-prefix.svg" />

22 22 

23<img src="https://mintcdn.com/claude-code/VbDJw--l6T9a9Wvm/images/prompt-caching-prefix-dark.svg?fit=max&auto=format&n=VbDJw--l6T9a9Wvm&q=85&s=7434a04e08187edd26ec6c3dd332f624" className="hidden dark:block" alt="Quatre tours affichés sous forme de barres horizontales croissantes. La requête de chaque tour contient tout ce qui provient du tour précédent plus l'échange le plus récent ajouté à la fin. Aux tours deux et trois, le préfixe inchangé est lu à partir du cache et seul le nouvel échange est traité. Au tour quatre, le prompt système a changé, donc le préfixe ne correspond plus et la requête entière est retraitée et écrite." width="720" height="454" data-path="images/prompt-caching-prefix-dark.svg" />23<img src="https://mintcdn.com/claude-code/_xqph1dUOslCOwsj/images/prompt-caching-prefix-dark.svg?fit=max&auto=format&n=_xqph1dUOslCOwsj&q=85&s=297dc1c639f0915cae858d0c4b6f3be5" className="hidden dark:block" alt="Quatre tours affichés sous forme de barres horizontales croissantes. La requête de chaque tour contient tout ce qui provient du tour précédent plus l'échange le plus récent ajouté à la fin. Aux tours deux et trois, le préfixe inchangé est lu à partir du cache et seul le nouvel échange est traité. Au tour quatre, le prompt système a changé, donc le préfixe ne correspond plus et la requête entière est retraitée et écrite." width="720" height="454" data-path="images/prompt-caching-prefix-dark.svg" />

24 24 

25Pour tirer le meilleur parti de la correspondance de préfixe, Claude Code organise chaque requête de sorte que le contenu qui change rarement entre les tours vient en premier :25Pour tirer le meilleur parti de la correspondance de préfixe, Claude Code organise chaque requête de sorte que le contenu qui change rarement entre les tours vient en premier :

26 26 

32 32 

33Un changement à la couche conversation laisse le prompt système et le contexte du projet en cache. Un changement au prompt système invalide tout, car tout le contenu ultérieur se trouve maintenant derrière un préfixe différent. La troisième colonne donne les déclencheurs courants plutôt qu'une liste exhaustive, et les sections ci-dessous couvrent l'ensemble complet, y compris le contenu tel que le style de sortie qui est fixé au démarrage de la session.33Un changement à la couche conversation laisse le prompt système et le contexte du projet en cache. Un changement au prompt système invalide tout, car tout le contenu ultérieur se trouve maintenant derrière un préfixe différent. La troisième colonne donne les déclencheurs courants plutôt qu'une liste exhaustive, et les sections ci-dessous couvrent l'ensemble complet, y compris le contenu tel que le style de sortie qui est fixé au démarrage de la session.

34 34 

35La règle de correspondance de préfixe explique la plupart des comportements sur cette page. Le [mode plan](/fr/permission-modes#analyze-before-you-edit-with-plan-mode) et le [chargement de compétences](/fr/skills), par exemple, ajoutent leurs instructions comme messages de conversation, de sorte que le préfixe en cache reste intact.35La règle de correspondance de préfixe explique la plupart des comportements sur cette page. Le [mode plan](/docs/fr/permission-modes#analyze-before-you-edit-with-plan-mode) et le [chargement de compétences](/docs/fr/skills), par exemple, ajoutent leurs instructions comme messages de conversation, de sorte que le préfixe en cache reste intact.

36 36 

37Deux paramètres ne font pas du tout partie du texte du prompt, donc ils n'apparaissent pas dans le tableau des couches, mais tous deux font partie de la clé de cache :37Deux paramètres ne font pas du tout partie du texte du prompt, donc ils n'apparaissent pas dans le tableau des couches, mais tous deux font partie de la clé de cache :

38 38 

49 49 

50Le caching se produit côté serveur, dans l'infrastructure qui sert votre modèle. L'endroit où cela se trouve dépend de la façon dont vous vous authentifiez :50Le caching se produit côté serveur, dans l'infrastructure qui sert votre modèle. L'endroit où cela se trouve dépend de la façon dont vous vous authentifiez :

51 51 

52* **Clé API, abonnement Claude, ou [Claude Platform on AWS](/fr/claude-platform-on-aws)** : le cache vit dans l'infrastructure d'Anthropic, accessible via l'[API Claude](https://platform.claude.com/docs)52* **Clé API, abonnement Claude, ou [Claude Platform on AWS](/docs/fr/claude-platform-on-aws)** : le cache vit dans l'infrastructure d'Anthropic, accessible via l'[API Claude](https://platform.claude.com/docs)

53* **Amazon Bedrock ou Google Cloud's Agent Platform** : le cache vit dans l'infrastructure de service de votre fournisseur cloud53* **Amazon Bedrock ou Google Cloud's Agent Platform** : le cache vit dans l'infrastructure de service de votre fournisseur cloud

54* **Microsoft Foundry** : les requêtes sont acheminées vers l'infrastructure d'Anthropic54* **Microsoft Foundry** : les requêtes sont acheminées vers l'infrastructure d'Anthropic

55* **`ANTHROPIC_BASE_URL` personnalisé ou [passerelle LLM](/fr/llm-gateway)** : le cache vit là où vos requêtes sont transférées, et le fonctionnement du caching dépend de la passerelle55* **`ANTHROPIC_BASE_URL` personnalisé ou [passerelle LLM](/docs/fr/llm-gateway)** : le cache vit là où vos requêtes sont transférées, et le fonctionnement du caching dépend de la passerelle

56 56 

57Pour ce que chaque fournisseur stocke et traite, voir [utilisation des données](/fr/data-usage). Où que le cache vive, les entrées expirent après une période d'inactivité, et [Durée de vie du cache](#cache-lifetime) ci-dessous couvre le TTL et comment l'étendre.57Pour ce que chaque fournisseur stocke et traite, voir [utilisation des données](/docs/fr/data-usage). Où que le cache vive, les entrées expirent après une période d'inactivité, et [Durée de vie du cache](#cache-lifetime) ci-dessous couvre le TTL et comment l'étendre.

58 58 

59<h2 id="actions-that-invalidate-the-cache">59<h2 id="actions-that-invalidate-the-cache">

60 Actions qui invalident le cache60 Actions qui invalident le cache

75 Changer de modèle75 Changer de modèle

76</h3>76</h3>

77 77 

78Chaque modèle a son propre cache. Changer avec [`/model`](/fr/model-config#setting-your-model) signifie que la requête suivante lit l'historique de conversation entier sans cache hits, même si le contenu est identique.78Chaque modèle a son propre cache. Changer avec [`/model`](/docs/fr/model-config#setting-your-model) signifie que la requête suivante lit l'historique de conversation entier sans cache hits, même si le contenu est identique.

79 79 

80Le [paramètre de modèle `opusplan`](/fr/model-config#opusplan-model-setting) se résout en Opus pendant le mode plan et Sonnet pendant l'exécution, donc chaque basculement de mode plan est un changement de modèle et démarre un cache frais.80Le [paramètre de modèle `opusplan`](/docs/fr/model-config#opusplan-model-setting) se résout en Opus pendant le mode plan et Sonnet pendant l'exécution, donc chaque basculement de mode plan est un changement de modèle et démarre un cache frais.

81 81 

82Le [basculement automatique du modèle](/fr/model-config#automatic-model-fallback) sur Fable 5 est également un changement de modèle. Quand un classificateur de sécurité signale une requête, Claude Code la réexécute sur le modèle Opus par défaut et la session continue là.82Le [basculement automatique du modèle](/docs/fr/model-config#automatic-model-fallback) sur Fable 5 est également un changement de modèle. Quand un classificateur de sécurité signale une requête, Claude Code la réexécute sur le modèle Opus par défaut et la session continue là.

83 83 

84<h3 id="changing-effort-level">84<h3 id="changing-effort-level">

85 Modifier le niveau d'effort85 Modifier le niveau d'effort

86</h3>86</h3>

87 87 

88Le cache est indexé par [niveau d'effort](/fr/model-config#adjust-effort-level) ainsi que par modèle, donc changer avec `/effort` signifie que la requête suivante lit l'historique de conversation entier sans cache hits. Une fois qu'une conversation a commencé, Claude Code affiche une boîte de dialogue de confirmation avant d'appliquer un changement d'effort qui invaliderait le cache. Un changement qui se résout au même niveau déjà en vigueur, comme définir explicitement la valeur par défaut du modèle, ignore la boîte de dialogue et conserve le cache.88Le cache est indexé par [niveau d'effort](/docs/fr/model-config#adjust-effort-level) ainsi que par modèle, donc changer avec `/effort` signifie que la requête suivante lit l'historique de conversation entier sans cache hits. Une fois qu'une conversation a commencé, Claude Code affiche une boîte de dialogue de confirmation avant d'appliquer un changement d'effort qui invaliderait le cache. Un changement qui se résout au même niveau déjà en vigueur, comme définir explicitement la valeur par défaut du modèle, ignore la boîte de dialogue et conserve le cache.

89 89 

90<h3 id="turning-on-fast-mode">90<h3 id="turning-on-fast-mode">

91 Activer le mode rapide91 Activer le mode rapide

92</h3>92</h3>

93 93 

94L'activation du [mode rapide](/fr/fast-mode) ajoute un en-tête de requête qui fait partie de la clé de cache, donc la requête suivante lit l'historique de conversation entier sans cache hits. Ces jetons d'entrée non mis en cache sont facturés aux [tarifs du mode rapide](/fr/fast-mode#understand-the-cost-tradeoff), c'est pourquoi l'activer au début d'une session coûte moins cher que de l'activer profondément dans une longue session. L'activation du mode rapide à partir d'un modèle non-Opus [bascule également votre modèle](#switching-models), ce qui démarre un cache frais en soi.94L'activation du [mode rapide](/docs/fr/fast-mode) ajoute un en-tête de requête qui fait partie de la clé de cache, donc la requête suivante lit l'historique de conversation entier sans cache hits. Ces jetons d'entrée non mis en cache sont facturés aux [tarifs du mode rapide](/docs/fr/fast-mode#understand-the-cost-tradeoff), c'est pourquoi l'activer au début d'une session coûte moins cher que de l'activer profondément dans une longue session. L'activation du mode rapide à partir d'un modèle non-Opus [bascule également votre modèle](#switching-models), ce qui démarre un cache frais en soi.

95 95 

96Le coût s'applique une fois par conversation. Après le premier tour en mode rapide, Claude Code continue d'envoyer l'en-tête et varie uniquement le paramètre de vitesse de la requête, qui ne fait pas partie de la clé de cache. Désactiver le mode rapide, le [basculement automatique vers la vitesse standard](/fr/fast-mode#handle-rate-limits) après une limite de débit, et le réactiver plus tard conservent tous le cache. `/clear` et `/compact` réinitialisent cela, puisqu'ils reconstruisent le cache à ces points de toute façon.96Le coût s'applique une fois par conversation. Après le premier tour en mode rapide, Claude Code continue d'envoyer l'en-tête et varie uniquement le paramètre de vitesse de la requête, qui ne fait pas partie de la clé de cache. Désactiver le mode rapide, le [basculement automatique vers la vitesse standard](/docs/fr/fast-mode#handle-rate-limits) après une limite de débit, et le réactiver plus tard conservent tous le cache. `/clear` et `/compact` réinitialisent cela, puisqu'ils reconstruisent le cache à ces points de toute façon.

97 97 

98<h3 id="connecting-or-disconnecting-an-mcp-server">98<h3 id="connecting-or-disconnecting-an-mcp-server">

99 Connecter ou déconnecter un serveur MCP99 Connecter ou déconnecter un serveur MCP

100</h3>100</h3>

101 101 

102Les définitions d'outils se trouvent dans la couche du prompt système, donc le cache s'invalide quand l'ensemble des définitions d'outils dans la requête change entre les tours. Basculer l'[outil conseiller](/fr/advisor) est une exception : sa définition se trouve après le point de rupture du cache, donc activer ou désactiver `/advisor` conserve le préfixe mis en cache intact. Qu'un changement de [serveur MCP](/fr/mcp) fasse cela dépend de si ses outils sont différés par la [recherche d'outils](/fr/mcp#scale-with-mcp-tool-search) ou chargés dans le préfixe :102Les définitions d'outils se trouvent dans la couche du prompt système, donc le cache s'invalide quand l'ensemble des définitions d'outils dans la requête change entre les tours. Basculer l'[outil conseiller](/docs/fr/advisor) est une exception : sa définition se trouve après le point de rupture du cache, donc activer ou désactiver `/advisor` conserve le préfixe mis en cache intact. Qu'un changement de [serveur MCP](/docs/fr/mcp) fasse cela dépend de si ses outils sont différés par la [recherche d'outils](/docs/fr/mcp#scale-with-mcp-tool-search) ou chargés dans le préfixe :

103 103 

104* **Outils différés**, la valeur par défaut sur les modèles supportés : un serveur qui se connecte, se déconnecte, ou change sa liste d'outils n'ajoute que du nouveau contenu et ne perturbe rien de ce qui est déjà en cache.104* **Outils différés**, la valeur par défaut sur les modèles supportés : un serveur qui se connecte, se déconnecte, ou change sa liste d'outils n'ajoute que du nouveau contenu et ne perturbe rien de ce qui est déjà en cache.

105* **Outils chargés dans le préfixe** : tout changement à leur égard invalide le cache. Cela se produit quand la [recherche d'outils n'est pas disponible ou est désactivée](/fr/mcp#configure-tool-search), comme sur Google Cloud's Agent Platform ou avec une passerelle `ANTHROPIC_BASE_URL` personnalisée. Cela se produit également pour un serveur ou un outil marqué [`alwaysLoad`](/fr/mcp#exempt-a-server-from-deferral), et pour les définitions conservées en avant par le [chargement basé sur le seuil](/fr/mcp#configure-tool-search).105* **Outils chargés dans le préfixe** : tout changement à leur égard invalide le cache. Cela se produit quand la [recherche d'outils n'est pas disponible ou est désactivée](/docs/fr/mcp#configure-tool-search), comme sur Google Cloud's Agent Platform ou avec une passerelle `ANTHROPIC_BASE_URL` personnalisée. Cela se produit également pour un serveur ou un outil marqué [`alwaysLoad`](/docs/fr/mcp#exempt-a-server-from-deferral), et pour les définitions conservées en avant par le [chargement basé sur le seuil](/docs/fr/mcp#configure-tool-search).

106 106 

107Quand les outils se chargent dans le préfixe, la cause la plus courante d'une invalidation est un serveur qui se connecte ou se déconnecte en cours de session, ce qui peut se produire sans aucune action de votre part : le processus d'un serveur stdio se termine, une session HTTP expire, ou un serveur se [reconnecte automatiquement après une défaillance transitoire](/fr/mcp#automatic-reconnection). Un serveur connecté peut également envoyer une [mise à jour d'outil dynamique](/fr/mcp#dynamic-tool-updates) qui change sa liste d'outils.107Quand les outils se chargent dans le préfixe, la cause la plus courante d'une invalidation est un serveur qui se connecte ou se déconnecte en cours de session, ce qui peut se produire sans aucune action de votre part : le processus d'un serveur stdio se termine, une session HTTP expire, ou un serveur se [reconnecte automatiquement après une défaillance transitoire](/docs/fr/mcp#automatic-reconnection). Un serveur connecté peut également envoyer une [mise à jour d'outil dynamique](/docs/fr/mcp#dynamic-tool-updates) qui change sa liste d'outils.

108 108 

109Éditer votre configuration MCP ne change pas le cache en soi. La nouvelle configuration ne prend effet qu'après un redémarrage, c'est à ce moment que le serveur se connecte ou se déconnecte.109Éditer votre configuration MCP ne change pas le cache en soi. La nouvelle configuration ne prend effet qu'après un redémarrage, c'est à ce moment que le serveur se connecte ou se déconnecte.

110 110 

112 Activer ou désactiver un plugin112 Activer ou désactiver un plugin

113</h3>113</h3>

114 114 

115Les [plugins](/fr/plugins) regroupent plusieurs types de composants, et le coût d'un changement dépend des composants que le plugin fournit. Les skills, les commandes, les agents, les hooks, les serveurs LSP, les moniteurs et les thèmes n'invalident jamais le cache : tout ce qu'ils ajoutent à la requête est ajouté après la conversation existante, donc la requête suivante paie pour le nouveau contenu mais lit toujours tout ce qui le précède à partir du cache.115Les [plugins](/docs/fr/plugins) regroupent plusieurs types de composants, et le coût d'un changement dépend des composants que le plugin fournit. Les skills, les commandes, les agents, les hooks, les serveurs LSP, les moniteurs et les thèmes n'invalident jamais le cache : tout ce qu'ils ajoutent à la requête est ajouté après la conversation existante, donc la requête suivante paie pour le nouveau contenu mais lit toujours tout ce qui le précède à partir du cache.

116 116 

117L'exception est un plugin qui fournit des [serveurs MCP](/fr/plugins-reference#mcp-servers). Activer ou désactiver l'un d'eux suit les mêmes règles que [connecter ou déconnecter un serveur MCP](#connecting-or-disconnecting-an-mcp-server) : le cache survit quand les outils du serveur sont différés, et la requête suivante relit la conversation entière quand ils se chargent dans le préfixe.117L'exception est un plugin qui fournit des [serveurs MCP](/docs/fr/plugins-reference#mcp-servers). Activer ou désactiver l'un d'eux suit les mêmes règles que [connecter ou déconnecter un serveur MCP](#connecting-or-disconnecting-an-mcp-server) : le cache survit quand les outils du serveur sont différés, et la requête suivante relit la conversation entière quand ils se chargent dans le préfixe.

118 118 

119Les changements de plugin s'appliquent quand vous exécutez [`/reload-plugins`](/fr/discover-plugins#apply-plugin-changes-without-restarting) ou démarrez une nouvelle session. Le coût, qu'il s'agisse d'annonces ajoutées ou d'une relecture complète, s'affiche au premier tour après le rechargement, pas quand vous exécutez `/plugin install`, `/plugin enable`, ou `/plugin disable`. {/* min-version: 2.1.163 */}À partir de la v2.1.163, quand un rechargement déclencherait la relecture complète, `/reload-plugins` affiche un avertissement et n'applique pas le rechargement. Passez `--force` pour appliquer de toute façon.119Les changements de plugin s'appliquent quand vous exécutez [`/reload-plugins`](/docs/fr/discover-plugins#apply-plugin-changes-without-restarting) ou démarrez une nouvelle session. Le coût, qu'il s'agisse d'annonces ajoutées ou d'une relecture complète, s'affiche au premier tour après le rechargement, pas quand vous exécutez `/plugin install`, `/plugin enable`, ou `/plugin disable`. {/* min-version: 2.1.163 */}À partir de la v2.1.163, quand un rechargement déclencherait la relecture complète, `/reload-plugins` affiche un avertissement et n'applique pas le rechargement. Passez `--force` pour appliquer de toute façon.

120 120 

121Désactiver un plugin que vous avez activé plus tôt dans la session restaure la forme de requête précédente. Si ce préfixe se trouve toujours dans sa [durée de vie du cache](#cache-lifetime), la requête suivante lit l'entrée de cache plus ancienne au lieu de la reconstruire.121Désactiver un plugin que vous avez activé plus tôt dans la session restaure la forme de requête précédente. Si ce préfixe se trouve toujours dans sa [durée de vie du cache](#cache-lifetime), la requête suivante lit l'entrée de cache plus ancienne au lieu de la reconstruire.

122 122 

124 Refuser un outil entier124 Refuser un outil entier

125</h3>125</h3>

126 126 

127Ajouter un nom d'outil simple comme `Bash` ou `WebFetch` comme [règle de refus](/fr/permissions#manage-permissions) supprime cet outil du contexte de Claude entièrement. Les définitions d'outils intégrés se chargent dans la couche du prompt système, donc ajouter ou supprimer l'une de ces règles en cours de session invalide le cache. Le changement prend effet au tour suivant, que vous l'ajoutiez via `/permissions` ou en [éditant un fichier de paramètres directement](/fr/settings#when-edits-take-effect).127Ajouter un nom d'outil simple comme `Bash` ou `WebFetch` comme [règle de refus](/docs/fr/permissions#manage-permissions) supprime cet outil du contexte de Claude entièrement. Les définitions d'outils intégrés se chargent dans la couche du prompt système, donc ajouter ou supprimer l'une de ces règles en cours de session invalide le cache. Le changement prend effet au tour suivant, que vous l'ajoutiez via `/permissions` ou en [éditant un fichier de paramètres directement](/docs/fr/settings#when-edits-take-effect).

128 128 

129Seul un nom d'outil simple, la forme équivalente `Bash(*)`, ou un [glob de nom d'outil](/fr/permissions#tool-name-wildcards) comme `"*"` a cet effet. Un glob qui correspond uniquement aux outils MCP, comme `"mcp__*"`, supprime ces outils de la même manière mais laisse le cache intact quand les outils correspondants sont [différés](#connecting-or-disconnecting-an-mcp-server), la valeur par défaut, puisque les définitions différées n'étaient jamais dans le préfixe mis en cache. Les règles de refus délimitées comme `Bash(rm *)`, et toutes les règles d'autorisation et de demande, ne changent pas les outils que Claude voit. Claude Code les vérifie quand Claude tente un appel, laissant le préfixe intact.129Seul un nom d'outil simple, la forme équivalente `Bash(*)`, ou un [glob de nom d'outil](/docs/fr/permissions#tool-name-wildcards) comme `"*"` a cet effet. Un glob qui correspond uniquement aux outils MCP, comme `"mcp__*"`, supprime ces outils de la même manière mais laisse le cache intact quand les outils correspondants sont [différés](#connecting-or-disconnecting-an-mcp-server), la valeur par défaut, puisque les définitions différées n'étaient jamais dans le préfixe mis en cache. Les règles de refus délimitées comme `Bash(rm *)`, et toutes les règles d'autorisation et de demande, ne changent pas les outils que Claude voit. Claude Code les vérifie quand Claude tente un appel, laissant le préfixe intact.

130 130 

131<h3 id="compacting-the-conversation">131<h3 id="compacting-the-conversation">

132 Compacter la conversation132 Compacter la conversation

133</h3>133</h3>

134 134 

135La [compaction](/fr/context-window#what-survives-compaction) remplace votre historique de messages par un résumé. Par conception, cela invalide la couche conversation, puisque la requête suivante a un nouvel historique plus court qui ne partage pas de préfixe avec l'ancien. Claude Code réutilise la couche du prompt système et recharge le contexte du projet à partir du disque, qui ne cache que si CLAUDE.md et la mémoire sont inchangés depuis le début de la session.135La [compaction](/docs/fr/context-window#what-survives-compaction) remplace votre historique de messages par un résumé. Par conception, cela invalide la couche conversation, puisque la requête suivante a un nouvel historique plus court qui ne partage pas de préfixe avec l'ancien. Claude Code réutilise la couche du prompt système et recharge le contexte du projet à partir du disque, qui ne cache que si CLAUDE.md et la mémoire sont inchangés depuis le début de la session.

136 136 

137Pour produire le résumé, Claude Code envoie une requête unique avec le même prompt système, les mêmes outils et le même historique que votre conversation, plus une instruction de résumé ajoutée comme dernier message utilisateur. Parce qu'elle partage votre préfixe, cette requête lit le cache existant plutôt que de retraiter l'historique complet. La plupart du temps de compaction va à la génération du résumé, pas à un cache miss. Le tour qui suit reconstruit le cache de conversation uniquement pour le résumé beaucoup plus court, donc le tour post-compaction n'est pas la partie lente.137Pour produire le résumé, Claude Code envoie une requête unique avec le même prompt système, les mêmes outils et le même historique que votre conversation, plus une instruction de résumé ajoutée comme dernier message utilisateur. Parce qu'elle partage votre préfixe, cette requête lit le cache existant plutôt que de retraiter l'historique complet. La plupart du temps de compaction va à la génération du résumé, pas à un cache miss. Le tour qui suit reconstruit le cache de conversation uniquement pour le résumé beaucoup plus court, donc le tour post-compaction n'est pas la partie lente.

138 138 

144 Mettre à niveau Claude Code144 Mettre à niveau Claude Code

145</h3>145</h3>

146 146 

147Une nouvelle version de Claude Code met généralement à jour le prompt système ou les définitions d'outils, donc la première requête après une mise à niveau reconstruit le cache à partir du début. La [mise à jour automatique](/fr/setup#auto-updates) télécharge les nouvelles versions en arrière-plan mais les applique au prochain lancement, jamais en cours de session, donc vous voyez cela comme un premier tour sans cache après redémarrage plutôt qu'une surprise pendant une session. Définissez `DISABLE_AUTOUPDATER=1` pour contrôler quand les mises à niveau s'appliquent.147Une nouvelle version de Claude Code met généralement à jour le prompt système ou les définitions d'outils, donc la première requête après une mise à niveau reconstruit le cache à partir du début. La [mise à jour automatique](/docs/fr/setup#auto-updates) télécharge les nouvelles versions en arrière-plan mais les applique au prochain lancement, jamais en cours de session, donc vous voyez cela comme un premier tour sans cache après redémarrage plutôt qu'une surprise pendant une session. Définissez `DISABLE_AUTOUPDATER=1` pour contrôler quand les mises à niveau s'appliquent.

148 148 

149<Note>149<Note>

150 [Reprendre une session](/fr/sessions#resume-a-session) après une mise à niveau retraite l'historique de conversation entier sans cache hits, puisque l'historique se trouve maintenant derrière un prompt système différent. Le coût s'adapte à la longueur de la conversation reprise, donc le premier tour de retour dans une longue session peut être la requête la plus coûteuse que vous envoyez.150 [Reprendre une session](/docs/fr/sessions#resume-a-session) après une mise à niveau retraite l'historique de conversation entier sans cache hits, puisque l'historique se trouve maintenant derrière un prompt système différent. Le coût s'adapte à la longueur de la conversation reprise, donc le premier tour de retour dans une longue session peut être la requête la plus coûteuse que vous envoyez.

151</Note>151</Note>

152 152 

153<h2 id="actions-that-keep-the-cache">153<h2 id="actions-that-keep-the-cache">

177 177 

178Vos fichiers CLAUDE.md au niveau de la racine du projet et au niveau utilisateur sont lus une fois au démarrage de la session et conservés en mémoire. Les éditer en cours de session n'invalide pas le cache, mais l'édition ne s'applique pas non plus. Claude continue de travailler avec la version qui a été chargée au démarrage de la session. Le nouveau contenu se charge au prochain `/clear`, `/compact`, ou redémarrage.178Vos fichiers CLAUDE.md au niveau de la racine du projet et au niveau utilisateur sont lus une fois au démarrage de la session et conservés en mémoire. Les éditer en cours de session n'invalide pas le cache, mais l'édition ne s'applique pas non plus. Claude continue de travailler avec la version qui a été chargée au démarrage de la session. Le nouveau contenu se charge au prochain `/clear`, `/compact`, ou redémarrage.

179 179 

180Les [fichiers CLAUDE.md imbriqués dans les sous-répertoires](/fr/memory) et les [règles avec frontmatter `paths:`](/fr/memory#path-specific-rules) se chargent plus tard, quand Claude lit pour la première fois un fichier correspondant. Éditer un avant qu'il se charge prend effet. Après son chargement, le contenu fait partie de l'historique de conversation, donc une édition en cours de session ne le change pas rétroactivement.180Les [fichiers CLAUDE.md imbriqués dans les sous-répertoires](/docs/fr/memory) et les [règles avec frontmatter `paths:`](/docs/fr/memory#path-specific-rules) se chargent plus tard, quand Claude lit pour la première fois un fichier correspondant. Éditer un avant qu'il se charge prend effet. Après son chargement, le contenu fait partie de l'historique de conversation, donc une édition en cours de session ne le change pas rétroactivement.

181 181 

182<h3 id="changing-output-style">182<h3 id="changing-output-style">

183 Changer le style de sortie183 Changer le style de sortie

184</h3>184</h3>

185 185 

186Le [style de sortie](/fr/output-styles) fait partie du prompt système, que Claude Code lit une fois au démarrage de la session. Le changer via `/config` ou le paramètre `outputStyle` en cours de session n'invalide pas le cache, mais le changement ne s'applique pas non plus. Claude continue d'utiliser le style qui a été chargé au démarrage de la session. Le nouveau style se charge au prochain `/clear` ou redémarrage.186Le [style de sortie](/docs/fr/output-styles) fait partie du prompt système, que Claude Code lit une fois au démarrage de la session. Le changer via `/config` ou le paramètre `outputStyle` en cours de session n'invalide pas le cache, mais le changement ne s'applique pas non plus. Claude continue d'utiliser le style qui a été chargé au démarrage de la session. Le nouveau style se charge au prochain `/clear` ou redémarrage.

187 187 

188<h3 id="changing-permission-mode">188<h3 id="changing-permission-mode">

189 Changer le mode de permission189 Changer le mode de permission

190</h3>190</h3>

191 191 

192Basculer entre les [modes de permission](/fr/permission-modes), comme du défaut à accepter les éditions, ne change pas le prompt système ou les définitions d'outils, donc les changements de mode sont sûrs pour le cache. L'exception est le mode plan avec le paramètre de modèle [`opusplan`](/fr/model-config#opusplan-model-setting), qui bascule le modèle entre Opus et Sonnet quand vous entrez ou quittez le mode plan. Cela rend le basculement de mode un [changement de modèle](#switching-models).192Basculer entre les [modes de permission](/docs/fr/permission-modes), comme du défaut à accepter les éditions, ne change pas le prompt système ou les définitions d'outils, donc les changements de mode sont sûrs pour le cache. L'exception est le mode plan avec le paramètre de modèle [`opusplan`](/docs/fr/model-config#opusplan-model-setting), qui bascule le modèle entre Opus et Sonnet quand vous entrez ou quittez le mode plan. Cela rend le basculement de mode un [changement de modèle](#switching-models).

193 193 

194<h3 id="invoking-skills-and-commands">194<h3 id="invoking-skills-and-commands">

195 Invoquer des compétences et des commandes195 Invoquer des compétences et des commandes

196</h3>196</h3>

197 197 

198Les [compétences](/fr/skills) et les [commandes](/fr/commands) injectent leurs instructions comme messages utilisateur au point d'invocation. Rien d'antérieur dans la conversation ne change.198Les [compétences](/docs/fr/skills) et les [commandes](/docs/fr/commands) injectent leurs instructions comme messages utilisateur au point d'invocation. Rien d'antérieur dans la conversation ne change.

199 199 

200<h3 id="running-/recap">200<h3 id="running-/recap">

201 Exécuter `/recap`201 Exécuter `/recap`

202</h3>202</h3>

203 203 

204[`/recap`](/fr/interactive-mode#session-recap) génère un résumé pour l'affichage dans votre terminal. Contrairement à `/compact`, il ajoute le résumé comme sortie de commande plutôt que de remplacer votre historique de messages, de sorte que le préfixe en cache reste intact.204[`/recap`](/docs/fr/interactive-mode#session-recap) génère un résumé pour l'affichage dans votre terminal. Contrairement à `/compact`, il ajoute le résumé comme sortie de commande plutôt que de remplacer votre historique de messages, de sorte que le préfixe en cache reste intact.

205 205 

206<h3 id="rewinding-the-conversation">206<h3 id="rewinding-the-conversation">

207 Rembobiner la conversation207 Rembobiner la conversation

208</h3>208</h3>

209 209 

210[`/rewind`](/fr/checkpointing) tronque votre conversation jusqu'à un tour antérieur. L'historique restant est le même contenu à partir duquel le cache a été construit à ce moment, et les couches du prompt système et du contexte du projet sont inchangées, donc la requête suivante atteint l'entrée de cache antérieure. Chaque tour depuis a lu ce préfixe, ce qui a gardé l'entrée active même si le tour original était plus loin que le TTL.210[`/rewind`](/docs/fr/checkpointing) tronque votre conversation jusqu'à un tour antérieur. L'historique restant est le même contenu à partir duquel le cache a été construit à ce moment, et les couches du prompt système et du contexte du projet sont inchangées, donc la requête suivante atteint l'entrée de cache antérieure. Chaque tour depuis a lu ce préfixe, ce qui a gardé l'entrée active même si le tour original était plus loin que le TTL.

211 211 

212Restaurer les points de contrôle de fichiers aux côtés de la conversation n'a aucun effet séparé sur le cache. Le contenu des fichiers entre en contexte uniquement quand Claude les lit, comme [éditer des fichiers dans votre référentiel](#editing-files-in-your-repository).212Restaurer les points de contrôle de fichiers aux côtés de la conversation n'a aucun effet séparé sur le cache. Le contenu des fichiers entre en contexte uniquement quand Claude les lit, comme [éditer des fichiers dans votre référentiel](#editing-files-in-your-repository).

213 213 

239 Remplacer le TTL239 Remplacer le TTL

240</h3>240</h3>

241 241 

242Définissez `FORCE_PROMPT_CACHING_5M=1` pour forcer le TTL de cinq minutes indépendamment de l'authentification. Ceci est utile quand vous déboguez le comportement du cache, comparez les deux TTL, ou remplacez un `ENABLE_PROMPT_CACHING_1H` défini dans les [paramètres gérés](/fr/settings#settings-files).242Définissez `FORCE_PROMPT_CACHING_5M=1` pour forcer le TTL de cinq minutes indépendamment de l'authentification. Ceci est utile quand vous déboguez le comportement du cache, comparez les deux TTL, ou remplacez un `ENABLE_PROMPT_CACHING_1H` défini dans les [paramètres gérés](/docs/fr/settings#settings-files).

243 243 

244<h2 id="cache-scope">244<h2 id="cache-scope">

245 Portée du cache245 Portée du cache

249 249 

250Les sessions que vous exécutez en parallèle dans le même répertoire construisent des préfixes correspondants et lisent le cache de l'autre. Les sessions séquentielles partagent le préfixe uniquement quand l'instantané du statut git au démarrage correspond, puisque le prompt système capture également la branche et les commits récents.250Les sessions que vous exécutez en parallèle dans le même répertoire construisent des préfixes correspondants et lisent le cache de l'autre. Les sessions séquentielles partagent le préfixe uniquement quand l'instantané du statut git au démarrage correspond, puisque le prompt système capture également la branche et les commits récents.

251 251 

252Le cache API sous-jacent est plus large. Les caches sont isolés entre les organisations, et sur certains fournisseurs, [entre les espaces de travail au sein d'une organisation](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#cache-storage-and-sharing). Dans ces limites, deux requêtes quelconques avec le même modèle et préfixe lisent le même cache. Pour les appelants du SDK Agent exécutant des flottes de processus automatisés, voir [améliorer le prompt caching entre les utilisateurs et les machines](/fr/agent-sdk/modifying-system-prompts#improve-prompt-caching-across-users-and-machines) pour supprimer les sections par machine du prompt système et partager le cache entre les machines.252Le cache API sous-jacent est plus large. Les caches sont isolés entre les organisations, et sur certains fournisseurs, [entre les espaces de travail au sein d'une organisation](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching#cache-storage-and-sharing). Dans ces limites, deux requêtes quelconques avec le même modèle et préfixe lisent le même cache. Pour les appelants du SDK Agent exécutant des flottes de processus automatisés, voir [améliorer le prompt caching entre les utilisateurs et les machines](/docs/fr/agent-sdk/modifying-system-prompts#improve-prompt-caching-across-users-and-machines) pour supprimer les sections par machine du prompt système et partager le cache entre les machines.

253 253 

254<h2 id="check-cache-performance">254<h2 id="check-cache-performance">

255 Vérifier les performances du cache255 Vérifier les performances du cache

256</h2>256</h2>

257 257 

258Les performances du cache s'affichent comme deux comptages de jetons que l'API rapporte sur chaque réponse. Le moyen le plus direct de les regarder en direct est un [script de ligne d'état](/fr/statusline) qui lit l'objet `current_usage` :258Les performances du cache s'affichent comme deux comptages de jetons que l'API rapporte sur chaque réponse. Le moyen le plus direct de les regarder en direct est un [script de ligne d'état](/docs/fr/statusline) qui lit l'objet `current_usage` :

259 259 

260| Champ | Signification |260| Champ | Signification |

261| ----------------------------- | -------------------------------------------------------------------------------------------- |261| ----------------------------- | -------------------------------------------------------------------------------------------- |

264 264 

265Un ratio lecture-création élevé signifie que le caching fonctionne bien. Si la création reste élevée tour après tour, quelque chose change dans votre préfixe. La section [Actions qui invalident le cache](#actions-that-invalidate-the-cache) énumère les causes habituelles.265Un ratio lecture-création élevé signifie que le caching fonctionne bien. Si la création reste élevée tour après tour, quelque chose change dans votre préfixe. La section [Actions qui invalident le cache](#actions-that-invalidate-the-cache) énumère les causes habituelles.

266 266 

267Pour la visibilité dans une organisation, l'exportateur OpenTelemetry rapporte les jetons de lecture et de création du cache par utilisateur et session. Voir [Surveiller l'utilisation](/fr/monitoring-usage) pour la référence des attributs de métrique et d'événement.267Pour la visibilité dans une organisation, l'exportateur OpenTelemetry rapporte les jetons de lecture et de création du cache par utilisateur et session. Voir [Surveiller l'utilisation](/docs/fr/monitoring-usage) pour la référence des attributs de métrique et d'événement.

268 268 

269<h2 id="subagents-and-the-cache">269<h2 id="subagents-and-the-cache">

270 Sous-agents et le cache270 Sous-agents et le cache

271</h2>271</h2>

272 272 

273Un [sous-agent](/fr/sub-agents) démarre sa propre conversation avec son propre prompt système et ensemble d'outils, séparé du parent. Il construit son propre cache, en commençant sans cache hits à son premier appel et en se réchauffant à travers ses propres tours. Les sous-agents utilisent le TTL de cinq minutes même sur un abonnement, puisque le TTL d'une heure automatique s'applique à la conversation principale.273Un [sous-agent](/docs/fr/sub-agents) démarre sa propre conversation avec son propre prompt système et ensemble d'outils, séparé du parent. Il construit son propre cache, en commençant sans cache hits à son premier appel et en se réchauffant à travers ses propres tours. Les sous-agents utilisent le TTL de cinq minutes même sur un abonnement, puisque le TTL d'une heure automatique s'applique à la conversation principale.

274 274 

275Le cache du parent n'est pas affecté. Du côté du parent, l'appel du sous-agent et le résultat s'ajoutent à la conversation, laissant le préfixe du parent intact.275Le cache du parent n'est pas affecté. Du côté du parent, l'appel du sous-agent et le résultat s'ajoutent à la conversation, laissant le préfixe du parent intact.

276 276 

277Un [fork](/fr/sub-agents#fork-the-current-conversation), en contraste, hérite du prompt système du parent, des outils, et de l'historique de conversation exactement, donc sa première requête lit le cache du parent. L'appel de résumé de compaction décrit dans [Compacter la conversation](#compacting-the-conversation) utilise la même approche de partage de préfixe.277Un [fork](/docs/fr/sub-agents#fork-the-current-conversation), en contraste, hérite du prompt système du parent, des outils, et de l'historique de conversation exactement, donc sa première requête lit le cache du parent. L'appel de résumé de compaction décrit dans [Compacter la conversation](#compacting-the-conversation) utilise la même approche de partage de préfixe.

278 278 

279<h2 id="disable-prompt-caching">279<h2 id="disable-prompt-caching">

280 Désactiver le prompt caching280 Désactiver le prompt caching

290| `DISABLE_PROMPT_CACHING_OPUS` | Désactiver pour Opus uniquement |290| `DISABLE_PROMPT_CACHING_OPUS` | Désactiver pour Opus uniquement |

291| `DISABLE_PROMPT_CACHING_FABLE` | Désactiver pour Fable uniquement |291| `DISABLE_PROMPT_CACHING_FABLE` | Désactiver pour Fable uniquement |

292 292 

293Pour définir la politique de caching dans une organisation, mettez l'une de ces variables ou les [variables TTL](#cache-lifetime) dans le bloc `env` des [paramètres gérés](/fr/settings#settings-files). Pour un usage normal, laissez le caching activé.293Pour définir la politique de caching dans une organisation, mettez l'une de ces variables ou les [variables TTL](#cache-lifetime) dans le bloc `env` des [paramètres gérés](/docs/fr/settings#settings-files). Pour un usage normal, laissez le caching activé.

294 294 

295<h2 id="related-resources">295<h2 id="related-resources">

296 Ressources connexes296 Ressources connexes

297</h2>297</h2>

298 298 

299* [Leçons de la construction de Claude Code : Le prompt caching est tout](https://claude.com/blog/lessons-from-building-claude-code-prompt-caching-is-everything) : la justification de la conception pour le mode plan, le chargement d'outils différé, et la compaction299* [Leçons de la construction de Claude Code : Le prompt caching est tout](https://claude.com/blog/lessons-from-building-claude-code-prompt-caching-is-everything) : la justification de la conception pour le mode plan, le chargement d'outils différé, et la compaction

300* [Explorer la fenêtre de contexte](/fr/context-window) : ce qui se charge en contexte et quand300* [Explorer la fenêtre de contexte](/docs/fr/context-window) : ce qui se charge en contexte et quand

301* [Réduire l'utilisation des jetons](/fr/costs#reduce-token-usage) : stratégies au-delà du caching pour gérer la taille du contexte301* [Réduire l'utilisation des jetons](/docs/fr/costs#reduce-token-usage) : stratégies au-delà du caching pour gérer la taille du contexte

302* [Suivre et réduire les coûts](/fr/agent-sdk/cost-tracking) : suivi des jetons de cache et configuration du TTL pour les appelants du SDK Agent302* [Suivre et réduire les coûts](/docs/fr/agent-sdk/cost-tracking) : suivi des jetons de cache et configuration du TTL pour les appelants du SDK Agent

303* [Prompt caching](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) : le mécanisme API sous-jacent, les points d'arrêt, et la tarification303* [Prompt caching](https://platform.claude.com/docs/fr/build-with-claude/prompt-caching) : le mécanisme API sous-jacent, les points d'arrêt, et la tarification