Ir al contenido principal

Túneles MCP

¿Qué es?

Conecta de forma segura Claude a servidores MCP que se ejecutan en tu red privada sin abrir puertos de entrada ni exponer servicios a Internet. MCP Tunnels está actualmente en versión beta privada y utiliza el servicio Tunnel de Cloudflare.

Cómo funciona

MCP Tunnels crea una conexión entre Claude y tus servidores MCP internos que está cifrada en tránsito con múltiples capas de seguridad.

Cuando Claude necesita acceder a un servidor MCP en tu red privada, la solicitud viaja a través de un túnel seguro. Implementas dos componentes de tu lado:

  • cloudflared (agente de túnel de Cloudflare)

  • MCP Gateway (proporcionado por Anthropic)

Cloudflared inicia una conexión solo de salida a la red perimetral de Cloudflare. No es necesario abrir puertos de entrada en tu firewall. MCP Gateway termina una capa TLS interna, valida direcciones IP ascendentes para prevenir SSRF y enruta cada solicitud al servidor MCP correcto según el subdominio.

La conexión está asegurada con tres capas independientes: mTLS externo entre Anthropic y Cloudflare (con validación de IP), TLS interno que cifra cargas útiles de extremo a extremo desde el backend de Anthropic hasta tu puerta de enlace (diseñado para que Cloudflare no tenga acceso a cargas útiles MCP) y autenticación OAuth en la capa de aplicación en cada servidor MCP.

Lo que implementas

cloudflared

Agente de túnel de Cloudflare. Inicia conexiones solo de salida — no se necesitan puertos de entrada.

MCP Gateway

Componente proporcionado por Anthropic que termina TLS interno, valida direcciones IP y enruta solicitudes a tus servidores MCP.

Propiedades de seguridad clave

  • No se requieren puertos de entrada. cloudflared inicia solo conexiones de salida — tu firewall permanece cerrado.

  • Cifrado de extremo a extremo. El tráfico está cifrado en tránsito desde el backend de Anthropic hasta tu puerta de enlace. Cloudflare no puede leer las cargas útiles MCP.

  • Defensa en profundidad. Múltiples capas de autenticación: mTLS, TLS interno y OAuth en la capa de aplicación.

  • Protección SSRF. La puerta de enlace valida direcciones IP ascendentes para ayudar a prevenir ataques de falsificación de solicitudes.

Esta guía proporciona implementaciones de referencia mediante Helm (para Kubernetes) y Docker Compose. Eres responsable de adaptarlas para cumplir con los requisitos de seguridad de tu organización.

Responsabilidad compartida

Mantener este sistema seguro es una responsabilidad compartida entre Anthropic y tu organización.

Anthropic es responsable de:

  • Garantizar que solo Anthropic pueda acceder a los túneles

  • Validar tu certificado CA antes de conectarse a tu puerta de enlace

  • Garantizar que Claude solo envíe solicitudes a túneles propiedad de tu organización

Eres responsable de:

  • Seguir la orientación en este documento y cualquier orientación posterior

  • Asegurar el token de túnel y las claves privadas TLS

  • Configurar tus servidores MCP para usar autenticación OAuth como se describe en la especificación MCP

  • Restringir el acceso a tus hosts de puerta de enlace y servidores MCP al personal apropiado

  • Notificar a Anthropic si sospechas que el sistema ha sido comprometido (consulta Responder a una posible violación)

⚠️ Riesgo de credenciales. Si un atacante obtiene tu token de túnel y una de tus claves privadas TLS, podría suplantar tu puerta de enlace y leer cargas útiles de solicitudes MCP, incluidos tokens OAuth. Protege estas credenciales según los requisitos de seguridad de tu organización, incluyendo permisos de archivo, cifrado en reposo y gestión de secretos.

Requisitos previos

  • Un destino de implementación — un clúster de Kubernetes (para Helm) o una máquina virtual con Docker y Docker Compose.

  • Un token de API de Anthropic para la API de Túneles — genera uno desde claude.ai → Configuración de la organización → Conectores → API de Túneles. La configuración utiliza este token para aprovisionar el túnel y registrar tu certificado CA. La puerta de enlace no lo necesita en tiempo de ejecución. Revócalo una vez que termines la configuración.

  • Acceso de red — conectividad de salida según la tabla siguiente.

  • Servidores MCP — uno o más servidores MCP que se ejecutan en tu red privada a los que la puerta de enlace pueda acceder.

