Gestion des processus Linux

Mise à jour : 01/05/2025

Comprendre le fonctionnement des processus Linux est une compétence indispensable pour tout administrateur système. Chaque commande exécutée, chaque service actif ou tâche planifiée repose sur des processus, qui consomment des ressources (CPU, mémoire, disques). Une mauvaise gestion peut entraîner des ralentissements, des blocages ou des interruptions de service.

Maîtriser les outils pour visualiser, contrôler, prioriser et terminer ces processus permet :

d’assurer la stabilité du système,
de réagir rapidement aux anomalies,
d’optimiser l’utilisation des ressources disponibles.

Ce guide a pour objectif de vous donner toutes les clés pour gérer efficacement les processus Linux, à l’aide de commandes simples (ps, top, kill, etc.) jusqu’aux outils avancés (strace, lsof, cgroups).

Fonctionnement des processus Linux

Pour vraiment comprendre la gestion des processus sous Linux, il faut savoir comment ça marche « sous le capot », même avec des mots simples.

Comment naît un processus ?

Quand vous tapez une commande, par exemple :

ls -l

le terminal (le shell) crée un nouveau processus pour exécuter cette commande. Voici ce qui se passe en coulisses :

Le shell duplique lui-même grâce à un mécanisme appelé fork(). C’est comme faire une photocopie de lui-même.
La « photocopie » devient un nouveau processus, qui charge le programme à exécuter grâce à un autre mécanisme : exec(). Là, il oublie tout ce qu’il faisait avant et remplace son contenu par le programme demandé (ici, ls).

Chaque processus a sa carte d’identité

Linux donne à chaque processus :

un PID : son numéro unique,
un PPID : le numéro de son « papa » (le processus qui l’a créé),
des informations sur :
- sa mémoire,
- son utilisateur,
- ses fichiers ouverts.

Toutes ces infos sont visibles dans le dossier spécial /proc. Par exemple :

cat /proc/1234/status

vous montre la « fiche signalétique » du processus 1234.

Comment Linux fait tourner plusieurs programmes en même temps ?

Linux utilise ce qu’on appelle un ordonnanceur (scheduler). Imaginez un professeur qui distribue la parole à chaque élève pour parler quelques secondes avant de passer au suivant. Linux fait pareil avec les processus :

il leur donne chacun un peu de temps pour s’exécuter,
il passe rapidement d’un processus à un autre pour donner l’impression que tout tourne en même temps.

Ce système est appelé multitâche.

Où tournent les processus ?

Il y a deux zones :

Espace utilisateur : là où tournent vos applications (navigateur, éditeur de texte…).
Espace noyau : là où Linux lui-même travaille pour gérer la mémoire, les fichiers, les périphériques…

Quand votre programme a besoin d’accéder à un fichier ou au réseau, il demande l’aide du noyau. On appelle ça un appel système.

Que se passe-t-il quand un processus reçoit un signal ?

Un signal est un message spécial envoyé à un processus pour lui demander quelque chose :

SIGTERM : « Termine-toi proprement »
SIGKILL : « Stoppe-toi tout de suite »
SIGSTOP : « Mets-toi en pause »
SIGCONT : « Reprends ton travail »

Par exemple :

kill -9 1234

demande à Linux de forcer l’arrêt du processus 1234.

Quand un processus se termine

Quand un processus a fini son travail, il s’arrête et prévient son processus parent qu’il est mort. Tant que le parent ne confirme pas qu’il a reçu le message, le processus reste visible sous forme de zombie (il n’utilise plus de ressources mais reste listé).

Pourquoi c’est utile de savoir tout ça ?

Savoir comment un processus fonctionne vous permet de :

mieux comprendre pourquoi certaines commandes bloquent,
savoir quoi faire si un programme plante ou se fige,
éviter des erreurs quand vous gérez des processus importants (services, scripts…).

En résumé : un processus Linux est comme un mini-programme qui naît, travaille, peut être mis en pause ou arrêté, et meurt quand il a fini sa tâche. Linux s’occupe de bien répartir le travail pour que tout soit fluide !

Visualiser les processus en cours

