Processus zombies sous Linux : comment les repérer et les supprimer

Un processus zombie est un processus fils qui a fini de s'exécuter mais qui occupe toujours un emplacement dans la table des processus du noyau. Il existe parce que le processus père n'a pas appelé wait() pour récupérer son statut de sortie. Les processus zombies ne consomment ni CPU ni mémoire, mais chacun d'entre eux occupe un PID. S'ils s'accumulent en nombre suffisant, votre système ne pourra plus créer de nouveaux processus. Cet article explique comment les repérer, les supprimer et empêcher leur apparition.

Pourquoi les processus zombies sont-ils importants sur les serveurs

Un seul processus zombie est inoffensif. Le problème commence lorsqu’ils s’accumulent. Linux dispose d’un espace PID limité : 32 768 sur les systèmes 32 bits, jusqu’à 4 194 304 sur les systèmes 64 bits. Si les processus zombies remplissent la table des processus, le noyau ne peut plus créer de nouveaux processus. Cela signifie : pas de nouvelles connexions, pas de nouveaux threads de travail, rien de nouveau.

Les serveurs web comme Apache et Nginx sont particulièrement exposés car ils créent des processus enfants pour gérer le trafic. Des tests de performance ont montré une baisse de 48 % du débit lorsque des zombies s’accumulent sur un serveur web très sollicité. En 2019, une fuite de canal Golang dans un pod DNS Kubernetes a créé plus de 26 000 zombies sur un seul nœud, remplissant la table des processus et provoquant un crash de la résolution DNS à l’échelle du cluster.

Le tableau ci-dessous présente les principales différences entre un processus normal et un zombie :

Le point essentiel à retenir : vous ne pouvez pas kill -9 un zombie. Il est déjà mort. La seule façon de le supprimer est de faire en sorte que le processus parent le récupère, ou de tuer le processus parent pour que init (PID 1) l'hérite et le récupère automatiquement.

Comment détecter les processus zombies

Les processus zombies apparaissent avec un Z dans la colonne STAT et <defunct> à côté du nom de la commande. Répertoriez-les avec :

ps aux | grep -w Z

Pour voir l'ID du processus parent (PPID), dont vous aurez besoin pour la suppression :

ps -eo pid,ppid,stat,comm | grep -w Z

La top commande indique également le nombre total de processus zombies dans sa ligne d'en-tête. Pour une vérification rapide et non interactive :

top -bn1 | grep zombie

Rechercher le processus parent avec pstree

Une fois que vous disposez du PID d'un zombie, remontez jusqu'au processus parent responsable :

pstree -p -s <zombie_pid>

Cela affiche l'arborescence complète depuis init jusqu'au zombie. Si pstree n'est pas installé, ps auxf fournit une arborescence ASCII similaire.

Comptage des zombies à des fins de surveillance

Un décompte net qui exclut le processus grep lui-même :

ps aux | awk '$8 ~ /Z/ {count++} END {print count+0}'

Pour une surveillance continue pendant le dépannage :

watch -n 1 'ps aux | grep -w Z | wc -l'

Comment supprimer les processus zombies

Les processus zombies ne peuvent être supprimés qu'en récupérant leur statut de sortie. Cela implique de passer par le processus parent.

1. Trouvez le processus parent.

ps -o ppid= -p <zombie_pid>

2. Signalez au processus parent de récupérer ses processus enfants.

kill -SIGCHLD <parent_pid>

Cela indique au processus parent d’appeler wait() sur tous les enfants terminés. Cette opération est non disruptive et fonctionne avec les applications qui se comportent correctement.

3. Si SIGCHLD ne fonctionne pas, redémarrez le service.

systemctl restart <service_name>

4. Si le processus parent ne répond pas, tuez-le.

kill <parent_pid>

Ou s'il ignore SIGTERM :

kill -9 <parent_pid>

Lorsque le processus parent s'arrête, init (PID 1) ou systemd adopte les zombies orphelins et les récupère immédiatement. Soyez prudent sur les systèmes de production. La suppression du processus parent met également fin à tous ses processus enfants actifs.

5. Vérifiez le nettoyage.

ps aux | awk '$8 ~ /Z/ {count++} END {print count+0}'

Si le compteur est à 0, tout va bien.

Prévenir les processus zombies

Gérer les processus enfants dans votre code

La cause principale de la plupart des accumulations de processus zombies est un processus parent qui n'appelle jamais wait(). Corrigez le problème à la source :

• C : Configurez signal(SIGCHLD, SIG_IGN); pour ignorer automatiquement les informations de sortie des processus enfants, ou utilisez un gestionnaire de signaux avec waitpid(-1, NULL, WNOHANG) pour les récupérer de manière asynchrone.
• Python : utilisez subprocess.run(), qui attend automatiquement. Si vous utilisez Popen, appelez proc.wait() explicitement.
• Bash : ajoutez wait à la fin des scripts qui lancent des tâches en arrière-plan.

Configurez correctement systemd

Pour les services gérés par systemd, ces paramètres empêchent l'accumulation de processus zombies :

• KillMode=control-group garantit que tous les processus enfants sont arrêtés simultanément lorsque le service s'arrête.
• TimeoutStopSec donne au processus parent le temps de récupérer les processus enfants avant que systemd n'envoie un SIGKILL.
• WatchdogSec redémarre automatiquement les services qui ne répondent plus, en détectant les cas où le processus parent se bloque et cesse de les récupérer.

Surveillez votre table des processus

Configurez une tâche cron qui s'exécute toutes les 15 minutes pour compter les processus zombies et émettre une alerte si leur nombre dépasse un seuil :

ps aux | awk '$8 ~ /Z/' | wc -l

Surveillez également l'utilisation de votre table des processus en comparant le nombre actuel à /proc/sys/kernel/pid_max. S'il dépasse 80 %, examinez la situation avant que cela ne devienne un problème. Quelques zombies transitoires pendant le fonctionnement normal ne sont pas inquiétants. Un nombre croissant qui ne retombe pas à zéro indique un bogue dans l'application qui doit être corrigé.

Conclusion

Les processus zombies sont des processus morts qui n'ont pas été nettoyés. Ils n'utilisent ni CPU ni mémoire, mais ils occupent des PID, et une table de processus pleine empêche votre serveur de faire quoi que ce soit d'utile.

• Identifiez-les à l'aide de ps aux | grep -w Z et tracez le processus parent avec pstree.
• Supprimez-les en envoyant SIGCHLD au processus parent, en redémarrant le service ou, en dernier recours, en tuant le processus parent.
• Prévenez leur apparition en écrivant du code qui appelle wait(), en configurant correctement systemd et en surveillant votre table des processus.

Si vous gérez des charges de travail à fort trafic et avez besoin d’une infrastructure fiable avec un accès root complet, les serveurs dédiés de FDC vous offrent un contrôle total sur la gestion de vos processus et la configuration de votre système.