Ubuntu 20.04 / Debian 10 – Installation d’une seedbox anonyme et sécurisée – (Partie 2) Accès de l’extérieur avec Traefik

Un reverse proxy est le récepteur frontal de toutes les requêtes HTTP venant de l’extérieur. Celui-ci les redirigera vers les bonnes instances des conteneurs Docker. Dans notre cas, nous disposons d’une multitude de containers Docker et nous ne pouvons pas toutes les faire écouter sur le port 80 ou 443, d’où l’utilisation d’un reverse proxy. Ajoutez à cela un joli nom de domaine à votre seedbox en sécurisant le tout avec le protocole SSL/TLS et un certificat Let’s Encrypt.

5 – Traefik

Traefik est un reverse-proxy et un load-balancer moderne conçu (par un Français) pour faciliter le déploiement des microservices (Docker, Kubernetes, AWS, etc.). Traefik est extrêmement simple à configurer et gère automatiquement vos certificats délivrés par Let’s Encrypt. De plus, il est capable de charger vos containers dynamiquement sans interruption de service et dispose d’un dashboard affichant l’ensemble de vos routes configurées.

Nous détaillerons ici la procédure avec l’image Deluge AirVPN mais celle-ci reste bien sûr compatible avec les images PIA et sans VPN si elle est suivie consciencieusement.

5.1 – Création de l’utilisateur traefik

Si vous avez plusieurs docker-compose.yml ou si vous avez pour projet d’en créer par la suite, il est préférable d’isoler et de dédier un docker-compose.yml à Traefik. Il est recommandé de ne pas le lancer sous votre super-utilisateur et de créer un utilisateur dédié.

1. Créez un utilisateur traefik :

   sudo adduser traefik

2. Ajoutez-le au groupe docker :

   sudo adduser traefik docker

5.2 – Le réseau Traefik

Dans la première partie de ce tutoriel, chaque container Docker partage le réseau de votre machine pour être accessible en local avec la propriété network_mode: "host". Avec un reverse proxy, cette configuration n’a plus lieu d’être et nous allons en profiter pour ajouter un peu plus de sécurité en isolant vos containers dans un réseau uniquement accessible par Traefik et vos containers.

1. Connectez-vous sous l’utilisateur traefik :

   su traefik

2. Déplacez-vous dans le répertoire personnel de cet utilisateur :

   cd

3. Créez le réseau dédié à Traefik et à l’ensemble de vos containers :

   docker network create traefik_network

5.3 – L’image Traefik

Créez le fichier /home/traefik/docker-compose.yml en ajoutant le contenu suivant :

version: '3.7'
services:
  traefik:
    image: "traefik:v2.2"
    container_name: "traefik"
    restart: unless-stopped
    networks:
      - traefik_network
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /home/traefik/traefik.toml:/traefik.toml:ro
      - /home/traefik/acme.json:/acme.json

networks:
  traefik_network:
    external: true

• /var/run/docker.sock:/var/run/docker.sock:ro : précise le socket Unix de votre docker. Laissez cette valeur par défaut.
• /home/traefik/traefik.toml:/traefik.toml:ro : précise le chemin du fichier de configuration de Traefik. Nous le créerons à l’étape suivante.
• /home/traefik/acme.json:/acme.json : précise le chemin du fichier contenant les informations relatives à vos certificats.
• traefik_network : ici nous spécifions le réseau créé précédemment et dédié à Traefik. Nous ajouterons les différents containers dans ce réseau par la suite.

5.4 – Configuration Traefik

Traefik peut être configuré de différentes manières, nous allons détailler ici, la configuration recommandée par Traefik, à savoir par un fichier statique au format TOML.

1. Traefik stocke les informations liées au certificat dans un fichier acme.json. Vous devez au préalable créer le fichier et lui attribuer un minimum de permissions :

   touch /home/traefik/acme.json && chmod 600 /home/traefik/acme.json

