Traefik : automatiser la publication des conteneurs

Dans ce tutoriel, nous allons voir comment utiliser Traefik pour automatiser la publication de conteneurs Docker.

L’objectif est de mettre en place un reverse proxy dynamique capable de détecter automatiquement les services, de les exposer via des règles de routage simples et de centraliser leur accès sans configuration manuelle à chaque déploiement.

Cette approche permet de standardiser la mise en ligne des applications conteneurisées et de faciliter leur exploitation au quotidien.

Présentation de Traefik

Traefik est un reverse proxy moderne et dynamique conçu pour s’intégrer nativement aux environnements conteneurisés. Contrairement aux reverse proxy traditionnels, Traefik détecte automatiquement les services exposés et adapte sa configuration en temps réel en fonction de l’infrastructure.

Il s’appuie sur des fournisseurs tels que Docker, Docker Swarm ou Kubernetes, et utilise des labels pour définir les règles de routage, ce qui permet d’automatiser la publication des applications sans rechargement manuel de configuration.

Cette approche simplifie la gestion des accès, améliore la maintenabilité et facilite l’exploitation des services conteneurisés.

À noter que les fonctionnalités de Traefik peuvent être étendues en fonction des besoins grâce à l’ajout de plugins, permettant par exemple d’adapter le routage, la sécurité ou les traitements appliqués aux requêtes

Les composants Traefik : comprendre les éléments clés du routage dynamique

Traefik s’appuie sur plusieurs composants clés pour gérer le routage dynamique des requêtes et l’exposition des services conteneurisés.

Chacun de ces éléments joue un rôle précis, depuis la réception des requêtes jusqu’à leur redirection vers les services finaux, tout en offrant des possibilités d’interception et de transformation via les middlewares.

Dans les sections suivantes, nous allons passer en revue les principaux composants de Traefik et leur rôle dans l’architecture d’un reverse proxy moderne.

Entrypoint

Un Entrypoint représente un point d’entrée réseau sur lequel Traefik écoute les connexions entrantes.
Il correspond généralement à un port et un protocole (HTTP, HTTPS, TCP ou UDP).

Les requêtes reçues sur un entrypoint sont ensuite évaluées par Traefik afin de déterminer la route à appliquer.
Un même Traefik peut exposer plusieurs entrypoints pour séparer les usages.

Cela permet de structurer clairement les flux réseau dès leur arrivée.

Routes

Les Routes définissent les règles de correspondance permettant d’orienter une requête entrante.

Elles s’appuient sur différents critères comme le nom de domaine, le chemin, les en-têtes ou le SNI.
Lorsqu’une requête correspond à une route, Traefik sait vers quel service la diriger.

Les routes constituent le cœur du routage dynamique.

Elles sont généralement définies via des labels ou des fichiers de configuration.

Services

Un Service représente la destination finale vers laquelle Traefik envoie le trafic.

Il s’agit le plus souvent d’un ou plusieurs conteneurs applicatifs.

Traefik peut répartir les requêtes entre plusieurs instances d’un même service.

Les services abstraient la notion de backend et facilitent l’évolution de l’infrastructure.

Ils permettent également de gérer la disponibilité et la répartition de charge.

Middleware

Les Middlewares permettent d’appliquer des traitements intermédiaires aux requêtes.

Ils peuvent modifier les en-têtes, gérer les redirections ou contrôler l’accès.

Les middlewares s’intercalent entre la route et le service.

Ils sont réutilisables et chaînables pour répondre à différents besoins.

Cette modularité renforce la flexibilité et la standardisation des configurations.

Provider

Un Provider est la source de configuration utilisée par Traefik.

Il permet à Traefik de récupérer dynamiquement les routes, services et middlewares.

Les providers les plus courants sont Docker, Docker Swarm, Kubernetes ou les fichiers statiques.

Grâce aux providers, Traefik s’adapte automatiquement aux changements d’infrastructure.

Ils sont essentiels à l’automatisation de la publication des services.

Dashboard

Le Dashboard fournit une interface web permettant de visualiser l’état de Traefik.

Il affiche les entrypoints, routes, services et middlewares configurés.

Cet outil facilite la compréhension et le diagnostic de la configuration en place.

