Traefik

O Traefik é um Edge Router de código aberto que descobre e configura automaticamente as rotas para os seus serviços, integrando-se diretamente com orquestradores como Docker e Kubernetes, atuando como um proxy reverso dinâmico e balanceador de carga.

Conceitos fundamentais

O Traefik opera com um modelo de configuração dinâmica, eliminando a necessidade de atualizar arquivos manualmente e reiniciar serviços quando os serviços de backend mudam. Essa adaptabilidade em tempo real é obtida por meio de vários componentes interligados.

Providers

Providers são os conectores que permitem ao Traefik interagir com a sua infraestrutura. Eles monitoram a API do orquestrador subjacente em busca de mudanças, como novos containers, serviços ou deployments.
Providers comuns incluem:
* Docker: monitora eventos do daemon Docker e labels de containers.
* Kubernetes: monitora a API do Kubernetes em busca de recursos Ingress, IngressRoute, Service e Endpoint.
* File: lê a configuração a partir de arquivos estáticos YAML ou TOML.
* Consul, etcd, ZooKeeper: integra-se com key-value stores para configuração dinâmica.

Configuração de roteamento

O Traefik processa as requisições recebidas por meio de um fluxo de roteamento definido:

• EntryPoints: são listeners de rede que definem as portas em que o Traefik escuta (por exemplo, web na porta 80, websecure na porta 443).
• Routers: os routers analisam as requisições recebidas com base em regras definidas (por exemplo, Host(), PathPrefix(), Headers()). Se uma requisição corresponder à regra de um router, ela é encaminhada. Os routers também especificam em quais EntryPoints escutam e podem aplicar Middlewares.
• Middlewares: são componentes que podem modificar as requisições antes que elas cheguem ao serviço, ou modificar as respostas antes que sejam enviadas de volta ao cliente. Podem ser encadeados.
• Services: os services definem como alcançar as instâncias reais da aplicação backend. Um service normalmente aponta para um ou mais endereços IP e portas da sua aplicação. O Traefik pode balancear a carga das requisições entre múltiplas instâncias de um service.

O fluxo é: Requisição -> EntryPoint -> Router -> Middleware(s) -> Service -> Aplicação backend.

Principais recursos

Descoberta automática de serviços

O Traefik integra-se diretamente com orquestradores como Docker e Kubernetes. Ele descobre serviços automaticamente lendo metadados (por exemplo, labels do Docker, annotations do Kubernetes ou Custom Resources) e atualiza dinamicamente a sua configuração de roteamento sem exigir qualquer intervenção manual ou reinício. Isso elimina a necessidade de manter arquivos de configuração de proxy separados.

Terminação SSL/TLS

O Traefik oferece suporte nativo à terminação SSL/TLS. Ele pode provisionar e renovar certificados automaticamente usando Let's Encrypt via protocolo ACME (Automatic Certificate Management Environment), com suporte aos desafios HTTP-01, TLS-ALPN-01 e DNS-01. Certificados personalizados também podem ser configurados.

Balanceamento de carga

O Traefik atua como balanceador de carga, distribuindo o tráfego recebido entre múltiplas instâncias de um serviço.
As estratégias de balanceamento disponíveis incluem:
* Round Robin: distribui as requisições sequencialmente para cada servidor.
* Weighted Round Robin: permite atribuir pesos aos servidores para controlar a distribuição do tráfego.
* Sticky Sessions: garante que as requisições de um cliente específico sejam sempre roteadas para o mesmo servidor.

Middlewares

Os middlewares oferecem uma forma flexível de modificar requisições ou respostas. Podem ser aplicados a routers específicos ou globalmente.
Exemplos de middlewares comuns:
* Autenticação: autenticação básica (BasicAuth), autenticação Digest.
* Rate Limiting: controla o número de requisições que um cliente pode fazer dentro de um período determinado.
* Manipulação de headers: adicionar, remover ou modificar headers de requisição/resposta.
* Redirecionamentos: redirecionamento de HTTP para HTTPS, redirecionamentos permanentes.
* Whitelisting/Blacklisting de IP: restringe o acesso com base nos endereços IP dos clientes.

Dashboard

O Traefik inclui um dashboard web que fornece uma visão em tempo real dos routers, services e middlewares configurados. Ele permite que os administradores inspecionem a configuração ativa e monitorem o tráfego.

Traefik com Docker

Integrar o Traefik com o Docker envolve rodar o Traefik como um container e permitir que ele acesse o socket do daemon Docker. A configuração dos serviços normalmente é gerenciada por meio de labels do Docker nos containers da aplicação.

Exemplo de configuração docker-compose.yml

O exemplo a seguir demonstra um arquivo docker-compose.yml para configurar o Traefik e uma aplicação de exemplo whoami.

version: '3.8'

