NAS #6 − Services avec Docker & Compose

Cet article fait partie d’une série :

Introduction

En plus des fonctions de bases de partage de fichier, ce NAS servira également à publier un certain nombre de services.
Ceux-ci seront mis en place sous la forme de container Docker. Docker Compose sera utilisé pour gérer la configuration des containers.

Docker

Se référer à la documentation de Docker & Compose pour l’installation : https://docs.docker.com/engine/install/debian/

Suite à l’installation, vous pouvez vouloir gérer Docker en tant qu’utilisateur standard (non root). Pour cela il faut ajouter votre utilisateur au groupe docker :

$ sudo groupadd docker
$ sudo usermod -aG docker $USER

Attention cependant, ceci donne des droits étendus à votre utilisateur et Docker est toujours exécuté avec le compte root.

Enfin, toutes les configurations (fichiers compose) ou stockages persistants de données seront placés dans /opt/.

Services “support”/infra

Portainer

Portainer CE (Community Edition) est une solution de gestion et d’orchestration de container Docker. Elle sera utile pour gérer l’ensemble de nos containers dans la suite de cet article.

Créer le répertoire pour Portainer :
```
$ sudo mkdir /opt/portainer
```

Créer le fichier /opt/portainer/docker-compose.yml :

services:
  portainer:
    image: portainer/portainer-ce
    restart: always
    ports:
      - "8000:8000"
      - "9000:9000"
    command: -H unix:///var/run/docker.sock
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - /opt/portainer/data:/data

Récupérer l’image et lancer le container :

$ docker compose pull
$ docker compose up -d

Dans votre navigateur, aller à http://<ip du serveur>:9000, et créer le premier utilisateur administrateur en renseignant un mot de passe.

Watchtower

Watchtower est un service permettant de surveiller la disponibilité de nouvelles images pour les containers et de les mettre à jour automatiquement.

Dans Portainer, créer un nouveau stack nommé watchtower.

Ajouter le contenu du fichier compose ci-dessous :

version: "3"

services:
  watchtower:
    image: containrrr/watchtower
    environment:
      WATCHTOWER_NOTIFICATIONS: email
      WATCHTOWER_NOTIFICATION_EMAIL_FROM: <adresse d'envoi des mails>
      WATCHTOWER_NOTIFICATION_EMAIL_TO: <adresse de réception des mails>
      WATCHTOWER_NOTIFICATION_EMAIL_SERVER_USER: <nom d'utilisateur>
      WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PASSWORD: <mot de passe>
      WATCHTOWER_NOTIFICATION_EMAIL_SERVER: mail.gandi.net
      WATCHTOWER_NOTIFICATION_EMAIL_SERVER_PORT: 465
      WATCHTOWER_NOTIFICATION_EMAIL_DELAY: 2
    restart: always
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock

Cliquer sur Deploy the stack en bas de la page.

DNS

Un service local de résolution de nom (DNS) permet de gérer une zone locale et ainsi résoudre facilement les noms des machines du réseau (et ainsi ne plus à avoir à retenir les adresses IP). Dnsmasq sera utilisé pour cela.

Créer le répertoire pour Dnsmasq :
```
$ sudo mkdir /opt/dnsmasq
```

Créer le fichier de configuration de Dnsmasq :

$ sudo vim /opt/dnsmasq/dnsmasq.conf

#dnsmasq config, for a complete example, see:
#  http://oss.segetech.com/intra/srv/dnsmasq.conf
#log all dns queries
log-queries
#dont use hosts nameservers
no-resolv
#use privacy oriented nameservers, prefer 1^4
server=80.67.169.12
server=195.160.173.53
strict-order
#serve all .company queries using a specific nameserver
server=/sw.lan/192.168.2.24
#explicitly define host-ip mappings
address=/c3po.sw.lan/192.168.2.68
address=/mosesley.sw.lan/192.168.2.24
#address=/chewie.sw.lan/192.168.2.57
address=/obiwan.sw.lan/192.168.2.57

Dans Portainer, créer un nouveau stack nommé dnsmasq.

Ajouter le contenu du fichier compose ci-dessous :

version: '3.7'

