TL;DR — Résumé Rapide

Guide complet des middlewares Traefik: routage HTTP, limitation de débit, en-têtes de sécurité, authentification et circuit breakers pour la production.

Middlewares Traefik: Routage HTTP, Limitation de Débit et Sécurité

Les middlewares Traefik sont le mécanisme central pour transformer les requêtes et réponses HTTP entre l’edge et vos services upstream. Que vous ayez besoin d’appliquer des limites de débit, d’injecter des en-têtes de sécurité, de supprimer des préfixes de chemin ou de déléguer l’authentification à un service externe, chaque comportement est un objet middleware discret que vous attachez à un routeur. Ce guide couvre toutes les catégories principales de middleware avec des exemples de configuration, une comparaison avec les alternatives et un exemple Docker Compose complet pour la production.

Prérequis

  • Traefik v2.x ou v3.x en cours d’exécution comme conteneur Docker ou sur un hôte
  • Familiarité de base avec les labels Docker Compose
  • Un domaine enregistré avec DNS pointant vers votre serveur
  • Optionnel: Authelia ou OAuth2-Proxy pour les flux ForwardAuth

Architecture de Traefik: Le Pipeline de Requêtes

Traefik organise le trafic à travers quatre primitives:

  • Entrypoints — ports réseau où le trafic arrive (:80, :443)
  • Routeurs — correspondent les requêtes entrantes par hôte, chemin ou en-têtes et les dirigent vers un service
  • Middlewares — transforment la requête ou la réponse (ou la rejettent) avant d’atteindre le service
  • Services — les conteneurs ou serveurs upstream qui reçoivent la requête finale

Traefik découvre ces objets automatiquement depuis les labels Docker, les fournisseurs de fichiers ou les CRDs Kubernetes.

Fournisseurs de Configuration des Middlewares

Labels Docker

labels:
  - "traefik.http.middlewares.mes-headers.headers.stsSeconds=31536000"
  - "traefik.http.routers.monapp.middlewares=mes-headers"

Fournisseur de Fichiers (YAML dynamique)

# dynamic/middlewares.yml
http:
  middlewares:
    mes-headers:
      headers:
        stsSeconds: 31536000
        stsIncludeSubdomains: true

Middleware d’En-têtes de Sécurité

Le middleware Headers injecte ou modifie les en-têtes HTTP dans les deux directions.

http:
  middlewares:
    headers-securises:
      headers:
        customRequestHeaders:
          X-Forwarded-Proto: "https"
        customResponseHeaders:
          X-Powered-By: ""
        stsSeconds: 31536000
        stsIncludeSubdomains: true
        stsPreload: true
        forceSTSHeader: true
        frameDeny: true
        contentTypeNosniff: true
        browserXssFilter: true
        referrerPolicy: "strict-origin-when-cross-origin"
        permissionsPolicy: "camera=(), microphone=(), geolocation=()"
        contentSecurityPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline'"
        accessControlAllowOrigin: "https://exemple.com"

Définir un en-tête avec une valeur vide le supprime de la réponse.

Limitation de Débit

Le middleware RateLimit limite la fréquence à laquelle un client peut effectuer des requêtes.

http:
  middlewares:
    limite-api:
      rateLimit:
        average: 100
        burst: 50
        period: 1m
        sourceCriterion:
          requestHeaderName: "X-API-Key"
  • average — requêtes soutenues autorisées par period
  • burst — pic maximum au-dessus de la moyenne
  • period — fenêtre glissante (par défaut 1s; supporte 1m, 1h)
  • sourceCriterion — identifie le “client” par en-tête, hôte ou stratégie IP

Pour les déploiements derrière un CDN, utilisez ipStrategy.depth: 1 pour que Traefik utilise la vraie IP du client.

BasicAuth et DigestAuth

Protégez les routes avec l’authentification HTTP lorsque le SSO n’est pas disponible.

http:
  middlewares:
    auth-basique:
      basicAuth:
        users:
          - "admin:$apr1$xyz$hashedpassword"
        usersFile: "/etc/traefik/.htpasswd"
        realm: "Zone Administration"
        removeHeader: true

Générez des hashes de mot de passe avec:

htpasswd -nb admin monsecret

removeHeader: true supprime l’en-tête Authorization avant le transfert pour éviter les fuites d’identifiants.

ForwardAuth: Intégration SSO et OAuth2

ForwardAuth délègue la décision d’authentification à un service externe comme Authelia ou OAuth2-Proxy.

http:
  middlewares:
    auth-sso:
      forwardAuth:
        address: "http://authelia:9091/api/verify"
        trustForwardHeader: true
        authResponseHeaders:
          - "Remote-User"
          - "Remote-Groups"
          - "Remote-Email"

Traefik envoie chaque requête entrante à address en premier. Si ce service retourne 2xx, la requête originale continue.

Middlewares de Manipulation de Chemin

StripPrefix

Supprime un préfixe avant la transmission, utile lorsque l’upstream attend un chemin racine.

http:
  middlewares:
    strip-api:
      stripPrefix:
        prefixes:
          - "/api/v1"
        forceSlash: true

Une requête vers /api/v1/utilisateurs arrive comme /utilisateurs à l’upstream.

AddPrefix

Ajoute un préfixe. Utile lorsque plusieurs routes pointent vers le même service.

http:
  middlewares:
    ajouter-v2:
      addPrefix:
        prefix: "/v2"

ReplacePathRegex

http:
  middlewares:
    redirection-legacy:
      replacePathRegex:
        regex: "^/ancien/(.*)"
        replacement: "/nouveau/$1"

Compression

http:
  middlewares:
    comprimer:
      compress:
        excludedContentTypes:
          - "image/jpeg"
          - "image/png"
        minResponseBodyBytes: 1024