services:
  traefik:
    image: traefik:v2.10
    command:
      - --api.dashboard=true
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false # Expõe apenas serviços com traefik.enable=true
      - --entrypoints.web.address=:80
      - --entrypoints.websecure.address=:443
      - --certificatesresolvers.myresolver.acme.tlschallenge=true # Para Let's Encrypt
      - --certificatesresolvers.myresolver.acme.email=your-email@example.com
      - --certificatesresolvers.myresolver.acme.storage=/letsencrypt/acme.json # Armazenamento persistente dos certificados
    ports:
      - "80:80"
      - "443:443"
      - "8080:8080" # Expõe o Dashboard do Traefik
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro" # Monta o socket do Docker para acesso do provider
      - "./letsencrypt:/letsencrypt" # Armazenamento persistente dos certificados ACME
    labels:
      # Habilita o Traefik para o próprio serviço do dashboard
      - "traefik.enable=true"
      # Router para o dashboard do Traefik
      - "traefik.http.routers.traefik-dashboard.rule=Host(`traefik.yourdomain.com`)"
      - "traefik.http.routers.traefik-dashboard.entrypoints=websecure"
      - "traefik.http.routers.traefik-dashboard.service=api@internal" # Serviço interno da API do Traefik
      - "traefik.http.routers.traefik-dashboard.tls.certresolver=myresolver"
      # Middleware de autenticação básica para o dashboard (substitua pelo hash htpasswd real)
      - "traefik.http.routers.traefik-dashboard.middlewares=dashboard-auth@docker"
      - "traefik.http.middlewares.dashboard-auth.basicauth.users=user:$$apr1$$YOUR_HTPASSWD_HASH"
    networks:
      - web

  whoami:
    image: traefik/whoami
    labels:
      - "traefik.enable=true" # Habilita o Traefik para este serviço
      - "traefik.http.routers.whoami.rule=Host(`whoami.yourdomain.com`)" # Define a regra de roteamento
      - "traefik.http.routers.whoami.entrypoints=websecure" # Escuta em websecure (HTTPS)
      - "traefik.http.routers.whoami.tls.certresolver=myresolver" # Usa o resolver do Let's Encrypt
    networks:
      - web

networks:
  web:
    external: true # Usa uma rede externa para todos os serviços expostos à web

Observação: antes de rodar docker-compose up -d, crie a rede externa com docker network create web.
Gere um hash htpasswd para dashboard-auth usando echo $(htpasswd -nb user password).

Traefik com Kubernetes

O Traefik integra-se ao Kubernetes por meio da sua API, utilizando recursos Ingress padrão e suas próprias Custom Resource Definitions (CRDs) para configurações avançadas. O método de instalação recomendado é via Helm.

Instalação com Helm

helm repo add traefik https://traefik.github.io/charts
helm repo update
helm install traefik traefik/traefik \
  --namespace traefik \
  --create-namespace \
  -f values.yaml

O arquivo values.yaml normalmente configura os EntryPoints, Providers e resolvers ACME do Traefik (por exemplo, myresolver para Let's Encrypt).

Configuração via Custom Resource Definitions (CRDs)

O Traefik estende as capacidades do Kubernetes com suas próprias CRDs, oferecendo mais controle do que o Ingress padrão:
* IngressRoute: define regras de roteamento, entry points e services associados, incluindo configuração de TLS e middlewares. É uma alternativa mais poderosa ao Ingress padrão do Kubernetes.
* Middleware: define modificadores reutilizáveis de requisição/resposta que podem ser aplicados a IngressRoutes.
* TraefikService: permite definir serviços de backend com mais detalhes, incluindo estratégias de balanceamento de carga e serviços externos.

Exemplo de configuração no Kubernetes

Este exemplo mostra um Deployment, um Service e um IngressRoute do Kubernetes para uma aplicação whoami.

# whoami-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: whoami
  labels:
    app: whoami
spec:
  replicas: 2
  selector:
    matchLabels:
      app: whoami
  template:
    metadata:
      labels:
        app: whoami
    spec:
      containers:
      - name: whoami
        image: traefik/whoami
        ports:
        - containerPort: 80

---
# whoami-service.yaml
apiVersion: v1
kind: Service
metadata:
  name: whoami
spec:
  selector:
    app: whoami
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

---
# whoami-ingressroute.yaml
apiVersion: traefik.containo.us/v1alpha1
kind: IngressRoute
metadata:
  name: whoami-ingressroute
spec:
  entryPoints:
    - websecure # Pressupõe que o entry point 'websecure' esteja configurado nos values do Helm do Traefik
  routes:
    - match: Host(`whoami.yourdomain.com`)
      kind: Rule
      services:
        - name: whoami # Refere-se ao Service 'whoami' do Kubernetes
          port: 80
  tls:
    certResolver: myresolver # Pressupõe que 'myresolver' para Let's Encrypt esteja configurado nos values do Helm do Traefik

Comparação: Traefik vs. proxies tradicionais (Nginx/HAProxy)

Monitoramento e dashboard

O dashboard do Traefik oferece uma interface gráfica para visualizar a configuração de roteamento atual e monitorar o status do Traefik. Pode ser acessado por um navegador web, normalmente na porta 8080 (conforme configurado no exemplo com Docker). Por segurança, é prática padrão proteger o dashboard com um middleware como autenticação básica.

Boas práticas

• Isole o Traefik: rode o Traefik em uma rede dedicada ou em um namespace próprio do Kubernetes para aumentar a segurança e simplificar o gerenciamento.
• Proteja o dashboard: sempre proteja o dashboard do Traefik com autenticação (por exemplo, middleware BasicAuth) e garanta que ele seja exposto apenas a pessoas autorizadas.
• Armazenamento persistente para ACME: para certificados Let's Encrypt, garanta que o caminho de armazenamento ACME (por exemplo, /letsencrypt/acme.json) esteja mapeado para armazenamento persistente. Isso evita a perda de certificados ao reiniciar ou reimplantar o container.
• Menor privilégio: ao montar o socket do Docker (/var/run/docker.sock), garanta que o Traefik rode com o mínimo de privilégios necessário. Considere usar uma montagem somente leitura (:ro) caso o acesso de escrita não seja necessário.
• exposedbydefault=false: para providers Docker, definir --providers.docker.exposedbydefault=false é uma boa prática de segurança e gerenciamento. Isso exige labels traefik.enable=true explícitas nos containers que devem ser expostos.