services:
 dnsmasq:
  image: 4km3/dnsmasq:latest
  container_name: dnsmasq
  ports:
    - '53:53/udp'
    - '53:53/tcp'
  cap_add: ['NET_ADMIN']
  volumes:
    - /opt/dnsmasq/dnsmasq.conf:/etc/dnsmasq.conf
  restart: always
  command: -k --log-facility=-
  logging:
    driver: local

Cliquer sur Deploy the stack en bas de la page.

Pour des listes plus complètes de résolveurs ouverts et orientés privacy :

Sources :

Reverse proxy

Chaque service déployé grâce à Docker sera accessible depuis un port différent, ce qui peut rendre leur accès complexe (il faut retenir tous les ports). De plus, par défaut, chaque service est publié en http uniquement, sans sécurité donc.
Ainsi, un reverse proxy, Traefik Proxy, sera utilisé pour centraliser les accès aux services et permettre la relation entre un nom de domaine (plus facile à retenir) avec un service, tout en mettant à disposition un certificat TLS via Let’s Encrypt.

Ces services (et donc domaines) n’étant accessibles que localement, la vérification de Let’s Encrypt se fera au travers du DNS (Gandi dans notre cas).

Créer le répertoire pour Traefik :
```
$ sudo mkdir /opt/traefik
```

Créer le fichier de configuration de Traefik :

$ sudo vim /opt/traefik/traefik.toml

[entryPoints]
  [entryPoints.web]
    address = ":80"
    [entryPoints.web.http.redirections.entryPoint]
      to = "websecure"
      scheme = "https"
  [entryPoints.websecure]
    address = ":443"
[providers]
  [providers.docker]
    exposedByDefault = false
    network = "web"
[api]
  dashboard = true
  insecure = true
[certificatesResolvers.default.acme]
  email = "<adresse e-mail du compte let's encrypt>"
  storage = "acme.json"
  [certificatesResolvers.default.acme.dnsChallenge]
    provider = "gandiv5"
    delayBeforeCheck = 0

Penser à changer la valeur de email.

Dans Portainer, créer un nouveau stack nommé traefik.

Ajouter le contenu du fichier compose ci-dessous :

---
version: "3.7"
services:
  traefik:
    container_name: traefik
    environment:
      GANDIV5_API_KEY: <votre clé API>
    restart: always
    image: traefik
    networks:
      - web
    ports:
      - 80:80
      - 443:443
      - 8080:8080
    volumes:
      - "/var/run/docker.sock:/var/run/docker.sock:ro"
      - "/opt/traefik:/etc/traefik:ro"
networks:
  web:
    name: web

Cliquer sur Deploy the stack en bas de la page.

Nous avons indiqué dans le fichier de configuration de Traefik que les containers n’étaient pas exposés par défaut. Il faudra ainsi ajuster les fichiers compose pour que les services soient publiés au travers de Traefik.

Ajout des labels pour activer Traefik pour ce container, indiqué le domaine et le configuration Let’s Encrypt :

labels:
  - traefik.enable=true
  - traefik.http.routers.<nom du service>.rule=Host(`<nom de domaine>`)
  - traefik.http.routers.<nom du service>.entrypoints=websecure
  - traefik.http.routers.<nom du service>.tls=true
  - traefik.http.routers.<nom du service>.tls.certresolver=default

Dans le cas où le container expose lui-même plusieurs ports, il faut indiquer à Traefik quel port prendre en compte avec le label suivant :

  - traefik.http.services.<nom du service>.loadbalancer.server.port=9091

Configuration réseau pour que Traefik et le container puissent échanger :
- Ajout d’un bloc réseau global au fichier compose référençant le réseau de Traefik :
```
networks:
  web:
    external: true
```
- Ajout du réseau en question au service :
```
networks:
  - web
```

Sources :

Autres sources :

DNS dynamique

Un DNS dynamique permet de vérifier régulièrement, et mettre à jour, le cas échéant, l’enregistrement DNS pour un nom de domaine. Cela est très utile lorsque vous souhaitez résoudre un nom de domaine avec l’IP publique de votre box, qui est le plus souvent non fixe.

Comme dans d’autres sections de cet article, nous utiliserons une solution pour le registrar Gandi (gandi-livedns).

Dans Portainer, créer un nouveau stack nommé dyndns.

Ajouter le contenu du fichier compose ci-dessous :

