Traefik vs Nginx: Ingress Controller para Kubernetes em 2026

SCHEMA MARKUP JSON-LD  |  ✎ Duarte Spínola  |  Tags:

O Kubernetes precisa de um Ingress Controller para expor serviços HTTP/HTTPS ao mundo exterior. Em 2026, duas opções dominam: Nginx Ingress (clássico, estável, omnipresente) e Traefik Ingress (moderno, dinâmico, auto-descoberta). A escolha afecta tudo — desde a configuração de HTTPS à gestão de múltiplos namespaces. Este artigo configura ambos com certificados TLS automáticos, compara performance e custos para PME, e dá um guia de decisão por cenário (Traefik docs, Nginx Ingress docs).

Neste artigo

  1. Entender Ingress Controller no Kubernetes
  2. Pré-requisitos e Instalação
  3. Passo 1 — Configurar Traefik Ingress com Helm
  4. Passo 2 — Configurar Nginx Ingress com Helm
  5. Passo 3 — HTTPS Automático com cert-manager
  6. Passo 4 — Rate Limiting e Middlewares
  7. Passo 5 — Monitorização e Dashboards
  8. Passo 6 — Múltiplos Namespaces e IngressRoute
  9. Traefik vs Nginx — Comparação Prática
  10. Erros Comuns
  11. Checklist Rápido de Verificação

1. Entender Ingress Controller no Kubernetes

No Kubernetes, os pods têm IPs efémeros que mudam a cada restart. Os Services dão um IP estável dentro do cluster, mas não expõem nada ao exterior. O Ingress Controller é a camada que recebe tráfego HTTP/HTTPS de fora do cluster e encaminha para o Service correcto baseado no host e path.

Analogia: o Ingress Controller é como a recepção de um hotel. Os hóspedes (pods) mudam de quarto frequentemente, mas a recepção (Ingress) sabe sempre onde cada um está e encaminha os visitantes (tráfego) correctamente.

Conceito Função Analogia
Pod Container que corre a aplicação Hóspede do hotel
Service IP estável dentro do cluster Lista de hóspedes no andar X
Ingress Regra HTTP que encaminha tráfego externo Placa na recepção: “hóspede Y → andar 3”
Ingress Controller Implementa as regras Ingress Recepcionista que executa as regras
cert-manager Obtém e renova certificados TLS Funcionário que trata das credenciais

A diferença fundamental entre Traefik e Nginx:

Característica Traefik Nginx Ingress
Configuração Dinâmica (auto-descoberta) Estática (reload ao mudar Ingress)
Descoberta de serviços Label watching automático Via Ingress resources
Dashboard web Nativo, em tempo real Requer instalação separada
Middlewares Nativo (chain de filtros) Via annotations (limitado)
Protocolo suportado HTTP, TCP, UDP, gRPC HTTP, HTTPS (TCP limitado)
Let’s Encrypt Integrado (ACME nativo) Requer cert-manager externo
Linguagem Go C (Nginx) + Lua
Binário ~100 MB ~50 MB

2. Pré-requisitos e Instalação

Requisito Detalhe
Cluster Kubernetes k3s, k8s, EKS, GKE ou AKS
kubectl Configurado e a comunicar com o cluster
Helm 3 Gestor de packages Kubernetes
IP público no LoadBalancer Ou NodePort para clusters sem LB
Domínio configurado Registo A a apontar para o IP do LoadBalancer

Instalar Helm se não estiver presente:

curl -fsSL https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash

Se não tiveres curl, usar wget -qO- URL | bash como alternativa.

Verificar que o cluster está acessível:

kubectl get nodes
kubectl get pods -A

O output deve mostrar todos os nós em estado Ready e os pods do cluster a correr (CoreDNS, CNI, etc.).

3. Passo 1 — Configurar Traefik Ingress com Helm

O Traefik é o Ingress Controller padrão do K3s. Para clusters Kubernetes standard, instalar via Helm:

helm repo add traefik https://traefik.github.io/charts
helm repo update
helm install traefik traefik/traefik \
–namespace traefik \
–create-namespace \
–set service.type=LoadBalancer \
–set ports.web.redirectTo=websecure \
–set ports.websecure.tls.enabled=true

O que cada parâmetro faz:

  • namespace traefik — instala o Traefik num namespace separado (boa prática)
  • service.type=LoadBalancer — expõe o Traefik via LoadBalancer (cloud) ou MetalLB (on-premises)
  • ports.web.redirectTo=websecure — redirecciona HTTP (porta 80) para HTTPS (porta 443) automaticamente
  • ports.websecure.tls.enabled=true — ativa TLS na porta 443

Criar um Ingress para expor uma aplicação:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: grafana-ingress
namespace: monitoring
annotations:
traefik.ingress.kubernetes.io/router.entrypoints: websecure
spec:
rules:
– host: grafana.empresa.pt
http:
paths:
– path: /
pathType: Prefix
backend:
service:
name: grafana
port:
number: 3000

