Hiérarchie du système de fichiers Linux expliquée avec des exemples pratiques : guide d'implémentation

Introduction

La hiérarchie du système de fichiers Linux (Linux filesystem hierarchy) est un contrat entre l'OS, les outils et les humains. Lorsque vous placez chaque fichier au bon endroit, vous obtenez des installations prévisibles, des sauvegardes plus simples, un dépannage facilité et de meilleures passations entre équipes.

Servez-vous de trois questions pour décider où va un élément :

• Statique ou variable ? Le code et les assets statiques vont sous /usr (ou /usr/local). Les données variables et journaux vont sous /var.
• Pour le système ou pour un utilisateur ? Les éléments système vivent sous /, /usr, /etc, /var. Les fichiers et réglages utilisateur vivent sous /home/UTILISATEUR.
• Éphémère ou persistant ? Les fichiers d'exécution éphémères vont dans /run ou /tmp. L'état persistant va sous /var/lib.

Ce guide explique les répertoires majeurs, montre où placer les fichiers courants d'une application, et propose un plan pilote minimal, sûr et exécutable en local.

Vue d'ensemble du workflow

Que vit où (cartographie pratique)

• / (root) : sommet de l'arborescence. N'y dispersez pas les fichiers de votre application.
• /bin, /sbin : commandes essentielles pour le boot et la réparation. Sur les systèmes modernes, ces chemins peuvent pointer vers /usr.
• /usr : code applicatif en lecture seule et données partagées gérés par le gestionnaire de paquets.
• /usr/bin : exécutables utilisateurs.
• /usr/sbin : exécutables système.
• /usr/lib ou /usr/lib64 : bibliothèques.
• /usr/share : données indépendantes de l'architecture (icônes, locales, pages de man).
• /usr/local : logiciels installés par l'admin, non gérés par l'OS. Miroite la structure de /usr : /usr/local/bin, /usr/local/lib, etc.
• /opt : applications fournies par un éditeur, auto‑contenues. Utile pour un runtime groupé ou un produit unique, ex. /opt/acme/hello-app.
• /etc : configuration système (statique ou éditée par un admin). Aucune application ne doit écrire ici à l'exécution.
• /var : données variables écrites à l'exécution.
• /var/lib/APP : état durable (bases, métadonnées).
• /var/log/APP : fichiers de journaux.
• /var/cache/APP : caches reconstruisibles.
• /var/spool/APP : files d'attente et travaux entrants.
• /run : fichiers d'exécution volatils (tmpfs). PIDs, verrous, sockets, fichiers de contrôle de courte durée, p. ex. /run/APP/APP.pid.
• /tmp : espace temporaire, souvent nettoyé automatiquement. Ne présumez ni persistance ni sécurité.
• /home/UTILISATEUR : données et dotfiles utilisateur. Pas pour des services système.
• /root : répertoire personnel de l'utilisateur root.
• /mnt : systèmes de fichiers montés par l'admin, temporaires ou manuels.
• /media : médias amovibles automontés (USB, CD).
• /srv : données servies par des services (ex. contenu web) quand vous souhaitez une racine de service conventionnelle.
• /dev : nœuds de périphériques.
• /proc et /sys : systèmes de fichiers virtuels exposant des infos noyau et périphériques.
• /boot : noyau, initramfs et fichiers du bootloader.

Placement des fichiers d'application courants

• Binaires :
• Paquets distro : /usr/bin/yourapp (librairies sous /usr/lib, données sous /usr/share).
• Installés localement par l'admin : /usr/local/bin/yourapp.
• Bundle éditeur : /opt/vendor/yourapp/bin/yourapp et le reste sous le même arbre.
• Configuration (système) : /etc/yourapp/
• Exemple : /etc/yourapp/config.yml et /etc/yourapp/env.conf
• État persistant : /var/lib/yourapp/
• Exemple : /var/lib/yourapp/state.db
• Journaux : /var/log/yourapp/
• Exemple : /var/log/yourapp/app.log
• Caches : /var/cache/yourapp/
• Files d'attente : /var/spool/yourapp/
• Exécution (volatile) : /run/yourapp/
• Exemple : /run/yourapp/yourapp.pid, /run/yourapp/yourapp.sock
• Fichiers temporaires : /tmp/yourapp-XXXXXX
• Points de montage pour volumes de données : /mnt/data ou un sous‑dossier d'équipe, monté via fstab ou systemd.

