Traefik : le reverse proxy cloud-native pour vos services

Traefik est un reverse proxy et load balancer cloud-native qui détecte automatiquement vos services et configure son routage en temps réel. Contrairement à NGINX ou HAProxy qui nécessitent des fichiers de configuration manuels, Traefik interroge directement Docker, Kubernetes ou Consul pour découvrir vos applications. Résultat : vous déployez un conteneur, Traefik l’expose immédiatement, sans recharger de configuration.

Ce guide vous explique l’architecture de Traefik, ses 5 concepts fondamentaux (Entrypoints, Routers, Services, Middlewares, Providers) et les nouveautés de la version 3.6. À la fin, vous saurez si Traefik convient à votre infrastructure.

Version actuelle

Ce guide couvre Traefik v3.6 (juin 2025). Les nouveautés majeures de v3 incluent HTTP/3 QUIC, OpenTelemetry natif et la Kubernetes Gateway API.

Qu’est-ce que Traefik ?

Un reverse proxy est un serveur intermédiaire qui reçoit les requêtes des clients (navigateurs, applications) et les transmet au bon service backend. C’est comme un standardiste téléphonique : quand vous appelez une entreprise, le standardiste vous dirige vers le bon service selon votre demande.

Traefik est un reverse proxy moderne, conçu pour les environnements cloud-native : Docker, Kubernetes, Swarm, Consul, Nomad. Sa particularité ? Il découvre automatiquement les services à exposer en interrogeant ces plateformes.

Terminologie essentielle

Avant d’aller plus loin, voici les termes clés à connaître :

Terme	Définition simple
Reverse proxy	Serveur qui reçoit les requêtes et les transmet aux services backend
Load balancer	Répartiteur de charge entre plusieurs instances d’un même service
Edge router	Point d’entrée unique pour tout le trafic vers votre infrastructure
Cloud-native	Conçu pour les environnements conteneurisés (Docker, Kubernetes)
Provider	Source de configuration (Docker, Kubernetes, fichier, etc.)

Glissez pour voir

Pourquoi utiliser Traefik ?

Découverte automatique des services

C’est la fonctionnalité phare de Traefik. Quand vous déployez un conteneur Docker avec des labels spécifiques, Traefik le détecte et crée automatiquement la route correspondante.

Exemple concret : Vous déployez une application web sur Docker :

docker run -d \
  --label "traefik.http.routers.monapp.rule=Host(\`monapp.example.com\`)" \
  --label "traefik.http.services.monapp.loadbalancer.server.port=80" \
  nginx

Sans Traefik (avec NGINX classique) :

1. Déployer le conteneur
2. Récupérer son adresse IP
3. Modifier la configuration NGINX
4. Recharger NGINX
5. Répéter à chaque changement

Avec Traefik : Le conteneur est exposé immédiatement, sans intervention manuelle.

Configuration dynamique sans redémarrage

Traefik applique les changements de configuration en temps réel, sans couper les connexions existantes. C’est ce qu’on appelle le hot-reload.

Analogie

Imaginez que vous puissiez changer les panneaux indicateurs d’une autoroute sans jamais arrêter le trafic. C’est exactement ce que fait Traefik avec sa configuration dynamique.

Intégration native avec les orchestrateurs

Traefik supporte nativement les principales plateformes d’orchestration :

Plateforme	Type de provider	Détail
Docker	docker	Labels sur les conteneurs
Docker Swarm	swarm	Labels sur les services
Kubernetes	kubernetesgateway, kubernetescrd, kubernetesingress	Gateway API, CRD IngressRoute, Ingress standard
Consul	consul, consulcatalog	Service discovery HashiCorp
Nomad	nomad	Jobs HashiCorp Nomad
Fichier	file	YAML/TOML pour tests ou cas simples

Glissez pour voir

Certificats SSL/TLS automatiques

Traefik intègre un client ACME (le protocole de Let’s Encrypt) pour générer et renouveler automatiquement les certificats SSL. Plus besoin de gérer Certbot ou des scripts de renouvellement.

Architecture de Traefik

Vue d’ensemble

Traefik fonctionne comme un routeur de périphérie (Edge Router). Il se place entre Internet et vos services, interceptant toutes les requêtes entrantes.

L’architecture repose sur deux types de configuration :