version: '3.7'
services:
  dyndns:
    image: jbbodart/gandi-livedns
    restart: unless-stopped
    environment:
      - APIKEY=<votre clé d'API>
      - RECORD_LIST=<le ou les sous-domaines à mettre à jour>
      - DOMAIN=<le domaine à mettre à jour>

Cliquer sur Deploy the stack en bas de la page.

Sources :

https://hub.docker.com/r/jbbodart/gandi-livedns

Services applicatifs

Gitea

Gitea est un service git pour la gestion de codes.

Créer le répertoire pour Gitea :
```
$ sudo mkdir /opt/gitea
```
Dans Portainer, créer un nouveau stack nommé gitea.

Ajouter le contenu du fichier compose ci-dessous :

Sans Traefik :

version: "3"

networks:
  gitea:
    external: false

services:
  gitea:
    image: gitea/gitea:latest
    environment:
      - USER_UID=1000
      - USER_GID=1000
    restart: always
    networks:
      - gitea
    volumes:
      - /opt/gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "3000:3000"
      - "222:22"

Avec Traefik :

version: "3"

networks:
  gitea:
    external: false
  web:
    external: true

services:
  gitea:
    image: gitea/gitea:latest
    environment:
      - USER_UID=1000
      - USER_GID=1000
    restart: always
    labels:
      - traefik.enable=true
      - traefik.http.routers.gitea.rule=Host(`gitea.h.gued.in`)
      - traefik.http.routers.gitea.entrypoints=websecure
      - traefik.http.routers.gitea.tls=true
      - traefik.http.routers.gitea.tls.certresolver=default
      - traefik.http.services.gitea.loadbalancer.server.port=3000
    networks:
      - web
      - default
      - gitea
    volumes:
      - /opt/gitea:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    ports:
      - "222:22"

Cliquer sur Deploy the stack en bas de la page.
Dans votre navigateur, aller à http://<ip du serveur>:3000 (sans Traefik) ou https://gitea.h.gued.in (avec Traefik).
Compléter la configuration initiale.
- Modifier:
  - SSH Server Domain
  - SSH Server Port
  - Gitea Base URL
- Dans Optional Settings
  - Desactiver :
    - Gravatar
    - OpenID
  - Activier :
    - Local Mode
Cliquer sur install gitea en bas du formulaire.
Créer le premier utilisateur.

Sources :

Todo :

Voir comment faire passer le ssh dans traefik ? (si cela à un sens)

Passerelle VPN

Une passerelle VPN permet d’accéder au réseau local depuis une connexion distante. Pour cela, nous allons utiliser la solution Wireguard, et plus particulièrement une image Docker proposant également une interface web pour l’administration.

Serveur

Charger les modules nécessaires (ip_tables & wireguard) sur la machine hôte et les chargers au démarrage du serveur :

$ sudo modprobe ip_tables
$ sudo modprobe wireguard
$ sudo echo ip_tables >> /etc/modules
$ sudo echo wireguard >> /etc/modules

Créer le répertoire pour Wireguard Access Server :
```
$ sudo mkdir -p /opt/wg-access-server/data
```
Dans Portainer, créer un nouveau stack nommé wireguard.
Depuis un client, générer la clé privée de Wireguard :
```
$ wg genkey
```

Ajouter le contenu du fichier compose ci-dessous :

Sans Traefik :

version: "3.0"
services:
  wg-access-server:
    image: ghcr.io/freifunkmuc/wg-access-server:latest
    container_name: wg-access-server
    cap_add:
      - NET_ADMIN
    volumes:
      - "/opt/wg-access-server/data:/data"
    environment:
      - "WG_ADMIN_PASSWORD=<mot de passe>"
      - "WG_WIREGUARD_PRIVATE_KEY=<clé privée - voir étape précédente>"
      - "WG_VPN_CIDRV6=0" # to disable IPv6
      - "WG_EXTERNAL_HOST=<nom d'hôte>"
      - "WG_VPN_GATEWAY_INTERFACE=eth0"
    ports:
      - "8001:8000/tcp"
      - "51820:51820/udp"
    devices:
      - "/dev/net/tun:/dev/net/tun"
    restart: always

Avec Traefik :

