---
title: MCP-Tunnel mit Docker Compose bereitstellen
url: https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose
description: Installiere den MCP-Tunnel-Stack auf einer VM mit Docker Compose.
---

<Note>
  „MCP tunnels" (MCP-Tunnel) befinden sich in der „research preview" (Forschungsvorschau). [Fordere Zugang an](https://claude.com/form/mcp-tunnels), um sie auszuprobieren.
</Note>

Diese Anleitung stellt den [Tunnel-Stack](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components) als gehärtete Container auf einem einzelnen Host bereit. Dieselbe Konfiguration kann für Verfügbarkeit auf mehrere Hosts repliziert werden.

## Bevor du beginnst

Du benötigst:

* **Einen Tunnel.** Mit programmatischem Zugriff erstellt die [Setup-Komponente](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components) einen für dich, wenn du keine Tunnel-ID angibst; um stattdessen einen bestehenden Tunnel anzubinden, [erstelle ihn in der Console](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/console#create-a-tunnel) und notiere die Tunnel-ID (`tnl_...`). Die manuelle Bereitstellung beginnt immer mit einem in der Console erstellten Tunnel.

* **Eine Möglichkeit für den Host, sich bei der Tunnels API zu authentifizieren.**

  * **Programmatischer Zugriff (empfohlen).** Aktiviere beim Erstellen des Tunnels **Set up programmatic access**, damit sich die Setup-Komponente über Workload Identity Federation authentifizieren kann. Wenn du die Setup-Komponente den Tunnel erstellen lässt, erstelle die Föderationsregel stattdessen direkt auf der Seite [Workload identity](https://platform.claude.com/settings/workload-identity-federation) (`platform.claude.com/settings/workload-identity-federation`) in der Claude Console. Notiere die Föderationsregel-ID (`fdrl_...`) und deine Organisations-ID.
  * **Manuell.** Überspringe den programmatischen Zugriff. Du [holst das Tunnel-Token aus der Console](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/console#get-the-connection-details), erzeugst selbst eine CA und ein Serverzertifikat und [registrierst die CA in der Console](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/console#add-a-ca-certificate).

* **Einen Host mit installiertem Docker und Docker Compose**. Der manuelle Ablauf erfordert außerdem `openssl` (1.1.1 oder neuer).

* **Ausgehende Netzwerkkonnektivität** vom Host zu `api.anthropic.com` (443 TCP) und zum [Tunnel-Edge](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components) (7844 TCP und UDP). Siehe die vollständigen [Netzwerkanforderungen](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview#network-requirements).

* **Einen oder mehrere MCP-Server**, die laufen und vom Host unter den Adressen erreichbar sind, die du unter `routes` konfigurierst. Wenn du noch keinen hast, [verwende den Beispielserver](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server).

## Optional: Einen Beispiel-MCP-Server verwenden

Wenn du keinen MCP-Server zum Testen zur Verfügung hast, verwende diesen minimalen:

```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
```

Die folgenden Installationsschritte wechseln mit `cd` in `mcp-tunnel/` und weisen darauf hin, wo der entsprechende Service und die Route hinzuzufügen sind.

## Installieren

Diese Anleitung bietet einen Referenzansatz mit Docker Compose. Du bist dafür verantwortlich, ihn an die Sicherheitsanforderungen deiner Organisation anzupassen.

<Tabs>
  <Tab title="Mit programmatischem Zugriff">
    Dieser Weg erfordert, dass der Host über einen OIDC-Identitätsanbieter verfügt (etwa einen Metadatenserver einer Cloud-VM oder SPIFFE). Falls nicht, verwende stattdessen den Tab **Ohne programmatischen Zugriff**.

    Die Setup-Komponente verwendet Workload Identity Federation, um das Tunnel-Token abzurufen, eine CA und ein Serverzertifikat zu erzeugen und die CA bei Anthropic zu registrieren.

    <Steps>
      <Step title="Das Bereitstellungsverzeichnis vorbereiten">
        ```bash
        mkdir -p mcp-tunnel/{config,data}
        cd mcp-tunnel
        sudo chown 65532:65532 data
        ```

        Die Container laufen als Nicht-Root-UID `65532` und benötigen Schreibzugriff auf `data/`.
      </Step>

      <Step title="docker-compose.yaml schreiben">
        Die Compose-Datei pinnt Images per SHA-256-Digest, führt jeden Container als Nicht-Root mit schreibgeschütztem Dateisystem aus, entfernt alle Linux-Capabilities und deaktiviert die Rechteausweitung.

        ```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
            # Teile den netns des Proxys, damit localhost:8080 ihn erreicht.
            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
        ```

        Wenn du den [Beispiel-MCP-Server](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server) verwendest, hänge ihn als Service an:

        ```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="Den Tunnel bereitstellen">
        Setze die Kennungen. Lass `TUNNEL_ID` ungesetzt, damit die Setup-Komponente einen Tunnel erstellt; setze sie, um einen bestehenden Tunnel aus der [Console](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/console#create-a-tunnel) anzubinden:

        ```bash
        # export TUNNEL_ID=tnl_...   # setzen, um an einen bestehenden Tunnel anzuhängen
        export ANTHROPIC_FEDERATION_RULE_ID=fdrl_...
        export ANTHROPIC_ORGANIZATION_ID=00000000-0000-0000-0000-000000000000
        ```

        Wenn deine Föderationsregel auf einen anderen Workspace als den Standard-Workspace deiner Organisation beschränkt ist, setze zusätzlich `ANTHROPIC_WORKSPACE_ID=wrkspc_...`; andernfalls verwendet die Setup-Komponente den Standard-Workspace. Ein automatisch erstellter Tunnel wird in diesem Workspace erstellt.

        Setze `ANTHROPIC_IDENTITY_TOKEN` auf ein OIDC-JWT vom Identitätsanbieter dieses Hosts. Folge der [WIF-Anleitung für deinen Anbieter](https://platform.claude.com/docs/de/manage-claude/workload-identity-federation#identity-providers), um den Issuer zu registrieren, das Subject der Regel zu setzen und das Token auszustellen; die Audience der Regel muss mit der Audience übereinstimmen, die du beim Ausstellen anforderst.

        Führe die Setup-Komponente aus:

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

        `setup init` ist idempotent bezüglich `data/`: Ein erneutes Ausführen verwendet die dort bereits gespeicherte Tunnel-ID und CA wieder und erstellt niemals einen zweiten Tunnel. Eine neue CA wird nur erzeugt und registriert, wenn `data/` leer ist oder sich `TUNNEL_ID` geändert hat; in diesem Fall gilt die Obergrenze von zwei aktiven Zertifikaten, widerrufe also zuerst eines in der Console, wenn beide Plätze belegt sind.

        Siehe [Authentifizierungsfehler der Setup-Komponente](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/troubleshooting#setup-component-authentication-failures), falls ein Fehler auftritt.

        Rufe deine Tunnel-Domain ab und exportiere sie für spätere Schritte:

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

        <Note>
          Workload-Identity-Federation-Token sind kurzlebig (standardmäßig 1 Stunde) und laufen automatisch ab; nach Abschluss des Setups gibt es nichts zu widerrufen.
        </Note>
      </Step>

      <Step title="Die Proxy-Konfiguration schreiben">
        `tunnel_domain` ist **erforderlich**: Der [Proxy](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components) verwendet sie, um das Domain-Suffix von eingehenden Hostnamen zu entfernen, bevor er die Subdomain in `routes` nachschlägt. `routes` ist eine flache Map von Subdomain zu Upstream-URL, keine 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
        ```

        Die Route `echo:` zielt auf den [Beispiel-MCP-Server](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server); ersetze sie durch deine eigenen Routen (oder füge diese hinzu). Siehe die Referenz zur [Proxy-Konfiguration](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/reference#proxy-configuration) für alle verfügbaren Felder.
      </Step>

      <Step title="Die Bereitstellung starten">
        ```bash
        export TUNNEL_TOKEN=$(sudo cat data/tunnel-token)
        docker compose up -d
        ```
      </Step>
    </Steps>
  </Tab>

  <Tab title="Ohne programmatischen Zugriff">
    Verwende diesen Ablauf, wenn du **Set up programmatic access** nicht aktiviert hast, oder für lokale Entwicklung und Tests. Es gibt keinen `setup`-Service.

    <Steps>
      <Step title="Tunnel-Token und Domain aus der Console holen">
        Kopiere auf der Tunnel-Detailseite die **Domain** (sie hat die Form `abcd1234.tunnel.anthropic.com`), klicke dann auf das Augensymbol neben **Token**, um das Tunnel-Token abzurufen, und verwende das Kopiersymbol, um es zu kopieren.

        Setze beide als Shell-Variablen für den Rest der Anleitung:

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

      <Step title="Gerüst anlegen und Zertifikate erzeugen">
        ```bash
        mkdir -p mcp-tunnel/{data,config}
        cd mcp-tunnel
        ```

        Der Proxy lauscht auf `:8080` über einfaches WebSocket; der [innere TLS](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components)-Handshake findet **innerhalb** dieses WebSocket-Streams mit diesen Zertifikaten statt. Anthropic verifiziert den inneren Handshake gegen die CA, die du in der Console registrierst. Der Subject Alternative Name (SAN) des Serverzertifikats muss gemäß den [Zertifikatsanforderungen](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/reference#certificate-requirements) `*.<tunnel-domain>` enthalten.

        ```bash
        # Selbstsignierte CA. Explizite Erweiterungen, damit sie die Zertifikats-
        # anforderungen unabhängig von den openssl.cnf-Standards der Distribution erfüllt.
        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"

        # Erweiterungsdatei für das Serverzertifikat. -extfile (statt
        # -copy_extensions, das nur in OpenSSL 3.0+ verfügbar ist) hält dies lauffähig auf
        # OpenSSL 1.1.x.
        cat > data/tls.ext <<EOF
        subjectAltName = DNS:${TUNNEL_DOMAIN},DNS:*.${TUNNEL_DOMAIN}
        authorityKeyIdentifier = keyid,issuer
        extendedKeyUsage = serverAuth
        EOF

        # Vom CA signiertes Serverzertifikat
        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

        # Erlaube dem Nicht-Root-Proxy-Container (UID 65532), den Key aus dem
        # Bind-Mount zu lesen. Ohne das World-Read-Bit kann der Container keine
        # dem Host gehörende Datei öffnen.
        chmod 644 data/tls.key
        ```
      </Step>

      <Step title="Das CA-Zertifikat in der Console registrieren">
        Scrolle auf der Tunnel-Detailseite zum Abschnitt **Certificates** und klicke auf **Add certificate**. Lade `data/ca.crt` direkt mit **Choose file** hoch (das Modal akzeptiert `.pem`, `.crt` und `.cer`) oder füge den Inhalt ein:

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

        Das Badge **Needs certificate** neben dem Namen des Tunnels verschwindet, sobald ein Zertifikat registriert ist. Siehe [Ein CA-Zertifikat hinzufügen](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/console#add-a-ca-certificate).
      </Step>

      <Step title="Die Proxy-Konfiguration schreiben">
        `tunnel_domain` ist **erforderlich**: Der Proxy verwendet sie, um das Domain-Suffix von eingehenden Hostnamen zu entfernen, bevor er die Subdomain in `routes` nachschlägt. `routes` ist eine flache Map von Subdomain zu Upstream-URL, keine 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
        ```

        Die Route `echo:` zielt auf den [Beispiel-MCP-Server](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server); ersetze sie durch deine eigenen Routen (oder füge diese hinzu). Siehe die Referenz zur [Proxy-Konfiguration](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/reference#proxy-configuration) für alle verfügbaren Felder.
      </Step>

      <Step title="docker-compose.yaml schreiben">
        Die Einstellung `network_mode: "service:mcp-proxy"` platziert [cloudflared](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components) im Netzwerk-Namespace des Proxys, sodass `localhost:8080` innerhalb des cloudflared-Containers den Proxy erreicht. Das Flag `--url http://localhost:8080` gibt cloudflared sein Weiterleitungsziel; ohne dieses Flag hat cloudflared keine Route für eingehende Anfragen und gibt einen 503 zurück.

        ```bash
        cat > docker-compose.yaml <<'EOF'
        services:
          cloudflared:
            image: cloudflare/cloudflared@sha256:6b599ca3e974349ead3286d178da61d291961182ec3fe9c505e1dd02c8ac31b0
            # --url ist erforderlich: Im manuellen Ablauf werden keine Ingress-Regeln gepusht,
            # daher beantwortet cloudflared ohne es jede Anfrage mit 503.
            command: tunnel --no-autoupdate run --url http://localhost:8080
            environment:
              - TUNNEL_TOKEN
            # Teile den netns des Proxys, damit localhost:8080 ihn erreicht.
            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
        ```

        Wenn du den [Beispiel-MCP-Server](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server) verwendest, hänge ihn als Service an:

        ```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="Die Bereitstellung starten">
        ```bash
        docker compose up -d
        ```
      </Step>
    </Steps>
  </Tab>
</Tabs>

Die Compose-Datei liest `TUNNEL_TOKEN` ohne Standardwert aus der Host-Umgebung, daher muss der Export in jeder neuen Shell und nach einem Neustart wiederholt werden.

Für eine Bereitstellung auf mehreren VMs kopiere das Verzeichnis `mcp-tunnel/` auf jeden Host, setze `TUNNEL_TOKEN` und führe `docker compose up -d` aus. Im programmatischen Ablauf ist `TUNNEL_TOKEN` gleich `$(sudo cat data/tunnel-token)`; im manuellen Ablauf ist es der Wert, den du aus der Console kopiert hast. Dasselbe Tunnel-Token und dieselben Zertifikate funktionieren über alle Replikate hinweg.

## Die Bereitstellung verifizieren

Verifiziere Ende-zu-Ende, indem du einen [Upstream-MCP-Server](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/concepts#components) von Anthropics Seite aus aufrufst: siehe [Die getunnelten MCP-Server verwenden](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview#use-the-tunneled-mcp-servers). Mit dem [Beispiel-MCP-Server](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/deploy-compose#optional-use-a-sample-mcp-server) lautet die geroutete URL `https://echo.<your-tunnel-domain>/mcp`. Wenn die Verifizierung fehlschlägt, siehe [Fehlerbehebung](https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/troubleshooting).

## Upgrades

Führe die Befehle in diesem Abschnitt innerhalb des Bereitstellungsverzeichnisses `mcp-tunnel/` aus.

### Das Tunnel-Token rotieren

Mit programmatischem Zugriff erhöhe `--token-version` im Befehl des `setup`-Services, setze die Workload-Identity-Federation-Kennungen, stelle ein frisches OIDC-JWT aus und führe die Setup-Komponente erneut aus:

```bash
# Bearbeite docker-compose.yaml: Erhöhe die Ganzzahl im Argument
# --token-version des setup-Dienstes (zum Beispiel --token-version=1 auf
# --token-version=2). Das setup-Binary verweigert die Rotation, wenn sich der Wert
# nicht geändert hat.

# export TUNNEL_ID=tnl_...   # nur setzen, wenn du es bei der Installation gesetzt hast
export ANTHROPIC_FEDERATION_RULE_ID=fdrl_...
export ANTHROPIC_ORGANIZATION_ID=00000000-0000-0000-0000-000000000000
# export ANTHROPIC_WORKSPACE_ID=wrkspc_...   # falls deine Regel Workspace-bezogen ist
# Erstelle ANTHROPIC_IDENTITY_TOKEN neu gemäß dem WIF-Provider-Leitfaden für deine
# Umgebung (es ist seit der Installation abgelaufen).
export ANTHROPIC_IDENTITY_TOKEN=...

docker compose run --rm setup

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

Das Argument `--token-version` wird in `docker-compose.yaml` bearbeitet statt auf der Kommandozeile übergeben, damit der neue Wert für zukünftige Ausführungen der Setup-Komponente erhalten bleibt. Die Setup-Komponente authentifiziert sich mit Workload Identity Federation; es gibt kein API-Token zu widerrufen.

Ohne programmatischen Zugriff klicke auf der Tunnel-Detailseite in der Console auf **Rotate token**, aktualisiere dann die Umgebungsvariable `TUNNEL_TOKEN` auf jedem Host und starte cloudflared neu (`docker compose up -d cloudflared`).

<Warning>
  Ein Klick auf **Rotate token** macht das aktuelle Token sofort ungültig. Zwischen diesem Moment und der Aktualisierung von `TUNNEL_TOKEN` auf jedem Host samt Neustart von cloudflared kann sich kein Host, dessen cloudflared neu startet (Absturz, Host-Neustart), wieder verbinden. Aktualisiere jeden Host umgehend nach dem Rotieren.
</Warning>

### Zertifikatserneuerung

Du bist dafür verantwortlich, den Ablauf zu überwachen und das Serverzertifikat zu erneuern, bevor es abläuft.

Mit programmatischem Zugriff:

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

Die CLI-Argumente ersetzen den `command` des `setup`-Services (die `init`-Argumente), behalten aber dessen `entrypoint` bei, sodass dies `/setup renew-cert --output=dir:/data` ausführt.

<Tip>
  Übergib `--renew-before=720h`, damit der Befehl nichts tut, wenn noch mehr als 30 Tage Gültigkeit verbleiben. Dadurch kann er sicher nach einem festen Zeitplan ausgeführt werden.
</Tip>

Ohne programmatischen Zugriff signiere ein neues Serverzertifikat mit deiner bestehenden CA (die in der Console registrierte CA ändert sich nicht) und ersetze `data/tls.crt`. Setze zuerst `TUNNEL_DOMAIN`, wenn du dies aus einer neuen Shell ausführst.

```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
```

In beiden Abläufen fragt der Proxy `tls.cert_file` regelmäßig ab und lädt sie automatisch neu, sodass kein Neustart erforderlich ist.

## Nächste Schritte

<CardGroup cols={2}>
  <Card title="Die getunnelten MCP-Server verwenden" icon="link" href="https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/overview#use-the-tunneled-mcp-servers">
    Binde einen Upstream-MCP-Server an einen Managed Agent oder die Messages API an.
  </Card>

  <Card title="Sicherheit" icon="lock" href="https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/security">
    Hinweise zur Härtung, Rotation von Zugangsdaten und Reaktion auf Sicherheitsvorfälle.
  </Card>

  <Card title="Fehlerbehebung" icon="wrench" href="https://platform.claude.com/docs/de/agents-and-tools/mcp-tunnels/troubleshooting">
    Diagnostiziere Konnektivitäts-, TLS- und Routing-Probleme.
  </Card>
</CardGroup>