Contenu

Installation et configuration de Traefik 2.4

Description

Traefik est un reverse proxy Open Source écrit en Go. Il a été spécialement développé pour fonctionner avec Docker. Voila les principales fonctionnalités :

  • Génération et renouvellement des certificats Let’s Encrypt
  • Support des plugins écrit en Go
  • Interface web

Pré-requis

Avant de continuer, assurez-vous d’avoir installé Docker et Docker-compose. Pour cela vous pouvez suivre les docs suivantes :

Création de la configuration Traefik

Traefik étant écrit en Go, vous pouvez télécharger le binaire mais la façon la plus commune est d’utiliser une image Docker.
Nous allons donc commencer par créer l’arborescence que nous allons utiliser

1
# mkdir -p /srv/docker/traefik/{certs,conf,dynamics,logs}
  • /srv/docker/traefik/certs/ contiendra les certificats Let’s Encrypt pour les sites web
  • /srv/docker/traefik/conf/ contiendra la configuration statique de Traefik
  • /srv/docker/traefik/dynamics/ contiendra la configuration dynamique de Traefik
  • /srv/docker/traefik/logs/ contiendra les logs de Traefik

La modification des fichiers de configuration statique nécessiteront un redémarrage du container pour être pris en compte.
La modification des fichiers de configuration dynamique sont lus à chaque requêtes HTTP.
L’ensemble des fichiers de configuration de cette doc seront au format YML.
Nous allons créer le fichier de configuration statique de Traefik. Pour cela on tape la commande suivante :

1
# vi /srv/docker/traefik/conf/traefik.yml

On y copie le contenu suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
global:
  # On spécifie que l'on ne veut pas envoyer/partager les données d'usage avec TraefikLabs (Société derrière Traefk
  sendAnonymousUsage: false

entryPoints:
  # On configure un point d'entré nommé arbitrairement "web"
  web:
    # On spécifie le port d'entré. Ici le port 80 (http)
    address: ':80'
    # On redirige l'ensemble du trafic arrivant sur le port 80 http) sur le point d'entré nommé "web_secure", qui est le port 443 (https)
    http:
      redirections:
        entryPoint:
          to: web_secure
  # On configure un point d'entré nommé arbitrairement "web_secure"
  web_secure:
    # On spécifie le port d'entré. Ici le port 443 (https)
    address: ':443'
    # Via le middlewares "SecHeader@file", on applique des 
    http:
      middlewares:
        - SecHeader@file

api:
  # On active le dashboard (Interface web)
  dashboard: True
  # On désactive l'accès à l'API de Traefik
  insecure: False

log:
  # On spécifie le répertoire de stockage des logs de Traefik
  filePath: /srv/docker/traefik/logs/traefik.log
  # On spécifie le format de stockage des logs
  format: common
  # On précise le niveau des logs
  level: INFO

accessLog:
  # On spécifie le répertoire de stockage des logs d'accès au container
  filePath: /var/log/traefik/traefik_access.log

providers:
 # On indique que l'on va utiliser Docker
  docker:
    # On désactive l'accès au container Docker autrement que via Traefik
    exposedByDefault: False
  file:
    # On spécifie le répertoire de stockage du fichier de configuration de Traefik
    directory: /etc/traefik/config/

certificatesResolvers:
  # On spécifie que l'on veut utiliser Certbot (Let's Encrypt pour la génération/gestion des certificats)
  certbot:
    acme:
      # On spécifie l'email à utiliser pour nous prévenir en cas d'expiration du/des certificats SSL
      email: mon_adresse_mail@mon-domaine.fr
      # On spécifie le format de clé privé à générer/utiliser avec notre certificat
      keyType: 'RSA4096'
      # On spécifie le répertoire de stockage du certificat
      storage: /letsencrypt/acme.json
      # On précise le point d'entré à utiliser pour la génération/renouvellement des certificats
      httpChallenge:
        entryPoint: web

Nous allons créer le fichier de configuration TLS de Traefik. Pour cela on tape la commande suivante :

1
# vi /srv/docker/traefik/dynamic/tls.yml

On y copie le contenu suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
tls:
  options:
    default:
      # On spécifie la version minimum de TLS qui sera prise en charge par Traefik
      minVersion: VersionTLS12
      # On refuse la connexion aux sites Web qui n'ont pas de certificat TLS valide
      sniStrict: True
      # On spécifie les suites de Cipher qui seront pris en charge par Traefik
      cipherSuites:
        - TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
        - TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
        - TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305
        - TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305

Nous allons créer le fichier de configuration middlewares de Traefik. Pour cela on tape la commande suivante :

1
# vi /srv/docker/traefik/dynamic/middleswares.yml

On y copie le contenu suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
http:
  middlewares:
    SecHeader:
      # On défini les différences headers
      headers:
        # On défini X-Frame-Options à deny
        frameDeny: True
        # On défine X-Content-Type-Options à nosniff
        contentTypeNosniff: True
        referrerPolicy: same-origin
        # On définie X-XSS-Protection à "1; mode=block"
        browserXssFilter: True

        # On ajoute les STSHeader même lorsque la connexion se fait en HTTP
        forceSTSHeader: True
        # On ajoute la directive "includeSubDomains" au header "Strict-Transport-Security"
        stsIncludeSubdomains: True
        # On défini la durée de vie du header "Strict-Transport-Security"
        stsSeconds: 31536000

Afin que Traefik puisse ajouter les logs, nous devons créer les fichiers de logs vide. Pour cela, on tape la commande suivante :

1
# touch /srv/docker/traefik/logs/{traefik.log,traefik_access.log}

