Docker Inventory - Prototype

Docker Inventory - Prototype

Notes

Centraliser l’inventaire de mon infrastructure Docker avec une interface web

Contexte

Mon infrastructure repose sur quatre machines Linux hébergeant plusieurs environnements Docker Standalone, administrés principalement avec Portainer.

Jusqu’ici, pour savoir précisément où fonctionnaient mes conteneurs, quelles Stacks les géraient et où étaient stockées leurs données, il fallait consulter plusieurs environnements Portainer et se connecter aux différents serveurs.

L’objectif est donc de disposer d’une vue centralisée de toute l’infrastructure Docker, accessible depuis une interface web locale.

Cette interface doit permettre de visualiser :

  • Les machines Docker disponibles.
  • Les conteneurs présents sur chaque machine.
  • Leur image et leur état d’exécution.
  • Les Stacks Compose auxquelles ils appartiennent.
  • Les volumes et répertoires utilisés pour stocker leurs données.
  • Les chemins réels de stockage sur les machines hôtes.

Infrastructure existante

Quatre machines constituent actuellement l’infrastructure :

Environnement Portainer Hostname Adresse IP
primary alder 192.168.0.205
alpine01 alpine01 192.168.0.224
alpine02 pvm-alpine02 192.168.0.222
alpine03 pvm-alpine03 192.168.0.223

La machine alder (192.168.0.205) a été retenue pour héberger la future interface centralisée.

Les environnements sont des installations Docker Standalone indépendantes, supervisées depuis Portainer.

Etat des conteneurs

Un premier inventaire a été réalisé à l’aide de commandes Docker exécutées à distance sur les quatre machines.

La commande utilisée pour obtenir les conteneurs est :

docker ps -a –format
“{{.Names}}|{{.Image}}|{{.Status}}|{{.Label "com.docker.compose.project"}}”

L’inventaire relevé est le suivant :

Machine Nombre de conteneurs
alder 8
alpine01 4
alpine02 8
alpine03 8
Total 28

Les services hébergés couvrent notamment :

  • Immich et ses composants associés.
  • Collabora.
  • Technitium DNS.
  • Portainer et ses agents.
  • Watchtower.
  • Uptime Kuma.
  • Beszel.
  • TT-RSS.
  • Speedtest Tracker.
  • Apprise.
  • Stirling PDF.
  • Omni Tools.
  • IT Tools.
  • PrivateBin.

Cette première photographie permet de connaître la répartition des conteneurs entre les différentes machines.

Identifier les Stacks Compose

Pour retrouver les Stacks auxquelles appartiennent les conteneurs, les labels Docker Compose ont été examinés.

Les informations importantes sont notamment :

  • com.docker.compose.project
  • com.docker.compose.project.working_dir
  • com.docker.compose.project.config_files

Elles permettent de retrouver le nom du projet Compose, son répertoire de travail et le fichier YAML utilisé.

Quelques exemples relevés :

Machine Stack Répertoire
alder immich /data/compose/45
alder collabora /data/compose/37
alpine01 uptime-kuma /data/compose/51
alpine02 ttrss /data/compose/31
alpine03 stirling-pdf /data/compose/25

Les labels ne sont toutefois pas systématiquement présents. Certains conteneurs, notamment des agents Portainer ou des conteneurs créés indépendamment de Compose, ne disposent pas de ces informations.

Il faudra donc compléter cette approche avec l’API Portainer pour obtenir un inventaire exhaustif des Stacks, y compris celles qui ne sont pas directement identifiables à partir des conteneurs actifs.

Retrouver emplacement réel des données

L’un des points essentiels de cet inventaire est de connaître l’emplacement des données persistantes sur chaque machine.

Pour cela, les montages Docker ont été inspectés avec :

1
docker inspect

Deux catégories de montages ont été identifiées.

Bind mounts

Les bind mounts associent directement un répertoire ou un fichier de la machine hôte à un chemin dans le conteneur.

Exemples :

Machine Conteneur Répertoire hôte Chemin conteneur
alder immich_server /sharenfs/docker-data/immich/data /data
alder technitium /sharenfs/docker-app/technitium/config /etc/dns
alpine02 speedtest-tracker /home/rad/docker-data/speedtest /config
alpine03 apprise /opt/apprise/config /config

Ces informations permettent de retrouver directement les données sur le système de fichiers de chaque machine.

Volumes Docker nommés

Les volumes Docker sont généralement stockés sous :

1
/var/lib/docker/volumes/

Quelques exemples :