Pour observer les processus actifs sur un système Linux, plusieurs outils sont disponibles, chacun offrant un niveau de détail et d’interaction différent.

Afficher une liste statique avec ps :

ps aux

Cette commande montre tous les processus en cours, quel que soit l’utilisateur. On peut filtrer un processus particulier :

ps aux | grep nginx

Autres variantes utiles :

ps -ef
ps -eo pid,ppid,ni,comm

Surveiller en temps réel avec top :

top

top affiche les processus classés par usage CPU ou mémoire. On peut y interagir avec les touches :

P pour trier par CPU
M pour trier par mémoire
k pour envoyer un signal à un processus

Naviguer avec htop (si installé) :

htop

Plus lisible que top, htop permet de :

filtrer par nom de commande
changer la priorité (avec F7/F8)
tuer un processus (F9)

Plus d’informations sur htop

Gérer les priorités des processus

Linux permet d’ajuster les priorités d’exécution des processus grâce à deux mécanismes : nice et renice. Cela permet de favoriser ou de limiter l’accès au processeur pour certains programmes.

Valeur nice : principe

Chaque processus a une valeur nice qui va de -20 (priorité la plus haute) à 19 (priorité la plus basse). Plus la valeur est élevée, moins le processus est prioritaire.

Consulter la valeur nice :

ps -o pid,ni,comm -p [PID]

Lancer un processus avec une priorité définie

Utilisez nice pour démarrer un programme avec une priorité personnalisée :

nice -n 10 tar czf archive.tar.gz /home/user

Par défaut, un utilisateur ne peut abaisser la valeur nice (augmenter la priorité) que s’il a les droits root.

Modifier la priorité d’un processus en cours

Avec renice, on ajuste la priorité d’un processus déjà lancé :

sudo renice -n 5 -p 1234

Autres syntaxes :

renice -n -10 -u utilisateur
renice -n 15 -g groupe

Visualiser dans top et htop

Dans top, la colonne NI indique la valeur nice :

Appuyez sur r pour modifier la priorité
Dans htop, utilisez F7 (augmenter) et F8 (diminuer)

Jouer avec les priorités permet d’éviter qu’un programme lourd monopolise le CPU, tout en assurant la fluidité des processus critiques.

Contrôler l’exécution des processus

Gérer un système Linux efficacement, c’est aussi savoir interagir avec les processus en cours : les suspendre, les reprendre ou les arrêter proprement.

Mais attention, il faut que vous soyez propriétaire du processus ou administrateur pour pouvoir le contrôler. Sinon, vous obtiendrez un message d’erreur.

Suspendre un processus

Dans un terminal, utilisez Ctrl+Z pour suspendre un processus actif. Il passe alors en état “stoppé” et peut être repris plus tard.

Reprendre un processus

En arrière-plan :

bg

Au premier plan :

fg

Utilisez jobs pour voir les tâches suspendues et leur numéro :

jobs

Puis, par exemple :

fg %1

Arrêter un processus

Pour arrêter un processus proprement :

kill [PID]

Par défaut, cela envoie le signal SIGTERM (15), qui demande au processus de se fermer. Pour forcer l’arrêt immédiat :

kill -9 [PID]

Cela envoie SIGKILL, que le processus ne peut ignorer.

Tuer plusieurs processus à la fois

Avec killall, on peut cibler tous les processus d’un même nom :

killall firefox

Envoyer d’autres signaux

La commande kill -l liste tous les signaux disponibles (comme SIGSTOP, SIGCONT, SIGHUP, etc.).

Exemple : redémarrer un service sans le tuer complètement :

kill -HUP [PID]

Ces commandes permettent de garder le contrôle total sur les programmes lancés, sans avoir à redémarrer la machine ou tuer des tâches manuellement.

Comprendre et utiliser les signaux Unix

Les signaux sont un mécanisme clé de Linux pour communiquer avec les processus. Ils permettent de contrôler leur comportement : les arrêter, les suspendre, ou leur faire recharger leur configuration.

Liste des signaux courants

Afficher tous les signaux disponibles :

kill -l
HUP INT QUIT ILL TRAP IOT BUS FPE KILL USR1 SEGV USR2 PIPE ALRM TERM STKFLT CHLD CONT STOP TSTP TTIN TTOU URG XCPU XFSZ VTALRM PROF WINCH POLL PWR SYS

