Traefik

Última atualização em 12 de fevereiro de 2026

Traefik é um ingress controller e proxy reverso para ambientes em nuvem e Kubernetes. Ele descobre serviços automaticamente, fornece terminação SSL/TLS e oferece recursos avançados de roteamento. Usar o Traefik no Kubernetes permite roteamento flexível de tráfego para serviços dentro do cluster.

Instalar Traefik
Copiar link

  1. Vá para a seção Kubernetes e clique no cluster.
  2. Navegue até a aba Complementos e selecione Traefik.
  3. O assistente de instalação será aberto. Você pode enviar seu próprio arquivo values.yaml para personalização ou manter as configurações padrão. Inicie a instalação clicando no botão Instalar.
  4. Aguarde até a instalação ser concluída. Depois disso, certifique-se de que todos os pods no namespace traefik estejam em execução com status Running:
kubectl get pods -n traefik

Usar Traefik
Copiar link

Por padrão, a configuração instalada do Traefik usa quatro entry points:

  • :8000/tcp — HTTP (web)
  • :8443/tcp — HTTPS (websecure)
  • :8080/tcp — API Dashboard (traefik)
  • :9100/tcp — Métricas do Prometheus (metrics)

Para trabalhar com Traefik, você precisa criar um Service que roteie o tráfego para sua aplicação:

apiVersion: v1
kind: Service
metadata:
  name: example-service
  namespace: default
spec:
  selector:
    app: example-app
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Este manifesto cria o example-service no namespace default, que:

  • Roteia tráfego HTTP (porta 80).
  • Direciona para pods com o label app: example-app.
  • Encaminha requisições para targetPort: 80 dentro dos pods.

Agora, você pode configurar o roteamento via Traefik usando IngressRoute:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: example-service-route
  namespace: default
spec:
  entryPoints:
    - web
  routes:
    - match: Host(`service.example.com`)
      kind: Rule
      services:
        - name: example-service
          port: 80

Neste manifesto:

  • entryPoints: web — especifica que o roteamento ocorre via HTTP (8000/tcp).
  • match: Host('service.example.com') — define a regra de roteamento baseada no nome de domínio.
  • As requisições são direcionadas para o example-service na porta 80.

Exemplo de uso
Copiar link

Vamos criar um exemplo usando Traefik. Criaremos duas implantações Nginx que vão operar em dois domínios diferentes: service1.example.com e service2.example.com. Também configuraremos um load balancer e o roteamento via Traefik. Por fim, configuraremos certificados SSL usando Traefik.

Criar ConfigMap
Copiar link

Primeiro, crie o arquivo configmap-nginx.yaml, que define páginas HTML para cada serviço:

apiVersion: v1
kind: ConfigMap
metadata:
  name: nginx-pages
  namespace: default
data:
  index1.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Service 1</title></head>
    <body><h1>Service 1</h1></body>
    </html>
  index2.html: |
    <!DOCTYPE html>
    <html>
    <head><title>Service 2</title></head>
    <body><h1>Service 2</h1></body>
    </html>

Criar Deployments para Nginx
Copiar link

O manifesto service1-nginx.yaml descreve a implantação para o primeiro serviço:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: service1
  namespace: default
  labels:
    app: service1
spec:
  replicas: 2
  selector:
    matchLabels:
      app: service1
  template:
    metadata:
      labels:
        app: service1
    spec:
      containers:
        - name: nginx
          image: nginx
          volumeMounts:
            - name: html-volume
              mountPath: /usr/share/nginx/html
          ports:
            - containerPort: 80
      volumes:
        - name: html-volume
          configMap:
            name: nginx-pages
            items:
              - key: index1.html
                path: index.html

O manifesto service2-nginx.yaml descreve a implantação para o segundo serviço:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: service2
  namespace: default
  labels:
    app: service2
spec:
  replicas: 2
  selector:
    matchLabels:
      app: service2
  template:
    metadata:
      labels:
        app: service2
    spec:
      containers:
        - name: nginx
          image: nginx
          volumeMounts:
            - name: html-volume
              mountPath: /usr/share/nginx/html
          ports:
            - containerPort: 80
      volumes:
        - name: html-volume
          configMap:
            name: nginx-pages
            items:
              - key: index2.html
                path: index.html

Criar Services
Copiar link

Defina os serviços para os quais o Traefik vai rotear o tráfego.

O manifesto service1-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: service1
  namespace: default
spec:
  selector:
    app: service1
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Este manifesto cria o serviço service1, que aceita requisições HTTP na porta 80 e as redireciona para pods com label app: service1.

O manifesto service2-service.yaml:

apiVersion: v1
kind: Service
metadata:
  name: service2
  namespace: default
spec:
  selector:
    app: service2
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80