Il est particulièrement utile lors des phases de mise en œuvre et de dépannage.

Le dashboard offre une vision globale du routage actif.

API

L’API de Traefik permet d’accéder programmatiquement à son état et à sa configuration dynamique.

Elle est utilisée notamment par le dashboard pour afficher les informations.

L’API facilite l’intégration avec des outils externes de supervision ou d’automatisation.

Elle offre une vue structurée des composants internes de Traefik.

Son utilisation doit être maîtrisée et sécurisée selon le contexte

Pourquoi utiliser Traefik pour la publication des conteneurs

Avant l’utilisation de Traefik, nos conteneurs web étaient publiés sur des ports non standard (par exemple 10000:80, 10001:80, etc.).

Cette approche nécessitait d’ouvrir de nombreux ports dans le pare-feu périmétrique pour permettre la communication entre le reverse proxy en DMZ et les hôtes Docker, ce qui compliquait la maintenance et augmentait les risques.

Avec Traefik, tous les conteneurs peuvent être exposés via un reverse proxy central sur les ports standard 80 et 443, tandis que les hôtes Docker n’exposent plus directement leurs ports applicatifs.
Cela simplifie la configuration du pare-feu, facilite la maintenance et élimine la recherche fastidieuse de ports libres pour chaque conteneur.

De plus, Traefik apporte plusieurs avantages supplémentaires pour un usage professionnel :

• Routage automatique basé sur les labels Docker : chaque service se publie automatiquement dès qu’il est lancé.
• Load balancing intégré : répartition automatique du trafic entre plusieurs instances pour plus de résilience.
• Gestion centralisée des certificats TLS/SSL : standardisation et simplification de la sécurité.
• Observabilité et diagnostic simplifiés : dashboard et API offrent une vue centralisée des routes, services et middlewares actifs.
• Extensibilité via les plugins : possibilité d’ajouter des middlewares personnalisés pour la sécurité, l’authentification ou le traitement des requêtes.
• Réduction de la complexité réseau : moins de ports exposés, règles de firewall simplifiées.
• Adapté aux environnements multi-services ou microservices : publication dynamique sans conflits de ports ni reconfiguration manuelle.

En résumé, Traefik permet d’automatiser, sécuriser et centraliser la publication des conteneurs, tout en réduisant la charge opérationnelle et les risques liés à la configuration réseau.

Sans Traefik :

Avec Traefik :

Les modes de configuration de Traefik

Traefik peut être configuré de deux manières principales : via des paramètres command dans Docker Compose ou via un fichier YAML.

Dans ce tutoriel, nous privilégions le mode command, qui permet de centraliser toute la configuration dans le fichier docker-compose.yml et de versionner facilement l’ensemble du déploiement.

Configuration via les paramètres command dans Docker Compose

La configuration via command consiste à passer toutes les options Traefik sous forme de flags directement dans le fichier docker-compose.yml.
Chaque option — entrypoints, providers, TLS, dashboard, logs ou comportements spécifiques — est définie dans la section command du service Traefik.

Les principaux avantages de cette approche sont :

• Centralisation complète : configuration et déploiement dans un seul fichier.
• Versioning simplifié : tout est versionné via Git ou un autre outil de gestion de code.
• Déploiement reproductible : la configuration est identique sur tous les environnements.
• Lisibilité immédiate : toutes les options visibles et modifiables directement.

Toute modification nécessite un redémarrage du conteneur pour être appliquée.

Configuration via un fichier YAML

La configuration YAML permet de définir les mêmes options de manière structurée dans un fichier externe.
Elle est souvent utilisée pour les configurations complexes ou pour séparer clairement la configuration du déploiement.

Le fichier YAML est chargé par Traefik au démarrage et nécessite également un redémarrage du conteneur pour appliquer les modifications.

Cette approche présente l’avantage de la lisibilité et de la maintenabilité sur de grandes infrastructures, mais ne centralise pas la configuration avec le déploiement, ce qui peut compliquer le versioning pour certaines équipes.

Déploiement de Traefik

Pour déployer Traefik dans votre environnement Docker, nous avons juste besoin de déployer un conteneur Traefik sur le serveur hôte Docker puis d’ajouter des labels aux conteneurs existant.