version: "3.0"
services:
  wg-access-server:
    image: ghcr.io/freifunkmuc/wg-access-server:latest
    container_name: wg-access-server
    cap_add:
      - NET_ADMIN
    volumes:
      - "/opt/wg-access-server/data:/data"
    environment:
      - "WG_ADMIN_PASSWORD=<mot de passe>"
      - "WG_WIREGUARD_PRIVATE_KEY=<clé privée - voir étape précédente>"
      - "WG_VPN_CIDRV6=0" # to disable IPv6
      - "WG_EXTERNAL_HOST=<nom d'hôte>"
      - "WG_VPN_GATEWAY_INTERFACE=eth0"
    labels:
      - traefik.enable=true
      - traefik.http.routers.wireguard.rule=Host(`wireguard.h.gued.in`)
      - traefik.http.routers.wireguard.entrypoints=websecure
      - traefik.http.routers.wireguard.tls=true
      - traefik.http.routers.wireguard.tls.certresolver=default
      - traefik.http.services.wireguard.loadbalancer.server.port=8000
    networks:
      - web
      - default
    ports:
      - "51820:51820/udp"
    devices:
      - "/dev/net/tun:/dev/net/tun"
    restart: always

networks:
  web:
    external: true

Cliquer sur Deploy the stack en bas de la page.
Dans votre navigateur, aller à http://<ip du serveur>:8000 (sans Traefik) ou https://wireguard.h.gued.in (avec Traefik).

Todo :

