Contrôler les services systemd et écrire des fichiers d’unité

systemd est le système d'initialisation et le gestionnaire de services utilisés par la plupart des distributions Linux modernes. Il est chargé de démarrer, d'arrêter et de gérer les services système, ainsi que de gérer les séquences de démarrage et l'état du système.

L'outil principal pour interagir avec systemd est systemctl. Il vous permet de :

• Démarrer et arrêter des services
• Activer ou désactiver des services au démarrage
• Examiner l'état et les journaux des services
• Recharger la configuration sans redémarrer

Tous les services gérés par systemd sont définis par des fichiers d'unité, c'est-à-dire des fichiers de configuration déclarative stockés dans /etc/systemd/system/ (à l'échelle du système) ou dans ~/.config/systemd/user/ (par utilisateur).

Voici les commandes systemctl les plus utilisées pour gérer les services au quotidien. Chaque commande agit sur un nom d’unité, tel que nginx.service ou simplement nginx.

• systemctl start <unit> — démarrer immédiatement un service
• systemctl stop <unit> — arrêter un service en cours d’exécution
• systemctl restart <unit> — arrêter puis démarrer le service (redémarrage complet)
• systemctl reload <unit> — envoyer SIGHUP pour recharger la configuration sans arrêter le service
• systemctl enable <unit> — créer des liens symboliques afin que l’unité démarre au démarrage du système
• systemctl disable <unit> — supprimer ces liens symboliques
• systemctl status <unit> — afficher l’état, le PID et les dernières lignes du journal

systemctl status fournit un instantané détaillé d’une unité. Comprendre sa sortie est essentiel pour diagnostiquer rapidement les problèmes.

• Loaded : chemin du fichier d’unité et indication de son activation au démarrage
• Active : état actuel — active (running), inactive (dead), failed
• Main PID : identifiant du processus principal du service
• CGroup : tous les processus enfants appartenant au service
• Log lines : les entrées les plus récentes du journal pour cette unité

Vous pouvez également interroger uniquement l’état d’activité avec systemctl is-active et l’état d’activation avec systemctl is-enabled ; ces commandes sont idéales pour les scripts.

Lorsque vous gérez de nombreux services, vous devez pouvoir répertorier et filtrer efficacement les unités. systemctl list-units affiche toutes les unités actuellement chargées, tandis que list-unit-files affiche tous les fichiers d’unité installés ainsi que leur état d’activation.

Options de filtrage utiles :

• --type=service — afficher uniquement les unités de service
• --state=failed — afficher uniquement les unités en échec
• --state=active — afficher uniquement les unités actives
• --all — inclure les unités inactives dans la liste

Associer ces filtres à grep vous permet de créer des pipelines d’inspection puissants dans les scripts de maintenance.

Un fichier d’unité de service est un fichier texte brut de style INI composé de sections. Chaque section contrôle un aspect différent du cycle de vie de l’unité.

• [Unité] — métadonnées : description et dépendances d’ordre (After=, Requires=, Wants=)
• [Service] — manière de démarrer et d’arrêter le processus : ExecStart, ExecStop, Restart, User, WorkingDirectory
• [Installation] — moment où cette unité doit être activée : WantedBy=multi-user.target signifie qu’elle est activée lors du démarrage normal en mode multi-utilisateur

Après avoir placé ou modifié un fichier d’unité sous /etc/systemd/system/, vous devez exécuter systemctl daemon-reload afin que systemd prenne en compte les changements.

Créons un fichier d’unité de service simple pour un script de serveur HTTP personnalisé en Python. Le fichier d’unité indique précisément à systemd comment gérer ce processus, comme s’il s’agissait de n’importe quel autre service système.

Directives [Service] principales utilisées ici :

• Type=simple — systemd considère le processus ExecStart comme le processus principal
• User=www-data — exécuter le processus sous un compte qui n’est pas root, pour renforcer la sécurité
• WorkingDirectory — définir le répertoire de travail du processus
• Restart=on-failure — redémarrer automatiquement le processus s’il se termine avec un code différent de zéro
• RestartSec=5 — attendre 5 secondes entre les tentatives de redémarrage

La directive Type= dans [Service] indique à systemd comment déterminer qu’un service a terminé son démarrage. Choisir le mauvais type est une source fréquente de problèmes d’ordre de démarrage.

• Type=simple — type par défaut ; systemd considère que le service a démarré dès le lancement de ExecStart. Aucun signal de disponibilité n’est nécessaire.
• Type=forking — le processus ExecStart crée un processus enfant puis se termine ; le véritable démon s’exécute en tant que processus enfant. Utilisez PIDFile= pour que systemd puisse le suivre.
• Type=notify — le processus envoie sd_notify(READY=1) lorsqu’il est réellement prêt. C’est le type le plus fiable pour les démons complexes.
• Type=oneshot — s’exécute une fois puis se termine ; les unités suivantes attendent la fin de son exécution. Idéal pour les scripts de configuration.
• Type=idle — similaire à simple, mais l’exécution est retardée jusqu’à la fin de toutes les tâches actives.

Les fichiers d’unité de service prennent en charge plusieurs directives permettant de transmettre des variables d’environnement et d’appliquer des restrictions de sécurité — ces deux aspects sont importants dans les systèmes de production.

Directives d’environnement :

• Environment="KEY=value" — définir une seule variable directement
• EnvironmentFile=/etc/myapp/env — charger des variables depuis un fichier (une paire KEY=value par ligne)

Directives courantes de renforcement de la sécurité :

• NoNewPrivileges=true — empêcher le processus d’obtenir des privilèges supplémentaires via setuid
• ProtectSystem=strict — monter /usr, /boot et /etc en lecture seule
• PrivateTmp=true — fournir au service son propre /tmp isolé
• CapabilityBoundingSet= — supprimer toutes les capacités Linux

Une temporisation systemd est une unité qui active une autre unité (généralement un .service) selon un calendrier. Elle remplace les tâches cron traditionnelles par un mécanisme plus intégré, permettant la journalisation et le contrôle.

Chaque unité de temporisation (foo.timer) est associée à une unité de service portant le même nom de base (foo.service) qui effectue réellement le travail. Vous activez et démarrez la temporisation, et non le service directement.

Types de temporisation :

• Temporisations en temps réel (calendrier) — se déclenchent à des heures précises en utilisant des expressions OnCalendar= telles que daily, weekly ou Mon *-*-* 02:00:00
• Temporisations monotones — se déclenchent par rapport à un événement système en utilisant OnBootSec=, OnActiveSec= ou OnUnitActiveSec=

Construisons une paire complète temporisation + service qui exécute chaque jour à 02:00 un script de sauvegarde. Remarquez que la section [Timer] se trouve dans son propre fichier .timer, tandis que le travail est défini dans le fichier .service associé.

Directives [Timer] principales :

• OnCalendar= — expression de calendrier définissant le programme d’exécution
• Persistent=true — si le système était éteint au moment prévu du déclenchement, exécuter la tâche immédiatement au prochain démarrage
• RandomizedDelaySec= — ajouter un décalage aléatoire pouvant atteindre N secondes afin d’éviter un afflux simultané lorsque de nombreux hôtes partagent le même calendrier
• Unit= — unité cible explicite (facultative si les noms correspondent)

systemd achemine toute la sortie des services vers le journal, que vous pouvez interroger avec journalctl. Cela centralise les journaux de toutes les unités dans un espace de stockage interrogeable.

Options essentielles de journalctl pour diagnostiquer les services :

• -u <unit> — filtrer selon le nom de l’unité
• -f — suivre le journal en temps réel (comme avec tail -f)
• -n 50 — afficher uniquement les 50 dernières lignes
• --since "1 hour ago" — limiter les résultats selon l’heure
• -p err — afficher uniquement les erreurs et les priorités supérieures
• -b — afficher uniquement les journaux du démarrage actuel

Lorsqu’une unité ne parvient pas à démarrer, exécutez d’abord journalctl -u <unit> -n 30 --no-pager, puis systemctl status <unit> afin d’obtenir le contexte des erreurs récentes.

Vérifiez votre compréhension de la configuration des unités de service et de temporisation systemd.

Dans cette leçon, vous avez étudié les concepts fondamentaux de la gestion des services systemd et de la rédaction de fichiers d’unité à un niveau professionnel. Voici un résumé des points abordés :

• Principes de base de systemctl — démarrer, arrêter, redémarrer, recharger, activer, désactiver et vérifier l’état avec start, stop, restart, reload, enable, disable, status, is-active et is-enabled, pour des vérifications adaptées aux scripts
• Répertorier et filtrer — utiliser list-units et list-unit-files avec les options --type et --state pour isoler les services en échec ou activés
• Anatomie d’un fichier d’unité — les trois sections [Unit], [Service] et [Install], ainsi que leurs directives principales
• Types de services — simple, forking, notify, oneshot et situations adaptées à chacun
• Environnement et sécurité — EnvironmentFile, NoNewPrivileges, ProtectSystem et PrivateTmp pour les démons renforcés
• Unités de temporisation — associer les fichiers .timer et .service, utiliser les expressions OnCalendar et le rattrapage prévu par Persistent
• Journalctl — filtrer selon l’unité, l’heure, le démarrage et la priorité afin de diagnostiquer efficacement les défaillances

Grâce à ces compétences, vous pouvez gérer n’importe quel service système, planifier de manière fiable des tâches récurrentes et rédiger des fichiers d’unité prêts pour la production pour vos propres démons.