Requisitos de red

Componente

Destino

Propósito

Configuración (una sola vez)

api.anthropic.com:443

(puerto 443)

Aprovisionamiento de túnel

cloudflared

Red perimetral de Cloudflare, puerto 7844 TCP/UDP (198.41.192.0/19, 2606:4700:a0::/44)

Conexión de túnel

Puerta de enlace MCP

Tus servidores MCP

Tráfico ascendente

Consulta la documentación del firewall de túnel de Cloudflare para obtener la lista de IP autorizada. Los usuarios de Helm pueden aplicar esta restricción de salida habilitando el valor networkPolicy del gráfico.

Elige tu método de implementación

Los túneles MCP se pueden implementar a través de Helm (Kubernetes) o Docker Compose. Elige el método que se adapte a tu infraestructura.

⎈ Helm / Kubernetes

Recomendado para la mayoría de clientes. Automatiza el aprovisionamiento de túneles y la renovación de certificados. Almacena credenciales como Secretos.

🐳 Docker Compose

Para implementaciones de host único o máquina virtual.

Implementación de Helm / Kubernetes

1. Obtén los valores del gráfico

Descarga el archivo de valores predeterminados. Incluye comentarios que explican cada campo.

Shell

helm show values \
  oci://us-docker.pkg.dev/anthropic-public-registry/charts/mcp-tunnel \
  --version 0.1.0 > values.yaml

2. Configura tus rutas

Edita values.yaml y añade al menos una ruta bajo gateway.config.routes. Cada ruta asigna un prefijo de subdominio a una URL de servidor MCP ascendente.

3. Revisa los manifiestos renderizados

Renderiza el gráfico con un token de marcador de posición para inspeccionar los recursos de Kubernetes antes de instalar. El gráfico requiere api.token para renderizar, pero helm template no llama a la API.

Shell

helm template mcp-tunnel \
  oci://us-docker.pkg.dev/anthropic-public-registry/charts/mcp-tunnel \
  --version 0.1.0 \
  -n mcp-tunnel \
  -f values.yaml \
  --set api.token=placeholder > rendered.yaml

Revisa rendered.yaml de acuerdo con las prácticas de tu organización para verificar manifiestos de terceros.

4. Instala el gráfico

Almacena tu token de API en una variable de entorno e instala. Se recomienda un espacio de nombres dedicado para el aislamiento.

Shell

# Paste your API token (input is hidden)
read -rs API_TOKEN && export API_TOKEN

helm install mcp-tunnel \
  oci://us-docker.pkg.dev/anthropic-public-registry/charts/mcp-tunnel \
  --version 0.1.0 \
  --namespace mcp-tunnel --create-namespace \
  -f values.yaml \
  --set api.token="$API_TOKEN"

⚠️ Importante: Revoca el token de API una vez que se complete la instalación. Pasar el token a través de --set lo mantiene fuera de tu archivo de valores, pero Helm aún lo registra en el historial de versiones (sh.helm.release.v1.* Secretos). Los Secretos de Kubernetes no están cifrados en reposo de forma predeterminada, por lo que el token sigue siendo recuperable del clúster hasta que lo revoques.

5. Recupera tu dominio de túnel

El Job de configuración escribe el dominio del túnel en un Secreto. Lo necesitarás para configurar servidores MCP en Claude.

Shell

kubectl get secret mcp-tunnel -n mcp-tunnel \
  -o jsonpath='{.data.tunnel-domain}' | base64 -d

Una vez que el túnel esté activo y funcionando, conéctate a Claude.

Opcional: Habilita NetworkPolicy

Establece networkPolicy.enabled: true en tu archivo de valores para restringir el egreso del pod del túnel a nivel de red. Configura networkPolicy.mcpServers con selectores de etiquetas de pod o rangos CIDR para tus servidores MCP ascendentes. La política ya incluye reglas de egreso para que cloudflared llegue al borde de Cloudflare. Tu CNI de clúster debe admitir NetworkPolicy; consulta el archivo de valores para ver un ejemplo.

