Gestion des tâches Linux

Introduction

Dans ce laboratoire (lab), vous apprendrez les bases de la gestion des tâches (jobs) sous Linux. La gestion des tâches est une compétence essentielle pour les utilisateurs Linux, car elle vous permet d'exécuter plusieurs processus simultanément et de contrôler leur exécution. En maîtrisant la gestion des tâches, vous pouvez exécuter efficacement des commandes en arrière-plan, basculer entre les tâches en premier plan et en arrière-plan, et maintenir le contrôle sur tous les processus en cours d'exécution.

Au cours de ce laboratoire, vous apprendrez :

• Comment démarrer des processus en arrière-plan
• Comment afficher et gérer les tâches en cours d'exécution
• Comment ramener des tâches en arrière-plan au premier plan
• Comment suspendre des tâches en cours d'exécution et les reprendre plus tard
• Comment terminer des tâches lorsqu'elles ne sont plus nécessaires

Ces compétences sont particulièrement utiles lorsque vous travaillez avec des tâches longues qui ne nécessitent pas d'interaction constante, vous permettant de continuer à travailler sur d'autres tâches tandis que les processus s'exécutent en arrière-plan.

Démarrer et gérer les tâches en arrière-plan

Dans cette étape, vous apprendrez comment démarrer un processus en arrière-plan en utilisant le symbole esperluette (&) et comment le gérer à l'aide de la commande jobs.

Qu'est-ce qu'une tâche en arrière-plan ?

Sous Linux, une tâche (job) est un processus géré par le shell. Par défaut, lorsque vous exécutez une commande dans un terminal, elle s'exécute en premier plan - cela signifie que votre terminal est occupé jusqu'à la fin de l'exécution de la commande. Cependant, en ajoutant le symbole & à la fin d'une commande, vous pouvez l'exécuter en arrière-plan, libérant ainsi votre terminal pour d'autres tâches.

Création d'un processus en arrière-plan

Créons un script simple qui s'exécutera en continu en arrière-plan. Cela simulera une tâche longue que vous pourriez vouloir exécuter tout en continuant à travailler sur d'autres choses.

Tout d'abord, accédez au répertoire du projet si vous n'y êtes pas déjà :

cd ~/project

Maintenant, créez un script appelé background_task.sh en utilisant l'éditeur de texte nano :

nano ~/project/background_task.sh

Dans l'éditeur, ajoutez le contenu suivant :

#!/bin/bash
## Un simple script qui simule une tâche longue
count=0
while true; do
  count=$((count + 1))
  echo "Task running: iteration $count"
  sleep 5
done

Ce script s'exécutera indéfiniment, affichant un message toutes les 5 secondes.

Appuyez sur Ctrl+O puis sur Entrée pour enregistrer le fichier, puis sur Ctrl+X pour quitter nano.

Ensuite, rendez le script exécutable :

chmod +x ~/project/background_task.sh

Maintenant, exécutez le script en arrière-plan en ajoutant le symbole & à la fin de la commande :

~/project/background_task.sh &

Vous devriez voir une sortie similaire à :

[1] 1234

Le nombre entre crochets [1] est le numéro de la tâche (job number), et le nombre qui le suit est l'identifiant de processus (PID). Ces nombres peuvent être différents sur votre système.

Vérification des tâches en cours d'exécution

Pour afficher toutes les tâches en arrière-plan actuellement en cours d'exécution, utilisez la commande jobs :

jobs

Vous devriez voir une sortie similaire à :

[1]  + running    ~/project/background_task.sh

Cela confirme que votre script s'exécute en arrière-plan.

Pour obtenir des informations plus détaillées sur la tâche, y compris son PID, utilisez :

jobs -l

La sortie devrait afficher le numéro de la tâche, le PID et l'état :

[1]  + 1234 running    ~/project/background_task.sh

Votre terminal reste disponible pour exécuter d'autres commandes tandis que le script continue de s'exécuter en arrière-plan. La sortie du script est toujours envoyée au terminal, vous verrez donc apparaître périodiquement des messages.

Ramener des tâches en arrière-plan au premier plan

Dans cette étape, vous apprendrez comment ramener une tâche en arrière-plan au premier plan en utilisant la commande fg. Cela est utile lorsque vous avez besoin d'interagir avec un processus qui s'exécute actuellement en arrière-plan.

Qu'est-ce que le passage au premier plan (foregrounding) ?

Le passage au premier plan (foregrounding) fait référence au processus de ramener une tâche en arrière-plan au premier plan, en la rendant le processus actif dans votre terminal. Lorsqu'une tâche est au premier plan, elle contrôle votre terminal - vous pouvez interagir directement avec elle, mais vous ne pouvez pas exécuter d'autres commandes tant qu'elle n'est pas terminée ou ramenée en arrière-plan.

Utilisation de la commande fg

Assurez-vous que votre script background_task.sh est toujours en cours d'exécution depuis l'étape précédente. Vous pouvez vérifier cela avec :

jobs

Vous devriez voir votre script répertorié comme une tâche en cours d'exécution.