Aplicar:

kubectl apply -f grafana-ingress.yaml

O Traefik detecta automaticamente o novo Ingress e começa a encaminhar tráfego — sem reload, sem restart. Isto é a vantagem principal do Traefik: configuração dinâmica (Traefik Kubernetes Ingress).

4. Passo 2 — Configurar Nginx Ingress com Helm

Para clusters que preferem Nginx (compatibilidade, comunidade, performance):

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx
helm repo update
helm install nginx-ingress ingress-nginx/ingress-nginx \
–namespace ingress-nginx \
–create-namespace \
–set controller.service.type=LoadBalancer \
–set controller.metrics.enabled=true

O que cada parâmetro faz:

  • controller.service.type=LoadBalancer — expõe o Nginx via LoadBalancer
  • controller.metrics.enabled=true — ativa métricas Prometheus para monitorização

Criar o mesmo Ingress para Nginx (a sintaxe é standard Kubernetes):

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: grafana-ingress
namespace: monitoring
annotations:
kubernetes.io/ingress.class: nginx
nginx.ingress.kubernetes.io/ssl-redirect: “true”
spec:
tls:
– hosts:
– grafana.empresa.pt
secretName: grafana-tls
rules:
– host: grafana.empresa.pt
http:
paths:
– path: /
pathType: Prefix
backend:
service:
name: grafana
port:
number: 3000

Aplicar:

kubectl apply -f grafana-ingress.yaml

⚠️ Atenção

Ao contrário do Traefik, o Nginx faz reload (não restart) quando um Ingress é adicionado ou modificado. Em clusters com centenas de Ingress, o reload pode causar latência momentânea. O Traefik não tem este problema.

5. Passo 3 — HTTPS Automático com cert-manager

O cert-manager é o standard de facto para gestão de certificados TLS no Kubernetes. Funciona com ambos Traefik e Nginx.

Instalar cert-manager:

helm repo add jetstack https://charts.jetstack.io
helm repo update
helm install cert-manager jetstack/cert-manager \
–namespace cert-manager \
–create-namespace \
–set installCRDs=true

Criar um ClusterIssuer para Let’s Encrypt:

apiVersion: cert-manager.io/v1
kind: ClusterIssuer
metadata:
name: letsencrypt-prod
spec:
acme:
server: https://acme-v02.api.letsencrypt.org/directory
email: [email protected]
privateKeySecretRef:
name: letsencrypt-prod
solvers:
– http01:
ingress:
class: traefik # ou nginx

O que cada campo faz:

  • server — endpoint ACME de produção do Let’s Encrypt (não usar o staging para certificados reais)
  • email — email para notificações de expiração
  • privateKeySecretRef — nome do Secret onde a chave ACME é guardada
  • http01.ingress.class — qual Ingress Controller vai responder ao challenge HTTP-01

Aplicar e o cert-manager vai obter certificados automaticamente quando um Ingress referenciar este issuer via annotation cert-manager.io/cluster-issuer: letsencrypt-prod (cert-manager docs).

6. Passo 4 — Rate Limiting e Middlewares

Traefik — Rate Limiting via Middleware

apiVersion: traefik.containo.us/v1alpha1
kind: Middleware
metadata:
name: rate-limit
namespace: monitoring
spec:
rateLimit:
average: 100
burst: 200

Aplicar no Ingress:

metadata:
annotations:
traefik.ingress.kubernetes.io/router.middlewares: monitoring-rate-limit@kubernetescrd

O que cada parâmetro faz:

  • average: 100 — 100 pedidos por segundo em média
  • burst: 200 — permite rajadas de 200 pedidos
  • router.middlewares — referencia o middleware pelo nome@provider

Nginx — Rate Limiting via Annotations

metadata:
annotations:
nginx.ingress.kubernetes.io/limit-rps: “100”
nginx.ingress.kubernetes.io/limit-burst: “200”
nginx.ingress.kubernetes.io/limit-connections: “50”
  • limit-rps — pedidos por segundo por IP
  • limit-burst — rajada permitida
  • limit-connections — máximo de ligações simultâneas por IP

ℹ️ Nota: O Traefik suporta middlewares mais ricos (compressão, autenticação, headers, redirect, retry) como recursos CRD separados. O Nginx faz tudo via annotations no Ingress, que pode tornar-se difícil de gerir com muitas regras.

7. Passo 5 — Monitorização e Dashboards

Traefik Dashboard

O Traefik tem um dashboard web nativo acessível em /dashboard/:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: traefik-dashboard
namespace: traefik
annotations:
traefik.ingress.kubernetes.io/router.entrypoints: websecure
spec:
rules:
– host: traefik.empresa.pt
http:
paths:
– path: /
pathType: Prefix
backend:
service:
name: traefik-dashboard
port:
number: 9000

