Administration Système Linux : le Guide Complet

Administrer un système Linux, c’est bien plus que taper quelques commandes dans un terminal. C’est comprendre comment les utilisateurs, les services, les processus et le stockage interagissent, et savoir intervenir rapidement quand quelque chose ne fonctionne plus. Dans ce guide, nous couvrons les sept piliers de l’administration système : la gestion des utilisateurs, les services systemd, les processus, la surveillance des ressources, les journaux, la planification de tâches et les sauvegardes. Chaque section contient des commandes réelles que vous pouvez exécuter sur n’importe quelle distribution moderne (Debian, Ubuntu, Rocky Linux, Fedora).

1. Gestion des Utilisateurs et des Groupes

Créer et modifier des utilisateurs

La commande useradd crée un utilisateur. Sur la plupart des distributions, pensez à l’option -m pour créer le répertoire personnel.

# Créer un utilisateur avec son répertoire personnel et un shell bash
sudo useradd -m -s /bin/bash alice

# Définir son mot de passe
sudo passwd alice

# Vérifier les informations d'un utilisateur
id alice
getent passwd alice

La commande usermod modifie un compte existant :

# Ajouter alice au groupe docker (l'option -a est indispensable pour ne pas
# écraser les groupes existants)
sudo usermod -aG docker alice

# Changer le shell de connexion
sudo usermod -s /bin/zsh alice

# Verrouiller un compte (interdit la connexion par mot de passe)
sudo usermod -L alice

# Déverrouiller le compte
sudo usermod -U alice

# Définir une date d'expiration du compte
sudo usermod -e 2026-12-31 alice

Gérer les groupes

# Créer un groupe
sudo groupadd developpeurs

# Lister les groupes d'un utilisateur
groups alice

# Supprimer un utilisateur d'un groupe
sudo gpasswd -d alice docker

# Supprimer un groupe
sudo groupdel developpeurs

Configurer sudo proprement

Ne modifiez jamais /etc/sudoers directement avec un éditeur classique : une erreur de syntaxe peut vous couper l’accès root. Utilisez toujours visudo, qui valide la syntaxe avant d’enregistrer.

# Éditer le fichier sudoers en toute sécurité
sudo visudo

# Bonne pratique : créer un fichier dédié dans /etc/sudoers.d/
sudo visudo -f /etc/sudoers.d/alice

Exemples de règles sudoers :

# Donner tous les droits à alice (avec mot de passe)
alice ALL=(ALL:ALL) ALL

# Autoriser le groupe admin à tout faire
%admin ALL=(ALL) ALL

# Autoriser alice à redémarrer nginx sans mot de passe, et rien d'autre
alice ALL=(root) NOPASSWD: /usr/bin/systemctl restart nginx

2. Services systemd

systemctl : le chef d’orchestre

systemd est le système d’init de la quasi-totalité des distributions actuelles. La commande systemctl pilote les services (appelés unités).

# Démarrer, arrêter, redémarrer un service
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx

# Recharger la configuration sans couper le service (si supporté)
sudo systemctl reload nginx

# Activer le démarrage automatique au boot
sudo systemctl enable nginx

# Activer et démarrer en une seule commande
sudo systemctl enable --now nginx

# Vérifier l'état détaillé
systemctl status nginx

# Lister toutes les unités en échec
systemctl --failed

# Lister tous les services actifs
systemctl list-units --type=service --state=running

Anatomie d’une unité systemd

Les unités personnalisées se placent dans /etc/systemd/system/. Voici un service minimal pour une application :

# /etc/systemd/system/monapp.service
[Unit]
Description=Mon application web
After=network.target

[Service]
Type=simple
User=monapp
WorkingDirectory=/opt/monapp
ExecStart=/opt/monapp/bin/serveur --port 8080
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Après toute modification d’un fichier d’unité, rechargez le démon :

# Prendre en compte les nouveaux fichiers d'unités
sudo systemctl daemon-reload
sudo systemctl enable --now monapp

journalctl : lire les journaux des services

# Journaux d'un service précis
journalctl -u nginx

# Suivre les journaux en temps réel (équivalent de tail -f)
journalctl -u nginx -f

# Journaux depuis le dernier démarrage
journalctl -b

# Journaux des deux dernières heures
journalctl --since "2 hours ago"

# Filtrer par niveau de gravité (erreurs et pire)
journalctl -p err -b

3. Gestion des Processus

Observer les processus