Pour ramener la tâche au premier plan, utilisez la commande fg suivie du numéro de la tâche précédé d'un signe pourcentage :

fg %1

Si vous n'avez qu'une seule tâche en arrière-plan, vous pouvez simplement utiliser :

fg

Après avoir exécuté la commande, le script sera ramené au premier plan, et vous verrez sa sortie directement dans votre terminal :

Task running: iteration X
Task running: iteration X+1
...

Vous remarquerez que votre invite de commande disparaît, et le script contrôle maintenant votre terminal. Vous ne pouvez plus entrer d'autres commandes tant que vous n'avez pas terminé le script ou ramené le script en arrière-plan.

Arrêt de la tâche au premier plan

Pour arrêter la tâche au premier plan et revenir à l'invite de commande, appuyez sur Ctrl+C. Cela envoie un signal d'interruption au processus, le faisant se terminer.

^C

Le terminal devrait maintenant afficher un message indiquant que la tâche a été terminée, et vous devriez voir à nouveau votre invite de commande.

Pour vérifier que la tâche n'est plus en cours d'exécution, exécutez :

jobs

Il ne devrait y avoir aucune sortie, indiquant qu'aucune tâche en arrière-plan n'est en cours d'exécution.

Commençons à nouveau notre script en arrière-plan pour l'étape suivante :

~/project/background_task.sh &

Vous devriez voir une confirmation que la tâche a démarré, avec une sortie similaire à :

[1] 1345

N'oubliez pas que le numéro de la tâche et le PID peuvent être différents sur votre système.

Suspendre et reprendre des tâches

Dans cette étape, vous apprendrez à suspendre une tâche en cours d'exécution au premier plan et à la reprendre, soit au premier plan, soit en arrière-plan. Cela est utile lorsque vous avez besoin de mettre temporairement en pause un processus sans le terminer.

Suspendre une tâche au premier plan

Tout d'abord, ramenons notre tâche en arrière-plan au premier plan :

fg %1

Vous devriez maintenant voir la sortie du script dans votre terminal. Pour suspendre cette tâche au premier plan, appuyez sur Ctrl+Z :

^Z

Vous devriez voir un message similaire à :

[1]  + suspended  ~/project/background_task.sh

Cela indique que la tâche a été suspendue. La tâche est toujours chargée en mémoire, mais elle n'est pas en cours d'exécution - elle est essentiellement « mise en pause ».

Pour vérifier que la tâche est suspendue, exécutez :

jobs

Vous devriez voir une sortie similaire à :

[1]  + suspended  ~/project/background_task.sh

Reprendre une tâche suspendue en arrière-plan

Vous pouvez reprendre une tâche suspendue soit au premier plan, soit en arrière-plan. Pour la reprendre en arrière-plan, utilisez la commande bg suivie du numéro de la tâche :

bg %1

Vous devriez voir un message confirmant que la tâche a été reprise en arrière-plan :

[1]  + continued  ~/project/background_task.sh

Vérifiez que la tâche est maintenant en cours d'exécution en arrière-plan :

jobs

La sortie devrait montrer que l'état de la tâche est passé de « suspended » (suspendue) à « running » (en cours d'exécution) :

[1]  + running    ~/project/background_task.sh

Reprendre une tâche suspendue au premier plan

Suspendons à nouveau la tâche. Tout d'abord, ramenons-la au premier plan :

fg %1

Puis appuyez sur Ctrl+Z pour la suspendre :

^Z

Maintenant, au lieu d'utiliser bg pour la reprendre en arrière-plan, utilisez fg pour la reprendre au premier plan :

fg %1

La tâche reprendra son exécution, et vous verrez à nouveau sa sortie dans votre terminal.

Arrêtons la tâche en appuyant sur Ctrl+C :

^C

Cela terminera la tâche et vous ramènera à l'invite de commande.

Utilisation du contrôle des tâches dans votre flux de travail

La capacité de suspendre, de reprendre en arrière-plan, de reprendre au premier plan et de terminer des tâches vous donne un contrôle puissant sur vos processus. Ce flux de travail est particulièrement utile lorsque :

1. Vous avez besoin de vérifier autre chose pendant que un processus est en cours d'exécution
2. Vous avez besoin de libérer temporairement des ressources système
3. Vous souhaitez exécuter plusieurs processus de manière interactive sans ouvrir plusieurs fenêtres de terminal

Pour l'étape suivante, démarrez à nouveau la tâche en arrière-plan :

~/project/background_task.sh &

Terminer des tâches en arrière-plan

Dans cette étape, vous apprendrez différentes méthodes pour terminer des tâches en arrière-plan lorsqu'elles ne sont plus nécessaires. La terminaison appropriée des tâches est importante pour libérer les ressources système et maintenir les performances du système.

Identifier les tâches à terminer

Tout d'abord, vérifions quelles tâches sont actuellement en cours d'exécution :

jobs

Vous devriez voir votre tâche en arrière-plan en cours d'exécution :

[1]  + running    ~/project/background_task.sh