Opcional: Configuración de puerta de enlace

Los campos bajo gateway.config.* se pasan al archivo de configuración de la puerta de enlace. Consulta el Apéndice: Configuración de puerta de enlace para obtener la lista completa. Los ajustes comunes incluyen upstream.allowed_ips, log_level y upstream.tls para rutas https://. Para montar archivos adicionales que la configuración referencia (como un paquete de CA para upstream.tls.ca_file), utiliza gateway.extraVolumes y gateway.extraVolumeMounts.

Actualizaciones

Siempre especifica --version en helm upgrade. Sin él, Helm extrae la última versión del gráfico del registro, que puede no ser la que revisaste.

Para cambios de configuración (rutas, réplicas, NetworkPolicy, etc.), no se necesita token de API. El Job de configuración se omite en las actualizaciones a menos que pases api.token:

Shell

helm upgrade mcp-tunnel \
  oci://us-docker.pkg.dev/anthropic-public-registry/charts/mcp-tunnel \
  --version 0.1.0 \
  -n mcp-tunnel \
  -f values.yaml

Para la rotación del token del túnel, incrementa tunnel.tokenVersion en tu archivo de valores, genera un token de API nuevo y actualiza:

Shell

# Paste your API token (input is hidden)
read -rs API_TOKEN && export API_TOKEN

helm upgrade mcp-tunnel \
  oci://us-docker.pkg.dev/anthropic-public-registry/charts/mcp-tunnel \
  --version 0.1.0 \
  -n mcp-tunnel \
  -f values.yaml \
  --set api.token="$API_TOKEN"

Revoca el token de API una vez que se complete la actualización.

Mantén un archivo de valores completo en lugar de depender de --reuse-values. Helm fusiona profundamente campos de mapa, por lo que eliminar una ruta con --reuse-values falla silenciosamente.

Uso de helm template con kubectl o kustomize

Si prefieres renderizar manifiestos y aplicarlos tú mismo (a través de kubectl apply u superposiciones de kustomize), utiliza el modo externo (setup.enabled: false). Aprovisiona el túnel por separado (consulta el Apéndice: API de túneles) y proporciona las credenciales como Secretos preexistentes referenciados por external.tunnelTokenSecretName y external.serverCertSecretName. Si emites tus propios certificados en lugar de usar el binario de configuración, consulta el Apéndice: Requisitos de certificados.

Implementación de Docker Compose

1. Prepara el directorio de implementación

Shell

mkdir -p mcp-gateway/{config,tunnel-data}
cd mcp-gateway
sudo chown 65532:65532 tunnel-data

El chown permite que el contenedor (que se ejecuta como UID 65532) escriba en el directorio montado por enlace.

2. Crea docker-compose.yaml

YAML

services:
  # One-time provisioning. Run with: docker compose run --rm setup
  setup:
    image: us-docker.pkg.dev/anthropic-public-registry/images/mcp-gateway@sha256:62ddf0897778c80997ca789189a8a0bd63df241659d661ff9d5b0e06b5ee1dcd
    entrypoint: ["/setup"]
    command:
      - init
      - --api-url=https://api.anthropic.com
      - --output=dir:/data
      - --token-version=1
    environment:
      - API_TOKEN
    volumes:
      - ./tunnel-data:/data
    user: "65532:65532"
    read_only: true
    security_opt:
      - no-new-privileges:true
    cap_drop:
      - ALL
    profiles: ["setup"]

  cloudflared:
    # Verify digest at https://hub.docker.com/r/cloudflare/cloudflared/tags
    image: cloudflare/cloudflared@sha256:6b599ca3e974349ead3286d178da61d291961182ec3fe9c505e1dd02c8ac31b0
    command: tunnel --no-autoupdate --config /etc/cloudflared/config.yaml run
    environment:
      - TUNNEL_TOKEN
    volumes:
      - ./config/cloudflared-config.yaml:/etc/cloudflared/config.yaml: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"

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

Medidas de seguridad: ejecución sin privilegios (UID 65532), sistema de archivos de solo lectura, sin escalada de privilegios, todas las capacidades de Linux eliminadas, fijación de imagen por resumen SHA256.

