Gestion des processus

Introduction

La gestion des processus est un aspect fondamental de l'administration système Linux. Comprendre comment fonctionnent les processus, comment les surveiller et les contrôler est essentiel pour maintenir un système performant et stable.

Qu'est-ce qu'un processus ?

Définition

Un processus est un programme en cours d'exécution. Lorsqu'on lance une commande, les instructions sont chargées en mémoire vive (RAM) afin que le processeur puisse les exécuter.

Caractéristiques importantes :

• Chaque processus possède un identifiant unique appelé PID (Process IDentifier)
• Un processus peut être lancé par un utilisateur ou par un autre processus
• Les processus s'organisent selon une hiérarchie parent-enfant

Cycle de vie d'un processus

Création → Réveil → Prêt → Actif → Terminé
            ↓         ↓       ↓
         Endormi  Suspendu  Zombie

1. Réveil (Wake up)

Lors du lancement d'une commande, il y a une phase d'initialisation où le programme attend que l'ordonnanceur soit prêt à le placer en mémoire.

2. Prêt (Ready)

Le processus est en file d'attente et attend que l'ordonnanceur lui attribue du temps processeur (CPU) pour être exécuté.

3. Actif (Running)

Le processus est en cours d'exécution par le CPU. Il alterne entre les états "Prêt" et "Actif" pendant toute la durée de son exécution.

4. Endormi (Sleeping)

Le processus est en attente d'une ressource (I/O disque, réseau, etc.). Dans cet état, il ne consomme pas de CPU.

5. Suspendu (Stopped)

Le processus est interrompu par un signal (par exemple, Ctrl+Z).

6. Zombie

Un processus terminé mais dont les informations ne peuvent pas être déchargées de la mémoire. Cela arrive généralement quand un processus parent n'a pas récupéré le code de sortie de son processus enfant.

Préemption

À tout moment, un processus peut être interrompu. Il s’agit alors de préemption.

La préemption est le mécanisme par lequel l'ordonnanceur peut interrompre un processus en cours d'exécution pour permettre à un autre processus de s'exécuter.

Utilité :

• Empêcher qu'un processus monopolise le CPU
• Garantir un temps de réponse équitable entre processus
• Maintenir la réactivité du système

!

La commande ps - Afficher les processus

Utilisation de base

La commande ps (Process Status) permet d'afficher les processus en cours d'exécution.

# Afficher les processus du terminal courant
$ ps

# Sortie typique :
#   PID TTY          TIME CMD
# 1699410 pts/39   00:00:00 bash
# 1702159 pts/39   00:00:00 ps

Colonnes par défaut

• PID : Identifiant unique du processus
• TTY : Terminal de contrôle (pts/0, tty1, etc.)
• TIME : Temps CPU accumulé (en format MM:SS)
• CMD : Commande exécutée avec ses arguments

Options essentielles de ps

Afficher tous les processus

# Tous les processus de tous les utilisateurs
$ ps -e
# ou
$ ps -A

# Format plus détaillé
$ ps -ef

Afficher les processus d'un utilisateur

# Processus d'un utilisateur spécifique
$ ps -u nomutilisateur

# Processus de l'utilisateur courant
$ ps -x

Format personnalisé avec -o

# Choisir les colonnes à afficher
$ ps -eo pid,ppid,user,%cpu,%mem,cmd

# Sortie :
#   PID  PPID USER     %CPU %MEM CMD
#  1234     1 root      0.0  0.1 /usr/bin/systemd
#  5678  1234 user      2.5  1.2 firefox

Colonnes utiles

Colonne	Description
PID	Process ID
PPID	Parent Process ID (processus parent)
USER	Utilisateur propriétaire du processus
%CPU	Pourcentage d'utilisation du CPU
%MEM	Pourcentage de mémoire utilisée
VSZ	Taille virtuelle de la mémoire (en Ko)
RSS	Mémoire résidente (mémoire physique utilisée)
START	Heure de démarrage du processus
TIME	Temps CPU cumulé
STAT	État du processus
NICE	Priorité du processus (-20 à 19)
CMD	Commande complète

Colonne STAT - États des processus

La colonne STAT indique l'état actuel du processus :