Règles rapides de permissions et ownership

• Créez un utilisateur et un groupe système dédiés pour votre service. Évitez d'exécuter en root.
• Possédez les répertoires d'exécution et d'état avec cet utilisateur: groupe. Appliquez le principe du moindre privilège.
• Modes typiques :
• Config : 640 ou 600 quand des secrets sont présents.
• État et journaux : 750 pour les dossiers, 640 pour les fichiers.
• Dossiers runtime : 750 ; fichiers PID et sockets créés par le service.

Checklist courte pour un nouveau service

1. Choisissez la cible d'installation : /usr (packagé), /usr/local (géré admin), ou /opt (bundle éditeur).
2. Placez les configs dans /etc/APP.
3. Créez /var/lib/APP, /var/log/APP, /var/cache/APP, /var/spool/APP selon besoin.
4. Créez /run/APP au démarrage (systemd peut le gérer) ou assurez-vous que l'app le crée.
5. Définissez les bons ownership et modes.
6. Fournissez une unité de service (ex. systemd) et assurez-vous que les journaux sont faciles à retrouver.
7. Documentez les chemins dans le README et dans les scripts de sauvegarde.

Plan pilote local

Gardez une première implémentation étroite, mesurable et inspectable en local. Exemple sûr avec un service factice nommé hello-app. Adaptez les noms à votre stack.

1) Créer un utilisateur de service

sudo useradd --system --no-create-home --shell /usr/sbin/nologin hello

2) Installer le binaire

Choisissez un style et tenez-vous‑y.

Option A : géré par l'admin sous /usr/local

sudo install -m 0755 ./hello-app /usr/local/bin/hello-app

Option B : bundle éditeur sous /opt

sudo mkdir -p /opt/acme/hello-app/bin
sudo install -m 0755 ./hello-app /opt/acme/hello-app/bin/hello-app
# Lien symbolique pratique (optionnel)
sudo ln -sf /opt/acme/hello-app/bin/hello-app /usr/local/bin/hello-app

3) Créer la configuration

sudo mkdir -p /etc/hello-app
printf '%s\n' \
  'listen_addr=127.0.0.1:8080' \
  'log_level=info' \
  'data_dir=/var/lib/hello-app' | sudo tee /etc/hello-app/hello.conf >/dev/null
sudo chmod 640 /etc/hello-app/hello.conf
sudo chown root: hello /etc/hello-app/hello.conf

4) Créer les répertoires d'état, de logs, de cache et d'exécution

sudo mkdir -p /var/lib/hello-app /var/log/hello-app /var/cache/hello-app /var/spool/hello-app
sudo chown -R hello: hello /var/lib/hello-app /var/log/hello-app /var/cache/hello-app /var/spool/hello-app
sudo chmod 750 /var/lib/hello-app /var/log/hello-app /var/cache/hello-app /var/spool/hello-app

# Laisser le gestionnaire de services créer /run/hello-app, ou pré-créer pour tester
sudo mkdir -p /run/hello-app
sudo chown hello: hello /run/hello-app
sudo chmod 750 /run/hello-app

5) Ajouter une unité systemd minimale (si votre distro utilise systemd)

# /etc/systemd/system/hello-app.service
[Unit]
Description=Hello App service
After=network.target

[Service]
User=hello
Group=hello
EnvironmentFile=-/etc/hello-app/hello.conf
ExecStart=/usr/local/bin/hello-app --config /etc/hello-app/hello.conf \
  --data-dir ${data_dir:-/var/lib/hello-app} --listen ${listen_addr:-127.0.0.1:8080}
WorkingDirectory=/
RuntimeDirectory=hello-app
RuntimeDirectoryMode=0750
Restart=on-failure

