Traefik Reverse Proxy: Guía Completa para Homelab 2025

—

📋 TL;DR (Resumen Ejecutivo)

Traefik es un reverse proxy moderno que automatiza la gestión de tráfico en tu homelab. A diferencia de Nginx Proxy Manager, Traefik detecta automáticamente tus contenedores Docker y configura SSL, routing y middlewares sin intervención manual. En esta guía completa aprenderás a instalar Traefik desde cero, configurar servicios con SSL automático, implementar middlewares avanzados (autenticación, rate limiting) e integrar Authelia para SSO.

Lo que conseguirás:

✅ Reverse proxy con auto-descubrimiento de servicios Docker
✅ Certificados SSL automáticos con Let’s Encrypt
✅ Middlewares avanzados (auth, rate limiting, headers de seguridad)
✅ Integración con Authelia para Single Sign-On
✅ Dashboard de monitoreo integrado

Tiempo de lectura: ~25 minutos | Nivel: Intermedio

—

📚 Tabla de Contenidos

Introducción
¿Qué es Traefik? Conceptos Fundamentales
Instalación de Traefik con Docker
Configuración de Servicios Básicos
Middlewares Avanzados
Integración con Let’s Encrypt
Integración con Authelia para SSO
Monitoreo y Métricas
Routing Avanzado
Comparativa: Traefik vs Nginx Proxy Manager
Troubleshooting Común
Mejores Prácticas
Casos de Uso Comunes
Preguntas Frecuentes
Conclusión

—

> 📅 Última actualización: Noviembre 2025

> ✅ Verificado con: Traefik v3.4 – Noviembre 2025

> 🔄 Próxima revisión: Febrero 2026

—

