Performance et scalabilité Traefik

Timeouts d'EntryPoint, pool de connexions, ordre des middlewares, ACME et cardinalité des métriques : les réglages qui font tenir Traefik sous charge, avec les pièges qui coûtent vraiment.

Performance et scalabilité Traefik

Un Traefik qui encaisse 200 requêtes par seconde et un Traefik qui en encaisse 8 000 tournent souvent sur le même matériel. La différence tient à une quinzaine de lignes de configuration, et presque jamais au nombre de cœurs du serveur. Je le vois sur mes deux VPS : à configuration par défaut, le reverse proxy craque avant les applications qu'il protège.

Voici les réglages qui font réellement la différence, dans l'ordre où ils coûtent cher : le transport, les middlewares, les certificats, la découverte de services, puis la mise à l'échelle.

Le coût réel d'une requête dans Traefik

Traefik est écrit en Go et traite chaque connexion dans une goroutine. Le surcoût du proxy lui-même reste de l'ordre de quelques millisecondes par requête. Ce qui explose, c'est ce que tu accroches autour : une chaîne de middlewares, un appel d'authentification distant, un handshake TLS non repris, ou un provider qui interroge l'API Kubernetes toutes les cinq secondes.

Exemple concret : une route publique avec cinq middlewares (headers, compress, rateLimit, forwardAuth, buffering). Chaque requête traverse cinq handlers, dont un qui sort du processus pour appeler un service d'auth. Sur une page qui charge trente assets, ça fait trente allers-retours d'authentification pour un seul visiteur.

Mon avis tranché : forwardAuth sur des assets statiques est la première cause de latence que je rencontre chez les gens qui se plaignent de Traefik. L'authentification appartient à l'application ou à un cookie signé vérifié localement, pas à un saut réseau par requête.

EntryPoints : verrouiller les timeouts avant tout

Les EntryPoints sont les seuls points d'écoute du proxy. Les valeurs par défaut sont volontairement permissives : sans readTimeout, un client lent garde une connexion ouverte indéfiniment et consomme une goroutine plus de la mémoire du buffer.

entryPoints:
  web:
    address: ":80"
    http:
      redirections:
        entryPoint:
          to: websecure
          scheme: https
          permanent: true

  websecure:
    address: ":443"
    http2:
      maxConcurrentStreams: 250
    transport:
      respondingTimeouts:
        readTimeout: 15s
        writeTimeout: 30s
        idleTimeout: 90s

Ces trois timeouts couvrent trois fuites différentes. readTimeout borne le temps de lecture de la requête cliente, writeTimeout borne l'écriture de la réponse, idleTimeout ferme les connexions keep-alive inactives.

RéglageValeur de départCe qu'il protège
readTimeout15sClients lents, slowloris
writeTimeout30sBackends qui streament sans fin
idleTimeout90sConnexions keep-alive mortes
maxConcurrentStreams250Un seul client qui monopolise HTTP/2

Le HTTP/3 reste expérimental en v3 : active-le sur un EntryPoint dédié avec un port UDP, jamais sur le port principal en production. La documentation des EntryPoints détaille chaque option (doc Traefik).

ServersTransport : le réglage que personne ne touche

Le transport est la couche qui parle à tes backends. Par défaut, Traefik ouvre une connexion par requête quand la charge monte, parce que la limite de connexions inactives par hôte est basse. Sur une API qui répond en 3 ms, le dial TCP devient le premier poste de latence.

serversTransport:
  maxIdleConnsPerHost: 200
  forwardingTimeouts:
    dialTimeout: 3s
    responseHeaderTimeout: 15s
    idleConnTimeout: 90s

maxIdleConnsPerHost: 200 garde un pool chaud vers chaque backend. Sans ça, tu paies un handshake TCP à chaque pic. Et un dialTimeout à 3 s évite qu'un conteneur mort bloque une requête pendant trente secondes.

Cas vécu : un service Docker redéployé qui garde son ancienne IP pendant quelques secondes. Avec un responseHeaderTimeout à 15 s, la requête échoue proprement et le retry prend le relais. Sans timeout, elle pend jusqu'à ce que le client abandonne.

