Terminaison de processus Linux

Introduction

Dans ce laboratoire (lab), vous allez apprendre les compétences essentielles de gestion des processus Linux, en vous concentrant sur la façon d'identifier et de terminer les processus. La gestion des processus est une compétence fondamentale pour tout utilisateur ou administrateur Linux, car elle vous permet de gérer efficacement les ressources du système.

Vous allez apprendre à utiliser la commande ps pour identifier les processus en cours d'exécution et la commande kill pour les terminer si nécessaire. Ces outils sont essentiels pour maintenir les performances du système et gérer les applications non réactives.

À la fin de ce laboratoire, vous serez en mesure d'identifier les processus, de comprendre leurs attributs et de les terminer en utilisant diverses méthodes. Ces compétences sont précieuses pour la résolution de problèmes et la gestion efficace des systèmes Linux.

Identification des processus

Sous Linux, chaque programme ou application en cours d'exécution est considéré comme un processus. Chaque processus a un identifiant unique appelé Process ID (PID). Avant de pouvoir terminer un processus, vous devez le identifier en utilisant son PID.

Commençons par apprendre à afficher les processus en cours d'exécution à l'aide de la commande ps. Cette commande affiche des informations sur les processus actifs dans votre système.

Tout d'abord, ouvrez un terminal dans l'environnement de la machine virtuelle (VM) LabEx et exécutez la commande suivante :

ps

Vous verrez une liste de base des processus en cours d'exécution dans votre session de terminal actuelle. La sortie devrait ressembler à ceci :

  PID TTY          TIME CMD
 2104 pts/0    00:00:00 zsh
 2116 pts/0    00:00:00 ps

Cette sortie montre :

• PID : Le numéro d'identifiant de processus
• TTY : Le type de terminal sur lequel le processus s'exécute
• TIME : La quantité de temps CPU utilisée par le processus
• CMD : La commande qui a lancé le processus

Pour voir une liste plus complète de tous les processus en cours d'exécution sur le système, utilisez la commande suivante avec des options supplémentaires :

ps -aux

Les options signifient :

• -a : Afficher les processus de tous les utilisateurs
• -u : Afficher un format détaillé axé sur l'utilisateur
• -x : Inclure les processus sans terminal de contrôle

La sortie sera beaucoup plus longue et plus détaillée, affichant tous les processus en cours d'exécution sur le système :

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.1 167936 11876 ?        Ss   10:30   0:01 /sbin/init
root           2  0.0  0.0      0     0 ?        S    10:30   0:00 [kthreadd]
...
labex       2104  0.0  0.1  11108  5456 pts/0    Ss   10:35   0:00 zsh
labex       2130  0.0  0.0   9828  3384 pts/0    R+   10:36   0:00 ps -aux

Maintenant, créons un simple processus en arrière-plan que nous pourrons utiliser pour l'entraînement :

sleep 300 &
sleep_pid=$!

Cette commande lance un processus qui "dort" (ne fait rien) pendant 300 secondes (5 minutes). Le symbole & le lance en arrière-plan, et $! capture le PID du dernier processus en arrière-plan lancé.

Vérifions que le processus est en cours d'exécution :

echo "The sleep process ID is: $sleep_pid"
ps | grep sleep

Vous devriez voir une sortie similaire à :

The sleep process ID is: 2135
 2135 pts/0    00:00:00 sleep

Maintenant, vous savez comment identifier les processus et trouver leurs PIDs. Dans l'étape suivante, nous apprendrons à terminer ce processus.

Terminaison de processus avec 'kill'

Maintenant que vous avez identifié un processus et son PID, vous pouvez apprendre à le terminer en utilisant la commande kill. La commande kill envoie un signal à un processus pour lui indiquer de se terminer.

La syntaxe de base de la commande kill est la suivante :

kill [options] <PID>

Terminons le processus sleep que nous avons créé à l'étape précédente. Nous avons stocké son PID dans la variable $sleep_pid. Utilisez la commande suivante pour le terminer :

kill $sleep_pid

Si vous avez oublié le PID, vous pouvez le retrouver en utilisant :

ps | grep sleep

Après avoir exécuté la commande kill, vérifiez que le processus a été terminé :

ps | grep sleep

Si le processus a été terminé avec succès, vous ne devriez voir aucune sortie ou seulement le processus grep lui-même dans la sortie. Cela signifie que le processus sleep n'est plus en cours d'exécution.

Si vous voulez être rigoureux, vous pouvez utiliser à nouveau la commande ps pour lister tous les processus :

ps -aux | grep sleep

Cela pourrait afficher quelque chose comme :

labex       2156  0.0  0.0   7236   720 pts/0    S+   10:40   0:00 grep --color=auto sleep

Le seul processus affiché est la commande grep elle-même, ce qui indique que le processus sleep a été terminé.

Par défaut, la commande kill envoie un signal TERM (terminer) au processus, ce qui permet au processus de se terminer proprement après avoir effectué toutes les opérations de nettoyage. Dans la plupart des cas, cela suffit pour terminer un processus.

Vous avez maintenant identifié et terminé avec succès un processus en utilisant la commande kill, ce qui est une compétence fondamentale pour la gestion des processus sous Linux.

Comprendre les signaux de kill

Sous Linux, la commande kill peut envoyer différents types de signaux aux processus, pas seulement des signaux de terminaison. Comprendre ces signaux vous donne plus de contrôle sur la façon dont les processus sont terminés.