2. Créez le fichier de configuration Traefik /home/traefik/traefik.toml en ajoutant les lignes suivantes. L’unique propriété à modifier est l’email :

   [providers.docker]
     endpoint = "unix:///var/run/docker.sock"
     watch = true
     exposedByDefault = false
   
   [entryPoints.web]
     address = ":80"
     [entryPoints.web.http.redirections.entryPoint]
       to = "websecure"
       scheme = "https"
   
   [entryPoints.websecure]
     address = ":443"
   
   [certificatesResolvers.leresolver.acme]
     email = "votre-adresse@email.com"
     storage = "acme.json"
     [certificatesResolvers.leresolver.acme.httpChallenge]
       entryPoint = "web"

   • [providers.docker] : cette directive permet tout simplement d’activer le support Docker.
   • endpoint = « unix:///var/run/docker.sock » : précise le socket Unix de votre Docker à Traefik. Laissez la valeur par défaut.
   • watch = true : permet de déployer à chaud les containers dès qu’un changement dans la configuration est détectée.
   • exposedByDefault = false : n’expose pas par défaut les containers au monde extérieur. Il est préférable d’activer cette option dans le docker-compose.yml pour chacun des containers dans le cas où, si pour une raison ou une autre, vous ne souhaiteriez plus rendre accessible un container de l’extérieur.
   • [entryPoints.web] et [entryPoints.websecure] : ces directives définissent les points d’entrée de votre Traefik. web et websecure sont purement indicatifs, vous pouvez les nommer autrement mais ils doivent correspondre aux labels que nous définirons plus tard dans le docker-compose.yml. Les propriétés adress précisent les ports sur lesquels Traefik « écoute » en fonction du point d’entrée.
   • [entryPoints.web.http.redirections.entryPoint] : force la redirection du port 80 vers le port 443 donc force le HTTP en HTTPS.
   • [certificatesResolvers.[NOM_RESOLVEUR].acme] : nous indiquons ici que nous souhaitons utiliser le protocole ACME (donc le service Let’s Encrypt) pour obtenir un certificat. Le nom du résolveur est purement indicatif, il doit simplement correspondre aux labels que nous définirons plus tard dans le docker-compose.yml.
   • storage = « acme.json » : la propriété storage précise à Traefik le fichier (que nous avons créé précédemment) où seront stockées les informations relatives aux certificats. L’erreur commune est d’indiquer le chemin absolu (dans notre cas /home/traefik/acme.json), ici le chemin à renseigner est celui au sein du container Traefik, il faut donc laisser cette valeur par défaut.
   • [certificatesResolvers.[NOM_RESOLVEUR].acme.httpChallenge] : cette directive précise tout simplement par quel point d’entrée (dans notre cas le port 80) Traefik peut obtenir un certificat.

3. Déplacez-vous dans le répertoire personnel de l’utilisateur traefik et démarrez le container :

   cd
   docker-compose up -d

5.5 – Labels et réseau Traefik

1. Connectez-vous sous l’utilisateur media :

   su media

2. Déplacez-vous dans son répertoire personnel :

   cd

3. Modifiez votre /home/media/.env en ajoutant les lignes suivantes en fin de fichier. Remplacez mondomaine.com par le vôtre. Attention ici à renseigner uniquement la base de votre domaine (aucun sous-domaine ni même les www) :

   [...]
   NETWORK=traefik_network
   BASE_HOST=mondomaine.com