Forward du traffic vpn au travers de traefik ? (https://community.traefik.io/t/need-help-settings-up-traefik-with-a-vpn-wireguard-pi-hole/10309)

Clients

Système	Client
Linux	en cli : https://blogs.gnome.org/thaller/2019/03/15/wireguard-in-networkmanager/ via gui : https://www.xmodulo.com/wireguard-vpn-network-manager-gui.html autre piste, mais ne semble pas très maintenu : https://mox.sh/sysadmin/wireguard-networkmanager-gnome/
Windows	Un client Windows est disponible sur le site de Wireguard : https://download.wireguard.com/windows-client/wireguard-installer.exe
Mac OS	Un client est disponible sur le Mac App Store : https://itunes.apple.com/us/app/wireguard/id1451685025
Android	Un client est disponible sur - le Play Store : https://play.google.com/store/apps/details?id=com.wireguard.android, - et sur F-Droid : https://f-droid.org/en/packages/com.wireguard.android/
iOS	Un client est disponible sur l’App Store : https://itunes.apple.com/us/app/wireguard/id1441195209

Sources :

Radaar

Radarr est un service qui surveille la disponibilité de torrent pour une liste de film personnalisée.

Créer le répertoire pour Radarr :
```
$ sudo mkdir -p /opt/Radarr
```
Dans Portainer, créer un nouveau stack nommé radarr.

Ajouter le contenu du fichier compose ci-dessous :

Sans Traefik :

---
version: "2.1"
services:
  radarr:
    image: lscr.io/linuxserver/radarr
    container_name: radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Paris
      - UMASK=022
    volumes:
      - /opt/radarr:/config
      - /tank/videos/films:/movies
      - /tank/misc/downloads/torrents:/downloads
    ports:
      - 7878:7878
    restart: always

Avec Traefik :

---
version: "2.1"
services:
  radarr:
    image: lscr.io/linuxserver/radarr
    container_name: radarr
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Paris
      - UMASK=022
    volumes:
      - /opt/radarr:/config
      - /tank/videos/films:/movies
      - /tank/misc/downloads/torrents:/downloads
    labels:
      - traefik.enable=true
      - traefik.http.routers.radarr.rule=Host(`radarr.h.gued.in`)
      - traefik.http.routers.radarr.entrypoints=websecure
      - traefik.http.routers.radarr.tls=true
      - traefik.http.routers.radarr.tls.certresolver=default
    networks:
      - web
      - default
    restart: always

networks:
  web:
    external: true

Cliquer sur Deploy the stack en bas de la page.
Dans votre navigateur, aller à http://<ip du serveur>:7878 (sans Traefik) ou https://radarr.h.gued.in (avec Traefik).

Sources :

https://hub.docker.com/r/linuxserver/radarr

Sickchill

Sickchill est un service qui surveille la disponibilité de torrent pour une liste de séries personnalisée.

Créer le répertoire pour Sickchill :
```
$ sudo mkdir -p /opt/sickchill
```
Dans Portainer, créer un nouveau stack nommé sickchill.

Ajouter le contenu du fichier compose ci-dessous :

Sans Traefik :

---
version: "2.1"
services:
  sickchill:
    image: ghcr.io/linuxserver/sickchill
    container_name: sickchill
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Paris
    volumes:
      - /opt/sickchill:/config
      - /tank/misc/downloads/torrents:/downloads
      - /tank/videos/series:/tv
    ports:
      - 8081:8081
    restart: always

Avec Traefik :

---
version: "2.1"
services:
  sickchill:
    image: ghcr.io/linuxserver/sickchill
    container_name: sickchill
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Paris
    volumes:
      - /opt/sickchill:/config
      - /tank/misc/downloads/torrents:/downloads
      - /tank/videos/series:/tv
    labels:
      - traefik.enable=true
      - traefik.http.routers.sickchill.rule=Host(`sickchill.h.gued.in`)
      - traefik.http.routers.sickchill.entrypoints=websecure
      - traefik.http.routers.sickchill.tls=true
      - traefik.http.routers.sickchill.tls.certresolver=default
    networks:
      - web
      - default
    restart: always

networks:
  web:
    external: true

Cliquer sur Deploy the stack en bas de la page.
Dans votre navigateur, aller à http://<ip du serveur>:8081 (sans Traefik) ou https://sickchill.h.gued.in (avec Traefik).

Sources :

https://hub.docker.com/r/linuxserver/sickchill

Transmission & OpenVPN

Transmission est un client Bittorent en mode service (et accessible depuis une interface web). Couplé à OpenVPN, l’image qui est installée ci-dessous permet d’avoir un client torrent non visible par son FAI local.

Cette image supporte un grand nombre de fournisseurs de service VPN, mais malheureusement pas celui que j’utilise. Malheureusement, il support l’usage d’une configuration custom.

Créer les répertoires pour Transmission :

$ sudo mkdir -p /opt/transmissionbt_ovpn/{ovpn_config,config,data}

Placer le fichier de configuration ovpn dans /opt/transmissionbt_ovpn/ovpn_config/.
Dans Portainer, créer un nouveau stack nommé transmission-openvpn.

Ajouter le contenu du fichier compose ci-dessous :

Sans Traefik :

version: '3.3'
services:
    transmission-openvpn:
        image: haugene/transmission-openvpn
        environment:
            - OPENVPN_PROVIDER=CUSTOM
            - OPENVPN_CONFIG=arethusa-v3-eu2
            - OPENVPN_USERNAME=<nom d'utilisateur du service VPN>
            - OPENVPN_PASSWORD=<mot de passe du service VPN>
            - OPENVPN_OPTS=--inactive 3600 --ping 10 --ping-exit 60 --pull-filter ignore ping
            - LOCAL_NETWORK=192.168.2.0/24
            - TRANSMISSION_UMASK=002
            - PUID=1000
            - PGID=100
        ports:
            - '9091:9091'
        cap_add:
            - NET_ADMIN
        volumes:
            - /opt/transmissionbt_ovpn/ovpn_config/:/etc/openvpn/custom/
            - /opt/transmissionbt_ovpn/config:/config
            - /opt/transmissionbt_ovpn/data:/data
            - /tank/misc/downloads/completed:/data/completed
            - /tank/misc/downloads/incomplete:/data/incomplete
            - /tank/misc/downloads/watch:/data/watch
        logging:
            driver: json-file
            options:
                max-size: 10m
        sysctls:
           net.ipv6.conf.all.disable_ipv6: 0
        restart: unless-stopped

Avec Traefik :

version: '3.3'
services:
    transmission-openvpn:
        image: haugene/transmission-openvpn
        environment:
            - OPENVPN_PROVIDER=CUSTOM
            - OPENVPN_CONFIG=arethusa-v3-eu2
            - OPENVPN_USERNAME=<nom d'utilisateur du service VPN>
            - OPENVPN_PASSWORD=<mot de passe du service VPN>
            - LOCAL_NETWORK=192.168.2.0/24
            - TRANSMISSION_UMASK=002
            - PUID=1000
            - PGID=100
            - OPENVPN_OPTS=--inactive 3600 --ping 10 --ping-exit 60 --pull-filter ignore ping
        labels:
            - traefik.enable=true
            - traefik.http.routers.transmission.rule=Host(`transmission.h.gued.in`)
            - traefik.http.routers.transmission.entrypoints=websecure
            - traefik.http.routers.transmission.tls=true
            - traefik.http.routers.transmission.tls.certresolver=default
            - traefik.http.services.transmission.loadbalancer.server.port=9091
        networks:
            - web
            - default
        cap_add:
            - NET_ADMIN
        volumes:
            - /opt/transmissionbt_ovpn/ovpn_config/:/etc/openvpn/custom/
            - /opt/transmissionbt_ovpn/config:/config
            - /opt/transmissionbt_ovpn/data:/data
            - /tank/misc/downloads/completed:/data/completed
            - /tank/misc/downloads/incomplete:/data/incomplete
            - /tank/misc/downloads/watch:/data/watch
        logging:
            driver: json-file
            options:
                max-size: 10m
        sysctls:
           net.ipv6.conf.all.disable_ipv6: 0
        restart: unless-stopped

networks:
  web:
    external: true

Cliquer sur Deploy the stack en bas de la page.
Dans votre navigateur, aller à http://<ip du serveur>:9091 (sans Traefik) ou https://transmission.h.gued.in (avec Traefik).

Quelques commentaires sur des variables modifiées par rapport aux valeurs par défaut :

umask : les permissions par défaut lors de la création de fichiers,
PUID/PGID : pour rentre les fichiers générés accessibles au groupe users,
volumes : bind direct des répertoires du container avec les répertoires du serveur de fichiers (voir parties précédentes),
sysctls : désactivation d’IPv6 qui semble empêcher une connexion au serveur (voir https://github.com/haugene/docker-transmission-openvpn/issues/960),
OPENVPN_OPTS : voir https://haugene.github.io/docker-transmission-openvpn/faq/#set_the_ping-exit_option_for_openvpn_and_restart-flag_in_docker.

Vous pouvez vérifier que le trafic du container passe bien par le tunnel VPN en comparant le résultat de la commande suivante depuis le container et depuis une machine sur le réseau local :

$ curl http://ipinfo.io/ip

Pour l’exécuter depuis le container :

$ sudo docker exec transmission_transmission-openvpn_1 curl http://ipinfo.io/ip

Sources :

Thingsboard

Thingsboard est une plateforme pour les objets connectés (IoT) permetant leur gestion, la collecte des données et la visualition de celles-ci.

Créer les répertoires pour Transmission :

$ sudo mkdir -p /opt/thingsboard/{.mytb-data,.mytb-logs}
$ sudo chown -R 799:799 /opt/thingsboard/{.mytb-data,.mytb-logs}

Dans Portainer, créer un nouveau stack nommé thingsboard.

Ajouter le contenu du fichier compose ci-dessous :

Sans Traefik :

version: '2.2'
services:
  mytb:
    restart: always
    image: "thingsboard/tb-postgres"
    ports:
      - "8081:9090"
      - "1883:1883"
      - "7070:7070"
      - "5683-5688:5683-5688/udp"
    environment:
      TB_QUEUE_TYPE: in-memory
    volumes:
      - /opt/thingsboard/.mytb-data:/data
      - /opt/thingsboard/.mytb-logs:/var/log/thingsboard

Avec Traefik [Non testé encore] :

version: '2.2'
services:
  mytb:
    restart: always
    image: "thingsboard/tb-postgres"
    ports:
      - "1883:1883"
      - "7070:7070"
      - "5683-5688:5683-5688/udp"
    environment:
      TB_QUEUE_TYPE: in-memory
    volumes:
      - /opt/thingsboard/.mytb-data:/data
      - /opt/thingsboard/.mytb-logs:/var/log/thingsboard
    labels:
      - traefik.enable=true
      - traefik.http.routers.thingsboard.rule=Host(`thingsboard.h.gued.in`)
      - traefik.http.routers.thingsboard.entrypoints=websecure
      - traefik.http.routers.thingsboard.tls=true
      - traefik.http.routers.thingsboard.tls.certresolver=default
      - traefik.http.services.thingsboard.loadbalancer.server.port=9090
    networks:
      - web
      - default
networks:
  web:
    external: true

Cliquer sur Deploy the stack en bas de la page.
Dans votre navigateur, aller à http://<ip du serveur>:8081 (sans Traefik) ou https://thingsboard.h.gued.in (avec Traefik).

Vous pouvez aller à l’article suivant pour poursuivre la construction du NAS : à venir.