# Vue complète de tous les processus
ps aux

# Arborescence des processus (qui a lancé quoi)
ps auxf

# Vue temps réel classique
top

# Vue temps réel améliorée (à installer : apt install htop)
htop

# Trouver le PID d'un processus par son nom
pgrep -a nginx

Priorités : nice et renice

La priorité d’un processus va de -20 (priorité maximale) à 19 (priorité minimale). Seul root peut attribuer une valeur négative.

# Lancer une compression avec une priorité basse pour ne pas gêner le système
nice -n 19 tar -czf /backup/archive.tar.gz /var/www

# Changer la priorité d'un processus déjà lancé (PID 4321)
sudo renice -n 10 -p 4321

Terminer un processus

# Demander l'arrêt propre (SIGTERM, signal 15)
kill 4321

# Forcer l'arrêt (SIGKILL, signal 9) : en dernier recours uniquement
kill -9 4321

# Tuer tous les processus portant un nom donné
pkill -f "python script_bloque.py"

# Envoyer un signal de rechargement de configuration
kill -HUP 4321

4. Surveillance Disque et Mémoire

Espace disque : df et du

# Occupation de tous les systèmes de fichiers, en unités lisibles
df -h

# Occupation des inodes (un disque peut être plein d'inodes avec de l'espace libre)
df -i

# Taille totale d'un répertoire
du -sh /var/log

# Les 10 plus gros sous-répertoires de /var
du -h --max-depth=1 /var | sort -rh | head -10

Mémoire : free

# État de la mémoire en unités lisibles
free -h

# Rafraîchir toutes les 5 secondes
free -h -s 5

Attention à la colonne available plutôt qu’à free : Linux utilise la mémoire inutilisée comme cache disque, et ce cache est libéré automatiquement quand les applications en ont besoin. Une mémoire « pleine » de cache est un comportement normal et sain.

Entrées/sorties disque : iostat

iostat fait partie du paquet sysstat (sudo apt install sysstat).

# Statistiques d'E/S étendues, rafraîchies toutes les 2 secondes
iostat -x 2

# Se concentrer sur un disque précis
iostat -x 2 /dev/sda

Les colonnes à surveiller : %util (saturation du disque, proche de 100 % = goulot d’étranglement) et await (temps d’attente moyen des requêtes en millisecondes).

5. Journaux : journald et logrotate

Contrôler la taille de journald

Par défaut, journald peut occuper un espace important dans /var/log/journal. Limitez-le dans /etc/systemd/journald.conf :

# /etc/systemd/journald.conf
[Journal]
SystemMaxUse=500M
MaxRetentionSec=1month

# Appliquer la configuration
sudo systemctl restart systemd-journald

# Vérifier l'espace occupé par les journaux
journalctl --disk-usage

# Purger manuellement au-delà de 200 Mo
sudo journalctl --vacuum-size=200M

logrotate pour les fichiers de logs classiques

Les applications qui écrivent dans /var/log (nginx, applications maison) doivent être gérées par logrotate. Exemple de configuration dans /etc/logrotate.d/monapp :

# /etc/logrotate.d/monapp
/var/log/monapp/*.log {
    daily
    rotate 14
    compress
    delaycompress
    missingok
    notifempty
    create 0640 monapp monapp
    postrotate
        systemctl reload monapp > /dev/null 2>&1 || true
    endscript
}

# Tester la configuration sans rien modifier
sudo logrotate -d /etc/logrotate.d/monapp

# Forcer une rotation immédiate
sudo logrotate -f /etc/logrotate.d/monapp

6. Tâches Planifiées : cron et timers systemd

cron : la méthode classique

# Éditer la crontab de l'utilisateur courant
crontab -e

# Lister les tâches planifiées
crontab -l

Syntaxe d’une ligne cron : minute heure jour_du_mois mois jour_de_semaine commande.

# Sauvegarde tous les jours à 2h30
30 2 * * * /usr/local/bin/backup.sh >> /var/log/backup.log 2>&1

# Nettoyage tous les dimanches à 4h
0 4 * * 0 find /tmp -type f -mtime +7 -delete

# Toutes les 15 minutes
*/15 * * * * /usr/local/bin/verifier-service.sh

Timers systemd : l’alternative moderne

Les timers offrent la journalisation via journalctl, la gestion des dépendances et le rattrapage des exécutions manquées (Persistent=true). Il faut deux fichiers : un service et un timer.