Machine Volume Chemin hôte
alder immich_model-cache /var/lib/docker/volumes/immich_model-cache/_data
alpine01 uptime-kuma_uptime-kuma-data /var/lib/docker/volumes/uptime-kuma_uptime-kuma-data/_data
alpine02 ttrss_app /var/lib/docker/volumes/ttrss_app/_data
alpine02 ttrss_db /var/lib/docker/volumes/ttrss_db/_data
alpine03 privatebin-data /var/lib/docker/volumes/privatebin-data/_data

Sur les quatre machines, le répertoire racine Docker est actuellement :

1
/var/lib/docker

Cette distinction entre bind mounts et volumes Docker sera importante pour la visualisation de l’espace de stockage et la préparation des sauvegardes.

Accès distant aux machines

Pour éviter de devoir se connecter manuellement à chaque serveur, un mécanisme SSH centralisé est déjà utilisé.

Une commande personnelle permet d’exécuter une commande Docker sur l’ensemble des machines :

1
sshm docker exe '<commande>'

Les clés SSH utilisées par ce mécanisme sont actuellement stockées sur le poste d’administration pc1, dans :

1
/home/yann/.ssh/

Pour la future application, il faudra disposer d’un accès SSH dédié depuis alder vers les quatre machines.

L’application pourra ainsi interroger les environnements Docker sans avoir besoin de monter directement les sockets Docker des machines distantes.

Sécurité - SSH dédié

Les clés actuellement utilisées par sshm sont sur pc1 (/home/yann/.ssh). Elles ne sont pas disponibles automatiquement sur cwwk.
Ne pas copier les clés privées existantes dans le conteneur.

Créer une clé dédiée sur cwwk, sous le compte qui administrera le projet :

1
2
3
4
sudo mkdir -p /opt/docker-inventory/ssh
sudo chown "$USER":"$USER" /opt/docker-inventory/ssh
chmod 700 /opt/docker-inventory/ssh
ssh-keygen -t ed25519 -N '' -f /opt/docker-inventory/ssh/id_ed25519 -C docker-inventory

Ajouter la clé publique (contenu de id_ed25519.pub)

1
echo "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIKQYg10jCcrW7rhR8UjusvfSjI5U42yLvSJnOi8IW7o5 docker-inventory"  >>  ~/.ssh/authorized_keys

au fichier ~/.ssh/authorized_keys des comptes distants :

  • yick@192.168.0.205 port 55205
  • alpa@192.168.0.224 port 55224
  • rad@192.168.0.222 port 55222
  • alpi@192.168.0.223 port 55223

Le compte doit pouvoir exécuter docker sans interaction. Attention : l’appartenance au groupe docker donne pratiquement des privilèges root sur l’hôte. Il ne s’agit donc pas d’une véritable restriction de lecture seule au niveau système, même si l’application n’émet que des commandes de consultation.

Précharger les clés d’hôtes et vérifier leurs empreintes par un canal de confiance avant de les accepter :

1
2
3
4
5
6
touch /opt/docker-inventory/ssh/known_hosts
ssh-keyscan -p 55205 192.168.0.205 >> /opt/docker-inventory/ssh/known_hosts
ssh-keyscan -p 55224 192.168.0.224 >> /opt/docker-inventory/ssh/known_hosts
ssh-keyscan -p 55222 192.168.0.222 >> /opt/docker-inventory/ssh/known_hosts
ssh-keyscan -p 55223 192.168.0.223 >> /opt/docker-inventory/ssh/known_hosts
chmod 600 /opt/docker-inventory/ssh/id_ed25519 /opt/docker-inventory/ssh/known_hosts

7. Architecture retenue pour l’interface centralisée

L’interface web sera hébergée sur alder, qui constitue déjà le point central de l’infrastructure.

L’architecture envisagée est la suivante :

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
                   Navigateur
                       |
                       |
             https://docker.home.arpa
                       |
                       v
                 Serveur Nginx
                       |
                 HTTPS / TLS
                       |
                       v
              127.0.0.1:8088
                       |
                       v
             Docker Inventory
                       |
                 Connexions SSH
                       |
          +------------+------------+
          |            |            |
          v            v            v
        alder       alpine01     alpine02
                                   |
                                   v
                                alpine03

L’application interrogera les machines Docker à distance pour récupérer :

  • Les conteneurs.
  • Les images.
  • Les états d’exécution.
  • Les labels Compose.
  • Les informations de stockage.
  • Les volumes et bind mounts.

L’objectif est de présenter ces informations dans une interface unique, sans modifier les environnements Docker existants.

8. Sécurisation de l’accès web

L’accès à l’interface est intégré au serveur Nginx existant.

Le nom DNS local retenu est :

1
docker.home.arpa

