Gestion des processus sous Linux : Terminer des processus avec kill, killall et pkill

Introduction

Dans ce laboratoire, vous apprendrez à terminer des processus sous Linux en utilisant les commandes kill, killall et pkill. Ces commandes sont essentielles pour gérer les processus en cours d'exécution et peuvent être utilisées pour arrêter les applications non réactives ou libérer des ressources système.

À la fin de ce laboratoire, vous serez en mesure de :

Utiliser la commande kill pour terminer un processus spécifique
Utiliser la commande killall pour terminer plusieurs processus par nom
Utiliser la commande pkill comme alternative à killall

Comprendre les identifiants de processus et les signaux

Avant de commencer à terminer des processus, il est important de comprendre deux concepts clés : les identifiants de processus (Process IDs - PIDs) et les signaux.

Ouvrez un terminal dans votre machine virtuelle Ubuntu. Vous devriez être par défaut dans le répertoire /home/labex/project. Si vous n'êtes pas sûr, vous pouvez toujours vérifier votre répertoire actuel en tapant pwd puis en appuyant sur Entrée.
Commençons par exécuter un simple processus en arrière - plan. Entrez la commande suivante :
```
sleep 1000 &
```
Cette commande lance un processus qui va dormir pendant 1000 secondes et l'exécute en arrière - plan. Le symbole & à la fin indique au shell d'exécuter la commande en arrière - plan, vous permettant de continuer à utiliser le terminal.
Pour voir les processus en cours d'exécution, utilisez la commande ps :
```
ps aux | grep sleep
```
Cette commande affiche tous les processus en cours d'exécution (ps aux) puis filtre la sortie pour n'afficher que les lignes contenant "sleep" (grep sleep).

Vous devriez voir une sortie similaire à celle - ci :

Terminal montrant le processus sleep

Le nombre dans la deuxième colonne est l'identifiant de processus (PID). Nous l'utiliserons plus tard pour terminer le processus.

Linux utilise des signaux pour communiquer avec les processus. Les signaux les plus courants pour terminer des processus sont :
- SIGTERM (15) : Termine le processus de manière gracieuse. C'est le signal par défaut envoyé par la commande kill.
- SIGKILL (9) : Tue le processus de force. Cela devrait être utilisé en dernier recours lorsque SIGTERM ne fonctionne pas.

Maintenant que nous comprenons les PIDs et les signaux, nous sommes prêts à passer à l'utilisation de la commande kill.

Utilisation de la commande kill

La commande kill est utilisée pour envoyer un signal à un processus spécifique, identifié par son PID. Par défaut, elle envoie le signal SIGTERM, qui demande au processus de se terminer de manière gracieuse.

Terminons le processus sleep que nous avons lancé précédemment. Tout d'abord, trouvez son PID en utilisant la commande ps :
```
ps aux | grep sleep
```
Notez le PID du processus sleep. Ce sera un nombre dans la deuxième colonne de la sortie.
Maintenant, utilisez la commande kill pour terminer le processus :
```
kill <PID>
```
Remplacez <PID> par l'identifiant de processus réel que vous avez noté. Par exemple, si le PID est 1234, vous taperiez kill 1234.
Vérifiez si le processus est toujours en cours d'exécution :
```
ps aux | grep sleep
```
Vous ne devriez plus voir le processus sleep dans la sortie, sauf pour la commande grep elle - même.

Si le processus est toujours en cours d'exécution (ce qui est peu probable pour une simple commande sleep, mais possible pour des applications plus complexes), vous pouvez utiliser un signal plus puissant :

kill -9 <PID>

Terminaison d'un processus avec la commande kill

Cela envoie le signal SIGKILL, qui termine le processus de force. Soyez prudent avec SIGKILL car il ne permet pas au processus de nettoyer ses ressources, ce qui peut entraîner une perte de données ou d'autres problèmes dans des applications plus complexes.

Utilisation de la commande killall

La commande killall vous permet de terminer des processus par leur nom, ce qui peut être plus pratique que d'utiliser les PIDs, surtout lorsque vous avez plusieurs instances du même programme en cours d'exécution.

Lancez plusieurs processus sleep :
```
sleep 2000 &
sleep 2000 &
sleep 2000 &
```
Cette commande lance trois processus sleep distincts, chacun s'exécutant pendant 2000 secondes en arrière - plan.
Vérifiez que les processus sont en cours d'exécution :
```
ps aux | grep sleep
```
Vous devriez voir trois processus sleep répertoriés.
Maintenant, utilisez la commande killall pour terminer tous les processus sleep :
```
sudo killall sleep
```
Nous utilisons sudo ici car killall peut avoir besoin de privilèges élevés pour terminer des processus lancés par d'autres utilisateurs ou des processus système. Vous pouvez être invité à entrer votre mot de passe.
Vérifiez que les processus ont été terminés :
```
ps aux | grep sleep
```
Vous ne devriez plus voir aucun processus sleep dans la sortie, sauf pour la commande grep elle - même.