Traefik prend en charge gzip et brotli. Le brotli est utilisé lorsque le client envoie Accept-Encoding: br.

Retry et CircuitBreaker

Retry

http:
  middlewares:
    reessayer:
      retry:
        attempts: 3
        initialInterval: "100ms"

CircuitBreaker

http:
  middlewares:
    disjoncteur:
      circuitBreaker:
        expression: "ResponseCodeRatio(500, 600, 0, 600) > 0.30"
        checkPeriod: "10s"
        fallbackDuration: "30s"
        recoveryDuration: "10s"

Le circuit s’ouvre lorsque expression est vraie, bloquant le trafic pendant fallbackDuration.

IPAllowList

Restreint l’accès à une liste blanche de plages IP.

http:
  middlewares:
    interne-seulement:
      ipAllowList:
        sourceRange:
          - "10.0.0.0/8"
          - "172.16.0.0/12"
          - "192.168.0.0/16"
        ipStrategy:
          depth: 2

Middlewares de Redirection

RedirectScheme (HTTP → HTTPS)

http:
  middlewares:
    redirection-https:
      redirectScheme:
        scheme: "https"
        permanent: true

RedirectRegex (www → sans www)

http:
  middlewares:
    redirection-www:
      redirectRegex:
        regex: "^https://www\\.(.+)"
        replacement: "https://${1}"
        permanent: true

Chaînes de Middlewares

Les chaînes permettent de composer plusieurs middlewares en un seul pipeline nommé.

http:
  middlewares:
    stack-securise:
      chain:
        middlewares:
          - headers-securises
          - redirection-https
          - limite-api
          - auth-sso

Attachez la chaîne à un routeur avec un seul label:

labels:
  - "traefik.http.routers.monapp.middlewares=stack-securise"

Comparaison: Traefik vs Alternatives

FonctionnalitéTraefikNginx (modules)Envoy (filtres)Kong (plugins)Caddy (handlers)
Limitation de débitIntégréelimit_reqratelimit filterPlugin officielrate_limit
Délégation d’authForwardAuthauth_requestext_authzPlugin OIDCforward_auth
Circuit breakerIntégréNon natifIntégréRequiert pluginNon natif
Réécriture de cheminIntégréerewriterewrite filterIntégréerewrite
CompressionIntégréemodule gzipcompressorNon natifIntégrée
Config dynamiqueAuto (labels/CRD)Nécessite reloadxDS APIAdmin APIAuto (Caddyfile)

Exemple Docker Compose Complet pour la Production

Vous avez un service API en production qui nécessite HTTPS, limitation de débit, en-têtes de sécurité et BasicAuth sur le chemin d’administration.

services:
  traefik:
    image: traefik:v3.1
    restart: unless-stopped
    command:
      - --providers.docker=true
      - --providers.docker.exposedbydefault=false
      - --entrypoints.web.address=:80
      - --entrypoints.web.http.redirections.entryPoint.to=websecure
      - --entrypoints.web.http.redirections.entryPoint.scheme=https
      - --entrypoints.websecure.address=:443
      - --certificatesresolvers.le.acme.email=ops@exemple.com
      - --certificatesresolvers.le.acme.storage=/letsencrypt/acme.json
      - --certificatesresolvers.le.acme.tlschallenge=true
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./letsencrypt:/letsencrypt
    networks:
      - edge

  api:
    image: ghcr.io/exemple/api:latest
    restart: unless-stopped
    networks:
      - edge
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.api.rule=Host(`api.exemple.com`)"
      - "traefik.http.routers.api.entrypoints=websecure"
      - "traefik.http.routers.api.tls.certresolver=le"
      - "traefik.http.routers.api.middlewares=stack-securise"
      - "traefik.http.services.api.loadbalancer.server.port=8080"
      - "traefik.http.middlewares.hdrs.headers.stsSeconds=31536000"
      - "traefik.http.middlewares.hdrs.headers.frameDeny=true"
      - "traefik.http.middlewares.rl.rateLimit.average=120"
      - "traefik.http.middlewares.rl.rateLimit.burst=40"
      - "traefik.http.middlewares.rl.rateLimit.period=1m"
      - "traefik.http.middlewares.compress.compress=true"
      - "traefik.http.middlewares.stack-securise.chain.middlewares=hdrs,rl,compress"

networks:
  edge:
    external: true

Pièges et Cas Limites

  • Les signes dollar dans les hashes BasicAuth doivent être doublés ($$) dans les labels Docker car Docker Compose interpole $ comme une variable.
  • L’ordre des middlewares dans une chaîne est important. Appliquez les redirections avant l’authentification; appliquez la compression en dernier.
  • La latence de ForwardAuth ajoute un round-trip supplémentaire par requête. Utilisez le cache de décisions dans Authelia ou OAuth2-Proxy.
  • Les compteurs RateLimit sont par réplica. Avec trois réplicas Traefik le débit autorisé est multiplié par trois.
  • CircuitBreaker utilise son propre langage d’expression, pas PromQL. Consultez la documentation officielle Traefik.

Résumé

  • Les middlewares Traefik s’attachent aux routeurs et transforment les requêtes avant qu’elles n’atteignent les services upstream
  • Utilisez Headers pour HSTS, CSP et CORS; supprimez toujours les en-têtes sensibles vers l’upstream
  • RateLimit avec sourceCriterion gère le throttling des API; configurez ipStrategy.depth derrière les CDN
  • ForwardAuth intègre Authelia et OAuth2-Proxy pour le SSO sans modifier le code de l’application
  • Les chaînes Chain composent des pipelines de sécurité réutilisables attachables à n’importe quel routeur avec un seul label

Articles Connexes