4. Dans votre fichier /home/media/docker-compose.yml, remplacez toutes les directives network_mode: "host" par votre nouveau réseau. Attention, l’image Deluge sans VPN possède aussi cette directive. De plus, toutes les expositions de ports sont inutiles, vous pouvez supprimer toutes les directives ports: avec les ports associés.

   Ensuite, ajoutez les labels permettant de communiquer avec Traefik et terminez par ajouter le réseau traefik_network en fin de fichier :

   version: '3.7'
   services:
     deluge:
       image: binhex/arch-delugevpn:latest
       container_name: deluge
       restart: unless-stopped
       networks:
         - ${NETWORK}
       cap_add:
         - NET_ADMIN
       environment:
         - PUID=${PUID}
         - PGID=${PGID}
         - VPN_ENABLED=yes
         - VPN_PROV=airvpn
         - ENABLE_PRIVOXY=yes
         - LAN_NETWORK=${LAN_NETWORK}
         - NAME_SERVERS=209.222.18.222,37.235.1.174,8.8.8.8,209.222.18.218,37.235.1.177,8.8.4.4
         - UMASK=000
         - DEBUG=false
       volumes:
         - /home/deluge/config:/config
         - /etc/localtime:/etc/localtime:ro
         - ${PATH_MEDIA}:/data
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.deluge.entrypoints=web,websecure"
         - "traefik.http.routers.deluge.rule=Host(`deluge.${BASE_HOST}`)"
         - "traefik.http.services.deluge.loadbalancer.server.port=8112"
         - "traefik.http.routers.deluge.tls=true"
         - "traefik.http.routers.deluge.tls.certresolver=leresolver"
   
     jackett:
       image: linuxserver/jackett:latest
       container_name: jackett
       restart: unless-stopped
       networks:
         - ${NETWORK}
       environment:
         - PUID=${PUID}
         - PGID=${PGID}
         - TZ=Europe/Paris
       volumes:
         - /home/media/jackett/config:/config
         - /etc/localtime:/etc/localtime:ro
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.jackett.entrypoints=web,websecure"
         - "traefik.http.routers.jackett.rule=Host(`jackett.${BASE_HOST}`)"
         - "traefik.http.services.jackett.loadbalancer.server.port=9117"
         - "traefik.http.routers.jackett.tls=true"
         - "traefik.http.routers.jackett.tls.certresolver=leresolver"
   
     sonarr:
       image: linuxserver/sonarr:latest
       container_name: sonarr
       restart: unless-stopped
       networks:
         - ${NETWORK}
       environment:
         - PUID=${PUID}
         - PGID=${PGID}
         - TZ=Europe/Paris
       volumes:
         - /home/media/sonarr/config:/config
         - ${PATH_MEDIA}:/data
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.sonarr.entrypoints=web,websecure"
         - "traefik.http.routers.sonarr.rule=Host(`sonarr.${BASE_HOST}`)"
         - "traefik.http.services.sonarr.loadbalancer.server.port=8989"
         - "traefik.http.routers.sonarr.tls=true"
         - "traefik.http.routers.sonarr.tls.certresolver=leresolver"
   
     radarr:
       image: linuxserver/radarr:latest
       container_name: radarr
       restart: unless-stopped
       networks:
         - ${NETWORK}
       environment:
         - PUID=${PUID}
         - PGID=${PGID}
         - TZ=Europe/Paris
       volumes:
         - /home/media/radarr/config:/config
         - ${PATH_MEDIA}:/data
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.radarr.entrypoints=web,websecure"
         - "traefik.http.routers.radarr.rule=Host(`radarr.${BASE_HOST}`)"
         - "traefik.http.services.radarr.loadbalancer.server.port=7878"
         - "traefik.http.routers.radarr.tls=true"
         - "traefik.http.routers.radarr.tls.certresolver=leresolver"
   
     lidarr:
       image: linuxserver/lidarr:latest
       container_name: lidarr
       restart: unless-stopped
       networks:
         - ${NETWORK}
       environment:
         - PUID=${PUID}
         - PGID=${PGID}
         - TZ=Europe/Paris
       volumes:
         - /home/media/lidarr/config:/config
         - ${PATH_MEDIA}:/data
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.lidarr.entrypoints=web,websecure"
         - "traefik.http.routers.lidarr.rule=Host(`lidarr.${BASE_HOST}`)"
         - "traefik.http.services.lidarr.loadbalancer.server.port=8686"
         - "traefik.http.routers.lidarr.tls=true"
         - "traefik.http.routers.lidarr.tls.certresolver=leresolver"
   
     plex:
       image: linuxserver/plex:latest
       container_name: plex
       restart: unless-stopped
       networks:
         - ${NETWORK}
       environment:
         - VERSION=latest
         - PUID=${PUID}
         - PGID=${PGID}
         - TZ=Europe/Paris
       volumes:
         - /home/media/plex/config:/config
         - ${PATH_MEDIA}:/data
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.plex.entrypoints=web,websecure"
         - "traefik.http.routers.plex.rule=Host(`plex.${BASE_HOST}`)"
         - "traefik.http.services.plex.loadbalancer.server.port=32400"
         - "traefik.http.routers.plex.tls=true"
         - "traefik.http.routers.plex.tls.certresolver=leresolver"
   
   networks:
     traefik_network:
       external: true

   • traefik.enable=true : ce label expose le container au monde extérieur. Il surchage la propriété exposedByDefault de votre fichier /home/traefik/traefik.toml.
   • traefik.docker.network=traefik_network : ce label précise à Traefik quel réseau utilise le container.
   • traefik.http.routers.[NOM_DU_CONTAINER].entrypoints : chaque règle de routage spécifique à un container doit être spécifiée par un nom, ici nous utilisons tout simplement le nom du container. Le label entrypoints précise que les requêtes entrantes sur les points d’entrée web (port 80) et websecure (port 443) seront transmises au container.
   • traefik.http.routers.[NOM_DU_CONTAINER].rule=Host(`[SERVICE].${BASE_HOST}`) : ici nous précisons une règle, toute requête arrivant sur http://SERVICE.mondomaine.com sera transmise au container Docker associé.
   • traefik.http.services.[NOM_DU_CONTAINER].loadbalancer.server.port=[PORT] : ici nous précisons le port du container sur lequel les requêtes doivent être transmises.
   • traefik.http.routers.[NOM_DU_CONTAINER].tls : active le support SSL/TLS.
   • traefik.http.routers.[NOM_DU_CONTAINER].tls.certresolver : précise le résolveur et donc les certificats à utiliser.