# /etc/systemd/system/backup.service
[Unit]
Description=Sauvegarde quotidienne

[Service]
Type=oneshot
ExecStart=/usr/local/bin/backup.sh

# /etc/systemd/system/backup.timer
[Unit]
Description=Déclenche la sauvegarde quotidienne

[Timer]
OnCalendar=*-*-* 02:30:00
Persistent=true

[Install]
WantedBy=timers.target

# Activer le timer et vérifier la prochaine exécution
sudo systemctl daemon-reload
sudo systemctl enable --now backup.timer
systemctl list-timers backup.timer

Critère	cron	Timer systemd
Simplicité	Une ligne suffit	Deux fichiers d’unités
Journalisation	À gérer soi-même	Intégrée à journalctl
Rattrapage si machine éteinte	Non (sauf anacron)	Oui avec Persistent=true
Dépendances entre tâches	Non	Oui (After=, Requires=)
Précision	À la minute	À la seconde

7. Sauvegardes : rsync et tar

rsync : synchronisation incrémentale

rsync ne transfère que les différences, ce qui le rend idéal pour des sauvegardes régulières, en local comme à distance.

# Sauvegarde locale : -a préserve permissions, dates et liens ; -v verbeux
rsync -av /var/www/ /backup/www/

# Simulation sans rien copier (toujours tester d'abord)
rsync -avn --delete /var/www/ /backup/www/

# Miroir exact : --delete supprime dans la destination ce qui a disparu de la source
rsync -av --delete /var/www/ /backup/www/

# Sauvegarde distante via SSH avec exclusions
rsync -av --delete \
  --exclude 'cache/' \
  --exclude '*.tmp' \
  -e "ssh -p 2222" \
  /var/www/ backup@serveur-backup:/backups/www/

Attention à la barre oblique finale : /var/www/ copie le contenu du répertoire, tandis que /var/www copie le répertoire lui-même dans la destination.

tar : archives complètes

# Créer une archive compressée horodatée
tar -czf /backup/www-$(date +%Y%m%d).tar.gz /var/www

# Lister le contenu sans extraire
tar -tzf /backup/www-20260917.tar.gz

# Extraire dans un répertoire précis
tar -xzf /backup/www-20260917.tar.gz -C /tmp/restauration

# Archive avec compression zstd (plus rapide que gzip)
tar --zstd -cf /backup/www.tar.zst /var/www

Vérifier vos sauvegardes

Une sauvegarde non testée n’est pas une sauvegarde. Programmez des restaurations de test régulières :

# Restaurer dans un répertoire temporaire et comparer avec la source
mkdir /tmp/test-restauration
tar -xzf /backup/www-20260917.tar.gz -C /tmp/test-restauration
diff -r /tmp/test-restauration/var/www /var/www

Bonnes pratiques

• Utilisez toujours visudo pour modifier la configuration sudo, et préférez des fichiers dédiés dans /etc/sudoers.d/.
• Accordez les droits sudo les plus restreints possible : une commande précise plutôt que ALL.
• Après chaque modification d’une unité systemd, exécutez systemctl daemon-reload puis vérifiez avec systemctl status.
• Préférez kill (SIGTERM) à kill -9 : laissez aux processus la chance de se terminer proprement.
• Surveillez les inodes (df -i) autant que l’espace disque : un système peut être bloqué avec de l’espace libre.
• Limitez la taille de journald et mettez en place logrotate dès l’installation d’un nouveau service.
• Redirigez la sortie de vos tâches cron vers un fichier de log ou utilisez des timers systemd pour bénéficier de journalctl.
• Appliquez la règle 3-2-1 pour les sauvegardes : trois copies, deux supports différents, une copie hors site.
• Testez vos restaurations régulièrement, pas seulement vos sauvegardes.

Conclusion

L’administration système Linux repose sur un petit nombre d’outils fondamentaux que vous utiliserez quotidiennement : useradd et visudo pour les comptes, systemctl et journalctl pour les services, ps, top et kill pour les processus, df, free et iostat pour les ressources, cron ou les timers systemd pour l’automatisation, et rsync pour les sauvegardes. Maîtriser ces outils vous permet de diagnostiquer et de résoudre la grande majorité des incidents de production.

La prochaine étape logique est d’automatiser : transformez vos interventions manuelles en scripts, puis en tâches planifiées, puis en configuration gérée par des outils comme Ansible. Un bon administrateur système est un administrateur qui ne refait jamais deux fois la même opération à la main.