[Install]
WantedBy=multi-user.target

Activer et démarrer :

sudo systemctl daemon-reload
sudo systemctl enable --now hello-app
sudo systemctl status hello-app --no-pager

6) Valider le comportement

• Le binaire est dans le PATH :

  command -v hello-app

• Le service écoute en local :

  ss -lntp | grep 8080 || sudo lsof -nP -iTCP:8080 -sTCP:LISTEN

• Les journaux sont au bon endroit :

  ls -l /var/log/hello-app
  sudo journalctl -u hello-app --no-pager | tail -n 50

• Le répertoire d'état évolue à l'usage :

  ls -l /var/lib/hello-app

• Les fichiers runtime existent pendant l'exécution :

  ls -l /run/hello-app

7) Ajouter un volume de données (optionnel, local)

Si votre app manipule de gros volumes, montez‑les sous /mnt. Exemple avec un fichier loopback pour tests locaux :

sudo mkdir -p /mnt/hello-data
# En supposant que /dev/loop10 est préparé et formaté
sudo mount /dev/loop10 /mnt/hello-data
sudo chown hello: hello /mnt/hello-data

Documentez le montage dans /etc/fstab uniquement après tests.

8) Nettoyer en sécurité

sudo systemctl disable --now hello-app
sudo rm -f /etc/systemd/system/hello-app.service
sudo systemctl daemon-reload
sudo userdel hello
sudo rm -rf /etc/hello-app /var/lib/hello-app /var/log/hello-app /var/cache/hello-app /var/spool/hello-app /run/hello-app /usr/local/bin/hello-app /opt/acme/hello-app

Exemples pratiques pour des stacks courantes

Exemple 1 : binaire Go ou Rust unique (installé par l'admin)

• Binaire : /usr/local/bin/logship
• Config : /etc/logship/config.yml
• État : /var/lib/logship/
• Journaux : /var/log/logship/
• Runtime : /run/logship/
• Temp : /tmp/logship-*
• Service : /etc/systemd/system/logship.service

Snippet d'installation :

sudo install -m 0755 ./logship /usr/local/bin/logship
sudo mkdir -p /etc/logship /var/lib/logship /var/log/logship /run/logship
sudo chown -R logship: logship /var/lib/logship /var/log/logship /run/logship

Exemple 2 : application Python bundle éditeur sous /opt

• Bundle : /opt/vendor/insight-app/{bin, lib,...}
• Symlink pratique : /usr/local/bin/insight -> /opt/vendor/insight-app/bin/insight
• Config : /etc/insight-app/
• État : /var/lib/insight-app/
• Journaux : /var/log/insight-app/

Exemple 3 : contenu web servi depuis /srv

• Racine web : /srv/www/site
• Journaux : /var/log/nginx/site/
• Cache : /var/cache/nginx/
• Config : /etc/nginx/sites-available/site

Astuces de dépannage et maintenance

• Si une app se plaint de permissions d'écriture manquantes, vérifiez si elle tente d'écrire dans /etc ou /usr. Redirigez les écritures vers /var/lib ou /run.
• Gardez les secrets hors des chemins lisibles par tous. Utilisez 600 ou 640 et un groupe dédié.
• Faites tourner les logs dans /var/log avec la configuration logrotate de votre distribution.
• Sauvegardez /etc et /var/lib. Recréez /var/cache et /run à la demande.
• Utilisez find et du pour auditer l'espace :

  sudo du -sh /var/lib/* | sort -h | tail
  sudo find /var/log -type f -mtime +14 -print

Conclusion

Bien appliquer la Linux filesystem hierarchy rend vos services prévisibles et faciles à opérer. Démarrez par un pilote local : placez binaires, configs, état, journaux, caches et fichiers runtime aux bons emplacements. Utilisez des utilisateurs dédiés, des permissions strictes et une cartographie claire pour chaque artefact. Ensuite, packagéz pour des installations reproductibles, sauvegardez /etc et /var/lib, configurez la rotation des journaux et surveillez l'usage disque sous /var. En suivant ces principes, vous garderez une Linux file structure propre et durable.