Maîtriser Systemd et Journalctl pour surveiller Linux

Introduction à Systemd

Systemd est le gestionnaire de services et de système standard sur les distributions Linux modernes (Ubuntu 18+, Debian 8+, CentOS 7+, etc.). Il a remplacé les anciens scripts SysVinit et Upstart, offrant une meilleure gestion des dépendances entre services, un démarrage plus rapide et une architecture orientée unités.

Les logs système sont centralisés via journald, l'outil de journalisation natif de systemd, accessible via la commande journalctl.

Gérer les services avec systemctl

La commande systemctl est l'interface principale pour gérer les services systemd. Voici les opérations essentielles :

# Démarrer un service
sudo systemctl start nginx

# Arrêter un service
sudo systemctl stop nginx

# Redémarrer un service
sudo systemctl restart nginx

# Recharger la configuration (sans interruption)
sudo systemctl reload nginx

# Vérifier le statut d'un service
sudo systemctl status nginx

# Activer un service au démarrage
sudo systemctl enable nginx

# Désactiver un service au démarrage
sudo systemctl disable nginx

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

# Voir les services qui ont échoué
sudo systemctl list-units --type=service --state=failed

Le fichier de service est généralement situé dans /etc/systemd/system/ ou /usr/lib/systemd/system/ pour les services système.

Journalctl : maîtriser les logs système

Journalctl permet de consulter les logs stockés dans la journalisation binaire de systemd. Contrairement aux logs texte traditionnels dans /var/log/, journalctl offre un accès structuré et recherche avancée.

# Voir les derniers logs (comme 'tail -f')
sudo journalctl -f

# Voir les 100 dernières lignes
sudo journalctl -n 100

# Filtrer par unité (service)
sudo journalctl -u nginx

# Voir les logs du service avec suivi en temps réel
sudo journalctl -u nginx -f

# Filtrer par priorité (emerg, alert, crit, err, warning, notice, info, debug)
sudo journalctl -p err

# Voir les logs des 24 dernières heures
sudo journalctl --since "24 hours ago"

# Voir les logs entre deux dates
sudo journalctl --since "2026-04-20" --until "2026-04-24"

# Filtrer par processus ID
sudo journalctl _PID=1234

# Voir les logs avec sortie formatée JSON
sudo journalctl -u nginx -o json

# Combiner plusieurs filtres
sudo journalctl -u nginx -p err --since "1 hour ago"

Créer des unités systemd personnalisées

Vous pouvez créer vos propres services systemd pour automatiser le démarrage d'applications. Voici un exemple complet pour une application Node.js :

# Créer le fichier de service
sudo nano /etc/systemd/system/myapp.service

Contenu du fichier :

[Unit]
Description=Mon application Node.js
After=network.target
Wants=network-online.target

[Service]
Type=simple
User=nodeuser
WorkingDirectory=/home/nodeuser/myapp
ExecStart=/usr/bin/node server.js
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal

# Limiter les ressources
LimitNOFILE=65535
MemoryMax=512M

[Install]
WantedBy=multi-user.target

Puis activer et démarrer le service :

# Recharger systemd
sudo systemctl daemon-reload

# Activer au démarrage
sudo systemctl enable myapp

# Démarrer le service
sudo systemctl start myapp

# Vérifier le statut
sudo systemctl status myapp

# Voir les logs
sudo journalctl -u myapp -f

Rotation des logs et gestion d'espace

Journalctl stocke les logs dans /var/log/journal/. Pour éviter que les logs ne consomment tout l'espace disque, configurez la rétention :

# Voir la taille actuelle des logs
sudo journalctl --disk-usage

# Voir la limite de stockage
sudo journalctl --vacuum-size=1G

# Supprimer les logs de plus de 30 jours
sudo journalctl --vacuum-time=30d

# Configurer les limites de façon permanente
sudo nano /etc/systemd/journald.conf

Dans /etc/systemd/journald.conf, ajoutez :

# Limite la taille du journal à 1GB
SystemMaxUse=1G

# Conserve les logs pendant 30 jours
MaxRetentionSec=30day

# Taille max par fichier journal
SystemMaxFileSize=100M

Puis redémarrez le service :

sudo systemctl restart systemd-journald

Alertes et monitoring des logs

Pour monitorer les logs en production et déclencher des alertes, utilisez des outils comme Prometheus avec l'exporteur systemd_exporter, ou créez des scripts automatisés.

Exemple 1 : Script bash pour alerter sur erreurs :

#!/bin/bash
# Script de monitoring des erreurs nginx

ALERT_EMAIL="admin@example.com"

# Chercher les erreurs des 5 dernières minutes
ERRORS=$(journalctl -u nginx -p err --since "5 minutes ago")

if [ ! -z "$ERRORS" ]; then
    echo "Erreurs détectées dans Nginx:" | mail -s "Alerte Nginx" "$ALERT_EMAIL"
    echo "$ERRORS" | mail -s "Alerte Nginx" "$ALERT_EMAIL"
fi

Planifiez ce script avec cron :

# Exécuter toutes les 5 minutes
*/5 * * * * /usr/local/bin/monitor-nginx-errors.sh

Exemple 2 : Intégration Prometheus (basique) :

# Installer systemd_exporter
sudo apt install -y prometheus-systemd-exporter

# Activer le service
sudo systemctl enable prometheus-systemd-exporter
sudo systemctl start prometheus-systemd-exporter

# Accessible sur http://localhost:9558/metrics

Debugging avec les logs système

Quand une application crash ou ne démarre pas, les logs sont votre meilleur ami. Voici comment investiguer :

# 1. Vérifier le statut du service
sudo systemctl status myapp

# 2. Voir les logs détaillés avec contexte
sudo journalctl -u myapp -n 50 -o short-precise

# 3. Voir ALL les logs (pas seulement depuis le boot)
sudo journalctl -u myapp --all

# 4. Rechercher des erreurs spécifiques
sudo journalctl -u myapp | grep "ERROR\|Failed\|error"

# 5. Exporter les logs pour analyse offline
sudo journalctl -u myapp -o json > logs_export.json

# 6. Voir les limites de ressources
sudo systemctl show myapp | grep Limit

Cas courant : service redémarre en boucle

Vérifiez les logs pour la cause :

sudo journalctl -u myapp -f

# Puis essayez de démarrer manuellement pour voir l'erreur
sudo -u myapp /usr/bin/node /path/to/app/server.js

Bonnes pratiques production

• Logging structuré : Écrivez des logs JSON ou structurés (ex: Winston pour Node.js) plutôt que du texte libre.
• Niveaux de log : Utilisez les niveaux appropriés (debug en dev, info/warning/error en prod).
• Centralisez les logs : En production, utilisez une stack centralisée (ELK, Loki, Splunk) plutôt que de relire des fichiers serveur par serveur.
• Alertes automatiques : Configurez des alertes sur les erreurs critiques (5xx, timeouts, crashes).
• Rotation des logs : Configurez la rétention pour éviter de saturer le disque.
• Sécurité : Les logs peuvent contenir des données sensibles (tokens, IPs). Chiffrez et limitez l'accès.
• Monitoring des services : Utilisez healthchecks et notifications pour détecter rapidement les arrêts non attendus.