3. Aprovisionar el túnel

Shell

# Paste your API token (input is hidden)
read -rs API_TOKEN && export API_TOKEN

docker compose run --rm setup

El comando de configuración crea un túnel a través de la API de Tunnels, genera un certificado de CA y servidor, registra la CA con Anthropic y escribe todos los resultados en ./tunnel-data/.

Recupera tu dominio de túnel para el siguiente paso:

Shell

sudo cat tunnel-data/tunnel-domain

⚠️ Importante: Revoca el token de API antes de continuar.

4. Configurar la puerta de enlace

Crea config/mcp-gateway.yaml:

YAML

listen_addr: ":8080"
log_level: info
shutdown_timeout: 30s

# Your tunnel domain from Step 3
tunnel_domain: abcd1234.tunnel.anthropic.com

tls:
  cert_file: /data/tls.crt
  key_file: /data/tls.key

routes:
  # Replace with your actual MCP servers.
  # With tunnel_domain set, keys are subdomain prefixes.
  docs: http://docs-mcp.internal:8080
  search: http://search-mcp.internal:8080

upstream:
  allowed_ips:
    - 10.0.0.0/8

Consulta Apéndice: Configuración de la puerta de enlace para todos los campos disponibles.

Crea config/cloudflared-config.yaml:

YAML

ingress:
  - service: http://mcp-gateway:8080

5. Implementar

Shell

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

Estructura de directorios:

mcp-gateway/
├── docker-compose.yaml
├── config/
│   ├── cloudflared-config.yaml
│   └── mcp-gateway.yaml
└── tunnel-data/
    ├── tunnel-id
    ├── tunnel-domain
    ├── tunnel-token
    ├── token-version
    ├── ca.crt
    ├── ca.key
    ├── tls.crt
    └── tls.key

Considera mover la clave privada de CA y el token de túnel a almacenamiento seguro.

Para implementaciones de múltiples máquinas virtuales: copia el directorio mcp-gateway/ a cada host. El mismo token de túnel y certificados funcionan en todas las réplicas.

Una vez que el túnel esté activo y funcionando, conéctate a Claude.

Renovación de certificados (Compose)

El certificado del servidor tiene una validez de 90 días. Renuévalo antes de que expire:

Shell

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

La puerta de enlace consulta el archivo de certificado cada 30 segundos y lo recarga automáticamente cuando cambia. Consulta Apéndice: Referencia de CLI de configuración para las banderas que hacen que este comando sea seguro para ejecutar en una programación.

Rotación de token de túnel (Compose)

Edita docker-compose.yaml para incrementar --token-version, luego vuelve a ejecutar la configuración con un token de API nuevo:

# Paste your API token (input is hidden)
read -rs API_TOKEN && export API_TOKEN

docker compose run --rm setup

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

Revoca el token de API una vez que se complete la rotación.

Conectar a Claude

Una vez que el túnel esté en funcionamiento, registra tus servidores MCP en Claude para que estén disponibles para los usuarios.

1. Agregar servidores MCP

Un administrador de la organización navega a Configuración de la organización → Conectores → Agregar → Personalizado → Web en claude.ai.

Ingresa cada servidor MCP usando su nombre de host de túnel. Por ejemplo, docs.abcd1234.tunnel.anthropic.com. El prefijo del subdominio coincide con la clave de ruta de tu configuración de puerta de enlace.

2. Los usuarios se conectan

Los usuarios individuales navegan a Configuración → Conectores y hacen clic en Conectar para cada servidor MCP que deseen usar.

¿Agregar más servidores más adelante? Agrega una nueva ruta a tu configuración, aplica el cambio (helm upgrade o docker compose restart mcp-gateway) y registra el nuevo nombre de host en Claude. No se necesitan cambios de certificado o cloudflared. El certificado comodín cubre todos los subdominios.

