MessagesTúneles MCP

Inicio rápido de túneles MCP

Conecta Claude a un servidor MCP privado usando un despliegue local de Docker Compose.

Este inicio rápido te lleva desde cero hasta que Claude llame a un servidor MCP privado a través de un túnel. Usa Docker Compose con aprovisionamiento manual de credenciales, que es el camino más corto para pruebas locales. Para despliegues de producción, consulta Desplegar con Helm o Desplegar con Docker Compose.

Lo que construirás

Una pila de túnel de dos contenedores (el proxy y cloudflared) más un servidor MCP de ejemplo ejecutándose junto a ella. Cuando todo esté en ejecución, el servidor de ejemplo será accesible desde Claude en https://echo.<your-tunnel-domain>/mcp aunque nada esté escuchando en un puerto público.

Lo que necesitas

Docker y Docker Compose en una máquina con acceso saliente a internet.
Un rol en la Claude Console que pueda administrar túneles MCP. Consulta los requisitos previos de la guía de la Console.
OpenSSL 1.1.1 o posterior. Viene preinstalado en macOS y en la mayoría de las distribuciones de Linux; en Windows, instálalo por separado (el binario openssl debe estar en tu PATH).

1
Crea un túnel
En la barra lateral de la Claude Console, ve a Manage > MCP tunnels y haz clic en New tunnel. Asígnale un nombre. Deja Set up programmatic access desactivado; este inicio rápido usa aprovisionamiento manual de credenciales.
Una vez creado, abre el túnel. Copia dos valores de la sección Connection:
- Domain (tiene un aspecto como abcd1234.tunnel.anthropic.com)
- Token (haz clic en el icono del ojo y luego copia)

Configura el directorio de despliegue

mkdir -p mcp-tunnel/{config,data}
cd mcp-tunnel
export TUNNEL_DOMAIN=YOUR_TUNNEL_DOMAIN_HERE   # from step 1
export TUNNEL_TOKEN='eyJ...'            # from step 1

Genera una CA y un certificado de servidor

El proxy termina el TLS interno ("inner TLS") usando un certificado firmado por una CA que tú controlas. Genera ambos:

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"

cat > data/tls.ext <<EOF
subjectAltName = DNS:${TUNNEL_DOMAIN},DNS:*.${TUNNEL_DOMAIN}
authorityKeyIdentifier = keyid,issuer
extendedKeyUsage = serverAuth
EOF

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

chmod 644 data/tls.key

De vuelta en la Console, en la página de detalles del túnel, haz clic en Add certificate y sube data/ca.crt (o pega su contenido). El estado del túnel cambia a Active.

Escribe el servidor MCP de ejemplo

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

Escribe la configuración del proxy y el archivo compose

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

cat > docker-compose.yaml <<'EOF'
services:
  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

  cloudflared:
    image: cloudflare/cloudflared@sha256:6b599ca3e974349ead3286d178da61d291961182ec3fe9c505e1dd02c8ac31b0
    command: tunnel --no-autoupdate run --url http://localhost:8080
    environment:
      - TUNNEL_TOKEN
    network_mode: "service:mcp-proxy"
    restart: unless-stopped

  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

6
Inícialo
docker compose up -d docker compose logs mcp-proxy | grep "route configured" docker compose logs cloudflared | grep "Registered tunnel connection"
Deberías ver una línea route configured para echo y cuatro líneas Registered tunnel connection. Los contenedores tardan unos segundos en iniciarse; vuelve a ejecutar los comandos de registro si regresan vacíos.
Llámalo desde Claude
En la Console, ve a Managed Agents > Sessions y crea una sesión. En el selector de agentes elige Create new agent, asígnale un nombre al agente y conserva el modelo precargado. Haz clic en + MCP Server, selecciona tu túnel, establece Subdomain en echo y Path en mcp. Luego pregunta:

Use the hello tool to greet tunnel.

Deberías ver una llamada a herramienta seguida de su resultado.

Próximos pasos

El túnel está verificado de extremo a extremo. Para sustituirlo por tu propio servidor MCP, agrégalo a docker-compose.yaml (o ejecútalo en la misma red de Docker), agrega una ruta para él en config/mcp-proxy.yaml y luego reinicia el proxy (docker compose restart mcp-proxy).

Para despliegues de producción:

Desplegar con Docker Compose

Despliegue reforzado en un solo host, con o sin acceso programático.

Desplegar con Helm

Despliegue en Kubernetes con gestión automática de credenciales.

Lo que construirás

Lo que necesitas

Crea un túnel