Type	Quand ça change	Exemples
Configuration d’installation (statique)	Au démarrage uniquement	Entrypoints, providers activés, certificats ACME
Configuration de routage (dynamique)	En temps réel, sans redémarrage	Routers, services, middlewares

Glissez pour voir

Distinction importante

La configuration d’installation (anciennement “configuration statique”) se définit au démarrage de Traefik et ne peut pas être modifiée sans redémarrage. La configuration de routage (anciennement “configuration dynamique”) peut changer à tout moment.

Flux d’une requête

Voici comment Traefik traite une requête HTTP entrante :

1. Entrypoint : La requête arrive sur un point d’entrée (exemple : port 443 pour HTTPS)

2. Router : Traefik analyse la requête (Host, Path, Headers) pour trouver le router correspondant

3. Middlewares : La requête traverse une chaîne de middlewares (authentification, rate limiting, headers…)

4. Service : La requête atteint le service backend qui la traite

5. Réponse : La réponse remonte la chaîne (middlewares en sens inverse) vers le client

Les concepts fondamentaux

Traefik repose sur 5 concepts clés qui s’enchaînent pour traiter chaque requête.

Entrypoints

Les Entrypoints sont les portes d’entrée réseau de Traefik. Ils définissent sur quels ports et protocoles Traefik écoute.

Analogie : Ce sont les guichets d’accueil d’une gare. Chaque guichet (entrypoint) accepte un type de billet (protocole) spécifique.

# traefik.yaml (configuration d'installation)
entryPoints:
  web:
    address: ":80"
  websecure:
    address: ":443"
  metrics:
    address: ":8082"

Entrypoint	Port	Usage typique
web	80	HTTP (redirection vers HTTPS)
websecure	443	HTTPS (trafic principal)
traefik	8080	Dashboard et API interne
metrics	8082	Métriques Prometheus

Glissez pour voir

Routers

Les Routers analysent les requêtes entrantes et les dirigent vers le bon service. Ils utilisent des règles (rules) pour matcher les requêtes.

Analogie : Ce sont les panneaux indicateurs sur l’autoroute. Selon votre destination (Host, Path), ils vous orientent vers la bonne sortie.

# Configuration dynamique (labels Docker ou fichier)
http:
  routers:
    api-router:
      rule: "Host(`api.example.com`) && PathPrefix(`/v1`)"
      service: api-service
      entryPoints:
        - websecure
      tls:
        certResolver: letsencrypt

Règles de routage disponibles :

Règle	Description	Exemple
Host(...)	Nom de domaine	Host('api.example.com')
HostRegexp(...)	Domaine avec regex	HostRegexp('{subdomain:[a-z]+}.example.com')
Path(...)	Chemin exact	Path('/api/health')
PathPrefix(...)	Préfixe de chemin	PathPrefix('/api')
Headers(...)	En-tête HTTP	Headers('X-Api-Key', 'secret')
ClientIP(...)	IP du client	ClientIP('192.168.1.0/24')

Glissez pour voir

Les règles peuvent être combinées avec && (ET) et || (OU).

Services

Les Services représentent vos applications backend. Traefik leur transmet les requêtes après le routage.

Analogie : Ce sont les comptoirs de service dans une administration. Chaque comptoir (service) traite un type de demande spécifique.

http:
  services:
    api-service:
      loadBalancer:
        servers:
          - url: "http://api-1:3000"
          - url: "http://api-2:3000"
          - url: "http://api-3:3000"
        healthCheck:
          path: /health
          interval: 10s
          timeout: 3s

Traefik gère automatiquement le load balancing entre les instances et retire les serveurs en échec grâce aux health checks.

Middlewares

Les Middlewares transforment les requêtes avant qu’elles n’atteignent le service (ou modifient les réponses avant qu’elles ne reviennent au client).

Analogie : Ce sont les contrôles de sécurité à l’aéroport. Chaque middleware est un checkpoint qui peut autoriser, modifier ou bloquer le passage.

http:
  middlewares:
    auth-middleware:
      basicAuth:
        users:
          - "admin:$apr1$xxx"

    rate-limit:
      rateLimit:
        average: 100
        burst: 50

    secure-headers:
      headers:
        stsSeconds: 31536000
        contentTypeNosniff: true
        frameDeny: true

Middlewares les plus utilisés :