Si vous souhaitez des informations plus détaillées, y compris l'identifiant de processus (PID), utilisez :

jobs -l

Cela affichera une sortie similaire à :

[1]  + 1456 running    ~/project/background_task.sh

Notez le PID (le nombre après le numéro de tâche), car il peut être utilisé pour terminer le processus.

Méthode 1 : Terminer une tâche en utilisant son numéro de tâche

La méthode la plus directe pour terminer une tâche en arrière-plan consiste à utiliser la commande kill avec le numéro de tâche :

kill %1

Vérifiez si la tâche a été terminée :

jobs

Vous pourriez voir :

[1]  + terminated  ~/project/background_task.sh

Si la tâche est toujours en cours d'exécution (certains processus peuvent nécessiter un signal de terminaison plus puissant), vous pouvez utiliser :

kill -9 %1

Le flag -9 envoie un signal SIGKILL, qui termine forcément le processus sans lui permettre de nettoyer.

Méthode 2 : Terminer une tâche en utilisant son PID

Démarrons une autre instance de notre script en arrière-plan :

~/project/background_task.sh &

Vous devriez voir une sortie montrant le numéro de tâche et le PID :

[1] 1567

Pour terminer cette tâche en utilisant son PID, utilisez :

kill 1567

Remplacez 1567 par le PID réel de votre tâche.

Vérifiez que la tâche a été terminée :

jobs

Méthode 3 : Utiliser le nom du processus avec killall

Démarrons encore une autre instance de notre script :

~/project/background_task.sh &

Si vous avez plusieurs instances du même processus en cours d'exécution, vous pouvez les terminer toutes à la fois en utilisant la commande killall :

killall background_task.sh

Cette commande termine tous les processus ayant le nom background_task.sh.

Vérifiez qu'aucune tâche n'est en cours d'exécution :

jobs

Il ne devrait y avoir aucune sortie, indiquant que toutes les tâches en arrière-plan ont été terminées.

Comprendre les signaux de terminaison

Lorsque vous utilisez la commande kill, vous envoyez un signal au processus. Par défaut, kill envoie le signal SIGTERM (signal 15), qui demande au processus de se terminer proprement. Si un processus ne répond pas au SIGTERM, vous pouvez utiliser SIGKILL (signal 9) pour forcer la terminaison :

kill -TERM %1 ## Identique à kill %1
kill -KILL %1 ## Identique à kill -9 %1

D'autres signaux utiles incluent :

• SIGHUP (signal 1) : Souvent utilisé pour recharger les fichiers de configuration
• SIGINT (signal 2) : Identique à appuyer sur Ctrl+C
• SIGSTOP (signal 19) : Met en pause un processus (ne peut pas être capturé ou ignoré)
• SIGCONT (signal 18) : Reprend un processus arrêté

Pour une dernière démonstration, démarrons notre tâche en arrière-plan à nouveau, puis terminons-la :

~/project/background_task.sh &
jobs
kill %1
jobs

Cette séquence démarre la tâche, confirme qu'elle est en cours d'exécution, la termine, puis vérifie qu'elle n'est plus en cours d'exécution.

Résumé

Dans ce laboratoire, vous avez appris des compétences essentielles pour gérer les tâches dans un environnement Linux :

1. Démarrer des tâches en arrière-plan : Vous avez appris à exécuter des processus en arrière-plan en utilisant le symbole &, ce qui vous permet de continuer à travailler dans le terminal pendant que des tâches longues à exécuter s'exécutent.

2. Vérifier l'état des tâches : Vous avez utilisé la commande jobs pour afficher des informations sur les tâches en cours d'exécution, y compris leur état, leur numéro de tâche et leur identifiant de processus.

3. Ramener des tâches en arrière-plan au premier plan : Vous avez pratiqué le fait de ramener des tâches en arrière-plan au premier plan en utilisant la commande fg, ce qui vous permet d'interagir directement avec elles.

4. Suspendre et reprendre des tâches : Vous avez appris à suspendre des tâches en cours d'exécution au premier plan avec Ctrl+Z et à les reprendre soit au premier plan (fg), soit en arrière-plan (bg).

5. Terminer des tâches : Vous avez exploré différentes méthodes pour terminer des tâches lorsqu'elles ne sont plus nécessaires, y compris l'utilisation de la commande kill avec des numéros de tâche ou des PID, et l'utilisation de killall pour terminer plusieurs processus par leur nom.

Ces compétences de gestion des tâches sont précieuses pour tout utilisateur Linux, en particulier lorsqu'il travaille avec des processus longs à exécuter ou lorsqu'il effectue plusieurs tâches simultanément dans un environnement. En contrôlant la façon dont et le moment où les processus s'exécutent, vous pouvez utiliser plus efficacement les ressources de votre système et rationaliser votre flux de travail.

N'oubliez pas que différents signaux peuvent être utilisés avec la commande kill pour contrôler le comportement des processus, depuis la terminaison gracieuse jusqu'à la terminaison forcée, vous donnant un contrôle précis sur les processus de votre système.