Création du Docker-compose

Docker-compose est un outils indispensable pour simplifier la gestion des conteneurs Docker. Il est disponible sur le dépôt Github du même nom Docker-compose. Nous allons récupérer la dernière version à la date d’écriture de l’article et l’installer dans le r epertoire /usr/local/bin/ via la commande suivante :

1
# curl -L "https://github.com/docker/compose/releases/download/1.28.6/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

Nous avons récupéré le binaire de Docker-compose, pour autant nous ne pouvons pas l’utiliser. Nous devons le rendre exécutable. Pour cela, on tape la commande suivante :

1
# chmod +x /usr/local/bin/docker-compose

Et voilà, vous êtes prêt à utiliser des conteneurs 😉

Installation de Traefik

Docker met à disposition un site regroupant un très grand nombre d’images Docker, le Docker Hub. Il n’est pas nécessaire de créer pour récupérer des images. Il l’est uniquement si l’on souhaite mettre à disposition des images.
Nous allons utiliser l’image officielle mise à disposition pour la société éditrice “Containous”.
Nous n’allons pas récupérer manuellement l’image Traefik. Nous la récupérons automatiquement lorsque nous lancerons la commande “docker-compose”. En effet c’est elle qui s’en chargera automatiquement.

Nous allons créer le fichier docker-compose.yml via la commande suivante :

1
# vi /srv/docker/docker-compose.yml

On y copie le contenu suivant :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
---
# Version du format du fichier docker-compose.yml
version: '3.7'
services:
  # On défini le nom du service
  traefik:
    # On défini le nom du container
    container_name: traefik
    # On défini l'image à utiliser
    image: traefik:latest
    # On défini la politique de redémarrage du container
    restart: unless-stopped
    # On défini les dossiers et fichiers qui seront accessibles depuis le container
    volumes:
      # Trafik peut se connecter au socket Docker
      - /var/run/docker.sock:/var/run/docker.sock
      # On défini que le répertoire /letsencrypt/ du container correspond au répertoire /srv/docker/traefik/certs/ de notre hôte
      - ./certs/:/letsencrypt/
      # On défini que le fichier /etc/traefik/traefik.yml du container correspond au répertoire /srv/docker/traefik/conf/traefik.yml de notre hôte. Le container n'y aura accès qu'en lecture
      - ./conf/traefik.yml:/etc/traefik/traefik.yml:ro
      # On défini que le répertoire /etc/traefik/config/ du container correspond au répertoire /srv/docker/traefik/dynamic/ de notre hôte. Le container n'y aura accès qu'en lecture
      - ./dynamic/:/etc/traefik/config/:ro
      # On défini que le fichier /var/log/traefik/traefik.log du container correspond au répertoire /srv/docker/traefik/logs/traefik.log de notre hôte
      - ./logs/traefik.log:/var/log/traefik/traefik.log
      # On défini que le fichier /var/log/traefik/traefik_access.log du container correspond au répertoire /srv/docker/traefik/logs/traefik_access.log de notre hôte
      - ./logs/traefik_access.log:/var/log/traefik/traefik_access.log
    # On défini les réseaux. J'en ai volontairement créé deux. Afin de pouvoir isoler les futurs containers dans un réseau à part
    networks:
      traefik_lan:
      wan:
    # On défini les ports réseaux qui seront accessibles depuis l'hôte
    ports:
      - '80:80'
      - '443:443'
      - '9090:8080'
    # On défini les paramètres spécifiques à Traefik
    labels:
      # On active Traefik pour ce container
      traefik.enable: True
      # On indique à Traefik que les ports accessibles depuis l'hôte, le seront sur le réseau "wan"
      traefik.docker.network: wan
      # On indique à Traefik de lire la configuration SSL/TLS contenu dans le fichier SecHeader@file précédemment créé
      traefik.http.routers.traefik.middlewares: SecHeader@file
      # On indique l'URL à partir de laquelle l'interface web de Traefik sera accessible
      traefik.http.routers.traefik.rule: Host(`traefik.mon-domaine.fr`)
      # 
      traefik.http.routers.traefik.service: api@internal
      # On indique à Traefik d'activer le TLS pour ce container
      traefik.http.routers.traefik.tls: True
      # On indique à Traefik d'utiliser "certbot" (Let's Encrypt) pour la génération des certificats
      traefik.http.routers.traefik.tls.certresolver: certbot
      # On indique à Traefik de rediriger les connexions sur le port 9090 du container
      traefik.http.services.traefik.loadbalancer.server.port: 9090

# On défini les réseaux liés au container
networks:
  traefik_lan:
    # On indique que le réseau sera externe. C'est à dire qu'il ne sera pas supprimé lors de la suppression du container
    external: True
  wan:
    # # On indique que le réseau sera externe. C'est à dire qu'il ne sera pas supprimé lors de la suppression du container
    external: True

Il nous reste une dernière chose à faire, créer les réseaux qui seront utilisés par notre container (wan et traefik_lan). Pour cela, on tape la commande suivante :

1
2
# docker network create wan
# docker network create traefik_lan

Maintenant que l’ensemble des fichiers sont créés, nous pouvons lancer notre container. Pour cela, on tape la commande suivante :

1
# docker-compose -f /srv/docker/traefik/docker-compose.yml up -d

Via l’option “-d” on indique à docker de lancer le container en mode daemon.
Vous pouvez vérifier le bon fonctionnement de votre conteneur en vous connectant sur l’interface web :
https://traefik.mon-domaine.fr/
Vous devriez avoir cela :

https://www.lecoindesdocs.fr/images/2021/04/08/Traefik-dashboard.png