⚠️ Atenção

O dashboard do Traefik mostra informações sensíveis (rotas, serviços, IPs internos). Proteger com autenticação ou restringir a VPN/IPs autorizados.

Nginx Dashboard

O Nginx não tem dashboard nativo. Instalar o Grafana + Prometheus e importar o dashboard oficial (ID 9614):

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/grafana/dashboards/nginx-ingress.json

Métricas Prometheus do Nginx Ingress:

kubectl exec -n ingress-nginx deployment/nginx-ingress-controller — curl -s http://localhost:10254/metrics | head -20

8. Passo 6 — Múltiplos Namespaces e IngressRoute

O Traefik suporta IngressRoute — um CRD próprio mais expressivo que o Ingress standard:

apiVersion: traefik.containo.us/v1alpha1
kind: IngressRoute
metadata:
name: api-route
namespace: production
spec:
entryPoints:
– websecure
routes:
– match: Host(`api.empresa.pt`) && PathPrefix(`/v1`)
kind: Rule
services:
– name: api-v1
port: 8080
– match: Host(`api.empresa.pt`) && PathPrefix(`/v2`)
kind: Rule
services:
– name: api-v2
port: 8080
tls:
certResolver: letsencrypt

O que cada linha faz:

  • entryPoints: websecure — escuta apenas na porta 443 (HTTPS)
  • match: Host(...) && PathPrefix(...) — encaminha baseado em host E path simultaneamente
  • services — pode encaminhar para múltiplos serviços com load balancing
  • tls.certResolver — usa o resolver ACME configurado no Traefik para obter certificados

O Nginx não tem equivalente ao IngressRoute — tudo via Ingress standard com annotations.

9. Traefik vs Nginx — Comparação Prática

Critério Traefik Nginx Ingress Vencedor
Facilidade de setup Helm + auto-descoberta Helm + annotations Traefik
HTTPS auto ACME nativo Requer cert-manager Traefik
Performance (RPS) ~50k RPS ~80k RPS Nginx
Dashboard Nativo, real-time Requer Grafana Traefik
Comunidade/docs Crescente Enorme Nginx
Middlewares CRD rico (chain) Annotations (limitado) Traefik
Configuração dinâmica Zero reload Reload a cada mudança Traefik
TCP/UDP Suportado Limitado Traefik
Estabilidade Bom (projeto maduro) Excelente (battle-tested) Nginx
Para PME Simples, rápido Standard, robusto Depende

Recomendação para PME: Traefik se valorizas simplicidade e auto-descoberta. Nginx se já tens experiência com Nginx e preferes a configuração standard. Para K3s, o Traefik já vem instalado por defeito — não há motivo para mudar.

10. Erros Comuns

Problema Causa Solução
502 Bad Gateway Service backend não existe ou porta errada Verificar kubectl get svc e kubectl get endpoints
Certificado não obtido Domínio não aponta para o IP do LoadBalancer Verificar dig dominio.pt — tem de apontar para o LB externo
Too many redirects SSL redirect em loop com backend que também força HTTPS desativar SSL redirect no backend ou usar ssl-redirect: "false"
Traefik não encaminha IngressRoute com match incorrecto Verificar traefik.ingress.kubernetes.io/router.entrypoints annotation
Nginx reload lento Muitos Ingress resources Considerar Traefik (zero reload) ou dividir namespaces
Dashboard Traefik 404 Path errado O dashboard fica em /dashboard/ (com barra no fim)
cert-manager stuck ClusterIssuer não aplicado ou email inválido Verificar kubectl get clusterissuer e logs kubectl logs -n cert-manager deployment/cert-manager
Rate limit não funciona Middleware não referenciado no Ingress Verificar annotation router.middlewares com nome@provider correctos

11. Checklist Rápido de Verificação

  • [ ] Ingress Controller instalado e a correr (kubectl get pods -n traefik ou ingress-nginx)
  • [ ] LoadBalancer com IP externo (kubectl get svc -n traefik ou ingress-nginx)
  • [ ] Domínio a apontar para o IP do LoadBalancer (dig dominio.pt)
  • [ ] HTTPS funciona no browser (cadeado verde)
  • [ ] cert-manager instalado e ClusterIssuer Ready
  • [ ] Rate limiting configurado em APIs expostas
  • [ ] Dashboard acessível (Traefik) ou métricas Prometheus (Nginx)
  • [ ] Pods backend acessíveis (kubectl get endpoints)
  • [ ] Logs sem erros (kubectl logs -n traefik deployment/traefik)
  • [ ] Reinício do pod — Ingress Controller volta automaticamente (Deployment replica)

Artigos Relacionados

← Voltar ao Índice

Este artigo foi útil?

Duarte Spínola

Artigos  

Deixe um Comentário