Mejores prácticas de seguridad

  1. Requiere OAuth en tus servidores MCP. Las capas de túnel y TLS protegen el transporte, pero si alguna vez se ven comprometidas, OAuth en la capa de aplicación aún previene la invocación de herramientas no autorizadas. Configura cada servidor MCP para requerir autenticación OAuth como se describe en la especificación de MCP.

  2. Habilita SSO para tu organización de claude.ai. Los tokens de túnel se generan desde la Consola de claude.ai. Con SSO aplicado, los controles de sesión de tu proveedor de identidad rigen las sesiones de administrador.

  3. Restringe allowed_ips. Usa los rangos CIDR más pequeños que cubran tus servidores MCP.

  4. Monitorea registros. Configura alertas para advertencias, errores y patrones inusuales.

  5. Rota credenciales. Rota certificados en una programación regular o inmediatamente si se sospecha un compromiso.

  6. Mantén las imágenes actualizadas. Aplica actualizaciones de puerta de enlace rápidamente. Fija imágenes por resumen SHA256.

  7. Limita el acceso a la red. La puerta de enlace y cloudflared deben tener solo el acceso a la red requerido.

  8. Limita el alcance del servidor MCP. Los servidores MCP solo deben exponer la funcionalidad necesaria.

  9. Protege credenciales en reposo. Aplica permisos de archivo apropiados, cifrado en reposo y gestión de secretos al directorio tunnel-data/ (Compose) o al Secret de credenciales (Helm).

Responder a una posible violación

Si sospechas que tus credenciales de túnel, claves TLS o algún otro aspecto del sistema ha sido comprometido:

  1. Detén la implementación inmediatamente (helm uninstall o docker compose down --timeout 0)

  2. Elimina servidores MCP de Claude (Configuración de la organización → Conectores)

  3. Archiva el túnel a través de la API (consulta Teardown, paso 3)

  4. Contacta a Anthropic para que puedan investigar

  5. Rota credenciales — reaprovisiona un túnel nuevo, rota tokens de OAuth en tus servidores MCP

  6. Revisa los registros antes de restaurar el servicio

Solución de problemas

Fallos de validación de IP

"IP validation failed" en los registros de la puerta de enlace significa que la resolución ascendente apuntó a una IP fuera de allowed_ips. Verifica la IP resuelta:

Shell

dig +short docs-mcp.internal

Si la IP es legítima, actualiza allowed_ips en la configuración de tu puerta de enlace para incluir el rango CIDR correcto.

El túnel no se conecta

Verifica los registros de cloudflared para detectar errores. Causas comunes:

  • Token de túnel inválido

  • El firewall bloquea el puerto 7844 TCP/UDP saliente hacia el borde de Cloudflare

Verifica la conectividad saliente a los rangos de IP de Cloudflare: 198.41.192.0/19 y 2606:4700:a0::/44.

Advertencias de tamaño de búfer UDP

cloudflared puede registrar failed to sufficiently increase receive buffer size. Este es un problema de ajuste del transporte QUIC — consulta la documentación de búfer UDP de quic-go para ajustar.

Errores de certificado

Si el protocolo de enlace TLS falla, verifica que:

  • El certificado del servidor no ha expirado (validez de 90 días)

  • El SAN del certificado coincide con *.<tunnel-domain>

  • El certificado de CA está registrado con Anthropic a través de la API

  • Para Compose, los archivos de certificado son legibles por UID 65532

Enrutamiento de OAuth a través del túnel (servidor de autenticación detrás de lista de permitidos de IP)

Problema: Tu servidor de autenticación se encuentra detrás de una lista de permitidos de IP de origen. El backend de Claude necesita alcanzarlo para el descubrimiento de OAuth, el registro de clientes e intercambio de tokens, pero prefieres no incluir en la lista blanca los rangos de IP de salida de Anthropic.

Solución: configuración de punto final dividido. Enruta las llamadas de OAuth de backend a backend a través del túnel. Mantén el punto final /authorize orientado al navegador en tu nombre de host incluido en la lista blanca existente. Esto funciona porque Claude lee el authorization_endpoint de tus metadatos de descubrimiento y redirige el navegador del usuario allí. No necesita alcanzar esa URL por sí mismo.

Paso 1: Añade una ruta de puerta de enlace para tu servidor de autenticación

YAML — mcp-gateway.yaml

routes:
  mcp: http://your-mcp-server:8080
  auth: http://your-auth-server:8080