Middlewares : l'ordre change la facture

Un middleware placé en tête s'exécute avant tous les autres, à l'entrée. Un middleware placé en queue s'exécute juste avant le backend. Le bon ordre suit une règle simple : rejeter le plus tôt possible, transformer le plus tard possible.

http:
  middlewares:
    chain-public:
      chain:
        middlewares:
          - rate-limit
          - in-flight
          - compress
          - security-headers
MiddlewareCoûtPlacement
rateLimitFaible, en mémoireEn tête : rejette avant tout travail
inFlightReqFaibleEn tête : protège le backend de la surcharge
forwardAuthÉlevé (saut réseau)Uniquement sur les routes qui en ont besoin
compressCPU proportionnel au débitEn queue : compresse la réponse finale
bufferingMémoire (mégaoctets par requête)En queue, avec maxRequestBodyBytes borné

Deux pièges classiques. buffering sans maxRequestBodyBytes laisse un upload de 2 Go remplir la RAM du proxy. Et compress combiné à retry recompresse la réponse à chaque tentative, ce qui triple le coût CPU sur un backend instable.

Le rateLimit de Traefik est local à l'instance. Derrière deux replicas, ta limite réelle est doublée : si tu veux 100 requêtes par seconde au total, configure 50 par instance, ou déplace la limitation dans un middleware distribué.

ACME : arrêter de faire sauter le rate limit

Let's Encrypt plafonne à 50 certificats par domaine enregistré et par semaine, et à 5 certificats identiques. Une configuration ACME mal cadrée atteint ces plafonds en quelques minutes, puis tu attends une semaine.

La cause la plus fréquente : plusieurs instances Traefik qui partagent le même acme.json sans verrou, ou un exposedByDefault: true qui déclenche une demande de certificat par conteneur. Chaque nouvelle règle Host devient une commande ACME.

certificatesResolvers:
  le:
    acme:
      email: admin@example.com
      storage: /acme/acme.json
      caServer: https://acme-v02.api.letsencrypt.org/directory
      dnsChallenge:
        provider: ovh
        delayBeforeCheck: 30
      # en test, toujours passer par le staging :
      # caServer: https://acme-staging-v02.api.letsencrypt.org/directory

Le dnsChallenge évite d'exposer le port 80 et permet les wildcards, comme expliqué dans la documentation ACME. Le delayBeforeCheck: 30 laisse à la zone DNS le temps de se propager chez tous les résolveurs, sinon la validation échoue et Traefik retente en boucle.

Une seule instance doit posséder l'acme.json en écriture. Les autres la lisent. Si tu fais tourner trois replicas avec un volume partagé en écriture, tu prends le risque de corrompre le fichier — et un acme.json corrompu, c'est un redémarrage avec tous les certificats à refaire. J'ai détaillé la mécanique côté serveur classique dans le guide Nginx équivalent.

Providers : écouter les événements plutôt que sonder

Le provider Docker de Traefik s'abonne aux événements du démon, il ne sonde pas l'API. Le provider Kubernetes utilise des informers. Dans les deux cas, le coût vient du nombre d'objets surveillés, pas de la fréquence.

Deux garde-fous suffisent à diviser la charge de découverte. D'abord exposedByDefault: false : seuls les conteneurs explicitement étiquetés sont exposés. Ensuite une contrainte de label, qui filtre au niveau du provider au lieu de créer puis ignorer des routeurs.

providers:
  docker:
    exposedByDefault: false
    watch: true
    constraints: "Label(`traefik.constraint`, `edge`)"
    defaultRule: "Host(`{{ index .Labels \"com.docker.compose.service\" }}.example.com`)"

Sur une machine à 300 conteneurs, exposedByDefault: true génère 300 routeurs et 300 demandes de certificat. Avec le filtre par contrainte, seuls les services de l'edge sont pris en compte et le reste du bruit disparaît.

Le provider fichier, lui, recharge la configuration à chaque écriture. Si un script réécrit le fichier toutes les dix secondes, tu paies un parse complet à chaque fois : écris de façon atomique (fichier temporaire puis mv), et seulement quand le contenu change. Même logique pour les volumes qui portent la configuration, comme dans la mise en place des volumes persistants.