Criar Rotas no Traefik
Copiar link

O manifesto service1-ingressroute.yaml descreve a rota para o primeiro serviço:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: service1-route
  namespace: default
spec:
  entryPoints:
    - web
  routes:
    - match: Host(`service1.example.com`)
      kind: Rule
      services:
        - name: service1
          port: 80

Este manifesto define um IngressRoute para service1.example.com. Vamos detalhar os componentes:

  • entryPoints: web — a rota está disponível via HTTP (porta 80, especificada no load balancer do Traefik).
  • match: Host('service1.example.com') — a rota é acionada ao acessar service1.example.com.
  • name: service1 — a rota encaminha o tráfego para o serviço service1.
  • port: 80 — o tráfego é enviado para a porta 80 dentro do serviço Kubernetes service1.

O manifesto service2-ingressroute.yaml descreve a rota para o segundo serviço:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: service2-route
  namespace: default
spec:
  entryPoints:
    - web
  routes:
    - match: Host(`service2.example.com`)
      kind: Rule
      services:
        - name: service2
          port: 80

Configurar o Load Balancer
Copiar link

Defina o load balancer do Traefik no arquivo traefik-loadbalancer.yaml:

apiVersion: v1
kind: Service
metadata:
  name: traefik
  namespace: traefik
spec:
  type: LoadBalancer
  selector:
    app.kubernetes.io/name: traefik
  ports:
    - name: web
      port: 80
      targetPort: 8000
    - name: websecure
      port: 443
      targetPort: 8443

Aplicar a configuração
Copiar link

Aplique todos os manifests:

kubectl apply -f ./

Após criar o load balancer, defina seu endereço IP como os registros A dos domínios. Agora, os serviços estão acessíveis em:

  • http://service1.example.com
  • http://service2.example.com

Configuramos dois serviços no Kubernetes usando Traefik, garantindo roteamento e balanceamento de carga.

Configurar SSL
Copiar link

O Traefik permite obter certificados SSL de duas formas:

  • Usando recursos internos do Traefik.
  • Usando o cert-manager.

A escolha depende da configuração do cluster. Se outros Ingress controllers forem usados, recomenda-se cert-manager para gerenciamento centralizado de certificados. Se apenas o Traefik for usado no cluster, você pode utilizar o recurso interno de obtenção de certificados.

Atualizar configuração do Traefik
Copiar link

Para habilitar suporte ao Let's Encrypt, modifique a configuração do Traefik:

  1. Vá para seção Kubernetes e clique em cluster.
  2. Na aba Complementos, selecione Traefik.
  3. Habilite o modo de instalação avançado.
  4. Ajuste a configuração:
image:
  registry: docker.io

deployment:
  kind: Deployment

updateStrategy:
  rollingUpdate:
    maxUnavailable: 1
    maxSurge: 0

additionalArguments:
  - "--certificatesresolvers.le.acme.email=admin@example.com"
  - "--certificatesresolvers.le.acme.storage=/data/acme.json"
  - "--certificatesresolvers.le.acme.tlschallenge=true"

Alterações realizadas:

  • Por padrão, o Traefik é instalado como DaemonSet. Neste modo, ele não consegue obter certificados usando Traefik. Portanto, alteramos o tipo de deployment para Deployment.
  • Adicionado o segmento additionalArguments. Defina seu e-mail para registro no Let's Encrypt em --certificatesresolvers.le.acme.email.
  1. Salve as alterações e aguarde a atualização ser concluída.

Verificar configuração
Copiar link

Após atualizar, verifique se a configuração foi aplicada corretamente:

kubectl get pod -n traefik

Em seguida, confira os parâmetros ACME:

kubectl get pod <pod_name> -n traefik -o yaml | grep acme

A saída deve conter linhas como:

 - --certificatesresolvers.le.acme.email=admin@example.com
  - --certificatesresolvers.le.acme.storage=/data/acme.json
  - --certificatesresolvers.le.acme.tlschallenge=true

Redirecionamento automático de HTTP para HTTPS
Copiar link

Crie um middleware para redirecionamento automático de HTTP para HTTPS.

Arquivo redirect-https.yaml:

apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: redirect-to-https
  namespace: default
spec:
  redirectScheme:
    scheme: https
    permanent: true

Aplique o manifesto:

kubectl apply -f redirect-https.yaml

Atualizar IngressRoute
Copiar link

Atualize o IngressRoute para adicionar o middleware de redirecionamento de HTTP para HTTPS.

Manifesto service1-ingressroute.yaml:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: service1-route
  namespace: default
spec:
  entryPoints:
    - web
  routes:
    - match: Host(`service1.example.com`)
      kind: Rule
      middlewares:
        - name: redirect-to-https
      services:
        - name: service1
          port: 80

