Introduction
Dans les systèmes Linux, la gestion efficace des processus est essentielle pour maintenir la stabilité et les performances du système. Bien que la commande kill permette de terminer un processus en utilisant un identifiant de processus (PID - Process ID) spécifique, il existe des situations où vous devez terminer plusieurs processus en fonction de motifs. C'est là que la commande pkill devient inestimable.
Ce laboratoire (LabEx) se concentre sur l'utilisation de la commande pkill pour terminer des processus en fonction de leur nom, de leurs arguments ou d'autres critères. Vous apprendrez à identifier les processus en cours d'exécution, à les terminer de manière sélective en utilisant la correspondance de motifs et à vérifier les résultats de vos opérations. Ces compétences sont essentielles pour l'administration système et la résolution de problèmes dans les environnements Linux.
Comprendre la gestion des processus et la terminaison de processus de base
Dans cette première étape, nous allons explorer comment identifier les processus en cours d'exécution et les terminer en utilisant une correspondance de motifs de base. Linux propose plusieurs commandes pour la gestion des processus, notamment ps, pgrep et pkill.
Création de processus de test
Commençons par créer un script simple que nous pouvons exécuter en arrière - plan. Nous allons créer plusieurs instances de ce script pour simuler un scénario où vous devez terminer plusieurs processus similaires.
Tout d'abord, accédez au répertoire du projet et créez un script appelé rogue_app.sh :
cd ~/project
nano rogue_app.sh
Ajoutez le contenu suivant au script :
#!/bin/bash
while true; do
echo "Process running with PID $$"
sleep 5
done
Ce script exécute une boucle infinie, affichant son identifiant de processus (PID - Process ID) toutes les 5 secondes.
Maintenant, rendez le script exécutable :
chmod +x ~/project/rogue_app.sh
Exécutons plusieurs instances de ce script en arrière - plan :
for i in {1..5}; do
~/project/rogue_app.sh &
done
Le symbole & à la fin de la commande exécute chaque instance du script en arrière - plan, vous permettant de continuer à utiliser le terminal.
Affichage des processus en cours d'exécution
Pour voir les processus que vous venez de démarrer, utilisez la commande ps avec les options appropriées :
ps aux | grep rogue_app.sh
La sortie ressemblera à ceci :
labex 12345 0.0 0.0 2308 580 pts/0 S 10:00 0:00 /bin/bash /home/labex/project/rogue_app.sh
labex 12346 0.0 0.0 2308 580 pts/0 S 10:00 0:00 /bin/bash /home/labex/project/rogue_app.sh
labex 12347 0.0 0.0 2308 580 pts/0 S 10:00 0:00 /bin/bash /home/labex/project/rogue_app.sh
labex 12348 0.0 0.0 2308 580 pts/0 S 10:00 0:00 /bin/bash /home/labex/project/rogue_app.sh
labex 12349 0.0 0.0 2308 580 pts/0 S 10:00 0:00 /bin/bash /home/labex/project/rogue_app.sh
labex 12350 0.0 0.0 2432 584 pts/0 S+ 10:00 0:00 grep --color=auto rogue_app.sh
Notez que les PID réels (les nombres dans la deuxième colonne) seront différents sur votre système.
Terminaison de processus avec pkill
Maintenant, utilisons la commande pkill pour terminer toutes les instances de notre script :
pkill -f rogue_app.sh
L'option -f indique à pkill de faire correspondre la ligne de commande complète, pas seulement le nom du processus. Cela est important car lorsqu'un script s'exécute, le nom du processus est souvent l'interpréteur (comme /bin/bash) plutôt que le nom du script.
Vérifiez que toutes les instances du script ont été terminées :
ps aux | grep rogue_app.sh
Vous devriez maintenant voir seulement la commande grep elle - même dans la sortie :
labex 12351 0.0 0.0 2432 584 pts/0 S+ 10:01 0:00 grep --color=auto rogue_app.sh
Cela confirme que toutes les instances de rogue_app.sh ont été terminées avec succès.
Terminaison sélective de processus avec correspondance de motifs
Dans les scénarios réels, vous avez souvent besoin d'être plus sélectif quant aux processus à terminer. La commande pkill vous permet d'utiliser la correspondance de motifs pour cibler des processus spécifiques en fonction de divers critères.
Création de processus avec différents arguments
Créons un nouveau script que nous exécuterons avec différents arguments de ligne de commande :
cd ~/project
nano service_worker.sh
Ajoutez le contenu suivant au script :
#!/bin/bash
while true; do
echo "Running service worker with argument: $1"
sleep 5
done
Rendez le script exécutable :
chmod +x ~/project/service_worker.sh
Maintenant, exécutons plusieurs instances de ce script avec différents arguments :
~/project/service_worker.sh normal &
~/project/service_worker.sh normal &
~/project/service_worker.sh --malfunctioning &
~/project/service_worker.sh --malfunctioning &
~/project/service_worker.sh emergency &
Cela crée cinq processus en arrière - plan : deux travailleurs ("workers") "normaux", deux travailleurs "dysfonctionnels" et un travailleur "en urgence".
Affichage des processus avec différents arguments
Vérifiez les processus en cours d'exécution :
ps aux | grep service_worker.sh
Vous devriez voir une sortie similaire à :
labex 12360 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex 12361 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex 12362 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh --malfunctioning
labex 12363 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh --malfunctioning
labex 12364 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh emergency
labex 12365 0.0 0.0 2432 584 pts/0 S+ 10:05 0:00 grep --color=auto service_worker.sh
Terminaison sélective avec correspondance de motifs
Maintenant, terminons sélectivement uniquement les processus avec l'argument --malfunctioning :
pkill -f "service_worker.sh --malfunctioning"
L'option -f garantit que pkill effectue la correspondance sur la ligne de commande complète, y compris les arguments.
Vérifiez que seuls les processus ciblés ont été terminés :
ps aux | grep service_worker.sh
Vous devriez maintenant voir seulement les processus "normaux" et "en urgence" :
labex 12360 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex 12361 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh normal
labex 12364 0.0 0.0 2308 580 pts/0 S 10:05 0:00 /bin/bash /home/labex/project/service_worker.sh emergency
labex 12366 0.0 0.0 2432 584 pts/0 S+ 10:06 0:00 grep --color=auto service_worker.sh
Cela démontre comment vous pouvez terminer sélectivement des processus en fonction de motifs spécifiques dans leurs lignes de commande.
Terminons maintenant tous les processus de travailleurs de service restants :
pkill -f service_worker.sh
Vérifiez que tous les processus de travailleurs de service ont été terminés :
ps aux | grep service_worker.sh
Vous devriez maintenant voir seulement la commande grep elle - même :
labex 12367 0.0 0.0 2432 584 pts/0 S+ 10:07 0:00 grep --color=auto service_worker.sh
Options avancées de terminaison de processus
Dans cette étape, nous allons explorer quelques options avancées de la commande pkill qui permettent une gestion des processus plus sophistiquée.
Utilisation de Différents Types de Signaux
Par défaut, pkill envoie le signal SIGTERM (signal 15) aux processus. Ce signal permet aux processus de se terminer proprement, en fermant les fichiers et en effectuant les opérations de nettoyage. Cependant, il existe des cas où vous pourriez vouloir utiliser un signal différent.
Créons un script qui gère les signaux :
cd ~/project
nano signal_handler.sh
Ajoutez le contenu suivant au script :
#!/bin/bash
trap 'echo "Received SIGHUP (1)"; exit 0' SIGHUP
trap 'echo "Received SIGINT (2)"; exit 0' SIGINT
trap 'echo "Received SIGTERM (15)"; exit 0' SIGTERM
echo "Process started with PID $$"
echo "Use: pkill -[signal] -f signal_handler.sh to send signals"
while true; do
sleep 1
done
Rendez le script exécutable :
chmod +x ~/project/signal_handler.sh
Exécutez le script en arrière-plan :
~/project/signal_handler.sh &
Maintenant, essayons d'envoyer différents signaux au processus :
- Envoyez un signal SIGHUP (signal 1) :
pkill -HUP -f signal_handler.sh
- Relancez le script et envoyez SIGINT (signal 2) :
~/project/signal_handler.sh &
pkill -INT -f signal_handler.sh
- Relancez le script et envoyez le SIGTERM par défaut (signal 15) :
~/project/signal_handler.sh &
pkill -f signal_handler.sh ## Default is SIGTERM
Pour chaque signal, vous devriez voir le message correspondant dans la sortie du terminal avant que le processus ne se termine.
Terminer des Processus par Âge
pkill vous permet de cibler des processus en fonction de leur âge en utilisant l'option --newest, qui sélectionne les processus démarrés le plus récemment.
Créons quelques processus avec des heures de démarrage différentes :
cd ~/project
nano age_test.sh
Ajoutez le contenu suivant au script :
#!/bin/bash
while true; do
echo "Process running with PID $$"
sleep 5
done
Rendez le script exécutable :
chmod +x ~/project/age_test.sh
Démarrez le premier processus :
~/project/age_test.sh &
Attendez quelques secondes, puis démarrez deux processus supplémentaires :
sleep 5
~/project/age_test.sh &
~/project/age_test.sh &
Maintenant, terminons uniquement les deux processus démarrés le plus récemment en utilisant l'option --newest :
pkill -f --newest 2 age_test.sh
Vérifiez quels processus sont toujours en cours d'exécution :
ps aux | grep age_test.sh
Vous ne devriez voir que le premier processus toujours en cours d'exécution, car il a été démarré avant les deux autres processus.
Terminez le processus restant :
pkill -f age_test.sh
Limiter pkill par Propriétaire du Processus
Vous pouvez également limiter les actions de pkill aux processus appartenant à un utilisateur spécifique. Dans un système multi-utilisateur, ceci est particulièrement utile.
À des fins de démonstration, exécutons quelques processus en tant qu'utilisateur actuel :
~/project/rogue_app.sh &
~/project/rogue_app.sh &
Maintenant, terminons ces processus, mais uniquement ceux appartenant à votre utilisateur actuel :
pkill -f -u $(whoami) rogue_app.sh
L'option -u spécifie le nom d'utilisateur du propriétaire du processus. La substitution de commande $(whoami) récupère votre nom d'utilisateur actuel.
Vérifiez que tous les processus ont été terminés :
ps aux | grep rogue_app.sh
Vous ne devriez voir que la commande grep elle-même dans la sortie.
Cette capacité à cibler des processus par propriétaire est particulièrement utile dans les environnements multi-utilisateurs où vous souhaitez éviter d'affecter les processus appartenant à d'autres utilisateurs.
Résumé
Dans ce laboratoire (lab), vous avez appris à utiliser la commande pkill pour gérer les processus dans un environnement Linux. Cette commande puissante vous permet de terminer des processus en fonction de divers critères, ce qui en fait un outil essentiel pour l'administration système.
Concepts clés abordés :
Terminaison de processus de base : Vous avez appris à identifier les processus en cours d'exécution à l'aide de la commande
pset à les terminer en utilisantpkillavec une correspondance de motifs de base.Terminaison sélective de processus : Vous avez exploré comment utiliser la correspondance de motifs pour cibler sélectivement des processus en fonction de leurs arguments de ligne de commande, permettant un contrôle précis sur les processus à terminer.
Options avancées de terminaison de processus : Vous avez découvert les options avancées de
pkill, notamment :- Comment envoyer différents types de signaux aux processus
- Comment terminer des processus en fonction de leur âge
- Comment limiter la portée de
pkillaux processus appartenant à un utilisateur spécifique
Ces compétences sont précieuses pour maintenir la stabilité du système, gérer les ressources et résoudre les problèmes dans les environnements Linux. En maîtrisant la commande pkill, vous avez ajouté un outil important à votre boîte à outils d'administration système Linux.