Tout d'abord, affichons tous les signaux disponibles en exécutant :

kill -l

Cela affichera tous les signaux que la commande kill peut envoyer. La sortie ressemble à ceci :

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
...

Les signaux les plus couramment utilisés sont :

• SIGTERM (15) : Signal par défaut envoyé par la commande kill. Demande au processus de se terminer proprement.
• SIGKILL (9) : Force le processus à se terminer immédiatement. Utilisez-le lorsque le processus ne répond pas au SIGTERM.
• SIGHUP (1) : Traditionnellement utilisé pour réinitialiser ou recharger les fichiers de configuration.
• SIGINT (2) : Envoyé lorsque vous appuyez sur Ctrl+C dans le terminal.

Créons un autre processus sleep pour pratiquer :

sleep 300 &
sleep_pid=$!
echo "The new sleep process ID is: $sleep_pid"

Maintenant, envoyons un signal spécifique au processus en utilisant le numéro du signal :

kill -15 $sleep_pid

Cela équivaut à la commande kill par défaut car elle envoie le SIGTERM (signal 15).

Vérifions que le processus a été terminé :

ps | grep sleep

Créons encore un autre processus sleep pour démontrer le signal SIGKILL :

sleep 300 &
sleep_pid=$!
echo "The third sleep process ID is: $sleep_pid"

Maintenant, utilisons le signal SIGKILL pour forcer la terminaison du processus :

kill -9 $sleep_pid

Vérifions que le processus a été terminé :

ps | grep sleep

Le signal SIGKILL (9) est une option de "dernier recours" car :

1. Il ne permet pas au processus de se nettoyer lui-même
2. Il peut laisser des ressources dans un état incohérent
3. Il peut entraîner une perte de données si le processus était en train d'écrire des données

Essayez toujours le SIGTERM en premier, et n'utilisez le SIGKILL que si le processus ne répond pas au SIGTERM.

Gestion avancée des processus

Linux propose des commandes supplémentaires pour gérer les processus en plus des commandes de base ps et kill. Ces outils offrent plus de flexibilité et de commodité pour identifier et terminer des processus.

La commande pgrep

La commande pgrep vous permet de trouver des processus par leur nom plutôt que de devoir examiner visuellement la sortie de ps :

pgrep sleep

Cette commande trouvera tous les processus dont le nom contient "sleep" et affichera leurs PID.

La commande pkill

La commande pkill combine les fonctionnalités de pgrep et de kill - elle trouve des processus par leur nom et leur envoie un signal :

## Démarrer deux processus sleep
sleep 300 &
sleep 300 &

## Tuer tous les processus sleep
pkill sleep

Vérifiez que tous les processus sleep ont été terminés :

ps | grep sleep

La commande killall

À l'instar de pkill, la commande killall termine des processus par leur nom :

## Démarrer deux autres processus sleep
sleep 300 &
sleep 300 &

## Tuer tous les processus sleep
killall sleep

Vérifiez encore une fois :

ps | grep sleep

Priorité des processus avec nice et renice

Linux vous permet également de contrôler la priorité des processus en utilisant les commandes nice et renice.

Démarrons un processus avec une priorité plus basse :

nice -n 10 sleep 300 &

La valeur de nice va de -20 (priorité la plus élevée) à 19 (priorité la plus basse). La valeur par défaut est 0. Seul l'utilisateur root peut définir des valeurs de nice négatives.

Vous pouvez modifier la priorité d'un processus en cours d'exécution en utilisant renice :

sleep_pid=$!
echo "Sleep process ID with lower priority: $sleep_pid"
renice -n 15 -p $sleep_pid

Vérifions la nouvelle priorité :

ps -o pid,nice,cmd -p $sleep_pid

Enfin, terminons ce processus :

kill $sleep_pid

Ces commandes avancées de gestion des processus offrent des moyens plus efficaces de gérer plusieurs processus et de contrôler les ressources système, ce qui est particulièrement utile sur les systèmes chargés ou lors de la résolution de problèmes de performance.

Résumé

Dans ce laboratoire, vous avez appris des compétences essentielles en gestion des processus Linux, qui sont précieuses pour l'administration système et la résolution de problèmes :

1. Identification des processus : Vous avez appris à utiliser la commande ps pour lister les processus en cours d'exécution et trouver leurs identifiants de processus (PID, de l'anglais Process ID).

2. Terminaison des processus : Vous avez pratiqué l'utilisation de la commande kill pour envoyer des signaux de terminaison aux processus en utilisant leurs PID.

3. Compréhension des signaux de kill : Vous avez exploré différents types de signaux qui peuvent être envoyés aux processus, notamment SIGTERM (15) pour une terminaison propre et SIGKILL (9) pour une terminaison forcée.

4. Gestion avancée des processus : Vous avez découvert des outils plus puissants tels que pgrep, pkill et killall pour trouver et terminer des processus par leur nom, ainsi que comment contrôler la priorité des processus avec nice et renice.

Ces compétences vous permettent de :

• Surveiller efficacement les processus du système
• Terminer les applications non réactives
• Gérer les ressources du système
• Résoudre les problèmes de performance

La gestion des processus est un aspect fondamental de l'administration système Linux, et les commandes que vous avez apprises dans ce laboratoire sont utilisées quotidiennement par les administrateurs et les utilisateurs Linux pour maintenir les performances et la stabilité du système.