Passer à plusieurs instances sans casser les sessions

Une seule instance Traefik finit par être un point de défaillance unique et un plafond de CPU. La sortie classique : deux ou trois replicas derrière un load balancer de niveau 4, avec une découverte de services partagée.

ApprocheQuand l'utiliserLimite
2 replicas + LB L4La plupart des infras DockerCertificats à centraliser
KV store (Consul, etcd)Configuration partagée dynamiqueUne dépendance de plus à maintenir
Kubernetes Ingress / CRDCluster K8s déjà en placeComplexité des CRD
http:
  services:
    app:
      loadBalancer:
        sticky:
          cookie:
            name: lb
            httpOnly: true
            secure: true
        healthCheck:
          path: /healthz
          interval: 10s
          timeout: 3s

Le sticky cookie n'est nécessaire que si ton application garde un état en mémoire. Si elle est stateless, laisse le round-robin pondéré et gagne en répartition. Le health check, lui, n'est pas optionnel : sans lui, Traefik continue d'envoyer du trafic à un conteneur qui répond 500.

Dernier point souvent oublié : les sessions et le stockage des certificats doivent vivre en dehors du conteneur. Un replica qui redémarre sans son acme.json redemande tous ses certificats, et tu retombes sur le rate limit.

Mesurer : les cinq métriques qui comptent

Optimiser sans mesure revient à deviner. Active Prometheus sur un EntryPoint interne, jamais sur le port public.

metrics:
  prometheus:
    entryPoint: metrics
    addEntryPointsLabels: true
    addServicesLabels: true
    addRoutersLabels: false

addRoutersLabels: false n'est pas un détail : avec 300 routeurs, chaque métrique est dupliquée 300 fois et la cardinalité fait exploser la mémoire de Prometheus comme celle de Traefik.

Les cinq séries à surveiller : traefik_entrypoint_requests_total pour le débit, traefik_entrypoint_request_duration_seconds pour la latence côté client, traefik_service_request_duration_seconds pour la latence côté backend, traefik_service_server_up pour la santé des backends, et traefik_entrypoint_open_connections pour détecter les fuites de connexions.

La comparaison entre les deux durées est l'information la plus utile : si la latence EntryPoint dépasse la latence Service de 200 ms, le problème est dans Traefik (middlewares, TLS, saturation CPU). Si les deux se suivent, le problème est dans ton application. La doc observabilité liste l'ensemble des séries disponibles, et j'ai détaillé le côté rétention dans maintenir Prometheus sur le long terme.

FAQ : les questions qui reviennent

Traefik est-il plus lent que Nginx ? Sur un proxy statique pur, Nginx garde un avantage de quelques dixièmes de milliseconde. Dès que la configuration change souvent (conteneurs qui apparaissent, certificats automatiques), Traefik rattrape largement ce qu'il perd en overhead brut.

Combien de requêtes par seconde par instance ? Ça dépend entièrement des middlewares. Une instance à 2 vCPU sans middleware tient plusieurs milliers de requêtes statiques par seconde ; avec forwardAuth et compression, table plutôt sur quelques centaines. Mesure avant de dimensionner.

HTTP/2 ou HTTP/3 ? HTTP/2 sur le port 443, sans hésiter. HTTP/3 en test seulement : le support reste expérimental et le débogage UDP coûte cher en production.

Faut-il activer l'access log ? Oui, mais filtré. Garde les erreurs et les 5xx, et échantillonne le reste. Un access log complet sur 5 000 requêtes par seconde représente plusieurs gigaoctets par jour et du CPU de sérialisation.

Les trois réglages à appliquer aujourd'hui

Si tu ne retiens que trois choses : borne les timeouts de chaque EntryPoint, mets exposedByDefault: false et un filtre de contrainte sur tes providers, et sépare la mesure EntryPoint de la mesure Service pour savoir où se trouve ta latence.

Le reste — compression, buffering, tracing — s'ajoute une fois que tu as des chiffres. Un proxy bien réglé n'est pas celui qui a le plus d'options activées, c'est celui dont chaque option est justifiée par une courbe.