Docker Inventory - Prototype
Centraliser l’inventaire de mon infrastructure Docker avec une interface web
- Contexte
- Infrastructure existante
- Etat des conteneurs
- Identifier les Stacks Compose
- Retrouver emplacement réel des données
- Accès distant aux machines
- 7. Architecture retenue pour l’interface centralisée
- 8. Sécurisation de l’accès web
- Déploiement
- 9. Les prochaines étapes
- Conclusion
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.projectcom.docker.compose.project.working_dircom.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.205port55205alpa@192.168.0.224port55224rad@192.168.0.222port55222alpi@192.168.0.223port55223
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
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 :
- Finaliser l’inventaire des Stacks en utilisant l’API Portainer.
- Centraliser les informations des machines dans une interface unique.
- Afficher les conteneurs par machine et par Stack.
- Visualiser les volumes et les bind mounts avec leurs chemins réels sur les hôtes.
- Identifier les conteneurs non gérés par Portainer ou Compose.
- Ajouter des informations sur les images et les mises à jour disponibles.
- Envisager une visualisation de l’espace disque utilisé par les données Docker.
- 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.