Sur votre serveur, commencer par créer le dossier où vous allez mettre les fichiers du conteneur pour Traefik :

sudo mkdir -p /containers/traefik

Cloner le dossier du dépôt dans le dossier créer précédemment :

cd /containers/traefik
bash <(wget -qO- https://git.rdr-it.com/root/scripts/-/raw/master/Linux/rdr-it/get-docker-compse/get.sh) Traefik

Le dépôt se trouve ici, je vous invite à vous rendre dessus pour lire le README qui explique l’ensemble de la configuration du fichier docker-compose.yml

Avant de démarrer le service Traefik, il est nécessaire de créer un réseau « Docker » qui sera utilisé pour la communication entre Traefik et les autres conteneurs.

sudo docker network create proxy

Cette commande permet de créer un réseau « Docker » qui se nomme proxy.

Maintenant, démarrer le conteneur Traefik :

sudo docker compose up -d

Pour vérifier que Traefik est démarré, aller sur son Dashboad http://host-docker:8080.

Depuis la tableau de bord, on peut voir les différents composants que l’on a évoqué au début de ce tutoriel (Router, Middleware …)

Notre reverse proxy Traefik est opérationnel.

Publier des conteneurs à travers Traefik

On va maintenant, voir comment publier des conteneurs en utilisant Traefik.

Avant de commencer, on va mettre publier un conteneur Apache2 que je vais utiliser le long de ce tutoriel.

Voici le fichier docker-compose.yml de mon conteneur Apache2 que l’on aurait sans Traefik :

services:
  apache:
    image: httpd:latest
    ports:
      - 8081:80

Celui ci est basique, je publie le port 80 interne de mon conteneur sur le 8081 de mon hôte Docker, car les ports 80 et 8080 sont déjà utilisés par Traefik.

Une fois mon conteneur Apache2 démarré, je vais sur URL suivante pour tester son fonctionnement http://docker-host:8081.

J’ai bien la page par défaut qui s’affiche.

Avant de publier le conteneur, Traefik va avoir besoin d’une URL pour router le trafic vers le bon conteneur, pour cela configurer un enregistrement DNS qui pointe vers l’hôte Docker.

Ici, je vais utiliser le nom DNS apache-1.rdr-it.demo.

Configuration 1 : publication simple d’un conteneur à travers Traefik

Arrêter le conteneur Apache2 et modifier le fichier docker-compose.yml en ajoutant les éléments ci-dessous :

services:
  apache:
    image: httpd:latest
    #ports:
    #  - 8081:80
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=proxy"
	  - "traefik.http.routers.apache1.rule=Host(`apache-1.rdr-it.demo`)"
	  - "traefik.http.routers.apache1.entrypoints=web"
      - "traefik.http.services.apache1.loadbalancer.server.port=80"

networks:
  proxy:
    external: true

Les modifications apportés :

• Lignes 4 et 5 : j’ai commenté le transfert de ports, car celui-ci n’est plus nécessaire car on va passer par Traefik
• Lignes 6 et 7 : on « connecte » le service au réseau « proxy » que l’on a créé au début
• Lignes 8 à 13 : déclaration des Labels qui va permettre la configuration automatique de Traefik
  • traefik.enable=true : Indique à Traefik que ce conteneur doit être pris en compte, sans ce label, Traefik ignore complètement le service (car exposedByDefault=false est activé).
  • traefik.docker.network=proxy : Précise à Traefik sur quel réseau Docker il doit contacter le conteneur, ici, Traefik utilisera le réseau proxy pour joindre le service.
  • traefik.http.routers.apache1.rule=Host(apache-1.rdr-it.demo) : Définit la règle de routage HTTP, si le nom de domaine demandé est apache-1.rdr-it.demo, alors Traefik route la requête vers ce service
  • traefik.http.routers.apache1.entrypoints=web : Indique sur quel point d’entrée Traefik écoute pour ce service (web = port 80)
  • traefik.http.services.apache1.loadbalancer.server.port=80 : Définit le port interne du conteneur sur lequel Traefik doit envoyer le trafic, ici : Apache écoute sur le port 80 dans le conteneur (expose 80)
• Lignes 15 à 17 : on déclare le réseau proxy en indiquant que celui-ci est externe, cela indique que le réseau ne doit pas être créé lors démarrage du stack.

Si on devait résumé en une phrase les labels : Traefik expose le conteneur Apache sur le domaine apache-1.rdr-it.demo, via le port 80, en passant par le réseau Docker proxy, sans exposer directement de port Docker.

Dans les labels : apache1 est simplement le nom logique du routeur dans Traefik

Les modifications effectuées, redémarrer le conteneur Apache, puis aller sur le Dashboard Traefik dans la partie HTTP Services et vérifier que le service apache1@docker est présent.

Dans les détails du service apache1@docker, on peut voir le router utilisé avec l’URL que l’on a indiqué et dans la partie Servers, vers quelle IP est envoyée le trafic qui correspond à l’adresse IP du conteneur Apache2 sur le réseau proxy.

Depuis un navigateur internet, aller maintenant à l’adresse que vous avez configuré http://apache-1.rdr-it.demo.

Dans les logs du conteneur Traefik (docker compose logs -f), on peut voir les requêtes HTTP qui sont envoyé vers le conteneur Apache2.

Vous savez comment publier un service « simple » avec Traefik.

Configuration 2 : le Load-Balancing (Répartition de charge)

Maintenant, je vais vous montrer comment faire du Load-Balancing avec Traefik, en gardant la même configuration de notre conteneur Apache, je vais seulement démarrer 3 conteneurs du même service à l’aide de la commande suivante :

sudo docker compose up -d --scale apache=3

Comme on peut le voir j’ai maintenant 3 conteneur Apache qui sont démarrés.

Depuis le tableau de bord Traefik, dans les détails du service, on peut voir qu’il y a maintenant 3 Servers :

Par défaut, Traefik fait du Round Robin entre les différents Servers, si votre application utilise des sessions et qu’un même visiteur soit toujours dirigé vers le même server, on peut configurer des sessions persistantes (Sticky Sessions) à l’aide d’un cookie, pour cela, il faut ajouter les labels suivants :

labels:
  - "traefik.enable=true"
  - "traefik.docker.network=proxy"
  - "traefik.http.routers.apache1.rule=Host(`apache-1.rdr-it.demo`)"
  - "traefik.http.routers.apache1.entrypoints=web"
  - "traefik.http.services.apache1.loadbalancer.server.port=80"
  - "traefik.http.services.apache1.loadbalancer.sticky.cookie=true"
  - "traefik.http.services.apache1.loadbalancer.sticky.cookie.name=mon_cookie_perso"

Pour configurer un Healcheck, il faut également configuer les labels suivants :

labels:
  - "traefik.enable=true"
  - "traefik.docker.network=proxy"
  - "traefik.http.routers.apache1.rule=Host(`apache-1.rdr-it.demo`)"
  - "traefik.http.routers.apache1.entrypoints=web"
  - "traefik.http.services.apache1.loadbalancer.server.port=80"
  - "traefik.http.services.apache1.loadbalancer.sticky.cookie=true"
  - "traefik.http.services.apache1.loadbalancer.sticky.cookie.name=mon_cookie_perso"
  - "traefik.http.services.apache1.loadbalancer.healthcheck.path=/health"
  - "traefik.http.services.apache1.loadbalancer.healthcheck.interval=10s"

Le /health doit existé sur le conteneur avec une page index.html qui va répondre.

La configuration de Load-Balancing est très simple avec Traefik et facile à mettre en place notamment dans l’utilisation d’un Swarm Docker.

Vous savez comment configurer le load-balancing avec Traefik.

Configuration 3 : plusieurs services avec Traefik

L’avantage d’utiliser des applications en conteneur, c’est de pouvoir faire tourner plusieurs applications sur un même serveur hôte Docker.

Pour continuer ce tutoriel, je vais démarrer un autre stack Apache2, qui sera routé en utilisant l’URL apache-2.rdr-it.demo dont voici le fichier docker-compose.yml

services:
  apache:
    image: httpd:latest
    #ports:
    #  - 8081:80
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=proxy"
      - "traefik.http.routers.apache2.rule=Host(`apache-2.rdr-it.demo`)"
      - "traefik.http.routers.apache2.entrypoints=web"
      - "traefik.http.services.apache2.loadbalancer.server.port=80"

networks:
  proxy:
    external: true

Comme vous pouvez le voir, les labels sont quasiment identique, j’ai juste changé le nom du service apache1 en apache2.

Il est impératif que les noms de service soit différents entre chaque stack docker compose.

Le nouveau service Apache2 démarré, celui-ci est bien configuré dans Traefik.

Configuration 4 : publier un service en HTTPS

Pour continuer, on va voir comment publier un service en HTTPS, pour commencer, on va publier le conteneur Apache2 en HTTP et HTTPS.

Voici la configuration dans le fichier docker-compose.yml :

services:
  apache:
    image: httpd:latest
    #ports:
    #  - 8081:80
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=proxy"
      - "traefik.http.services.apache1-svc.loadbalancer.server.port=80"
      # HTTP
      - "traefik.http.routers.apache1-http.rule=Host(`apache-1.rdr-it.demo`)"
      - "traefik.http.routers.apache1-http.entrypoints=web"
      - "traefik.http.routers.apache1-http.service=apache1-svc"
      # HTTPS
      - "traefik.http.routers.apache1-https.rule=Host(`apache-1.rdr-it.demo`)"
      - "traefik.http.routers.apache1-https.entrypoints=websecure"
      - "traefik.http.routers.apache1-https.tls=true"
      - "traefik.http.routers.apache1-https.service=apache1-svc"

networks:
  proxy:
    external: true

Explications des modifications :

• Pour commencer, nous avons deux routers apache1-http et apache1-https, un pour chaque protocole.
• Ligne 11 – traefik.http.services.apache1-svc.loadbalancer.server.port=80 : Déclare un service Traefik nommé apache1-svc, indique à Traefik que le conteneur écoute en interne sur le port 80
• Ligne 15 – traefik.http.routers.apache1-http.service=apache1-svc : Associe le routeur HTTP apache1-http au service Traefik apache1-svc, quand la règle HTTP est matchée, envoie le trafic vers ce service
• Ligne 17 – traefik.http.routers.apache1-https.rule=Host(apache-1.rdr-it.demo) : Définit la règle de routage HTTPS, le trafic est routé si le nom de domaine correspond
• Ligne 18 – traefik.http.routers.apache1-https.entrypoints=websecure : Indique que ce routeur écoute sur l’entrypoint HTTPS
• Ligne 19 – traefik.http.routers.apache1-https.tls=true : Active le TLS (HTTPS) pour ce routeur (Les certificats définis dans tls.yaml)
• Ligne 20 – traefik.http.routers.apache1-https.service=apache1-svc : Associe le routeur HTTPS au même service Traefik apache1-svc

HTTP et HTTPS pointent vers le même backend Apache

Schéma logique simplifié

Redémarrer le conteneur pour la prise en compte de la configuration.

Maintenant, sur le Dashboard, on peut voir les deux routers (HTTP et HTTPS), l’utilisation de HTTPS ajoute un bouclier vert pour indiquer que le TLS est actif.

En allant sur URL en HTTPS, on arrive sur un erreur de certificat, car à ce stade, Traefik va utiliser un certificat auto-généré car nous n’avons pas configurer de certificat, cela permet de valider l’utilisation de HTTPS.

Pour forcer, la redirection HTTP -> HTTPS, on va devoir ajouter un Middelware qui va faire cette redirection, voici le fichier docker-compose.yml du service Apache2.

services:
  apache:
    image: httpd:latest
    #ports:
    #  - 8081:80
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=proxy"
      - "traefik.http.services.apache1-svc.loadbalancer.server.port=80"
      # Middleware http -> https
      - "traefik.http.middlewares.apache-redirect.redirectscheme.scheme=https"
      # HTTP
      - "traefik.http.routers.apache1-http.rule=Host(`apache-1.rdr-it.demo`)"
      - "traefik.http.routers.apache1-http.entrypoints=web"
      - "traefik.http.routers.apache1-http.middlewares=apache-redirect"
      # HTTPS
      - "traefik.http.routers.apache1-https.rule=Host(`apache-1.rdr-it.demo`)"
      - "traefik.http.routers.apache1-https.entrypoints=websecure"
      - "traefik.http.routers.apache1-https.tls=true"
      - "traefik.http.routers.apache1-https.service=apache1-svc"

networks:
  proxy:
    external: true

Explications :

• Ligne 13 – traefik.http.middlewares.apache-redirect.redirectscheme.scheme=https : déclaration du middleware qui va appliquer la redirection vers le protocole HTTPS.
• Ligne 17 – traefik.http.routers.apache1-http.middlewares=apache-redirect : on application le middleware au router apache1-http.

Redémarrer le conteneur apache pour la prise en compte de la configuration.

Depuis le Dashboard, on peut voir le middleware que l’on a déclaré et qu’il est utilisé par le router qui publie le service en HTTP.

Si vous accéder à l’URL avec le protocole HTTP, on peut voir qu’une redirection 302 est appliqué par Traefik.

Utiliser ses certificats, il faut ajouter les dans dossier certs/ le fichier du certificat et le fichier de clé privée puis le déclarer dans le fichier dynamic/tls.yaml. La sélection du certificat se fait automatiquement par Traefik en fonction du SNI.

L’utilisation de Let’s Encrypt sera abordé dans un autre tutoriel dédié, pour rappel, ici le but d’exposé Traefik derrière un autre reverse proxy (Nginx) qui lui porte déjà les certificats et Let’s Encrypt. En interne, on va utiliser des certificats émit par une autorité interne.

Configuration 5 : transfert des Headers émanant d’un reverse proxy en amont

Comme déjà évoquer au début de ce tutoriel, on traite l’utilisation de Traefik en environnement « professionnel », ce implique souvent « normalement », l’utilisation d’un reverse proxy frontal de type Nginx, F5, Kemp …

Souvent les reverse proxy en amont ajoute des Headers pour indiquer l’adresse IP réel du visiteur, le protocole (http / https) ou encore un header qui indique qu’il est passé par reverse proxy amont, il est généralement nécessaire de passer toutes ces informations à l’application, pour cela, il faut transférer ces headers, ce qui implique l’ajout de labels supplémentaires.

Pour permettre ce transfert, Traefik est démarré avec la commande suivante :

services:
  traefik:
    ...
    command:
      ...
      - "--entryPoints.websecure.forwardedHeaders.insecure=true"
      ...

--entryPoints.websecure.forwardedHeaders.insecure=true : Autorise Traefik à faire confiance aux en-têtes HTTP X-Forwarded-* reçus sur l’entrypoint websecure (HTTPS / 443), sans vérifier l’origine du client.

Traefik acceptera les headers suivants tels quels :

• X-Forwarded-For → IP réelle du client
• X-Forwarded-Proto → http / https
• X-Forwarded-Host
• X-Real-IP

Ces headers sont souvent ajoutés par :

• un firewall
• un load balancer
• un reverse proxy en amont (HAProxy, F5, Cloudflare, etc.)

Par défaut, les Headers sont suivant automatiquement transmis :

• X-Forwarded-For
• X-Forwarded-Proto
• X-Forwarded-Host
• X-Real-IP

Dans certain cas, il peut être nécessaire de transférer d’autres Headers venant de Nginx ou de les modifier, pour cela on va configurer un middleware.

Voici un exemple de docker-compose.yml avec les labels :

services:
  apache:
    image: httpd:latest
    #ports:
    #  - 8081:80
    networks:
      - proxy
    labels:
      - "traefik.enable=true"
      - "traefik.docker.network=proxy"
      - "traefik.http.services.apache1-svc.loadbalancer.server.port=80"
      # Middleware http -> https
      - "traefik.http.middlewares.apache-redirect.redirectscheme.scheme=https"
      # HTTP
      - "traefik.http.routers.apache1-http.rule=Host(`apache-1.rdr-it.demo`)"
      - "traefik.http.routers.apache1-http.entrypoints=web"
      - "traefik.http.routers.apache1-http.middlewares=apache-redirect"
      # HTTPS
      - "traefik.http.routers.apache1-https.rule=Host(`apache-1.rdr-it.demo`)"
      - "traefik.http.routers.apache1-https.entrypoints=websecure"
      - "traefik.http.routers.apache1-https.tls=true"
      - "traefik.http.routers.apache1-https.service=apache1-svc"
	  # HEADERS
	  - "traefik.http.routers.apache1-https.middlewares=apache1-headers"
      - "traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Forwarded-Proto=https"
      - "traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Forwarded-For=true"
      - "traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Real-Ip=true"
      - "traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Forwarded-Port=443"
      - "traefik.http.middlewares.apache1-headers.headers.customRequestHeaders.X-Forwarded-Proto=https"
      - "traefik.http.middlewares.apache1-headers.headers.customRequestHeaders.X-Forwarded-Port=443"

networks:
  proxy:
    external: true

Explications sslProxyHeaders :

Les directives sslProxyHeaders permettent à Traefik de traiter certains headers comme des indicateurs fiables d’un contexte HTTPS, lorsqu’un proxy SSL est présent dans la chaîne.

• « traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Forwarded-Proto=https » : Indique que si le header X-Forwarded-Proto est présent avec la valeur https, Traefik doit considérer la requête comme sécurisée (HTTPS).
• « traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Forwarded-For=true » : Autorise Traefik à prendre en compte le header X-Forwarded-For comme source de l’IP client.
• "traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Real-Ip=true" : Autorise l’utilisation du header X-Real-IP comme IP client.
• "traefik.http.middlewares.apache1-headers.headers.sslProxyHeaders.X-Forwarded-Port=443" : Définit le port d’entrée d’origine de la requête côté client.

Explication customRequestHeaders :

Les directives customRequestHeaders permettent de forcer ou écraser des headers HTTP dans la requête envoyée au backend.

• "traefik.http.middlewares.apache1-headers.headers.customRequestHeaders.X-Forwarded-Proto=https" : Force la valeur du header X-Forwarded-Proto à https dans la requête transmise à Apache. (Garantir que l’application détecte toujours HTTPS)
• "traefik.http.middlewares.apache1-headers.headers.customRequestHeaders.X-Forwarded-Port=443" : Force le port public exposé vu par l’application backend. (Typiquement utilisé lorsque le backend écoute sur 80 mais est exposé publiquement en 443)

Vue d’ensemble du flux :

Client
  ↓ HTTPS (443)
Proxy / Traefik
  ↓
Headers interprétés / injectés :
- X-Forwarded-For
- X-Real-IP
- X-Forwarded-Proto=https
- X-Forwarded-Port=443
  ↓
Apache (backend)

A la place de la command "--entryPoints.websecure.forwardedHeaders.insecure=true" il est possible de configurer Traefik avec une liste de proxy amant de confiance "--entryPoints.websecure.forwardedHeaders.trustedIPs=10.0.0.0/8,192.168.0.0/16" ou "--entryPoints.websecure.forwardedHeaders.trustedIPs=IP_DU_PROXY/32".

Conclusion

Dans ce tutoriel, nous avons vu comment utiliser Traefik pour automatiser la publication des conteneurs Docker, simplifier la gestion des ports et centraliser la configuration grâce au mode command dans Docker Compose.
Nous avons présenté les différents composants de Traefik — entrypoints, routes, services, middlewares, providers, dashboard et API — ainsi que les avantages concrets pour un environnement professionnel : routage dynamique, simplification du firewall, load balancing et observabilité.

Traefik offre également de nombreuses fonctionnalités avancées que vous pouvez explorer ensuite, comme :

• La génération automatique de certificats TLS/SSL avec Let’s Encrypt, pour sécuriser vos services sans configuration manuelle.
• La publication de conteneurs de test via des services simples comme whoami, utile pour valider le routage et le comportement des middlewares.
• L’ajout de plugins pour étendre les fonctionnalités, contrôler l’authentification, transformer les requêtes ou intégrer des outils spécifiques.

Grâce à ces fonctionnalités, Traefik permet non seulement de simplifier et sécuriser la publication des services, mais aussi d’industrialiser et automatiser le déploiement des conteneurs dans un contexte professionnel.

FAQ – Traefik et publication des conteneurs