Code	Signification
R	Running - En cours d'exécution ou prêt
S	Sleeping - Suspendu (en attente d'un événement)
D	Uninterruptible sleep - Sommeil non interrompable (I/O)
T	Stopped - Arrêté par un signal (SIGSTOP, SIGTSTP)
Z	Zombie - Terminé mais pas récupéré par le parent

Exemple avec ps -Ao user,stat,cmd

Modificateurs additionnels :

Certaines lettres peuvent être accompagnées de symboles supplémentaires :

Symbole	Signification
<	Processus à haute priorité (valeur nice négative)
N	Processus à basse priorité (valeur nice positive)
L	Pages verrouillées en mémoire (pour les opérations temps réel)
s	Leader de session
+	Processus avec une valeur nice positive
l	Multi-thread

Exemples pratiques

# Afficher tous les processus avec détails
$ ps aux

# Afficher les processus en arbre (hiérarchie)
$ ps -ef --forest
# ou
$ ps auxf

# Filtrer les processus Firefox
$ ps aux | grep firefox

# Top 10 des processus utilisant le plus de CPU
$ ps aux --sort=-%cpu | head -10

# Top 10 des processus utilisant le plus de mémoire
$ ps aux --sort=-%mem | head -10

# Afficher seulement certaines colonnes, triées par mémoire
$ ps -eo pid,ppid,cmd,%mem,%cpu --sort=-%mem | head -20

Hiérarchie des processus

Le processus init/systemd

Tous les processus Linux sont organisés en hiérarchie. Le processus racine (PID 1) est généralement systemd sur les systèmes modernes (ou init sur les systèmes plus anciens).

systemd est responsable de :

• Démarrage et arrêt des services système
• Gestion des ressources système
• Surveillance des processus
• Gestion des points de montage
• Gestion des timers et des cron jobs

# Voir la hiérarchie avec ps
$ ps -ef --forest

# Exemple de sortie :
# UID    PID  PPID CMD
# root     1     0 /sbin/init
# root   456     1  \_ /usr/lib/systemd/systemd
# user  1234   456      \_ sshd: user@pts/0
# user  1235  1234          \_ -bash
# user  5678  1235              \_ ps -ef --forest

Hiérarchie des processus

Chaque processus peut engendrer des processus enfants, formant ainsi une structure arborescente. Le processus parent est identifié par le PPID (Parent Process ID).

Exemple :

La commande pstree

pstree affiche l'arbre des processus de manière visuelle :

# Afficher l'arbre complet
$ pstree

# Afficher avec les PIDs
$ pstree -p

# Afficher pour un utilisateur
$ pstree username

La commande pgrep

pgrep permet de trouver les PIDs de processus selon différents critères :

# Trouver les PIDs de Firefox
$ pgrep firefox

# Afficher aussi le nom du processus
$ pgrep -l firefox

# Trouver le processus le plus ancien
$ pgrep -o firefox

# Trouver le processus le plus récent
$ pgrep -n firefox

# Trouver les processus d'un utilisateur
$ pgrep -u username

# Compter les processus
$ pgrep -c firefox

# Recherche exacte du nom
$ pgrep -x bash

Firefox peut avoir plusieurs processus (onglets, extensions, etc.), donc pgrep firefox peut retourner plusieurs PIDs.

La commande top - Surveillance en temps réel

Présentation

top est l'équivalent Linux du Gestionnaire des tâches de Windows. Il affiche en temps réel les processus actifs et les statistiques système.

# Lancer top
$ top

# Quitter top
# Appuyez sur 'q'

L'en-tête de top

L'en-tête affiche des informations globales sur le système :

top - 14:23:45 up 5 days, 3:21, 2 users, load average: 0.52, 0.48, 0.45
Tasks: 245 total,   1 running, 244 sleeping,   0 stopped,   0 zombie
%Cpu(s):  5.2 us,  2.1 sy,  0.0 ni, 92.1 id,  0.3 wa,  0.0 hi,  0.3 si,  0.0 st
MiB Mem :  15873.4 total,   2341.2 free,   8234.1 used,   5298.1 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   6892.3 avail Mem

Ligne 1 : Uptime et charge

• 14:23:45 : Heure actuelle
• up 5 days, 3:21 : Temps depuis le démarrage (uptime)
• 2 users : Nombre d'utilisateurs connectés
• load average : Charge moyenne sur 1, 5 et 15 minutes

Ligne 2 : Tâches

• total : Nombre total de processus
• running : Processus en cours d'exécution
• sleeping : Processus en attente
• stopped : Processus arrêtés
• zombie : Processus zombies

Ligne 3 : Utilisation CPU

• us (user) : Temps CPU en mode utilisateur
• sy (system) : Temps CPU en mode noyau
• ni (nice) : Temps CPU pour processus "gentils" (priorité basse - nice signifie gentil, un processus gentil laisse passer en priorité les autres processus, plus la priorité est forte et positive et plus le processus est gentil pour les autres processus)
• id (idle) : Temps CPU inactif
• wa (wait) : Temps d'attente I/O (disque, réseau)
• hi (hardware interrupts) : Interruptions matérielles
• si (software interrupts) : Interruptions logicielles
• st (stolen) : Temps volé (machines virtuelles)

Lignes 4-5 : Mémoire et Swap

• total : Mémoire totale
• free : Mémoire libre
• used : Mémoire utilisée
• buff/cache : Mémoire utilisée pour cache
• avail Mem : Mémoire disponible pour nouveaux processus

Liste des processus dans top

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 1234 user      20   0 2567890 234567  89012 S   5.3   1.5   1:23.45 firefox
 5678 root      20   0  123456  12345   6789 R   2.0   0.1   0:05.12 systemd

Colonnes importantes :

• PID : Process ID
• USER : Propriétaire du processus
• PR : Priorité (plus petit = plus prioritaire)
• NI : Valeur nice (-20 à 19)
• VIRT : Mémoire virtuelle totale
• RES : Mémoire résidente (RAM physique utilisée)
• SHR : Mémoire partagée
• S : État (R=running, S=sleeping, D=disk wait, T=stopped, Z=zombie)
• %CPU : Pourcentage d'utilisation CPU
• %MEM : Pourcentage de mémoire utilisée
• TIME+ : Temps CPU total utilisé
• COMMAND : Nom de la commande

Options de top

# Rafraîchir toutes les 1 seconde
$ top -d 1

# Surveiller un processus spécifique
$ top -p 1234

# Surveiller plusieurs processus
$ top -p 1234 -p 5678

# Arrêter après N rafraîchissements
$ top -n 10

# Afficher les processus d'un utilisateur
$ top -u username

Commandes interactives dans top

Une fois top lancé, vous pouvez utiliser ces touches :

Touche	Action
h ou ?	Afficher l'aide
q	Quitter
k	Tuer un processus (demande le PID)
r	Modifier la priorité (renice)
s	Changer l'intervalle de rafraîchissement
P	Trier par %CPU (défaut)
M	Trier par %MEM
T	Trier par temps CPU
N	Trier par PID
c	Afficher la ligne de commande complète
u	Filtrer par utilisateur
1	Afficher tous les CPUs séparément
d	Changer le délai de rafraîchissement

Exemples pratiques

# Surveiller avec un rafraîchissement rapide
$ top -d 0.5

# Surveiller systemd pendant 2 minutes
$ top -p 1 -d 1 -n 120

# Capturer un snapshot dans un fichier
$ top -b -n 1 > top_snapshot.txt

# Surveiller les processus d'un utilisateur
$ top -u www-data

Tuer des processus

La commande kill

kill envoie un signal à un processus identifié par son PID.

# Syntaxe de base
$ kill PID

# Exemples
$ kill 1234
$ kill 5678 9012

Les signaux Linux

Les signaux sont des notifications envoyées aux processus pour déclencher certaines actions.

Par défaut, kill envoie le signal appelé SIGTERM (15) qui demande poliment au processus de se terminer.

Signaux principaux

Signal	Numéro	Nom	Description
SIGHUP	1	Hangup	Terminal fermé
SIGINT	2	Interrupt	Interruption (Ctrl+C)
SIGQUIT	3	Quit	Quitter avec core dump
SIGKILL	9	Kill	Tuer immédiatement (ne peut être intercepté)
SIGTERM	15	Terminate	Terminaison propre (défaut)
SIGSTOP	17/19	Stop	Pause (Ctrl+Z)
SIGCONT	18/20	Continue	Reprendre après pause

# Voir tous les signaux disponibles
$ kill -l

# Consulter le manuel des signaux
$ man 7 signal

Utilisation des signaux

-s permet de spécifier un signal par nom ou numéro mais on peut aussi directement utiliser -SIGNAL ou -NUMERO.

SIGTERM (15) - Signal par défaut

Demande poliment au processus de se terminer. Le processus peut ignorer ce signal ou effectuer un nettoyage avant de s'arrêter.

# Ces commandes sont équivalentes
$ kill 1234
$ kill -15 1234
$ kill -SIGTERM 1234
$ kill -TERM 1234

SIGKILL (9) - Terminaison forcée

Force la terminaison immédiate. Le processus ne peut pas intercepter ce signal. À utiliser en dernier recours !

$ kill -9 1234
$ kill -SIGKILL 1234
$ kill -KILL 1234

SIGINT (2) - Interruption

Équivalent à appuyer sur Ctrl+C dans un terminal.

$ kill -2 1234
$ kill -SIGINT 1234
$ kill -INT 1234

SIGHUP (1) - Hangup

Recharge la configuration de nombreux démons sans les arrêter.

# Recharger la configuration d'un service
$ kill -HUP 1234
$ kill -1 1234

Exemples pratiques

# Terminaison douce
$ kill 1234

# Attendre 5 secondes puis forcer si nécessaire
$ kill 1234 && sleep 5 && kill -9 1234

# Envoyer SIGHUP à Apache pour recharger la config
$ kill -HUP $(pgrep apache2)

La commande killall

killall envoie un signal à tous les processus portant un nom donné.

# Syntaxe
$ killall [options] nom_processus

# Exemples
$ killall firefox
$ killall -9 firefox

Options de killall

# Demander confirmation avant chaque terminaison
$ killall -i firefox

# Tuer les processus d'un utilisateur spécifique
$ killall -u username firefox

# Mode silencieux (pas de message si processus non trouvé)
$ killall -q firefox

# Mode verbeux
$ killall -v firefox

# Tuer les processus plus vieux que X temps
$ killall -o 5h firefox    # Plus de 5 heures
$ killall -o 7d chromium   # Plus de 7 jours

# Tuer les processus plus récents que X temps
$ killall -y 10m firefox   # Moins de 10 minutes
$ killall -y 1w chromium   # Moins d'1 semaine

Unités de temps

• s : secondes
• m : minutes
• h : heures
• d : jours
• w : semaines

Exemples pratiques

# Tuer tous les Firefox avec confirmation
$ killall -i firefox

# Forcer la terminaison de tous les Firefox
$ killall -9 firefox

# Tuer les processus Apache de plus de 1 heure
$ killall -o 1h apache2

# Tuer tous les processus d'un utilisateur
$ killall -u www-data php-fpm

Gestion des priorités

Principe

Les processus Linux ont une priorité qui détermine l'accès aux ressources CPU. La priorité permet de favoriser certains processus importants ou de limiter d'autres moins critiques.

Échelle de priorité :

• Valeurs nice : -20 (priorité la plus élevée) à +19 (priorité la plus basse)
• Valeur par défaut : 0
• Seul root peut définir des valeurs négatives

Plus la valeur est basse, plus le processus est prioritaire !

La commande nice

nice lance un processus avec une priorité spécifiée :

# Syntaxe
$ nice -n VALEUR commande

# Lancer avec priorité basse (+10)
$ nice -n 10 ./script.sh

# Lancer avec priorité très basse (+19)
$ nice -n 19 tar czf backup.tar.gz /data # Processus très gentil

# En tant que root, lancer avec haute priorité (-10)
$ sudo nice -n -10 ./important_process

# Forme courte (sans -n)
$ nice -10 commande     # Équivalent à -n 10

La commande renice

renice modifie la priorité d'un processus en cours d'exécution :

# Syntaxe
$ renice PRIORITÉ -p PID

# Exemples
$ renice 10 -p 1234              # Baisser la priorité
$ sudo renice -5 -p 1234         # Augmenter la priorité (root requis)
$ renice 15 -p 1234 -p 5678      # Modifier plusieurs processus

# Modifier tous les processus d'un utilisateur
$ renice 10 -u username

# Modifier tous les processus d'un groupe
$ renice 10 -g groupname

Exemples pratiques

# Lancer une compilation avec priorité basse
$ nice -n 15 make -j4

# Encoder une vidéo sans ralentir le système
$ nice -n 19 ffmpeg -i input.mp4 output.mp4

# Lancer une sauvegarde de nuit
$ nice -n 19 rsync -av /data /backup

# Réduire la priorité d'un processus existant
$ renice 10 -p $(pgrep firefox)

# Augmenter la priorité d'une base de données (en tant que root)
$ sudo renice -10 -p $(pgrep mysqld)

# Dans top, utiliser 'r' puis entrer le PID et la nouvelle priorité

Surveiller les priorités

# Voir les priorités avec ps
$ ps -eo pid,ni,cmd

# Voir les priorités dans top
# La colonne NI affiche la valeur nice
$ top

Processus en arrière-plan

Lancer un processus en arrière-plan

Le symbole & à la fin d'une commande lance le processus en arrière-plan :

# Lancer en arrière-plan
$ ./long_script.sh &

# Le shell affiche le numéro de job et le PID
# [1] 12345

# Exemples pratiques
$ firefox &
$ gedit fichier.txt &
$ python3 server.py &

Gestion des jobs

# Lister les jobs en arrière-plan
$ jobs

# Sortie typique :
# [1]+  Running    firefox &
# [2]-  Stopped    nano fichier.txt

# Mettre un processus au premier plan
$ fg %1        # Ramener le job 1
$ fg           # Ramener le dernier job

# Mettre un processus en arrière-plan
$ bg %1        # Continuer le job 1 en arrière-plan
$ bg           # Continuer le dernier job

# Suspendre un processus au premier plan
# Ctrl+Z

# Tuer un job
$ kill %1

Le processus nohup

nohup (No Hangup) permet de lancer un processus qui continue même après déconnexion :

# Lancer avec nohup
$ nohup ./script.sh &

# La sortie est redirigée vers nohup.out
$ nohup ./script.sh > output.log 2>&1 &

# Vérifier le processus
$ jobs
$ ps aux | grep script.sh

Détacher complètement un processus

# Méthode 1 : nohup + & + exit
$ nohup commande > /dev/null 2>&1 &
$ exit

# Méthode 2 : disown
$ commande &
$ disown

# Méthode 3 : screen ou tmux
$ screen -dmS session_name commande
$ tmux new-session -d -s session_name 'commande'

Commandes supplémentaires

htop - Version améliorée de top

# Installer htop (si nécessaire)
$ sudo apt install htop   # Debian/Ubuntu
$ sudo dnf install htop   # Fedora
$ sudo pacman -S htop     # Arch

# Lancer htop
$ htop

# Avantages :
# - Interface colorée et plus intuitive
# - Navigation avec les flèches
# - Sélection visuelle des processus
# - Affichage en arbre facile
# - Actions directes (F9=kill, F7/F8=nice)

pidof - Trouver le PID d'un programme

# Trouver le PID de Firefox
$ pidof firefox

# Tuer tous les Firefox trouvés
$ kill $(pidof firefox)

watch - Exécuter périodiquement

# Surveiller les processus toutes les 2 secondes
$ watch "ps aux | grep firefox"

# Surveiller l'utilisation mémoire
$ watch -n 1 free -h

# Surveiller avec mise en évidence des changements
$ watch -d -n 1 "ps aux --sort=-%cpu | head -20"

Exemples pratiques d'administration

Surveiller un système

# Processus consommant le plus de CPU
$ ps aux --sort=-%cpu | head -20

# Processus consommant le plus de mémoire
$ ps aux --sort=-%mem | head -20

# Surveiller un processus spécifique
$ watch -n 1 "ps aux | grep apache2"

Nettoyer le système

# Tuer tous les processus d'un utilisateur (avec précaution!)
$ pkill -u username

# Redémarrer proprement un service bloqué
$ killall -TERM service_name
$ sleep 5
$ killall -KILL service_name

Gestion des ressources

# Limiter un processus gourmand
$ renice 19 -p $(pgrep process_name)

# Lancer une tâche lourde sans impacter le système
$ nice -n 19 ./heavy_task.sh &

# Surveiller l'impact d'un processus
$ top -p $(pgrep process_name)

Bonnes pratiques 🤹‍♂️

Sécurité

1. Toujours vérifier avant de tuer

# Vérifier d'abord
$ ps aux | grep processus
# Puis tuer
$ kill PID

2. Préférer SIGTERM avant SIGKILL

$ kill PID          # Essayer d'abord
$ sleep 5
$ kill -9 PID       # Forcer si nécessaire

3. Ne jamais tuer PID 1 (systemd/init)

# JAMAIS faire ceci !
$ kill -9 1

Performance

1. Surveiller régulièrement

# Créer un rapport quotidien
$ top -b -n 1 > /var/log/top-$(date +%Y%m%d).log

2. Identifier les processus actifs depuis longtemps

# Processus actifs depuis longtemps
$ ps -eo pid,etime,cmd --sort=-etime | head -20

# Exemple de sortie :
#   PID     ELAPSED CMD
#     1 108-01:45:54 /sbin/init
#     2 108-01:45:54 [kthreadd]
#  1234    05:23:12 firefox
#  5678       45:30 python script.py

Note sur le format ELAPSED : Le temps affiché suit le format [[JOURS-]HEURES:]MINUTES:SECONDES

• 108-01:45:54 = 108 jours, 1 heure, 45 minutes, 54 secondes
• 05:23:12 = 5 heures, 23 minutes, 12 secondes
• 45:30 = 45 minutes, 30 secondes

3. Utiliser nice pour les tâches lourdes

$ nice -n 19 tar czf backup.tar.gz /data

Pratique 💃

Exercice 1 : Surveillance de base

1. Affichez tous les processus en cours

$ ps aux

2. Trouvez les 5 processus utilisant le plus de CPU

$ ps aux --sort=-%cpu | head -6

3. Trouvez les 5 processus utilisant le plus de mémoire

$ ps aux --sort=-%mem | head -6

4. Affichez l'arbre des processus

$ pstree -p

5. Ouvrez 3 terminaux et dans l'un d'entre eux, affichez les processus bash avec la commande pgrep. Affichez les PIDs et les noms des processus.

$ pgrep -l bash

Exercice 2 : Gestion des processus

1. Lancez le processus sleep en arrière-plan avec une durée de 300 secondes (sleep --help pour voir les options)

$ sleep 300 &

2. Listez les jobs actifs

$ jobs

3. Suspendez le processus (Ctrl+Z)

# Appuyez sur Ctrl+Z dans le terminal où le processus est lancé

4. Remettez-le en arrière-plan

$ bg %1

5. Tuez le processus proprement

$ kill %1

Exercice 3 : Priorités

1. Lancez une commande avec une priorité basse

$ nice -n 10 sleep 300 &

2. Modifiez la priorité d'un processus existant

$ renice 5 -p PID

3. Surveillez les changements dans top

$ top

Exercice 4 : Recherche avancée

1. Trouvez tous les processus d'un utilisateur

$ ps -u username

2. Comptez le nombre de processus par état

$ ps -eo stat | sort | uniq -c

3. Trouvez les processus zombies (s'il y en a)

$ ps aux | grep 'Z'

4. Affichez les processus avec les plus récents en premier (10 premiers)

$ ps -eo pid,etime,cmd --sort=etime | head

Références

• man ps - Manuel de la commande ps
• man top - Manuel de la commande top
• man kill - Manuel de la commande kill
• man 7 signal - Manuel des signaux Linux
• man nice - Manuel de la commande nice
• man renice - Manuel de la commande renice

Quiz 🎉

👋🏾 Cliquez sur la bonne réponse.

1 / 20 👉🏾 Qu'est-ce qu'un processus sous Linux ?

• A. Un fichier exécutable sur le disque

• B. Un programme en cours d'exécution en mémoire

• C. Un utilisateur connecté au système

• D. Un script shell