Le serveur Nginx assure déjà :

  • La terminaison HTTPS.
  • La présentation du certificat local.
  • Le filtrage des adresses IP autorisées.
  • Le refus des connexions ne correspondant pas au nom de domaine attendu.

Le bloc serveur utilise notamment les directives suivantes :

1
2
3
4
5
6
7
8
9
10
11
12
listen 443 ssl;
listen [::]:443 ssl;

allow 192.168.0.0/24;
allow 100.64.0.0/10;
allow fd7a:115c:a1e0::/48;
allow 2a01:e0a:95a:e2f0::/64;
deny all;

http2 on;

server_name docker.home.arpa;

Le certificat et sa clé sont stockés localement :

1
2
3
4
5
ssl_certificate
    /etc/ssl/homearpa/homearpa.crt;

ssl_certificate_key
    /etc/ssl/homearpa/homearpa.key;

La redirection vers l’application est réalisée en HTTP sur le réseau local :

1
2
3
4
5
6
7
8
9
10
11
12
13
location / {
    proxy_pass http://127.0.0.1:8088;

    proxy_http_version 1.1;
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;

    proxy_connect_timeout 10s;
    proxy_read_timeout 60s;
    proxy_send_timeout 60s;
}

Le port de l’application est volontairement limité à l’interface loopback de la machine hôte :

1
2
ports:
  - "127.0.0.1:8088:8080"

Cette configuration présente un avantage important : le port 8088 n’est pas directement accessible depuis le réseau local. Seul Nginx, exécuté sur la même machine, peut accéder à l’application par 127.0.0.1.

Proxy nginx /etc/nginx/conf.d/docker.home.arpa.conf

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
server {
    # ipv4 listening port/protocol
    listen       443 ssl;
    # ipv6 listening port/protocol
    listen           [::]:443 ssl;
    allow 192.168.0.0/24;
    allow 100.64.0.0/10;
    allow fd7a:115c:a1e0::/48;
    allow 2a01:e0a:95a:e2f0::/64;
    deny all;
    http2 on;
    server_name  docker.home.arpa;

    ssl_certificate      /etc/ssl/homearpa/homearpa.crt;
    ssl_certificate_key  /etc/ssl/homearpa/homearpa.key;

    # connexion nginx fermée si sous domaine inexistant
    if ($http_host != "docker.home.arpa") {
     return 444;
    }

 location / {
    proxy_pass http://127.0.0.1:8088;

    proxy_http_version 1.1;
    proxy_set_header Host              $host;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;

    proxy_connect_timeout 10s;
    proxy_read_timeout 60s;
    proxy_send_timeout 60s;
 }

}

L’accès utilisateur passe donc exclusivement par : https://docker.home.arpa

Déploiement

Copier le projet dans /opt/docker-inventory, puis :

1
2
cd /opt/docker-inventory
docker compose up -d --build

Aperçu première visualisation

9. Les prochaines étapes

La collecte des premières informations est réalisée. La suite du projet consiste à transformer cet inventaire en véritable outil de supervision et de documentation.

Les évolutions envisagées sont :

  1. Finaliser l’inventaire des Stacks en utilisant l’API Portainer.
  2. Centraliser les informations des machines dans une interface unique.
  3. Afficher les conteneurs par machine et par Stack.
  4. Visualiser les volumes et les bind mounts avec leurs chemins réels sur les hôtes.
  5. Identifier les conteneurs non gérés par Portainer ou Compose.
  6. Ajouter des informations sur les images et les mises à jour disponibles.
  7. Envisager une visualisation de l’espace disque utilisé par les données Docker.
  8. Conserver une approche en lecture seule pour éviter toute modification accidentelle de l’infrastructure.

Conclusion

Cette première étape a permis de dresser une cartographie concrète de l’infrastructure Docker : quatre machines, 28 conteneurs et de nombreux volumes et répertoires persistants.

Le principal intérêt de cette démarche est de ne plus considérer les conteneurs comme des éléments isolés, mais de pouvoir les replacer dans leur environnement complet : machine hôte, Stack, configuration et stockage.

L’objectif final est de disposer d’une documentation vivante de l’infrastructure, accessible depuis une interface web locale, sécurisée par HTTPS et intégrée à l’environnement existant.

Un outil qui devrait simplifier considérablement l’administration quotidienne, le diagnostic et la préparation des sauvegardes.

Note : j’ai volontairement distingué les 28 conteneurs recensés des Stacks Compose identifiées par leurs labels. Ce ne sont pas des décomptes équivalents : l’inventaire Portainer reste à compléter pour confirmer l’ensemble des Stacks.