Introducción {#introduccion}

Si tienes un homelab con múltiples servicios (Portainer, Nextcloud, Home Assistant, etc.), probablemente te has enfrentado a estos problemas:

Múltiples puertos: Cada servicio expuesto en un puerto diferente (9000, 8080, 8123…)
SSL complejo: Configurar certificados SSL para cada servicio manualmente
Mantenimiento tedioso: Añadir un nuevo servicio requiere configurar nginx/apache manualmente
Sin automatización: Cambios en la infraestructura requieren recargar servicios

La solución: Traefik es un reverse proxy moderno diseñado específicamente para entornos dinámicos como Docker. A diferencia de Nginx Proxy Manager (que requiere configuración manual por servicio), Traefik detecta automáticamente tus contenedores Docker y configura routing, SSL y middlewares sin intervención manual.

En esta guía completa aprenderás:

Instalar y configurar Traefik desde cero en Docker
Exponer servicios con SSL automático usando Let’s Encrypt
Implementar middlewares avanzados (autenticación, rate limiting, headers de seguridad)
Integrar Authelia para Single Sign-On (SSO) en todos tus servicios
Monitorear y mantener Traefik en producción
Troubleshooting de errores comunes

Ya seas un sysadmin que busca automatización, un desarrollador que quiere infraestructura como código, o un entusiasta de homelab que quiere simplificar su stack, esta guía te dará todo lo necesario para implementar Traefik como reverse proxy profesional.

—

¿Qué es Traefik? Conceptos Fundamentales {#que-es-traefik}

Definición

Traefik es un reverse proxy y balanceador de carga de código abierto, diseñado específicamente para facilitar la gestión del tráfico en entornos dinámicos y modernos. Fue lanzado en 2016 y desde entonces ha ganado popularidad en la comunidad DevOps y homelab por su capacidad de auto-descubrimiento y configuración dinámica.

Características principales:

✅ Auto-descubrimiento: Detecta automáticamente contenedores Docker mediante la API de Docker
✅ Configuración dinámica: Cambios en tiempo real sin necesidad de recargas manuales
✅ SSL automático: Integración nativa con Let’s Encrypt para certificados SSL automáticos
✅ Múltiples protocolos: Soporte para HTTP, HTTPS, TCP y UDP
✅ Dashboard integrado: Panel web para monitorear routers, servicios y middlewares
✅ Middlewares potentes: Autenticación, rate limiting, headers de seguridad, compresión, etc.
✅ Métricas integradas: Exportación a Prometheus y otras herramientas de observabilidad

Arquitectura de Traefik

Traefik funciona con cuatro componentes principales:

EntryPoints: Puntos de entrada del tráfico (puertos 80, 443, etc.)
Routers: Reglas que determinan cómo se enruta el tráfico (ej: Host('app.dominio.com'))
Services: Backends que procesan las solicitudes (contenedores Docker)
Middlewares: Componentes que modifican las solicitudes/respuestas (auth, rate limiting, etc.)

Flujo de tráfico:

Cliente → EntryPoint → Router → Middleware → Service → Backend

El cliente envía una solicitud a un EntryPoint (ej: puerto 443)
El Router evalúa las reglas (ej: Host('app.dominio.com'))
Los Middlewares procesan la solicitud (ej: autenticación, headers)
El Service determina el backend (ej: contenedor Docker)
La solicitud se reenvía al backend

¿Por qué Traefik en lugar de otras soluciones?

Ventajas sobre Nginx Proxy Manager:

Auto-descubrimiento: Detecta automáticamente contenedores Docker sin configuración manual
Configuración basada en labels: Define reglas directamente en docker-compose.yml
Sin recargas: Cambios en tiempo real sin reiniciar el servicio
Integración profunda con Docker: Acceso directo al socket de Docker
Métricas integradas: Prometheus y otras herramientas de observabilidad
Configuración declarativa: Todo en código (YAML), versionable con Git

Ventajas sobre Nginx tradicional:

Configuración más simple: Labels vs archivos de configuración complejos
Menos mantenimiento: Auto-discovery reduce errores de configuración
Mejor para entornos dinámicos: Ideal para contenedores que aparecen/desaparecen

Desventajas:

Curva de aprendizaje: Requiere entender conceptos de routers, middlewares, servicios
Sin UI visual: Todo se configura mediante archivos YAML y labels
Menos documentación en español: Principalmente en inglés

—

Instalación de Traefik con Docker {#instalacion}

Robot punk trabajando con docker-compose.yml y Traefik en homelab 2025

Requisitos Previos

Antes de comenzar, asegúrate de tener:

Docker instalado y funcionando
Docker Compose instalado (opcional pero recomendado)
Dominio con acceso a DNS (para SSL)
Puertos 80 y 443 disponibles
Conocimientos básicos de línea de comandos

Paso 1: Crear Red Docker

Primero, crea una red Docker dedicada para Traefik y tus servicios:

docker network create traefik-net

Esta red permitirá que Traefik se comunique con los servicios backend.

Paso 2: Configuración Básica con Docker Compose

Crea un directorio para Traefik y un archivo docker-compose.yml:

version: '3.8'

services:
  traefik:
    image: traefik:v3.4
    container_name: traefik
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    networks:
      - traefik-net
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./traefik.yml:/traefik.yml:ro
      - ./acme.json:/acme.json
      - ./logs:/var/log/traefik
      - ./config:/config
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.traefik.rule=Host(`traefik.tudominio.com`)"
      - "traefik.http.routers.traefik.service=api@internal"
      - "traefik.http.routers.traefik.entrypoints=websecure"
      - "traefik.http.routers.traefik.tls.certresolver=letsencrypt"

networks:
  traefik-net:
    external: true

Explicación de labels:

traefik.enable=true: Habilita Traefik para este contenedor
traefik.http.routers.traefik.rule=Host(...): Regla de enrutamiento basada en dominio
traefik.http.routers.traefik.service=api@internal: Usa el servicio interno del dashboard
traefik.http.routers.traefik.entrypoints=websecure: Usa el entrypoint HTTPS
traefik.http.routers.traefik.tls.certresolver=letsencrypt: Usa Let’s Encrypt para SSL

Paso 3: Configuración Estática (traefik.yml)

Crea un archivo traefik.yml con la configuración estática:

global:
  checkNewVersion: true
  sendAnonymousUsage: false

entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
          permanent: true
  websecure:
    address: ":443"

api:
  dashboard: true
  insecure: false

providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    network: traefik-net
    watch: true
  file:
    directory: "/config"
    watch: true

certificatesResolvers:
  letsencrypt:
    acme:
      email: tuemail@dominio.com
      storage: "/acme.json"
      httpChallenge:
        entryPoint: web

log:
  level: INFO
  filePath: "/var/log/traefik/traefik.log"
  format: json

accessLog:
  filePath: "/var/log/traefik/access.log"
  format: json
  bufferingSize: 100

Explicación:

entryPoints: Define puertos 80 (HTTP) y 443 (HTTPS)
redirections: Redirige automáticamente HTTP a HTTPS
api.dashboard: Habilita el dashboard web
providers.docker: Configura el provider de Docker
exposedByDefault: false: Solo expone servicios con traefik.enable=true
certificatesResolvers: Configura Let’s Encrypt para SSL automático

Paso 4: Crear Archivo acme.json

Crea el archivo que almacenará los certificados SSL:

touch acme.json
chmod 600 acme.json

Paso 5: Iniciar Traefik

Inicia Traefik con Docker Compose:

docker-compose up -d

Verifica que está funcionando:

docker logs traefik
docker ps | grep traefik

Si todo está correcto, deberías ver Traefik ejecutándose y el dashboard accesible en https://traefik.tudominio.com (después de configurar DNS).

—

Configuración de Servicios Básicos {#configuracion-servicios}

Labels Básicos Explicados

Para exponer un servicio detrás de Traefik, añade estas labels en su docker-compose.yml:

services:
  mi-servicio:
    image: nginx:latest
    container_name: mi-servicio
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.mi-servicio.rule=Host(`servicio.tudominio.com`)"
      - "traefik.http.routers.mi-servicio.entrypoints=websecure"
      - "traefik.http.routers.mi-servicio.tls.certresolver=letsencrypt"
      - "traefik.http.services.mi-servicio.loadbalancer.server.port=80"

networks:
  traefik-net:
    external: true

Labels explicadas:

traefik.enable=true: Habilita Traefik para este servicio
traefik.http.routers.mi-servicio.rule=Host(...): Regla de enrutamiento
traefik.http.routers.mi-servicio.entrypoints=websecure: Usa HTTPS
traefik.http.routers.mi-servicio.tls.certresolver=letsencrypt: SSL automático
traefik.http.services.mi-servicio.loadbalancer.server.port=80: Puerto del backend

Ejemplo 1: Portainer

services:
  portainer:
    image: portainer/portainer-ce:latest
    container_name: portainer
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - portainer_data:/data
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.portainer.rule=Host(`portainer.tudominio.com`)"
      - "traefik.http.routers.portainer.entrypoints=websecure"
      - "traefik.http.routers.portainer.tls.certresolver=letsencrypt"
      - "traefik.http.services.portainer.loadbalancer.server.port=9000"

volumes:
  portainer_data:

networks:
  traefik-net:
    external: true

Despliega con:

docker-compose -f docker-compose.portainer.yml up -d

Accede en: https://portainer.tudominio.com

Ejemplo 2: Nextcloud

services:
  nextcloud:
    image: nextcloud:latest
    container_name: nextcloud
    restart: unless-stopped
    volumes:
      - nextcloud_data:/var/www/html
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.nextcloud.rule=Host(`nextcloud.tudominio.com`)"
      - "traefik.http.routers.nextcloud.entrypoints=websecure"
      - "traefik.http.routers.nextcloud.tls.certresolver=letsencrypt"
      - "traefik.http.services.nextcloud.loadbalancer.server.port=80"
      - "traefik.http.middlewares.nextcloud-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
      - "traefik.http.routers.nextcloud.middlewares=nextcloud-headers"

volumes:
  nextcloud_data:

networks:
  traefik-net:
    external: true

Nota: Nextcloud requiere headers personalizados para funcionar correctamente detrás de un reverse proxy.

Ejemplo 3: Múltiples Routers para un Servicio

Puedes tener múltiples dominios apuntando al mismo servicio:

services:
  mi-servicio:
    image: nginx:latest
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true"
      # Router 1: api.dominio.com
      - "traefik.http.routers.api.rule=Host(`api.dominio.com`)"
      - "traefik.http.routers.api.entrypoints=websecure"
      - "traefik.http.routers.api.tls.certresolver=letsencrypt"
      - "traefik.http.routers.api.service=mi-servicio"
      # Router 2: app.dominio.com
      - "traefik.http.routers.app.rule=Host(`app.dominio.com`)"
      - "traefik.http.routers.app.entrypoints=websecure"
      - "traefik.http.routers.app.tls.certresolver=letsencrypt"
      - "traefik.http.routers.app.service=mi-servicio"
      # Service compartido
      - "traefik.http.services.mi-servicio.loadbalancer.server.port=80"

—

Middlewares Avanzados {#middlewares}

Robot punk comparando Traefik vs Nginx Proxy Manager en homelab 2025

Los middlewares permiten modificar las solicitudes/respuestas antes de llegar al backend. Traefik incluye muchos middlewares útiles.

Middleware de Autenticación Básica

Protege un servicio con usuario/contraseña:

# Generar contraseña encriptada
htpasswd -nb usuario contraseña
# Salida: usuario:$apr1$hash_aqui

labels:
  - "traefik.http.middlewares.auth.basicauth.users=usuario:$$apr1$$hash_aqui"
  - "traefik.http.routers.mi-servicio.middlewares=auth"

Nota: En docker-compose, usa $$ para escapar el $ del hash.

Middleware de Rate Limiting

Limita el número de solicitudes por IP:

labels:
  - "traefik.http.middlewares.ratelimit.ratelimit.average=100"
  - "traefik.http.middlewares.ratelimit.ratelimit.period=1m"
  - "traefik.http.middlewares.ratelimit.ratelimit.burst=50"
  - "traefik.http.routers.mi-servicio.middlewares=ratelimit"

Esto permite 100 solicitudes por minuto con un burst de 50.

Middleware de IP Whitelist

Permite acceso solo desde IPs específicas:

labels:
  - "traefik.http.middlewares.ipwhitelist.ipwhitelist.sourcerange=192.168.1.0/24,10.0.0.0/8"
  - "traefik.http.routers.mi-servicio.middlewares=ipwhitelist"

Middleware de Headers de Seguridad

Añade headers de seguridad (HSTS, X-Frame-Options, etc.):

labels:
  - "traefik.http.middlewares.security-headers.headers.sslRedirect=true"
  - "traefik.http.middlewares.security-headers.headers.stsSeconds=31536000"
  - "traefik.http.middlewares.security-headers.headers.stsIncludeSubdomains=true"
  - "traefik.http.middlewares.security-headers.headers.stsPreload=true"
  - "traefik.http.middlewares.security-headers.headers.frameDeny=true"
  - "traefik.http.middlewares.security-headers.headers.contentTypeNosniff=true"
  - "traefik.http.middlewares.security-headers.headers.browserXssFilter=true"
  - "traefik.http.routers.mi-servicio.middlewares=security-headers"

Middleware de Strip Prefix

Útil para servicios que esperan rutas sin prefijo:

labels:
  - "traefik.http.middlewares.strip-api.stripprefix.prefixes=/api"
  - "traefik.http.routers.mi-servicio.rule=Host(`dominio.com`) && PathPrefix(`/api`)"
  - "traefik.http.routers.mi-servicio.middlewares=strip-api"

Si accedes a https://dominio.com/api/users, el backend recibirá /users.

Middleware de Add Prefix

Añade un prefijo a la ruta antes de reenviar:

labels:
  - "traefik.http.middlewares.add-api.addprefix.prefix=/api/v1"
  - "traefik.http.routers.mi-servicio.middlewares=add-api"

Combinar Múltiples Middlewares

Puedes aplicar varios middlewares a un router:

labels:
  - "traefik.http.middlewares.auth.basicauth.users=usuario:$$apr1$$hash"
  - "traefik.http.middlewares.ratelimit.ratelimit.average=100"
  - "traefik.http.middlewares.security-headers.headers.sslRedirect=true"
  - "traefik.http.routers.mi-servicio.middlewares=auth,ratelimit,security-headers"

—

Integración con Let’s Encrypt {#lets-encrypt}

Traefik puede obtener y renovar certificados SSL automáticamente usando Let’s Encrypt.

HTTP Challenge (Básico)

Ya está configurado en traefik.yml:

certificatesResolvers:
  letsencrypt:
    acme:
      email: tuemail@dominio.com
      storage: "/acme.json"
      httpChallenge:
        entryPoint: web

Requisitos:

Puerto 80 accesible desde internet
Dominio apuntando a tu IP pública
DNS configurado correctamente

DNS Challenge (Wildcard)

Para certificados wildcard (*.dominio.com), usa DNS Challenge:

certificatesResolvers:
  letsencrypt:
    acme:
      email: tuemail@dominio.com
      storage: "/acme.json"
      dnsChallenge:
        provider: cloudflare
        resolvers:
          - "1.1.1.1:53"
          - "8.8.8.8:53"

Configurar Cloudflare API:

Añade variables de entorno en docker-compose.yml:

environment:
  - CF_API_EMAIL=tuemail@dominio.com
  - CF_API_KEY=tu_api_key_de_cloudflare

Proveedores DNS soportados:

Cloudflare
DigitalOcean
Route53 (AWS)
Google Cloud DNS
Azure DNS
Y muchos más…

Renovación Automática

Traefik renueva automáticamente los certificados antes de expirar. No requiere intervención manual.

Troubleshooting Certificados

Si tienes problemas con certificados:

Verifica que el puerto 80 está accesible: curl -I http://tu-dominio.com
Verifica DNS: dig tu-dominio.com debe apuntar a tu IP
Revisa logs: docker logs traefik | grep acme
Verifica permisos: chmod 600 acme.json

—

Integración con Authelia para SSO {#authelia}

Authelia es un servidor de autenticación y autorización que proporciona SSO (Single Sign-On) y 2FA.

Configurar Authelia

services:
  authelia:
    image: authelia/authelia:latest
    container_name: authelia
    restart: unless-stopped
    volumes:
      - ./authelia:/config
    networks:
      - traefik-net
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.authelia.rule=Host(`auth.tudominio.com`)"
      - "traefik.http.routers.authelia.entrypoints=websecure"
      - "traefik.http.routers.authelia.tls.certresolver=letsencrypt"
      - "traefik.http.services.authelia.loadbalancer.server.port=9091"

Configurar ForwardAuth en Traefik

Para proteger servicios con Authelia, usa el middleware ForwardAuth:

labels:
  # Middleware ForwardAuth
  - "traefik.http.middlewares.authelia-forward.forwardauth.address=http://authelia:9091/api/verify?rd=https://auth.tudominio.com/"
  - "traefik.http.middlewares.authelia-forward.forwardauth.authResponseHeaders=Remote-User,Remote-Groups,Remote-Name,Remote-Email"
  - "traefik.http.middlewares.authelia-forward.forwardauth.trustForwardHeader=true"
  # Aplicar a servicios
  - "traefik.http.routers.mi-servicio.middlewares=authelia-forward"

Ahora, cuando accedas a https://servicio.tudominio.com, serás redirigido a Authelia para autenticarte. Una vez autenticado, podrás acceder a todos los servicios protegidos sin volver a introducir credenciales (SSO).

Para más detalles sobre Authelia, consulta nuestra guía: Authelia + LLDAP: SSO y Gestión de Usuarios para tu Homelab.

—

Monitoreo y Métricas {#monitoreo}

Dashboard de Traefik

El dashboard está disponible en https://traefik.tudominio.com (si está configurado) o http://localhost:8080 (solo desarrollo).

Información disponible:

Routers activos
Services y backends
Middlewares configurados
Certificados SSL
Health checks

Métricas con Prometheus

Habilita métricas en traefik.yml:

metrics:
  prometheus:
    entryPoint: metrics
    addEntryPointsLabels: true
    addServicesLabels: true
    addRoutersLabels: true

entryPoints:
  metrics:
    address: ":8082"

Expón las métricas:

labels:
  - "traefik.http.routers.metrics.rule=Host(`metrics.tudominio.com`)"
  - "traefik.http.routers.metrics.service=prometheus@internal"
  - "traefik.http.routers.metrics.entrypoints=websecure"
  - "traefik.http.routers.metrics.tls.certresolver=letsencrypt"

Logs

Traefik genera logs estructurados en JSON:

log:
  level: INFO
  filePath: "/var/log/traefik/traefik.log"
  format: json

accessLog:
  filePath: "/var/log/traefik/access.log"
  format: json

Ver logs:

docker logs traefik
tail -f logs/traefik.log
tail -f logs/access.log

—

Routing Avanzado {#routing-avanzado}

Routing por Path

traefik.http.routers.mi-servicio.rule=Host(`dominio.com`) && PathPrefix(`/api`)

Routing por Headers

traefik.http.routers.mi-servicio.rule=Host(`dominio.com`) && Headers(`X-API-Key`, `mi-clave`)

Routing por Método HTTP

traefik.http.routers.mi-servicio.rule=Host(`dominio.com`) && Method(`GET`, `POST`)

Prioridad de Routers

Si tienes múltiples routers que coinciden, usa prioridad:

# Router específico (mayor prioridad)
traefik.http.routers.especifico.rule=Host(`dominio.com`) && PathPrefix(`/admin`)
traefik.http.routers.especifico.priority=10

# Router general (menor prioridad)
traefik.http.routers.general.rule=Host(`dominio.com`)
traefik.http.routers.general.priority=1

TCP y UDP Routing

Traefik también puede enrutar tráfico TCP/UDP (útil para bases de datos, SSH, etc.):

# En traefik.yml
entryPoints:
  mysql:
    address: ":3306"

# En labels del servicio
traefik.tcp.routers.mysql.rule=HostSNI(`mysql.dominio.com`)
traefik.tcp.routers.mysql.entrypoints=mysql
traefik.tcp.routers.mysql.service=mysql
traefik.tcp.services.mysql.loadbalancer.server.port=3306

—

Comparativa: Traefik vs Nginx Proxy Manager {#comparativa}

Característica	Traefik	Nginx Proxy Manager
Interfaz gráfica	❌ Solo dashboard de monitoreo	✅ UI completa para configuración
Auto-descubrimiento	✅ Automático con Docker	❌ Manual por servicio
Configuración	YAML/labels (código)	UI visual
Cambios en tiempo real	✅ Sin recargas	❌ Requiere recarga
SSL automático	✅ Let’s Encrypt integrado	✅ Let’s Encrypt integrado
Middlewares	✅ Muy avanzados	⚠️ Limitados
Métricas	✅ Prometheus integrado	❌ No
Curva de aprendizaje	⚠️ Media-Alta	✅ Baja
Ideal para	Entornos dinámicos, automatización	Usuarios que prefieren UI

¿Cuándo usar cada uno?

Usa Nginx Proxy Manager si:

Prefieres una interfaz gráfica
Tienes pocos servicios (menos de 10)
No necesitas automatización
Eres principiante en DevOps

Usa Traefik si:

Tienes muchos servicios (10+)
Quieres automatización completa
Usas Docker/Kubernetes extensivamente
Necesitas configuración versionable (Git)
Prefieres infraestructura como código

Para más detalles sobre Nginx Proxy Manager, consulta nuestra guía: Nginx Proxy Manager: Reverse Proxy con UI Visual y SSL Automático.

—

Troubleshooting Común {#troubleshooting}

Robot punk resolviendo errores de SSL y configuración Traefik en homelab 2025

Error: «No valid certificate found»

Causa: Let’s Encrypt no puede validar el dominio.

Soluciones:

Verifica que el puerto 80 está accesible desde internet:

curl -I http://tu-dominio.com

Verifica DNS:

dig tu-dominio.com

Debe apuntar a tu IP pública.

Revisa logs:

docker logs traefik | grep acme

Verifica permisos de acme.json:

chmod 600 acme.json

Error: «Service not found»

Causa: El servicio no está en la misma red que Traefik.

Solución:

Asegúrate de que el servicio está en la red traefik-net:

networks:
  - traefik-net

networks:
  traefik-net:
    external: true

Error: «Connection refused»

Causa: El puerto del backend es incorrecto.

Solución:

Verifica el puerto interno del contenedor:

docker inspect contenedor | grep -A 10 "ExposedPorts"

Asegúrate de que el label traefik.http.services.mi-servicio.loadbalancer.server.port coincide con el puerto real.

Error: «Too many redirects»

Causa: Loop de redirección HTTP → HTTPS.

Solución:

Verifica que el servicio no está forzando HTTPS internamente. Si el servicio redirige a HTTPS y Traefik también, se crea un loop.

Dashboard no accesible

Causa: Dashboard deshabilitado o mal configurado.

Solución:

Verifica que el dashboard está habilitado en traefik.yml:

api:
     dashboard: true
     insecure: false

Añade labels para acceso seguro:

labels:
     - "traefik.http.routers.traefik.rule=Host(`traefik.dominio.com`)"
     - "traefik.http.routers.traefik.service=api@internal"
     - "traefik.http.routers.traefik.entrypoints=websecure"
     - "traefik.http.routers.traefik.tls.certresolver=letsencrypt"

—

Mejores Prácticas {#mejores-practicas}

Seguridad

Nunca expongas el dashboard sin autenticación
Usa exposedByDefault: false en la configuración de Docker
Aplica middlewares de seguridad (headers, rate limiting)
Mantén Traefik actualizado regularmente
Usa redes Docker dedicadas para aislar servicios
Protege acme.json con permisos 600: chmod 600 acme.json

Performance

Habilita compresión para contenido estático
Usa caché cuando sea posible
Configura timeouts apropiados
Monitorea métricas con Prometheus
Revisa logs regularmente

Mantenimiento

Versiona tu configuración con Git
Documenta tus labels y middlewares
Prueba cambios en entorno de desarrollo primero
Haz backups de acme.json regularmente
Revisa actualizaciones de Traefik mensualmente

—

Casos de Uso Comunes {#casos-uso}

Homelab Básico

Servicios comunes que puedes exponer con Traefik:

Portainer: Gestión de Docker
Nextcloud: Almacenamiento en la nube
Home Assistant: Automatización del hogar
Plex/Jellyfin: Servidor de medios
GitLab/Gitea: Control de versiones

Homelab Avanzado

Configuraciones más complejas:

Múltiples servicios con SSO: Authelia protegiendo todos los servicios
Balanceo de carga: Múltiples instancias del mismo servicio
Routing TCP/UDP: Bases de datos, SSH, etc.
Métricas y monitoreo: Prometheus + Grafana
CI/CD pipelines: Webhooks y automatización

Producción

Para entornos de producción:

Kubernetes ingress: Traefik como Ingress Controller
Canary deployments: Despliegues graduales
A/B testing: Routing condicional
Circuit breakers: Protección contra fallos
Distributed tracing: Trazabilidad de solicitudes

—

Preguntas Frecuentes {#faq}

Robot punk consultando documentación y FAQs de Traefik en homelab 2025

¿Traefik es mejor que Nginx Proxy Manager?

Depende de tus necesidades. Traefik es mejor para automatización y entornos dinámicos, mientras que Nginx Proxy Manager es mejor si prefieres una interfaz gráfica. Consulta la sección Comparativa para más detalles.

¿Puedo usar Traefik sin Docker?

Sí, Traefik puede funcionar sin Docker usando el File Provider o Kubernetes. Sin embargo, pierde la ventaja del auto-descubrimiento.

¿Cómo migro de Nginx Proxy Manager a Traefik?

Exporta la configuración de NPM
Crea archivos docker-compose.yml con labels de Traefik
Migra certificados SSL (o deja que Traefik los obtenga de nuevo)
Prueba en un entorno de desarrollo primero

¿Traefik funciona con Kubernetes?

Sí, Traefik tiene un provider nativo para Kubernetes y puede funcionar como Ingress Controller.

¿Puedo usar certificados SSL propios?

Sí, puedes usar certificados propios en lugar de Let’s Encrypt. Consulta la documentación oficial para más detalles.

¿Cómo protejo el dashboard de Traefik?

Usa autenticación básica o integra con Authelia. Ver sección Middlewares Avanzados.

¿Traefik soporta WebSockets?

Sí, Traefik soporta WebSockets de forma nativa.

¿Cómo configuro rate limiting?

Usa el middleware de rate limiting. Ver sección Middlewares Avanzados.

¿Puedo usar Traefik con Cloudflare?

Sí, puedes usar Cloudflare como CDN delante de Traefik, o usar DNS Challenge de Cloudflare para certificados wildcard.

¿Cómo hago backup de los certificados?

Simplemente copia el archivo acme.json:

cp acme.json acme.json.backup
chmod 600 acme.json.backup

¿Traefik consume muchos recursos?

No, Traefik es muy eficiente. En un homelab típico consume menos de 100MB de RAM.

¿Cómo actualizo Traefik?

Actualiza la imagen en docker-compose.yml:

image: traefik:v3.4  # Cambiar a la versión más reciente

Luego:

docker-compose pull
docker-compose up -d

¿Puedo usar Traefik con servicios no-Docker?

Sí, usando el File Provider o configurando servicios estáticos en traefik.yml.

¿Cómo configuro múltiples dominios?

Crea múltiples routers con diferentes reglas Host(). Ver sección Routing Avanzado.

¿Traefik soporta IPv6?

Sí, Traefik soporta IPv6 de forma nativa.

—

🔗 Artículos Relacionados

Continúa aprendiendo con estas guías complementarias:

Uptime Kuma: Monitoreo Self-Hosted Gratis para tu Homelab (Guía Completa 2025)

Guía completa para instalar y configurar Uptime Kuma, la mejor alternativa open-source y self-hosted…

Authelia + LLDAP: SSO y Gestión de Usuarios para tu Homelab (Guía Completa 2025)

Implementa autenticación centralizada (SSO) y 2FA en tu homelab con Authelia + LLDAP. Docker Compose…

Nginx Proxy Manager: Reverse Proxy con UI Visual y SSL Automático (Guía Completa 2025)

Instala Nginx Proxy Manager con Docker: UI web visual, SSL Let’s Encrypt automático, wildcard …

Freenom Alternativas 2025: Los Mejores Dominios Gratis después del Cierre

Freenom cerró en 2024 tras demanda de Meta. Descubre las 8 mejores alternativas gratuitas: Duck DNS,…

Tailscale para Homelab: VPN Mesh sin Abrir Puertos (Guía Completa 2025)

Accede a tu homelab desde cualquier lugar sin abrir puertos ni configurar VPNs complejas. Guía compl…

Home Assistant + n8n + Ollama: Automatiza tu Casa con IA Local (Guía Completa 2025)

Aprende a crear automatizaciones inteligentes con Home Assistant + n8n + Ollama. Stack completo con …

n8n Database Workflows: PostgreSQL, MySQL, MongoDB (Guía Completa Tutorial 2025)

Automatiza bases de datos con n8n: ETL pipelines, backups, sincronización. Tutorial completo Postgre…

GPU Scheduling en Kubernetes: Deploy AI Workloads a Escala (Guía Completa 2025)

Guía técnica avanzada sobre GPU scheduling en Kubernetes: NVIDIA GPU Operator, MIG vs Time-Slicing, …

📦 Descargar Ejemplos

Todos los ejemplos de código de este artículo están disponibles en GitHub:

🔗 Repositorio de Ejemplos: Traefik Reverse Proxy

Incluye:

Configuración completa de Traefik
Ejemplos: Portainer, Nextcloud, Authelia
Scripts de instalación y backup
Stack completo funcional

—

Conclusión {#conclusion}

Traefik es una herramienta poderosa y flexible para gestionar el tráfico en homelabs. Su capacidad de auto-descubrimiento, configuración dinámica e integración con Docker lo convierten en una opción ideal para entornos que requieren automatización y escalabilidad.

Aunque tiene una curva de aprendizaje más pronunciada que Nginx Proxy Manager, los beneficios a largo plazo (menos mantenimiento, más flexibilidad, mejor integración) hacen que valga la pena el esfuerzo inicial.

Próximos pasos recomendados:

Instala Traefik siguiendo esta guía
Expón tus primeros servicios con SSL automático
Experimenta con middlewares avanzados
Integra Authelia para SSO en todos tus servicios
Configura métricas con Prometheus para monitoreo

Recursos adicionales:

¿Necesitas ayuda? Consulta la sección de Troubleshooting o visita el foro de la comunidad.

—

¿Te ha resultado útil esta guía? Compártela con otros entusiastas de homelab y ayúdanos a crecer. 🚀