5. Déplacez-vous dans le répertoire personnel de l’utilisateur media et redémarrez l’ensemble des containers :

   cd
   docker-compose up -d

5.6 – Configuration des services

Pour un accès à distance, il est nécessaire d’associer l’interface web Plex à votre serveur. Pour cela, vous devez préciser l’URL et un code d’association dont la validité est de 4 minutes.

1. Demandez le code d’association à l’adresse suivante : https://www.plex.tv/claim/

2. Modifiez votre fichier /home/media/docker-compose.yml et ajoutez les lignes suivantes en spécifiant le code obtenu précédemment :

   version: '3.7'
   services:
     [...]
   
     plex:
       image: linuxserver/plex:latest
       container_name: plex
       restart: unless-stopped
       networks:
         - ${NETWORK}
       environment:
         - VERSION=latest
         - PUID=${PUID}
         - PGID=${PGID}
         - TZ=Europe/Paris
         - PLEX_CLAIM=claim-424242424242
         - ADVERTISE_IP=plex.${BASE_HOST}:443
       volumes:
         - /home/media/plex/config:/config
         - ${PATH_MEDIA}:/data
       labels:
         - "traefik.enable=true"
         - "traefik.docker.network=${NETWORK}"
         - "traefik.http.routers.plex.entrypoints=web,websecure"
         - "traefik.http.routers.plex.rule=Host(`plex.${BASE_HOST}`)"
         - "traefik.http.services.plex.loadbalancer.server.port=32400"
         - "traefik.http.routers.plex.tls=true"
         - "traefik.http.routers.plex.tls.certresolver=leresolver"
   
   [...]

3. Redémarrez le container Plex avec la commande :

   docker-compose up -d

Les services sont désormais disponibles aux adresses suivantes :

• Deluge : http://deluge.mondomaine.com
• Jackett : http://jackett.mondomaine.com
• Sonarr : http://sonarr.mondomaine.com
• Radarr : http://radarr.mondomaine.com
• Lidarr : http://lidarr.mondomaine.com
• Plex : http://plex.mondomaine.com

6 – Configuration

Nous allons maintenant configurer les applications pour qu’elles puissent communiquer entre elles et que chacune d’elles dispose d’un minimum de sécurité.

Suite du tutoriel (configuration et problèmes rencontrés)