Paso 2: Sirve metadatos de descubrimiento de punto final dividido

El /.well-known/oauth-authorization-server de tu servidor de autenticación debe devolver:

JSON

{
  "issuer": "https://auth.<tunnel-id>.tunnel.anthropic.com",
  "authorization_endpoint": "https://<your-allowlisted-host>/authorize",
  "token_endpoint": "https://auth.<tunnel-id>.tunnel.anthropic.com/token",
  "registration_endpoint": "https://auth.<tunnel-id>.tunnel.anthropic.com/register",
  "code_challenge_methods_supported": ["S256"]
}

Solo authorization_endpoint apunta a tu nombre de host existente. Todo lo demás utiliza la URL del túnel.

Paso 3: Apunta tu servidor MCP al emisor del túnel

El /.well-known/oauth-protected-resource de tu servidor MCP:

JSON

{
  "resource": "https://mcp.<tunnel-id>.tunnel.anthropic.com",
  "authorization_servers": [
    "https://auth.<tunnel-id>.tunnel.anthropic.com"
  ]
}

Desmantelamiento

Cómo desmantelar un túnel cuando ya no es necesario.

1. Obtén el ID del túnel

Helm

TUNNEL_ID=$(kubectl get secret mcp-tunnel -n mcp-tunnel \
  -o jsonpath='{.data.tunnel-id}' | base64 -d)

Compose

TUNNEL_ID=$(sudo cat tunnel-data/tunnel-id)

2. Detén la implementación

Helm: helm uninstall mcp-tunnel -n mcp-tunnel (nota: el Secret de credenciales fue creado por el Job de configuración, no por Helm, por lo que sobrevive a la desinstalación)
​Compose: docker compose down

3. Archiva el túnel

Genera un token de API nuevo primero y revócalo cuando termines.

Shell

read -rs API_TOKEN && export API_TOKEN

curl -X POST "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/archive" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

4. Elimina las credenciales almacenadas

Helm: kubectl delete secret mcp-tunnel -n mcp-tunnel
​Compose: sudo rm -rf tunnel-data

Obtener ayuda

Contacta a tu equipo de cuenta de Anthropic para obtener asistencia.

Apéndice: Configuración de la puerta de enlace

La puerta de enlace lee su configuración desde un archivo YAML. En Docker Compose, escribes este archivo directamente como config/mcp-gateway.yaml. En Helm, establece estos campos bajo gateway.config.* en tu archivo de valores—el gráfico gestiona listen_addr, tls y tunnel_domain por ti.

Campo

Descripción

Predeterminado

listen_addr

Dirección y puerto en los que escuchar

Requerido

log_level

Verbosidad del registro: debug, info, warn, error

info

shutdown_timeout

Tiempo de espera para solicitudes en vuelo durante el apagado elegante

30s

tunnel_domain

Dominio base para la resolución de rutas con prefijo

Ninguno

tls.cert_file

Ruta al certificado TLS

Requerido

tls.key_file

Ruta a la clave privada TLS

Requerido

routes

Asignación de nombre de host (o prefijo) a URL ascendente

Requerido

upstream.allowed_ips

Rangos CIDR a los que la puerta de enlace puede conectarse

Rangos privados RFC 1918

upstream.disable_ip_validation

Deshabilitar completamente la validación de IP

false

upstream.tls.ca_file

Paquete de CA para validar TLS ascendente

Ninguno

upstream.tls.include_system_cas

Confiar en el paquete de CA del sistema para TLS ascendente

false

Para rutas https://, establece al menos uno de upstream.tls.ca_file o upstream.tls.include_system_cas.

Apéndice: API de túneles

Para flujos de trabajo de aprovisionamiento personalizados, puedes llamar directamente a la API de túneles. Todas las solicitudes requieren estos encabezados:

Shell

-H "Authorization: Bearer $API_TOKEN"
-H "anthropic-version: 2023-06-01"
-H "anthropic-beta: mcp-tunnels-2026-02-24"

Crear un túnel:

curl -X POST https://api.anthropic.com/v1/tunnels \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24" \
  -H "Content-Type: application/json" \
  -d '{}'

Listar túneles:

curl https://api.anthropic.com/v1/tunnels \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