Manifesto service2-ingressroute.yaml:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: service2-route
  namespace: default
spec:
  entryPoints:
    - web
  routes:
    - match: Host(`service2.example.com`)
      kind: Rule
      middlewares:
        - name: redirect-to-https
      services:
        - name: service2
          port: 80

Adicionamos o middleware redirect-to-https aos manifests de roteamento service1-ingressroute.yaml e service2-ingressroute.yaml, que redireciona automaticamente requisições HTTP para HTTPS.

Atualize os manifests:

kubectl apply -f service1-ingressroute.yaml
kubectl apply -f service2-ingressroute.yaml

Configurar IngressRoute HTTPS
Copiar link

Agora precisamos criar recursos IngressRoute separados para HTTPS, pois rotas HTTP padrão não suportam TLS. Para HTTPS funcionar, precisamos especificar certResolver, que usará Let's Encrypt para obter certificados automaticamente.

Na nova IngressRoute, especifique entryPoints: websecure e o parâmetro tls, que habilita suporte à criptografia.

Manifesto service1-ingressroute-https.yaml:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: service1-route-https
  namespace: default
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`service1.example.com`)
      kind: Rule
      services:
        - name: service1
          port: 80
  tls:
    certResolver: le

Manifesto service2-ingressroute-https.yaml:

apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: service2-route-https
  namespace: default
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`service2.example.com`)
      kind: Rule
      services:
        - name: service2
          port: 80
  tls:
    certResolver: le

Aplique os manifests das novas rotas:

kubectl apply -f service1-ingressroute-https.yaml
kubectl apply -f service2-ingressroute-https.yaml

Verificar emissão de certificados
Copiar link

Verifique a emissão de certificados com:

kubectl logs -n traefik -l app.kubernetes.io/name=traefik | grep acme

Agora, os serviços estão acessíveis via HTTPS:

  • https://service1.example.com
  • https://service2.example.com

Configuramos emissão automática de certificados SSL com Let's Encrypt no Traefik, garantindo conexões seguras para os serviços.

Configurar o dashboard
Copiar link

O Traefik fornece uma interface web que permite monitorar o status de rotas, serviços, middlewares e outros recursos gerenciados pela instância Traefik. O dashboard ajuda a diagnosticar problemas, analisar roteamento de tráfego e gerenciar a configuração.

Por padrão, o dashboard do Traefik é acessível sem autenticação, o que representa um risco de segurança, pois qualquer usuário pode visualizar informações sobre os serviços em execução. Para proteger o acesso, configuraremos autenticação básica usando middleware.

  1. Gere um hash de senha:
mkpasswd -m bcrypt "password"
  1. Codifique as credenciais em base64:
echo -n 'username:generated_hash' | base64
  1. Defina um secret em dashboard-secret.yaml:
apiVersion: v1
kind: Secret
metadata:
  name: dashboard-auth-secret
  namespace: traefik
type: Opaque
data:
  users: |
    login:base64_encoded_password
  1. Aplique o manifesto:
kubectl apply -f dashboard-secret.yaml
  1. Defina o middleware em dashboard-auth.yaml:
apiVersion: traefik.io/v1alpha1
kind: Middleware
metadata:
  name: dashboard-auth
  namespace: traefik
spec:
  basicAuth:
    secret: dashboard-auth-secret
  1. Aplique o manifesto:
kubectl apply -f dashboard-auth.yaml
  1. Defina o IngressRoute para o dashboard em dashboard-ingress.yaml:
apiVersion: traefik.io/v1alpha1
kind: IngressRoute
metadata:
  name: traefik-dashboard
  namespace: traefik
spec:
  entryPoints:
    - websecure
  routes:
    - match: Host(`dashboard.example.com`)
      kind: Rule
      middlewares:
        - name: dashboard-auth
      services:
        - kind: TraefikService
          name: api@internal
  tls:
    certResolver: le

Este manifesto define uma rota para acessar o dashboard do Traefik via HTTPS, aplicando autenticação básica.

Descrição dos parâmetros:

  • entryPoints: websecure — a rota será acessível apenas via HTTPS.
  • match: Host(dashboard.example.com) — direciona requisições recebidas para dashboard.example.com ao dashboard.
  • middlewares — aplica o middleware dashboard-auth criado anteriormente, que habilita autenticação HTTP básica.
  • services — direciona requisições para o serviço interno api@internal, responsável por exibir o dashboard.
  • tls.certResolver: le — habilita emissão automática de certificados SSL via Let's Encrypt.
  1. Aplique o manifesto:
kubectl apply -f dashboard-ingress.yaml
  1. Acesse https://dashboard.example.com. Após autenticação, você verá o dashboard do Traefik.