Instalación del Proxy Inverso Traefik

Traefik es un proxy inverso moderno y de código abierto y equilibrador de carga diseñado específicamente para microservicios y entornos en contenedores. A diferencia de los proxies inversos tradicionales que requieren reinicios de archivos de configuración, Traefik descubre dinámicamente servicios y configura automáticamente reglas de enrutamiento. Esta guía cubre la instalación, configuración e implementación de Traefik en su infraestructura de VPS o bare metal.

Tabla de Contenidos

  1. Requisitos del Sistema
  2. Métodos de Instalación
  3. Instalación Binaria
  4. Instalación de Docker
  5. Configuración Estática
  6. Configuración Dinámica
  7. Configuración de Puntos de Entrada
  8. Enrutadores y Servicios
  9. Integración de Let's Encrypt
  10. Acceso al Panel
  11. Verificaciones de Salud
  12. Solución de Problemas

Requisitos del Sistema

Antes de instalar Traefik, asegúrese de que su sistema cumpla con los siguientes requisitos:

  • Versión del kernel de Linux 3.10 o superior
  • Mínimo 512 MB de RAM (2 GB recomendado para producción)
  • 100 MB de espacio en disco para el binario
  • Conectividad de red con sus servicios de backend
  • Acceso root o sudo para la instalación a nivel del sistema

Traefik está escrito en Go y se distribuye como un único binario, lo que lo hace ligero y fácil de implementar en varias arquitecturas, incluidas x86_64, ARM y ARM64.

Métodos de Instalación

Traefik se puede instalar a través de múltiples enfoques dependiendo de su infraestructura:

  • Instalación Binaria: Implementación directa para servidores bare metal
  • Docker/Docker Compose: Implementación basada en contenedores con administración de volúmenes
  • Kubernetes: Integración nativa con plataformas de orquestación
  • Administradores de Paquetes: Paquetes específicos de distribución (disponibilidad limitada)

Instalación Binaria

Comience descargando el último binario de Traefik desde las versiones oficiales:

cd /tmp
wget https://github.com/traefik/traefik/releases/download/v2.10.0/traefik_v2.10.0_linux_amd64.tar.gz
tar xzf traefik_v2.10.0_linux_amd64.tar.gz

Cree un usuario dedicado y directorios para Traefik:

sudo useradd -r -s /bin/false -d /var/lib/traefik traefik
sudo mkdir -p /etc/traefik
sudo mkdir -p /var/lib/traefik
sudo mkdir -p /var/log/traefik
sudo chown -R traefik:traefik /var/lib/traefik /var/log/traefik

Mueva el binario a la ruta del sistema:

sudo mv /tmp/traefik /usr/local/bin/traefik
sudo chmod +x /usr/local/bin/traefik

Verifique la instalación:

traefik version

Cree un archivo de servicio systemd para inicio automático:

sudo tee /etc/systemd/system/traefik.service > /dev/null <<EOF
[Unit]
Description=Traefik Reverse Proxy
Documentation=https://doc.traefik.io/traefik/
After=network-online.target
Wants=network-online.target

[Service]
Type=notify
User=traefik
Group=traefik
ExecStart=/usr/local/bin/traefik --configFile=/etc/traefik/traefik.yaml
Restart=on-failure
RestartSec=5s
StandardOutput=journal
StandardError=journal
SyslogIdentifier=traefik

[Install]
WantedBy=multi-user.target
EOF

Habilite e inicie el servicio:

sudo systemctl daemon-reload
sudo systemctl enable traefik
sudo systemctl start traefik

Instalación de Docker

Para implementaciones en contenedores, cree un archivo docker-compose.yml:

version: '3.8'