Registrar un certificado de CA:

curl -X POST "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/certificates" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24" \
  -H "Content-Type: application/json" \
  -d "{\"ca_certificate_pem\": $(jq -Rs . < ca.crt)}"

Consulta Apéndice: Requisitos de certificados para ver qué deben contener los certificados de CA y servidor.

Listar certificados de CA:

curl "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/certificates" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

Revocar un certificado de CA:

curl -X POST "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/certificates/${CERT_ID}/revoke" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

Revelar el token del túnel:

curl -X POST "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/reveal_token" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

Rotar el token del túnel:

curl -X POST "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/rotate_token" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

Archivar un túnel:

curl -X POST "https://api.anthropic.com/v1/tunnels/${TUNNEL_ID}/archive" \
  -H "Authorization: Bearer $API_TOKEN" \
  -H "anthropic-version: 2023-06-01" \
  -H "anthropic-beta: mcp-tunnels-2026-02-24"

Apéndice: Requisitos de certificados

Si utilizas el binario de configuración (setup init / setup renew-cert), genera certificados compatibles automáticamente y puedes omitir esta sección. Estos requisitos se aplican si emites certificados a través de tu propia PKI.

Certificado de CA — cargado a través de POST /v1/tunnels/{id}/certificates. Un túnel contiene como máximo dos certificados de CA activos a la vez, lo que permite la rotación sin tiempo de inactividad.

  • Codificado en PEM, certificado único, máximo 8 KB

  • Extensión BasicConstraints con CA:TRUE, marcada como crítica

  • Extensión SubjectKeyIdentifier presente

  • KeyUsage incluye keyCertSign

  • Dentro del período de validez

  • RSA de 2048 bits o superior, o ECDSA P-256 o superior; firma SHA-256 o más fuerte

Certificado del servidor — presentado por la puerta de enlace durante el protocolo de enlace TLS interno. No se carga en Anthropic.

  • Firmado directamente por una CA registrada en el túnel

  • Extensión AuthorityKeyIdentifier presente, coincidiendo con el SubjectKeyIdentifier de la CA

  • SAN incluye un nombre DNS que coincide con <route>.<tunnel-domain> (un comodín *.<tunnel-domain> cubre todas las rutas)

  • Si una extensión ExtendedKeyUsage está presente, incluye serverAuth

  • Dentro del período de validez

  • RSA de 2048 bits o superior, o ECDSA P-256 o superior; firma SHA-256 o más fuerte

Referencia: el binario de configuración genera una CA ECDSA P-256 (validez de 5 años) y un certificado de servidor RSA de 4096 bits con SAN comodín (validez de 90 días).

Apéndice: Referencia de CLI de configuración

El binario setup se ejecuta dentro del contenedor de la puerta de enlace mediante docker compose run --rm setup <subcommand> (Compose) o como un gancho de Helm y CronJob (Kubernetes).

setup init — crea un túnel a través de la API de Túneles, genera una CA y certificado de servidor, registra la CA y escribe todos los resultados.

Bandera

Descripción

Predeterminado

--api-url

URL base de la API de Anthropic. También se lee desde API_URL.

requerido

--api-token

Token de API con alcance de túnel. También se lee desde API_TOKEN.

requerido

--output

Destino de salida: dir:/path o k8s-secret:NAME

k8s-secret:mcp-gateway

--cert-duration

Período de validez del certificado del servidor

2160h (90 días)

--token-version

Cadena de detección de cambios; un nuevo valor activa la rotación del token del túnel

ninguno

setup renew-cert — emite un nuevo certificado de servidor firmado por la CA almacenada. No se requiere llamada a API.

Bandera

Descripción

Predeterminado

--output

Destino de salida: dir:/path o k8s-secret:NAME

k8s-secret:mcp-gateway

--cert-duration

Período de validez del nuevo certificado

2160h (90 días)

--renew-before

Omitir si el certificado existente tiene más tiempo hasta la expiración

0 (renovar siempre)

Configurar --renew-before=720h hace que el comando sea inoperante cuando quedan más de 30 días, adecuado para ejecutar en una programación.

Artículos relacionados
¿Ha quedado contestada tu pregunta?