Middleware	Fonction	Cas d’usage
basicAuth	Authentification HTTP Basic	Protection simple
forwardAuth	Délégation à un service externe	SSO, OAuth
rateLimit	Limitation de débit	Protection API
headers	Ajout/modification headers	Sécurité (HSTS, CSP)
compress	Compression gzip/brotli	Performance
stripPrefix	Suppression préfixe URL	Microservices
retry	Réessai en cas d’erreur	Résilience
circuitBreaker	Disjoncteur	Protection backend

Glissez pour voir

Les middlewares peuvent être chaînés pour créer des pipelines de traitement.

Providers

Les Providers sont les sources de configuration dynamique de Traefik. Ils lui indiquent quels services exposer et comment les router.

Analogie : Ce sont les annuaires de l’entreprise. Chaque provider (Docker, Kubernetes, Consul) fournit à Traefik la liste des services disponibles.

# traefik.yaml (configuration d'installation)
providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false
  file:
    directory: /etc/traefik/dynamic
    watch: true

Provider	Source de configuration	Cas d’usage
docker	Labels des conteneurs	Développement, Docker Compose
swarm	Labels des services Swarm	Production Docker Swarm
kubernetesgateway	Gateway API CRD	Kubernetes moderne (recommandé)
kubernetescrd	IngressRoute CRD Traefik	Kubernetes avec CRD Traefik
kubernetesingress	Ingress standard	Compatibilité Ingress K8s
consul	Service Consul	Infrastructure HashiCorp
file	Fichiers YAML/TOML	Tests, configuration manuelle
http	Endpoint HTTP distant	Configuration centralisée

Glissez pour voir

Configuration statique vs dynamique

Cette distinction est fondamentale pour comprendre Traefik.

Configuration d’installation (statique)

Elle définit comment Traefik lui-même fonctionne. Elle se charge au démarrage via :

• Fichier traefik.yaml (ou .toml)
• Arguments CLI (traefik --entrypoints.web.address=:80)
• Variables d’environnement (TRAEFIK_ENTRYPOINTS_WEB_ADDRESS=:80)

Contenu typique :

• Entrypoints (ports d’écoute)
• Providers activés
• Configuration ACME/Let’s Encrypt
• Réglages du dashboard
• Options de logging

/etc/traefik/traefik.yaml

api:
  dashboard: true
  insecure: true  # En production, sécuriser !

entryPoints:
  web:
    address: ":80"
  websecure:
    address: ":443"

providers:
  docker:
    endpoint: "unix:///var/run/docker.sock"
    exposedByDefault: false

certificatesResolvers:
  letsencrypt:
    acme:
      email: admin@example.com
      storage: /acme.json
      httpChallenge:
        entryPoint: web

Configuration de routage (dynamique)

Elle définit comment router le trafic vers vos services. Elle peut changer à tout moment sans redémarrer Traefik.

Sources possibles :

• Labels Docker/Swarm
• CRD Kubernetes
• Fichiers surveillés (watch: true)
• Service Consul/etcd
• Endpoint HTTP distant

/etc/traefik/dynamic/whoami.yaml

http:
  routers:
    whoami:
      rule: "Host(`whoami.example.com`)"
      service: whoami
      entryPoints:
        - websecure
      tls:
        certResolver: letsencrypt

  services:
    whoami:
      loadBalancer:
        servers:
          - url: "http://whoami:80"

Traefik v3 : les nouveautés

La version 3 de Traefik (sortie en 2024) apporte des évolutions majeures.

HTTP/3 et QUIC

HTTP/3 utilise le protocole QUIC (basé sur UDP) au lieu de TCP. Avantages :

• Connexions plus rapides (0-RTT handshake)
• Meilleure résistance aux changements de réseau (mobile)
• Multiplexage sans head-of-line blocking

entryPoints:
  websecure:
    address: ":443"
    http3:
      advertisedPort: 443

OpenTelemetry natif

Traefik v3 intègre OpenTelemetry (OTEL) pour l’observabilité :

• Métriques : vers Prometheus, Datadog, InfluxDB…
• Traces : vers Jaeger, Zipkin, OTLP…

metrics:
  openTelemetry:
    address: "otel-collector:4317"
    grpc: true

tracing:
  openTelemetry:
    address: "otel-collector:4317"
    grpc: true

WebAssembly (Wasm) pour les plugins

Les plugins Traefik peuvent maintenant être écrits en WebAssembly, permettant :