services:
  traefik:
    image: traefik:v2.10
    restart: always
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /etc/traefik/traefik.yaml:/traefik.yaml:ro
      - /etc/traefik/dynamic.yaml:/dynamic.yaml:ro
      - /var/lib/traefik/acme.json:/acme.json
    networks:
      - traefik
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.traefik.rule=Host(\`traefik.example.com\`)"
      - "traefik.http.routers.traefik.service=api@internal"
      - "traefik.http.routers.traefik.entrypoints=websecure"

networks:
  traefik:
    driver: bridge

Despliegue usando Docker Compose:

sudo docker-compose -f /etc/traefik/docker-compose.yml up -d

Configuración Estática

La configuración estática define los puntos de entrada, acceso a API y configuración global. Cree /etc/traefik/traefik.yaml:

global:
  checkNewVersion: false
  sendAnonymousUsage: false

entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entrypoint:
          to: websecure
          scheme: https
  websecure:
    address: ":443"
    http:
      tls:
        certResolver: letsencrypt
        domains:
          - main: example.com
            sans:
              - '*.example.com'

api:
  dashboard: true
  insecure: false
  debug: false

providers:
  file:
    filename: /etc/traefik/dynamic.yaml
    watch: true
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
    watch: true

certificatesResolvers:
  letsencrypt:
    acme:
      email: [email protected]
      storage: /var/lib/traefik/acme.json
      httpChallenge:
        entryPoint: web
      certificatesDuration: 2160h

Establezca permisos apropiados:

sudo chown traefik:traefik /etc/traefik/traefik.yaml
sudo chmod 600 /etc/traefik/traefik.yaml

Configuración Dinámica

La configuración dinámica define servicios, enrutadores y middleware sin requerir reinicio de Traefik. Cree /etc/traefik/dynamic.yaml:

http:
  routers:
    web-app:
      rule: "Host(`app.example.com`)"
      service: web-backend
      entrypoints:
        - websecure
      tls:
        certResolver: letsencrypt
      middlewares:
        - compression
        - rate-limit

  services:
    web-backend:
      loadBalancer:
        servers:
          - url: "http://192.168.1.100:8000"
          - url: "http://192.168.1.101:8000"
        healthCheck:
          path: /health
          interval: 10s
          timeout: 5s

  middlewares:
    compression:
      compress: {}
    rate-limit:
      rateLimit:
        average: 100
        period: 60s
        burst: 200

Habilite la vigilancia de archivos para aplicar cambios de configuración automáticamente:

sudo systemctl restart traefik

Configuración de Puntos de Entrada

Los puntos de entrada definen las interfaces de red y puertos donde Traefik escucha:

entryPoints:
  web:
    address: ":80"
    forwardedHeaders:
      insecure: false
      trustedIPs:
        - "10.0.0.0/8"
        - "172.16.0.0/12"
        - "192.168.0.0/16"
    
  websecure:
    address: ":443"
    http:
      tls:
        options: modern
        certResolver: letsencrypt
  
  ssh:
    address: ":22"
    transport: tcp

  metrics:
    address: ":8082"
    metrics:
      prometheus:
        manualRouting: true

Enrutadores y Servicios

Los enrutadores determinan qué servicios manejan las solicitudes entrantes según reglas:

http:
  routers:
    api-router:
      rule: "Host(`api.example.com`) && PathPrefix(`/v1`)"
      service: api-backend
      entrypoints: [websecure]
      priority: 10
      middlewares:
        - api-auth
        - api-ratelimit

    static-router:
      rule: "Host(`cdn.example.com`)"
      service: static-content
      entrypoints: [websecure, web]

  services:
    api-backend:
      loadBalancer:
        servers:
          - url: "http://api1.internal:8080"
          - url: "http://api2.internal:8080"
          - url: "http://api3.internal:8080"
        stickySessions:
          cookie:
            name: "TRAEFIK_BACKEND"
            httpOnly: true
            secure: true
            sameSite: "Strict"

    static-content:
      loadBalancer:
        servers:
          - url: "http://192.168.1.50:80"
        healthCheck:
          path: /
          interval: 30s
          timeout: 10s

Integración de Let's Encrypt

Configure la administración automática de certificados HTTPS:

certificatesResolvers:
  letsencrypt:
    acme:
      email: [email protected]
      storage: /var/lib/traefik/acme.json
      httpChallenge:
        entryPoint: web
      caServer: https://acme-v02.api.letsencrypt.org/directory

  letsencrypt-staging:
    acme:
      email: [email protected]
      storage: /var/lib/traefik/acme-staging.json
      httpChallenge:
        entryPoint: web
      caServer: https://acme-staging-v02.api.letsencrypt.org/directory

Asegúrese de que el archivo acme.json tenga los permisos correctos:

sudo touch /var/lib/traefik/acme.json
sudo chmod 600 /var/lib/traefik/acme.json
sudo chown traefik:traefik /var/lib/traefik/acme.json

Acceso al Panel

Habilite el panel de Traefik para monitoreo:

api:
  dashboard: true
  insecure: false
  debug: false

http:
  routers:
    dashboard:
      rule: "Host(`traefik.example.com`)"
      entrypoints: [websecure]
      service: api@internal
      tls:
        certResolver: letsencrypt
      middlewares:
        - dashboard-auth

  middlewares:
    dashboard-auth:
      basicAuth:
        users:
          - "admin:$apr1$xyz123$encrypted_password_here"

Genere credenciales de autenticación HTTP básica:

sudo apt install apache2-utils
htpasswd -c /etc/traefik/.htpasswd admin

Acceda al panel en https://traefik.example.com con las credenciales configuradas.

Verificaciones de Salud

Configure verificación de salud para servicios de backend:

http:
  services:
    backend:
      loadBalancer:
        servers:
          - url: "http://192.168.1.10:8000"
          - url: "http://192.168.1.11:8000"
        healthCheck:
          path: /health
          interval: 10s
          timeout: 5s
          scheme: http
          headers:
            X-Check: "health"

Monitoree el estado de las verificaciones de salud en el panel de Traefik o en los registros:

sudo journalctl -u traefik -f

Solución de Problemas

Verifique los registros de Traefik para errores de configuración:

sudo systemctl status traefik
sudo journalctl -u traefik -n 50 -f

Valide la sintaxis de configuración:

traefik --configFile=/etc/traefik/traefik.yaml --testConfig

Verifique que los puntos de entrada estén escuchando:

sudo netstat -tlnp | grep traefik

Verifique la conectividad del proveedor de Docker:

ls -l /var/run/docker.sock

Pruebe la conectividad del servicio de backend:

curl -i http://192.168.1.100:8000/health

Conclusión

Traefik proporciona una solución moderna y poderosa de proxy inverso con descubrimiento automático de servicios, configuración dinámica e integración de Let's Encrypt. Ya sea implementando en bare metal o entornos en contenedores, la flexibilidad y el rendimiento de Traefik lo convierten en una excelente opción para la infraestructura moderna. El monitoreo regular a través del panel y los archivos de registro garantiza el funcionamiento confiable de sus servicios.