---
title: Déployer des tunnels MCP avec Docker Compose
url: https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose
description: Installez la pile de tunnel MCP sur une VM à l'aide de Docker Compose.
---

<Note>
  Les « MCP tunnels » (tunnels MCP) sont en « research preview » (aperçu de recherche). [Demandez l'accès](https://claude.com/form/mcp-tunnels) pour les essayer.
</Note>

Ce guide déploie la [pile de tunnel](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) sous forme de conteneurs durcis sur un seul hôte. La même configuration peut être répliquée sur plusieurs hôtes pour la disponibilité.

## Avant de commencer

Vous avez besoin de :

* **Un tunnel.** Avec l'accès programmatique, le [composant de configuration](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) (setup component) en crée un pour vous lorsque vous ne fournissez pas d'ID de tunnel ; pour vous rattacher à un tunnel existant à la place, [créez-le dans la Console](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/console#create-a-tunnel) et notez l'ID du tunnel (`tnl_...`). Le provisionnement manuel part toujours d'un tunnel créé dans la Console.

* **Un moyen pour l'hôte de s'authentifier auprès de l'API Tunnels.**

  * **Accès programmatique (recommandé).** Activez **Set up programmatic access** lors de la création du tunnel afin que le composant de configuration puisse s'authentifier via Workload Identity Federation. Si vous laissez le composant de configuration créer le tunnel, créez plutôt la règle de fédération directement sur la page [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`) dans la Claude Console. Notez l'ID de la règle de fédération (`fdrl_...`) et l'ID de votre organisation.
  * **Manuel.** Ignorez l'accès programmatique. Vous [récupérerez le jeton du tunnel depuis la Console](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/console#get-the-connection-details), générerez vous-même une CA et un certificat serveur, puis [enregistrerez la CA dans la Console](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/console#add-a-ca-certificate).

* **Un hôte avec Docker et Docker Compose** installés. Le flux manuel nécessite également `openssl` (1.1.1 ou ultérieur).

* **Une connectivité réseau sortante** depuis l'hôte vers `api.anthropic.com` (443 TCP) et la [périphérie du tunnel](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) (tunnel edge) (7844 TCP et UDP). Consultez l'ensemble des [exigences réseau](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/overview#network-requirements).

* **Un ou plusieurs serveurs MCP** en cours d'exécution et joignables depuis l'hôte aux adresses que vous configurerez sous `routes`. Si vous n'en avez pas encore, [utilisez le serveur d'exemple](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server).

## Facultatif : utiliser un serveur MCP d'exemple

Si vous ne disposez pas d'un serveur MCP pour les tests, utilisez ce serveur minimal :

```bash
mkdir -p mcp-tunnel
cat > mcp-tunnel/hello_server.py <<'EOF'
from mcp.server.fastmcp import FastMCP

mcp = FastMCP("hello-server", host="0.0.0.0", port=9000)


@mcp.tool()
def hello(name: str = "world") -> str:
    """Say hello to someone."""
    return f"Hello, {name}!"


if __name__ == "__main__":
    mcp.run(transport="streamable-http")
EOF
```

Les étapes d'installation suivantes font un `cd` dans `mcp-tunnel/` et indiquent où ajouter le service et la route correspondants.

## Installation

Ce guide fournit une approche de référence utilisant Docker Compose. Il vous incombe de l'adapter pour répondre aux exigences de sécurité de votre organisation.

<Tabs>
  <Tab title="Avec accès programmatique">
    Ce parcours nécessite que l'hôte dispose d'un fournisseur d'identité OIDC (tel qu'un serveur de métadonnées de VM cloud ou SPIFFE). Si ce n'est pas le cas, utilisez plutôt l'onglet **Sans accès programmatique**.

    Le composant de configuration utilise Workload Identity Federation pour récupérer le jeton du tunnel, générer une CA et un certificat serveur, et enregistrer la CA auprès d'Anthropic.

    <Steps>
      <Step title="Préparer le répertoire de déploiement">
        ```bash
        mkdir -p mcp-tunnel/{config,data}
        cd mcp-tunnel
        sudo chown 65532:65532 data
        ```

        Les conteneurs s'exécutent sous l'UID non root `65532` et ont besoin d'un accès en écriture à `data/`.
      </Step>

      <Step title="Écrire docker-compose.yaml">
        Le fichier compose épingle les images par empreinte SHA-256, exécute chaque conteneur en tant que non root avec un système de fichiers en lecture seule, supprime toutes les capacités Linux et désactive l'élévation de privilèges.

        ```bash
        cat > docker-compose.yaml <<'EOF'
        services:
          setup:
            image: us-docker.pkg.dev/anthropic-public-registry/images/mcp-proxy@sha256:efb27b299d627e4134815663cb8896641eeaee025d734c0f695582b4df38f013
            entrypoint: ["/setup"]
            command:
              - init
              - --api-url=https://api.anthropic.com
              - --output=dir:/data
              - --token-version=1
            environment:
              - TUNNEL_ID
              - ANTHROPIC_FEDERATION_RULE_ID
              - ANTHROPIC_ORGANIZATION_ID
              - ANTHROPIC_WORKSPACE_ID
              - ANTHROPIC_IDENTITY_TOKEN
            volumes:
              - ./data:/data
            user: "65532:65532"
            read_only: true
            security_opt:
              - no-new-privileges:true
            cap_drop:
              - ALL
            profiles: ["setup"]

          cloudflared:
            image: cloudflare/cloudflared@sha256:6b599ca3e974349ead3286d178da61d291961182ec3fe9c505e1dd02c8ac31b0
            command: tunnel --no-autoupdate run --url http://localhost:8080
            environment:
              - TUNNEL_TOKEN
            # Partage le netns du proxy pour que localhost:8080 l'atteigne.
            network_mode: "service:mcp-proxy"
            restart: unless-stopped
            user: "65532:65532"
            read_only: true
            security_opt:
              - no-new-privileges:true
            cap_drop:
              - ALL
            stop_grace_period: 30s
            logging:
              options:
                max-size: "10m"
                max-file: "3"

          mcp-proxy:
            image: us-docker.pkg.dev/anthropic-public-registry/images/mcp-proxy@sha256:efb27b299d627e4134815663cb8896641eeaee025d734c0f695582b4df38f013
            volumes:
              - ./config/mcp-proxy.yaml:/etc/mcp-gateway/config.yaml:ro
              - ./data:/data:ro
            restart: unless-stopped
            user: "65532:65532"
            read_only: true
            security_opt:
              - no-new-privileges:true
            cap_drop:
              - ALL
            stop_grace_period: 30s
            logging:
              options:
                max-size: "10m"
                max-file: "3"
        EOF
        ```

        Si vous utilisez le [serveur MCP d'exemple](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server), ajoutez-le en tant que service :

        ```bash
        cat >> docker-compose.yaml <<'EOF'

          hello-mcp:
            image: python:3.13-slim
            working_dir: /app
            volumes:
              - ./hello_server.py:/app/hello_server.py:ro
            command: sh -c "pip install --quiet mcp && python hello_server.py"
            restart: unless-stopped
        EOF
        ```
      </Step>

      <Step title="Provisionner le tunnel">
        Définissez les identifiants. Laissez `TUNNEL_ID` non défini pour que le composant de configuration crée un tunnel ; définissez-le pour vous rattacher à un tunnel existant depuis la [Console](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/console#create-a-tunnel) :

        ```bash
        # export TUNNEL_ID=tnl_...   # à définir pour se rattacher à un tunnel existant
        export ANTHROPIC_FEDERATION_RULE_ID=fdrl_...
        export ANTHROPIC_ORGANIZATION_ID=00000000-0000-0000-0000-000000000000
        ```

        Si votre règle de fédération est limitée à un espace de travail autre que celui par défaut de votre organisation, définissez également `ANTHROPIC_WORKSPACE_ID=wrkspc_...` ; sinon, le composant de configuration utilise l'espace de travail par défaut. Un tunnel créé automatiquement est créé dans cet espace de travail.

        Définissez `ANTHROPIC_IDENTITY_TOKEN` sur un JWT OIDC provenant du fournisseur d'identité de cet hôte. Suivez le [guide WIF de votre fournisseur](https://platform.claude.com/docs/fr/manage-claude/workload-identity-federation#identity-providers) pour enregistrer l'émetteur, définir le sujet de la règle et émettre le jeton ; l'audience de la règle doit correspondre à l'audience que vous demandez lors de l'émission.

        Exécutez le composant de configuration :

        ```bash
        docker compose run --rm setup
        ```

        `setup init` est idempotent sur `data/` : le réexécuter réutilise l'ID de tunnel et la CA déjà stockés à cet endroit et ne crée jamais de second tunnel. Une nouvelle CA n'est générée et enregistrée que lorsque `data/` est vide ou que `TUNNEL_ID` a changé ; dans ce cas, la limite de deux certificats actifs s'applique, donc révoquez-en d'abord un dans la Console si les deux emplacements sont occupés.

        Consultez [Échecs d'authentification du composant de configuration](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/troubleshooting#setup-component-authentication-failures) en cas d'erreur.

        Récupérez le domaine de votre tunnel et exportez-le pour les étapes suivantes :

        ```bash
        export TUNNEL_DOMAIN=$(sudo cat data/tunnel-domain)
        echo "$TUNNEL_DOMAIN"
        ```

        <Note>
          Les jetons Workload Identity Federation ont une durée de vie courte (1 heure par défaut) et expirent automatiquement ; il n'y a rien à révoquer une fois la configuration terminée.
        </Note>
      </Step>

      <Step title="Écrire la configuration du proxy">
        `tunnel_domain` est **obligatoire** : le [proxy](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) l'utilise pour retirer le suffixe de domaine des noms d'hôte entrants avant de rechercher le sous-domaine dans `routes`. `routes` est une table plate associant un sous-domaine à une URL amont, et non une liste.

        ```bash
        cat > config/mcp-proxy.yaml <<EOF
        listen_addr: ":8080"
        log_level: info
        shutdown_timeout: 30s
        tunnel_domain: ${TUNNEL_DOMAIN}
        tls:
          cert_file: /data/tls.crt
          key_file: /data/tls.key
        routes:
          echo: http://hello-mcp:9000
        EOF
        ```

        La route `echo:` cible le [serveur MCP d'exemple](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server) ; remplacez-la par vos propres routes (ou ajoutez-les). Consultez la référence de [configuration du proxy](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/reference#proxy-configuration) pour tous les champs disponibles.
      </Step>

      <Step title="Démarrer le déploiement">
        ```bash
        export TUNNEL_TOKEN=$(sudo cat data/tunnel-token)
        docker compose up -d
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Sans accès programmatique">
    Utilisez ce flux si vous n'avez pas activé **Set up programmatic access**, ou pour le développement et les tests en local. Il n'y a pas de service `setup`.

    <Steps>
      <Step title="Récupérer le jeton et le domaine du tunnel depuis la Console">
        Sur la page de détail du tunnel, copiez le **Domain** (il a la forme `abcd1234.tunnel.anthropic.com`), puis cliquez sur l'icône en forme d'œil à côté de **Token** pour récupérer le jeton du tunnel et utilisez l'icône de copie pour le copier.

        Définissez les deux comme variables de shell pour le reste du guide :

        ```bash
        export TUNNEL_DOMAIN=YOUR_TUNNEL_DOMAIN_HERE
        export TUNNEL_TOKEN='eyJ...'
        ```
      </Step>

      <Step title="Préparer la structure et générer les certificats">
        ```bash
        mkdir -p mcp-tunnel/{data,config}
        cd mcp-tunnel
        ```

        Le proxy écoute sur `:8080` en WebSocket non chiffré ; la négociation [TLS interne](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) (inner TLS) a lieu **à l'intérieur** de ce flux WebSocket à l'aide de ces certificats. Anthropic vérifie la négociation interne par rapport à la CA que vous enregistrez dans la Console. Le Subject Alternative Name (SAN) du certificat serveur doit inclure `*.<tunnel-domain>` conformément aux [exigences relatives aux certificats](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/reference#certificate-requirements).

        ```bash
        # CA auto-signée. Extensions explicites pour satisfaire aux exigences
        # de certificat quels que soient les défauts openssl.cnf de la distribution.
        openssl req -x509 -newkey rsa:2048 -nodes \
          -keyout data/ca.key -out data/ca.crt \
          -days 3650 -subj "/CN=mcp-tunnel-ca" \
          -addext "basicConstraints=critical,CA:TRUE" \
          -addext "keyUsage=critical,keyCertSign,cRLSign" \
          -addext "subjectKeyIdentifier=hash"

        # Fichier d'extensions pour le certificat serveur. Utiliser -extfile (au lieu de
        # -copy_extensions, réservé à OpenSSL 3.0+) garantit le fonctionnement sur
        # OpenSSL 1.1.x.
        cat > data/tls.ext <<EOF
        subjectAltName = DNS:${TUNNEL_DOMAIN},DNS:*.${TUNNEL_DOMAIN}
        authorityKeyIdentifier = keyid,issuer
        extendedKeyUsage = serverAuth
        EOF

        # Certificat serveur signé par la CA
        openssl req -newkey rsa:2048 -nodes \
          -keyout data/tls.key -out /tmp/server.csr \
          -subj "/CN=${TUNNEL_DOMAIN}"
        openssl x509 -req -in /tmp/server.csr \
          -CA data/ca.crt -CAkey data/ca.key -CAcreateserial \
          -out data/tls.crt -days 90 \
          -extfile data/tls.ext

        # Autoriser le conteneur proxy non root (UID 65532) à lire la clé depuis
        # le bind mount. Sans le bit de lecture pour tous, le conteneur ne peut pas ouvrir
        # un fichier appartenant à l'hôte.
        chmod 644 data/tls.key
        ```
      </Step>

      <Step title="Enregistrer le certificat CA dans la Console">
        Sur la page de détail du tunnel, faites défiler jusqu'à la section **Certificates** et cliquez sur **Add certificate**. Téléversez `data/ca.crt` directement avec **Choose file** (la fenêtre modale accepte `.pem`, `.crt` et `.cer`), ou collez son contenu :

        ```bash
        cat data/ca.crt
        ```

        Le badge **Needs certificate** à côté du nom du tunnel disparaît dès qu'un certificat est enregistré. Consultez [Ajouter un certificat CA](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/console#add-a-ca-certificate).
      </Step>

      <Step title="Écrire la configuration du proxy">
        `tunnel_domain` est **obligatoire** : le proxy l'utilise pour retirer le suffixe de domaine des noms d'hôte entrants avant de rechercher le sous-domaine dans `routes`. `routes` est une table plate associant un sous-domaine à une URL amont, et non une liste.

        ```bash
        cat > config/mcp-proxy.yaml <<EOF
        listen_addr: ":8080"
        log_level: info
        tunnel_domain: ${TUNNEL_DOMAIN}
        tls:
          cert_file: /data/tls.crt
          key_file: /data/tls.key
        routes:
          echo: http://hello-mcp:9000
        EOF
        ```

        La route `echo:` cible le [serveur MCP d'exemple](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server) ; remplacez-la par vos propres routes (ou ajoutez-les). Consultez la référence de [configuration du proxy](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/reference#proxy-configuration) pour tous les champs disponibles.
      </Step>

      <Step title="Écrire docker-compose.yaml">
        Le paramètre `network_mode: "service:mcp-proxy"` place [cloudflared](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) dans l'espace de noms réseau du proxy afin que `localhost:8080` à l'intérieur du conteneur cloudflared atteigne le proxy. L'option `--url http://localhost:8080` indique à cloudflared sa cible de transfert ; sans cette option, cloudflared n'a aucune route pour les requêtes entrantes et renvoie une erreur 503.

        ```bash
        cat > docker-compose.yaml <<'EOF'
        services:
          cloudflared:
            image: cloudflare/cloudflared@sha256:6b599ca3e974349ead3286d178da61d291961182ec3fe9c505e1dd02c8ac31b0
            # --url est requis : aucune règle d'ingress n'est poussée dans le flux manuel,
            # donc sans lui, cloudflared renvoie une erreur 503 pour chaque requête.
            command: tunnel --no-autoupdate run --url http://localhost:8080
            environment:
              - TUNNEL_TOKEN
            # Partager le netns du proxy pour que localhost:8080 l'atteigne.
            network_mode: "service:mcp-proxy"
            restart: unless-stopped
            user: "65532:65532"
            read_only: true
            security_opt:
              - no-new-privileges:true
            cap_drop:
              - ALL
            stop_grace_period: 30s
            logging:
              options:
                max-size: "10m"
                max-file: "3"

          mcp-proxy:
            image: us-docker.pkg.dev/anthropic-public-registry/images/mcp-proxy@sha256:efb27b299d627e4134815663cb8896641eeaee025d734c0f695582b4df38f013
            volumes:
              - ./config/mcp-proxy.yaml:/etc/mcp-gateway/config.yaml:ro
              - ./data:/data:ro
            restart: unless-stopped
            user: "65532:65532"
            read_only: true
            security_opt:
              - no-new-privileges:true
            cap_drop:
              - ALL
            stop_grace_period: 30s
            logging:
              options:
                max-size: "10m"
                max-file: "3"
        EOF
        ```

        Si vous utilisez le [serveur MCP d'exemple](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server), ajoutez-le en tant que service :

        ```bash
        cat >> docker-compose.yaml <<'EOF'

          hello-mcp:
            image: python:3.13-slim
            working_dir: /app
            volumes:
              - ./hello_server.py:/app/hello_server.py:ro
            command: sh -c "pip install --quiet mcp && python hello_server.py"
            restart: unless-stopped
        EOF
        ```
      </Step>

      <Step title="Démarrer le déploiement">
        ```bash
        docker compose up -d
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

Le fichier compose lit `TUNNEL_TOKEN` depuis l'environnement de l'hôte sans valeur par défaut, de sorte que l'export doit être répété dans chaque nouveau shell et après un redémarrage.

Pour un déploiement multi-VM, copiez le répertoire `mcp-tunnel/` sur chaque hôte, définissez `TUNNEL_TOKEN` et exécutez `docker compose up -d`. Dans le flux programmatique, `TUNNEL_TOKEN` vaut `$(sudo cat data/tunnel-token)` ; dans le flux manuel, il s'agit de la valeur que vous avez copiée depuis la Console. Le même jeton de tunnel et les mêmes certificats fonctionnent sur toutes les répliques.

## Vérifier le déploiement

Vérifiez de bout en bout en appelant un [serveur MCP amont](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/concepts#components) (upstream MCP server) depuis le côté d'Anthropic : consultez [Utiliser les serveurs MCP tunnelisés](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/overview#use-the-tunneled-mcp-servers). Avec le [serveur MCP d'exemple](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server), l'URL routée est `https://echo.<your-tunnel-domain>/mcp`. Si la vérification échoue, consultez [Dépannage](https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/troubleshooting).

## Mises à niveau

Exécutez les commandes de cette section depuis le répertoire de déploiement `mcp-tunnel/`.

### Effectuer la rotation du jeton du tunnel

Avec l'accès programmatique, incrémentez `--token-version` dans la commande du service `setup`, définissez les identifiants Workload Identity Federation, émettez un nouveau JWT OIDC et réexécutez le composant de configuration :

```bash
# Modifiez docker-compose.yaml : incrémentez l'entier dans l'argument
# --token-version du service setup (par exemple, de --token-version=1 à
# --token-version=2). Le binaire setup refuse la rotation lorsque la valeur
# n'a pas changé.

# export TUNNEL_ID=tnl_...   # à définir uniquement si vous l'avez défini lors de l'installation
export ANTHROPIC_FEDERATION_RULE_ID=fdrl_...
export ANTHROPIC_ORGANIZATION_ID=00000000-0000-0000-0000-000000000000
# export ANTHROPIC_WORKSPACE_ID=wrkspc_...   # si votre règle est limitée à un espace de travail
# Régénérez ANTHROPIC_IDENTITY_TOKEN selon le guide du fournisseur WIF pour votre
# environnement (il aura expiré depuis l'installation).
export ANTHROPIC_IDENTITY_TOKEN=...

docker compose run --rm setup

export TUNNEL_TOKEN=$(sudo cat data/tunnel-token)
docker compose up -d cloudflared
```

L'argument `--token-version` est modifié dans `docker-compose.yaml` plutôt que passé en ligne de commande afin que la nouvelle valeur persiste pour les exécutions futures du composant de configuration. Le composant de configuration s'authentifie avec Workload Identity Federation ; il n'y a pas de jeton API à révoquer.

Sans accès programmatique, cliquez sur **Rotate token** sur la page de détail du tunnel dans la Console, puis mettez à jour la variable d'environnement `TUNNEL_TOKEN` sur chaque hôte et redémarrez cloudflared (`docker compose up -d cloudflared`).

<Warning>
  Cliquer sur **Rotate token** invalide immédiatement le jeton actuel. Entre ce moment et la mise à jour de `TUNNEL_TOKEN` sur chaque hôte suivie du redémarrage de cloudflared, tout hôte dont cloudflared redémarre (plantage, redémarrage de l'hôte) ne peut pas se reconnecter. Mettez à jour chaque hôte rapidement après la rotation.
</Warning>

### Renouvellement des certificats

Il vous incombe de surveiller l'expiration et de renouveler le certificat serveur avant qu'il n'expire.

Avec l'accès programmatique :

```bash
docker compose run --rm setup renew-cert --output=dir:/data
```

Les arguments CLI remplacent la `command` du service `setup` (les arguments `init`) mais conservent son `entrypoint`, de sorte que cela exécute `/setup renew-cert --output=dir:/data`.

<Tip>
  Passez `--renew-before=720h` pour que la commande soit sans effet lorsqu'il reste plus de 30 jours de validité. Cela permet de l'exécuter en toute sécurité selon un calendrier fixe.
</Tip>

Sans accès programmatique, signez un nouveau certificat serveur avec votre CA existante (la CA enregistrée dans la Console ne change pas) et remplacez `data/tls.crt`. Définissez d'abord `TUNNEL_DOMAIN` si vous exécutez ceci depuis un nouveau shell.

```bash
export TUNNEL_DOMAIN=YOUR_TUNNEL_DOMAIN_HERE
openssl req -new -key data/tls.key -out /tmp/server.csr \
  -subj "/CN=${TUNNEL_DOMAIN}"
openssl x509 -req -in /tmp/server.csr \
  -CA data/ca.crt -CAkey data/ca.key -CAcreateserial \
  -out data/tls.crt -days 90 \
  -extfile data/tls.ext
```

Dans les deux flux, le proxy interroge `tls.cert_file` et le recharge automatiquement, de sorte qu'aucun redémarrage n'est nécessaire.

## Étapes suivantes

<CardGroup cols={2}>
  <Card title="Utiliser les serveurs MCP tunnelisés" icon="link" href="https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/overview#use-the-tunneled-mcp-servers">
    Rattachez un serveur MCP amont à un Managed Agent ou à l'API Messages.
  </Card>

  <Card title="Sécurité" icon="lock" href="https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/security">
    Conseils de durcissement, rotation des identifiants et réponse aux violations.
  </Card>

  <Card title="Dépannage" icon="wrench" href="https://platform.claude.com/docs/fr/agents-and-tools/mcp-tunnels/troubleshooting">
    Diagnostiquez les problèmes de connectivité, de TLS et de routage.
  </Card>
</CardGroup>