systemd Type= simple, forking ou notify : lequel choisir ?
Votre unité reste active alors que le daemon est arrêté ? Comparez simple, exec, forking, oneshot et notify pour identifier le vrai PID principal.
Pourquoi systemd indique-t-il qu’une unité est active alors que le processus s’est arrêté
Avec les valeurs par défaut ExitType=main et RemainAfterExit=no, une unité de service systemd reste active tant que le processus que systemd considère comme processus principal est actif. La section [Service] et la directive Type= déterminent le processus concerné. Si vous choisissez la mauvaise valeur, systemd surveille un wrapper shell ou un processus parent de courte durée, tandis que le daemon qui vous intéresse s’arrête au sein de la même unité. L’unité décrit correctement l’état du processus qu’on lui a demandé de surveiller.
Modifier la stratégie de redémarrage ne résoudra pas ce problème. Restart= réagit aux arrêts et aux échecs de processus, notamment aux dépassements de délai, mais ne détecte pas l’arrêt d’un daemon en arrière-plan si le PID principal (identifiant de processus) appartient à un autre processus qui fonctionne encore. Corrigez d’abord Type=. Le comportement de systemd après l’arrêt réel du processus principal relève d’une décision distincte, expliquée dans le guide de Restart= et RestartSec=.
Ce que Type= détermine réellement
Chaque valeur de Type= répond à deux questions à la fois. À quel moment systemd peut-il considérer cette unité comme démarrée ? Et quel processus est le processus principal ?
La première réponse contrôle l’ordre de démarrage. Une unité qui référence la vôtre dans After= attend que systemd considère la vôtre comme démarrée. Un Type= qui signale trop tôt que l’unité est « démarrée » permet aux unités dépendantes de s’exécuter avant que votre service puisse leur répondre.
La seconde réponse contrôle la supervision. systemd place chaque processus créé par une unité dans un cgroup (groupe de contrôle), une fonctionnalité du noyau qui regroupe les processus afin de pouvoir les limiter et les arrêter ensemble. Le cgroup permet à systemctl stop d’effectuer le nettoyage : KillMode= est défini par défaut sur control-group, donc l’arrêt d’une unité envoie un signal à tous les processus qu’elle contient. Le PID principal est plus limité. Avec ExitType=main et RemainAfterExit=no par défaut, il s’agit de l’unique processus dont la sortie met fin à l’unité et dont le code de sortie contribue au résultat de l’unité. La confusion commence lorsque l’on considère le cgroup comme s’il s’agissait du PID principal.
Type=simple signale un démarrage avant l’exécution du binaire
Type=simple est la valeur par défaut lorsque ExecStart= est défini, que ni Type= ni BusName= n’est présent et que l’unité n’utilise aucun identifiant d’authentification. Une unité qui charge des identifiants, par exemple avec LoadCredential=, utilise implicitement Type=exec à la place. Avec simple, systemd crée le processus, considère immédiatement l’unité comme démarrée et traite ce processus comme le PID principal. Les unités dépendantes démarrent aussitôt, avant même l’exécution du binaire du service.
Ce dernier point explique une surprise fréquente. Une faute de frappe dans le chemin ExecStart= produit tout de même une tâche de démarrage réussie. L’échec survient un instant plus tard, lorsque l’exécution échoue. systemd enregistre ce cas avec le code de sortie 203, que sa propre table nomme EXIT_EXEC et définit comme un échec de l’exécution effective du processus. Ainsi, le retour de systemctl start sans erreur ne prouve pas que votre binaire existe.
Utilisez simple pour un programme qui reste au premier plan et ne se place jamais lui-même en arrière-plan. Cela concerne la plupart des daemons modernes et pratiquement tous les programmes que vous écrivez vous-même.
Type=exec attend le démarrage effectif du programme
Type=exec est simple avec une étape supplémentaire. systemd considère l’unité comme démarrée uniquement une fois le fork et l’exécution du binaire réussis. Si le binaire est absent ou si un User= ne peut pas être résolu, la tâche de démarrage échoue elle-même au lieu de signaler une réussite puis d’échouer silencieusement quelques instants plus tard.
Type=exec a été intégré en amont dans systemd 240, mais les distributions le rétroportent dans des versions plus anciennes : RHEL 8 l’a ajouté dans systemd-239-15.el8. Certaines anciennes versions prises en charge peuvent toujours ne pas l’inclure : Ubuntu 18.04 reste sous ESM jusqu’en avril 2028, et son manuel systemd 237 ne répertorie pas exec comme type pris en charge. Ubuntu 24.04 fournit systemd 255 et Debian 13 fournit systemd 257, en octobre 2026. Vérifiez la vôtre avec systemctl --version et le manuel systemd.service de la distribution.
Le coût est une étape de synchronisation supplémentaire au démarrage. Le gain est un code de sortie fiable renvoyé par systemctl start. Pour un programme au premier plan, préférez exec à simple.
Type=forking et perte du PID principal
Type=forking indique à systemd que le processus de ExecStart= va créer un processus fils, puis se terminer volontairement. systemd attend la fin de ce premier processus, puis considère que l’unité a démarré. Le processus fils restant est le daemon. Cette pratique date de l’époque de SysV, où rien ne supervisait un daemon après le retour du script init et où un fichier PID constituait le seul enregistrement du processus en cours d’exécution. Cette limitation est au cœur de la raison pour laquelle systemd a remplacé les scripts init.
La difficulté concerne l’identité du processus. Le processus lancé par systemd a disparu. systemd doit donc déterminer quel processus survivant est le processus principal. Définissez PIDFile= avec le fichier écrit par le daemon, généralement un chemin sous /run. systemd y lit le PID. Lorsque ce fichier appartient à un utilisateur non privilégié, systemd vérifie également que le PID indiqué correspond à un processus appartenant déjà à ce service. Un fichier obsolète ou créé intentionnellement, qui désigne un processus sans rapport, est ainsi rejeté au lieu d’être considéré comme fiable.
Sans PIDFile=, GuessMainPID= s’applique et sa valeur par défaut est yes. Cette déduction n’est fiable que lorsque le service se stabilise en un seul processus. Le manuel indique clairement la limite : la déduction peut aboutir à une conclusion incorrecte si le daemon comporte plusieurs processus. Si le PID principal ne peut pas être déterminé, la détection des défaillances et le redémarrage automatique ne fonctionneront pas de manière fiable. Une unité peut également se retrouver avec un PID principal égal à 0. Cela signifie que systemd ne suit aucun processus principal, même si les processus du daemon s’exécutent encore dans le cgroup de l’unité.
La plupart des daemons qui créent un processus fils proposent aussi une option qui les maintient au premier plan. Utilisez cette option avec Type=exec et supprimez la ligne PIDFile=. Moins d’éléments à gérer signifie moins de risques de perdre le PID.
Type=oneshot pour les tâches qui se terminent
Type=oneshot attend que le processus s’exécute puis se termine. systemd considère l’unité comme démarrée seulement après sa fin. oneshot convient donc aux tâches dont une autre unité doit attendre la fin. C’est également la valeur par défaut implicite lorsqu’une unité ne spécifie ni Type= ni ExecStart=.
Deux comportements sont propres à oneshot. C’est le seul type qui accepte plusieurs lignes ExecStart=, exécutées dans l’ordre. Son délai d’expiration au démarrage est également désactivé par défaut. Ainsi, un oneshot qui se bloque attend indéfiniment, sauf si vous définissez vous-même TimeoutStartSec=.
Après la fin du processus, l’unité repasse à l’état inactive. RemainAfterExit=yes la maintient à l’état active sans aucun processus en cours. C’est la version volontaire du comportement décrit au début de cette page. Elle est correcte lorsque la tâche de l’unité consiste à laisser un état persistant plutôt qu’à maintenir un processus en cours : charger un jeu de règles de pare-feu ou démarrer une stack de conteneurs. C’est le modèle utilisé par une stack Docker Compose qui redémarre après un reboot : l’unité exécute la commande compose, se termine, puis reste active parce que les conteneurs qu’elle a démarrés continuent de fonctionner après elle. Une unité oneshot convient également aux tâches déclenchées selon un planning. C’est l’autre aspect de l’exécution d’une tâche avec un timer systemd plutôt qu’avec cron.
Type=notify permet au service d’indiquer quand il est prêt
Type=notify confie la décision au service. systemd maintient la tâche de démarrage ouverte jusqu’à ce que le processus envoie READY=1 sur un socket Unix dont le chemin lui est transmis dans la variable d’environnement NOTIFY_SOCKET. L’interface C est sd_notify(3), et de nombreux serveurs la prennent déjà en charge.
C’est la réponse exacte à la question « est-il démarré ? ». simple et exec indiquent que le service est démarré avant qu’il ait lu sa configuration ou ouvert son socket d’écoute. Une unité dépendante peut donc démarrer trop tôt et échouer lors de sa première connexion. notify indique que le service est démarré au moment où il se déclare lui-même prêt.
systemd n’accepte ce message que du processus principal. C’est ce que signifie NotifyAccess=main, et Type=notify l’implique. Si le message provient d’un processus enfant ou d’un helper, définissez NotifyAccess=all. Un script shell peut appeler systemd-notify --ready. Lorsqu’il dispose des privilèges nécessaires, systemd-notify envoie le message avec le PID de son parent. Un script qui est lui-même le processus principal transmet donc NotifyAccess=main. Sinon, il utilise son propre PID et l’unité a besoin de NotifyAccess=all. Par défaut, il attend que systemd ait traité le message avant de se terminer. Omettez donc --no-block, qui désactive cette attente. Un service qui implémente lui-même le protocole est plus fiable.
Deux paramètres associés sont utiles à connaître. Type=notify-reload, disponible depuis systemd 253, étend la même synchronisation aux rechargements. Ainsi, systemctl reload se termine lorsque le service indique que le rechargement est terminé, et non lorsque le signal a été envoyé. Depuis systemd 262, publié en septembre 2026, un service notify-reload qui envoie READY=1 sans intercepter ni bloquer son signal de rechargement (SIGHUP, sauf indication contraire de ReloadSignal=) échoue au démarrage avec une erreur de protocole. Il n’est pas tué par ce signal lors de son premier rechargement. WatchdogSec= demande à un service qui envoie des notifications d’émettre un message de maintien en vie selon un intervalle. systemd considère qu’une échéance manquée est un échec.
Type=dbus et Type=idle
Type=dbus attend que le service prenne un nom sur D-Bus, le bus de messages que les services système et les services de bureau utilisent pour communiquer. Il nécessite BusName= et devient la valeur par défaut dès que BusName= est défini. Utilisez-le uniquement pour un service qui enregistre réellement un nom sur le bus.
Type=idle se comporte comme simple, mais retarde l’exécution du programme jusqu’à ce que les tâches en attente aient été distribuées, avec une limite de cinq secondes. Cette option évite que la sortie de la console au démarrage se mélange aux messages d’état. Elle ne définit pas l’ordre de démarrage et n’a pas sa place dans un service standard.
Pourquoi un script wrapper laisse systemd suivre le mauvais PID
Voici la structure à l’origine du symptôme initial.
[Service]
Type=simple
ExecStart=/opt/app/run.sh#!/bin/bash
export APP_ENV=production
/opt/app/bin/server --config /etc/app.yaml &
/opt/app/bin/exporter --port 9101systemd enregistre le shell comme PID principal. Le shell reste actif tant que exporter s’exécute au premier plan. Si server s’arrête, le shell ne le détecte pas. Le PID principal reste donc actif, l’unité est toujours active et Restart= n’a rien sur quoi agir. Les deux processus restent dans le cgroup de l’unité pendant toute cette période, et systemctl stop effectue donc toujours correctement le nettoyage. C’est la supervision qui ne fonctionne plus, pas le nettoyage.
La correction dépend du nombre réel de processus persistants de l’unité.
S’il n’y en a qu’un, remplacez le shell par ce processus.
#!/bin/bash
export APP_ENV=production
exec /opt/app/bin/server --config /etc/app.yamlexec remplace le shell par le programme indiqué et conserve le même PID. Le PID enregistré par systemd appartient donc désormais au daemon. Mieux encore, supprimez le wrapper. Environment= et EnvironmentFile= transmettent les variables, tandis que ExecStartPre= exécute l’étape de préparation. systemd peut ainsi lancer directement le daemon et connaître son PID dès le départ.
S’il y en a deux, aucun PID unique ne représente l’unité. Séparez-les en deux unités et ordonnez-les avec After= et Wants=. Une unité par processus est la structure que systemd supervise le mieux. C’est aussi la seule manière d’attribuer à chaque processus son propre comportement de redémarrage.
Ce que modifie ExitType=cgroup
ExitType= a été ajouté dans systemd 250. La valeur par défaut est main : l’unité est considérée comme arrêtée lorsque le processus principal se termine. Avec ExitType=cgroup, l’unité reste considérée comme active tant qu’un processus de son cgroup est encore en vie.
[Service]
Type=simple
ExitType=cgroup
ExecStart=/opt/app/launcherCela résout un problème précis. Un launcher qui démarre le véritable traitement puis se termine ferait, avec ExitType=main, considérer l’unité comme arrêtée par systemd, qui tuerait les processus restants. Avec ExitType=cgroup, l’unité suit plutôt l’ensemble du groupe.
Il faut bien comprendre ce que cette option ne résout pas. ExitType=cgroup maintient une unité active tant qu’au moins un processus est en vie. Une unité qui contient deux daemons reste donc active après l’arrêt de l’un d’eux. Cette option corrige le cas du launcher. Elle ne transforme pas une unité en supervisor de plusieurs processus indépendants. ExitType=cgroup ne peut pas non plus être combiné avec Type=oneshot.
Le cgroup reçoit également les informations de comptabilisation des ressources. Les limites telles que MemoryMax= et CPUQuota= s’appliquent donc à chaque processus lancé par l’unité, quelle que soit la valeur de Type= concernant le PID principal. Cette partie est expliquée dans limiter la mémoire et le CPU d’un service avec systemd.
Comment trouver le processus que systemd surveille réellement
Effectuez ces vérifications dans cet ordre sur l’unité que vous déboguez. Lisez les fichiers d’unité, puis ce que systemd suit, et comparez ensuite ces informations avec la liste des processus.
systemctl cat app.service
systemctl show -p Type,ExitType,GuessMainPID,PIDFile,MainPID,RemainAfterExit app.servicesystemctl cat affiche le fichier d’unité ainsi que tous les drop-ins qui s’y appliquent depuis le disque ; ces éléments peuvent différer de ceux que systemd a chargés si les fichiers ont été modifiés sans exécuter daemon-reload. systemctl show affiche les valeurs effectives, y compris les valeurs par défaut que vous n’avez jamais définies. Notez la valeur de MainPID avant de continuer.
systemd-cgls --unit=app.service
ps -o pid,ppid,stat,etime,args -p "$(systemctl show -p MainPID --value app.service)"systemd-cgls liste tous les processus du cgroup de l’unité. La ligne ps décrit le processus unique que systemd supervise. Lisez ces deux informations ensemble. Une valeur MainPID égale à 0 signifie que systemd ne suit aucun processus principal, même si systemd-cgls liste encore des processus dans le cgroup de l’unité. Un MainPID qui désigne un shell alors que le cgroup contient aussi votre daemon correspond au cas du wrapper décrit plus haut. Un cgroup qui contient plus de processus que prévu indique la présence d’un launcher ou d’un daemon qui se duplique avec fork.
systemctl status app.service
journalctl -u app.service -bsystemctl status affiche simultanément la ligne d’état et l’arborescence du cgroup ; il répond donc souvent aux deux questions en même temps. journalctl -u limité au boot courant avec -b affiche les événements de démarrage et d’arrêt que systemd a enregistrés pour l’unité, avec les codes de sortie observés. Si le daemon écrit dans son propre fichier de log plutôt que dans le journal, lisez également ce fichier, car systemd ne peut enregistrer que ce qui lui est transmis.
Lorsque vous modifiez Type=, rechargez la configuration, puis redémarrez.
systemd-analyze verify /etc/systemd/system/app.service
sudo systemctl daemon-reload
sudo systemctl restart app.servicesystemd-analyze verify analyse le fichier et signale les paramètres qu’il ne peut pas accepter. daemon-reload demande à systemd de relire les fichiers d’unité sur le disque. La modification de Type= ne s’applique pas à une unité déjà en cours d’exécution ; le redémarrage est donc obligatoire.
Testez ensuite la modification. Relevez dans systemd-cgls le PID du processus qui vous intéresse réellement, puis tuez-le. Exécutez immédiatement systemctl is-active app.service. Avec ExitType=main et RemainAfterExit=no, tuer le processus principal met fin à cette instance en cours d’exécution, mais une politique de redémarrage peut le relancer avant votre vérification. S’il reste actif sans redémarrer, vérifiez si systemd surveille autre chose ou si l’unité utilise ExitType=cgroup ou RemainAfterExit=yes.
Quel Type= systemd devez-vous utiliser
- Un programme qui reste au premier plan :
Type=exec. - Un programme qui prend en charge la notification de disponibilité :
Type=notify, etnotify-reloads’il confirme également les rechargements. - Un daemon qui exige de s’exécuter en arrière-plan :
Type=forkingavecPIDFile=, ou son option de premier plan avecType=exec. - Un script qui effectue une tâche puis se termine :
Type=oneshot, ainsi queRemainAfterExit=yeslorsque l’objectif était de laisser un état derrière lui. - Un launcher qui se termine alors que ses processus enfants continuent de s’exécuter :
Type=simpleavecExitType=cgroup.
Si vous ne savez pas quel type utiliser pour un daemon tiers, consultez d’abord son unit file fourni avec le paquet. L’exécution de systemctl cat sur une unit fournie par la distribution affiche le choix Type= défini par le paquet ainsi que les surcharges locales.
FAQ
Pourquoi mon unité systemd reste-t-elle active alors que le processus est terminé ?
Avec ExitType=main et RemainAfterExit=no par défaut, cela se produit parce que le processus que systemd considère comme principal est toujours actif. Avec ces valeurs par défaut, systemd suit un seul PID principal par service, choisi selon Type=. Un script wrapper lancé avec Type=simple en est la cause habituelle : le shell est le PID principal. L’unité reste donc active lorsqu’un daemon lancé en arrière-plan par le shell se termine. Exécutez systemctl show -p MainPID app.service, puis affichez le cgroup de l’unité avec systemd-cgls --unit=app.service et comparez les deux résultats.
Quelle est la différence entre Type=simple et Type=exec ?
Type=simple considère que l’unité a démarré dès que systemd a créé le processus, avant l’exécution du binaire. Ainsi, un chemin incorrect dans ExecStart= produit quand même un job de démarrage réussi, suivi d’un échec. Type=exec attend que l’exécution ait réussi. L’échec est donc signalé directement par le job de démarrage. Les deux types considèrent le même processus comme le PID principal. Type=exec a été introduit en amont dans systemd 240, mais les distributions peuvent le rétroporter vers des versions plus anciennes, comme l’a fait RHEL 8 dans systemd-239-15.el8.
Ai-je encore besoin de PIDFile= avec Type=forking ?
Oui, lorsque le daemon en écrit un. Sans cette directive, systemd utilise GuessMainPID=, qui repose sur une estimation et n’est fiable que pour un service qui se stabilise en un seul processus. Lorsque cette estimation est incorrecte ou impossible, la détection des échecs et le redémarrage automatique ne fonctionnent pas de manière fiable pour cette unité. Faites pointer PIDFile= vers le chemin exact écrit par le daemon, généralement sous /run.
Quand dois-je utiliser RemainAfterExit=yes ?
Lorsque le rôle de l’unité est de modifier l’état du système plutôt que de maintenir un processus en cours d’exécution. Une unité Type=oneshot qui charge des règles de pare-feu ou démarre une stack de conteneurs se termine dès que son travail est terminé. Sans RemainAfterExit=yes, l’unité passe directement de l’état de démarrage à l’état d’arrêt. Ainsi, tout nettoyage ExecStop= s’exécute juste après la fin du travail, au lieu de s’exécuter lorsque vous choisissez d’arrêter l’unité, et systemctl stop n’a plus rien à arrêter. Avec cette directive, l’unité reste active sans processus. C’est le comportement attendu dans ce cas.
La modification de Type= nécessite-t-elle un daemon-reload ?
Oui, ainsi qu’un redémarrage de l’unité. systemctl daemon-reload demande à systemd de relire les fichiers d’unité présents sur le disque, mais une instance en cours d’exécution conserve le Type= avec lequel elle a démarré. Exécutez sudo systemctl daemon-reload, puis sudo systemctl restart app.service avant de tester. Sinon, vous observez encore l’ancien comportement de supervision.