• Logique personnalisée en Go, Rust, TinyGo…
• Middlewares sur mesure
• Extensibilité sans recompiler Traefik

SPIFFE mTLS

Traefik v3 supporte SPIFFE (Secure Production Identity Framework for Everyone) pour le mTLS (mutual TLS) :

• Identité vérifiable des services
• Rotation automatique des certificats
• Intégration avec SPIRE

Kubernetes Gateway API

Traefik implémente la Kubernetes Gateway API, le nouveau standard pour le routage sur Kubernetes (remplaçant Ingress) :

• Séparation claire des rôles (infra vs dev)
• Routage TCP/UDP/gRPC natif
• Support multi-cluster

Cas d’usage typiques

Microservices sur Docker

Traefik excelle pour exposer des microservices Docker Compose :

docker-compose.yaml

services:
  traefik:
    image: traefik:v3.6
    command:
      - "--providers.docker=true"
      - "--entrypoints.web.address=:80"
    ports:
      - "80:80"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

  api:
    image: mon-api:latest
    labels:
      - "traefik.http.routers.api.rule=Host(`api.localhost`)"
      - "traefik.http.services.api.loadbalancer.server.port=3000"

  frontend:
    image: mon-frontend:latest
    labels:
      - "traefik.http.routers.frontend.rule=Host(`app.localhost`)"

Cluster Kubernetes

Avec la Gateway API pour un routage moderne :

apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: api-route
spec:
  parentRefs:
    - name: traefik-gateway
  hostnames:
    - api.example.com
  rules:
    - matches:
        - path:
            type: PathPrefix
            value: /v1
      backendRefs:
        - name: api-service
          port: 80

API Gateway

Traefik peut servir d’API Gateway avec :

• Rate limiting par client
• Authentification JWT/OAuth
• Transformation des requêtes
• Métriques détaillées

Multi-cloud

Traefik peut agréger des backends de plusieurs clouds grâce à ses providers multiples (Consul, fichier HTTP, etc.).

Traefik vs autres reverse proxies

Critère	Traefik	NGINX	HAProxy	Caddy
Découverte auto	Natif (Docker, K8s, Consul…)	Non (plugins tiers)	Non	Non
Let’s Encrypt	Intégré natif	Via Certbot externe	Non intégré	Intégré natif
Dashboard	Intégré	Payant (NGINX Plus)	Stats page basique	Non intégré
Kubernetes	Gateway API + CRD + Ingress	Ingress Controller	Ingress Controller	Ingress Controller
Configuration	YAML/TOML/Labels	Fichiers .conf	Fichiers .cfg	Caddyfile
Hot-reload	Natif, temps réel	reload manuel	reload manuel	Natif
Protocoles	HTTP, TCP, UDP, gRPC	HTTP, TCP, UDP	HTTP, TCP	HTTP
Performance	Très bonne	Excellente	Excellente	Très bonne
Courbe d’apprentissage	Moyenne	Élevée	Élevée	Faible

Glissez pour voir

Choisir Traefik si :

• Vous utilisez Docker, Kubernetes ou un orchestrateur
• Vous voulez une configuration automatique
• Les certificats Let’s Encrypt automatiques sont importants
• Vous avez besoin de hot-reload fréquent

Choisir NGINX/HAProxy si :

• Performance brute maximale requise
• Configuration stable et peu changeante
• Équipe familière avec ces outils
• Fonctionnalités avancées de load balancing (HAProxy)

À retenir

1. Traefik est un reverse proxy cloud-native qui découvre automatiquement vos services via Docker, Kubernetes, Consul, etc.

2. 5 concepts clés : Entrypoints (ports), Routers (règles), Services (backends), Middlewares (transformations), Providers (sources de config)

3. Configuration d’installation (au démarrage) vs Configuration de routage (temps réel, hot-reload)

4. Let’s Encrypt intégré : Traefik gère automatiquement la génération et le renouvellement des certificats SSL

5. Traefik v3 apporte HTTP/3 QUIC, OpenTelemetry natif, WebAssembly pour les plugins et la Kubernetes Gateway API

6. Idéal pour les microservices : un conteneur déployé = une route créée automatiquement

7. Dashboard intégré pour visualiser routers, services et middlewares en temps réel

Prochaines étapes

Installer Traefik Installation binaire, Docker ou package manager

Traefik avec Docker Configuration avec labels et réseaux Docker

×

📖 Voir la documentation →