Quelques signaux utiles :

SIGHUP (1) : recharger la configuration
SIGTERM (15) : demande d’arrêt propre
SIGKILL (9) : arrêt immédiat (non interceptable)
SIGHUP (1) : rechargement de la configuration
SIGSTOP (19) : pause (comme Ctrl+Z)
SIGCONT (18) : reprise d’un processus stoppé
SIGINT (2) : interruption clavier (Ctrl+C)

Envoyer un signal à un processus

Syntaxe générale :

kill -SIGNAL PID

Exemples :

kill -TERM 1234
kill -KILL 1234

Signaux et noms numériques

On peut aussi utiliser les numéros :

kill -9 1234   # SIGKILL
kill -1 1234   # SIGHUP

Recharger un service avec SIGHUP

Certains programmes (comme nginx ou sshd) acceptent un rechargement sans redémarrage complet :

kill -HUP $(pidof nginx)

Utiliser `pkill` et `killall` avec des signaux

pkill : envoie un signal à tous les processus correspondant à un motif

pkill -HUP nginx

killall : agit sur tous les processus d’un même nom

killall -SIGTERM firefox

Les signaux sont une méthode souple et puissante pour interagir avec les processus sans couper brutalement leurs opérations.

Comprendre `nohup` : maintenir un processus actif

Le mot-clé nohup (abréviation de no hang up) est utilisé pour empêcher un processus de se terminer quand la session est fermée (par exemple lors d’une déconnexion SSH).

Fonctionnement

Par défaut, un processus est lié à un terminal. Si celui-ci se ferme, le système envoie un signal SIGHUP au processus, qui le termine. nohup bloque ce signal, permettant au processus de continuer à s’exécuter.

Syntaxe de base

nohup commande &

Exemple :

nohup rsync -avz /data remote:/backup &

Sortie par défaut

nohup redirige automatiquement la sortie standard et d’erreur vers un fichier nommé :

nohup.out

Pour rediriger explicitement :

nohup ./mon_script.sh > log.txt 2>&1 &

Avantages

Maintien du processus après déconnexion
Redirection facile des logs
Idéal pour les tâches longues ou critiques

Complément : `disown`

On peut aussi combiner nohup avec disown pour détacher le processus de la session shell :

nohup ./script.sh &
disown

Cela garantit que le processus n’est plus associé au terminal, même en cas de fermeture forcée.

nohup est donc une solution simple et fiable pour exécuter des tâches persistantes sans supervision manuelle constante.

Outils avancés et bonnes pratiques

Au-delà des commandes de base, Linux propose des outils puissants pour une gestion approfondie des processus, leur surveillance, et le diagnostic système.

Visualiser la hiérarchie avec `pstree`

Affiche les relations père-fils entre processus :

pstree -p

Utile pour comprendre quel processus a lancé quoi, et repérer des services en cascade.

Lister les fichiers ouverts avec `lsof`

lsof montre les fichiers ouverts par un processus :

lsof -p [PID]

Très utile pour :

Identifier les ports utilisés
Trouver les fichiers verrouillés
Savoir ce qu’un processus lit ou écrit

Lister les processus utilisant un port :

lsof -i :80

Surveiller les appels système avec `strace`

strace trace les appels système (fichiers, réseaux, signaux) :

strace -p [PID]

Très utile pour diagnostiquer :

Un programme qui semble bloqué
Des erreurs de fichiers manquants
Des problèmes de permissions

Ces outils avancés aident à aller plus loin dans l’analyse, le contrôle et la fiabilisation des systèmes en production.

Conclusion

Vous voilà désormais maître des processus sous Linux. Vous savez comment ils naissent, vivent et meurent, comment les surveiller, les contrôler, ajuster leurs priorités ou les arrêter proprement. Grâce aux outils comme ps, top, kill, ou encore strace et lsof, plus rien ne vous échappe. Vous pouvez diagnostiquer des blocages, optimiser l’utilisation des ressources, et garder votre système stable et réactif. En un mot : votre serveur est entre de bonnes mains.