Si vous recevez une erreur "Operation not permitted" (Opération non autorisée), cela signifie que vous n'avez pas les autorisations nécessaires pour tuer certains processus. Dans ce cas, utiliser sudo comme indiqué ci - dessus devrait résoudre le problème.

Utilisation de la commande pkill

La commande pkill est une autre façon de terminer des processus par leur nom, similaire à killall. Elle est particulièrement utile lorsque vous souhaitez terminer des processus en fonction de correspondances partielles de noms.

Lancez quelques autres processus sleep :
```
sleep 3000 &
sleep 3000 &
sleep 3000 &
```
Cela lance trois autres processus sleep, chacun s'exécutant pendant 3000 secondes en arrière - plan.
Utilisez la commande pkill pour terminer ces processus :
```
sudo pkill sleep
```
Comme avec killall, nous utilisons sudo pour nous assurer que nous avons les autorisations nécessaires pour terminer tous les processus correspondants.
Vérifiez que les processus ont été terminés :
```
ps aux | grep sleep
```
Vous ne devriez pas voir de processus sleep dans la sortie, sauf pour la commande grep elle - même.

La principale différence entre pkill et killall est que pkill peut correspondre à un nom de processus partiel. Par exemple, pkill fire tuerait à la fois les processus firefox et firebird. Cela peut être à la fois puissant et dangereux, donc vérifiez toujours vos commandes pkill avant de les exécuter.

Entraînement avec des applications réelles

Maintenant que vous avez appris à utiliser kill, killall et pkill, pratiquons avec une application réelle. Nous utiliserons Firefox comme exemple. Vous devez effectuer cette étape dans un environnement de bureau.

Exemple de terminaison du processus Firefox

Lancez le navigateur web Firefox :
```
firefox &
```
Cette commande lance Firefox en arrière - plan. Vous devriez voir la fenêtre de Firefox s'ouvrir sur votre bureau.
Utilisez la commande ps pour trouver le PID de Firefox :
```
ps aux | grep firefox
```
Notez le PID du processus principal de Firefox. Il sera généralement le premier processus Firefox répertorié.
Utilisez la commande kill pour terminer Firefox :
```
kill <PID>
```
Remplacez <PID> par l'identifiant de processus réel de Firefox que vous avez noté.
Si Firefox ne se ferme pas (ce qui est possible car certaines applications capturent le signal SIGTERM), essayez d'utiliser le signal SIGKILL :
```
kill -9 <PID>
```
Rappelez - vous que SIGKILL doit être utilisé en dernier recours car il ne permet pas à l'application de sauvegarder son état ou de se nettoyer correctement.
Alternativement, vous pouvez utiliser killall ou pkill :
```
sudo killall firefox
```
ou
```
sudo pkill firefox
```
Ces commandes termineront tous les processus Firefox d'un coup, ce qui peut être plus pratique que de tuer les processus un par un.

Rappelez - vous que la terminaison forcée d'applications peut entraîner une perte de données, il est donc toujours préférable de fermer les applications normalement lorsque cela est possible. Ces commandes doivent être utilisées lorsque une application ne répond pas ou lorsque vous avez besoin de libérer rapidement des ressources système.

Résumé

Félicitations! Vous avez réussi ce laboratoire sur la terminaison de processus sous Linux. Vous avez appris à :

Utiliser la commande kill pour terminer un processus spécifique en utilisant son PID
Utiliser la commande killall pour terminer plusieurs processus par leur nom
Utiliser la commande pkill comme alternative à killall
Appliquer ces commandes à la fois aux processus simples en arrière - plan et aux applications réelles

Rappelez - vous que, bien que ces commandes soient des outils puissants pour la gestion des processus, utilisez - les avec prudence. La terminaison de processus système critiques peut entraîner une instabilité du système. Vérifiez toujours le processus que vous allez terminer avant d'utiliser ces commandes.

Au fur et à mesure de votre progression dans le monde de Linux, vous trouverez que ces compétences en gestion de processus sont inestimables pour maintenir un système fonctionnant sans accroc et pour résoudre les problèmes. Continuez à pratiquer ces commandes pour vous sentir plus à l'aise avec la gestion des processus sous Linux!

Terminer des processus sous Linux