Gestion des tâches en arrière-plan Linux | Contrôle des processus | Compétences en ligne de commande

Introduction

Dans ce laboratoire, vous apprendrez à gérer les tâches en arrière-plan sous Linux en utilisant diverses commandes. Vous découvrirez comment exécuter des processus en arrière-plan, surveiller leur statut et les contrôler. Cette connaissance est essentielle pour un multitâche efficace dans un environnement Linux, vous permettant d'exécuter plusieurs tâches simultanément sans bloquer votre terminal.

Objectifs

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

Exécuter des commandes en arrière-plan en utilisant l'opérateur &
Lister et surveiller les tâches en arrière-plan en utilisant la commande jobs
Rappeler les tâches en arrière-plan au premier plan en utilisant la commande fg
Arrêter les tâches en arrière-plan en utilisant la commande kill
Comprendre la nature spécifique au terminal des tâches en arrière-plan

Exécution d'une commande en arrière-plan

Commençons par exécuter une commande simple en arrière-plan.

Ouvrez votre terminal. Vous devriez être dans le répertoire /home/labex/project. Sinon, vous pouvez vous déplacer dans ce répertoire en tapant :
```
cd /home/labex/project
```
Nous allons utiliser la commande sleep pour simuler un processus de longue durée. Exécutez la commande suivante :
```
sleep 600 &
```
La commande sleep met en pause l'exécution pendant un nombre spécifié de secondes (dans ce cas, 600 secondes ou 10 minutes). Le symbole & à la fin indique à Linux d'exécuter cette commande en arrière-plan.
Après avoir exécuté cette commande, vous verrez une sortie similaire à celle-ci :
```
[1] 1234
```
Cette sortie montre deux informations importantes :
- [1] est le numéro de tâche. Il est utilisé pour faire référence à cette tâche en arrière-plan spécifique.
- 1234 est l'identifiant de processus (PID). C'est un identifiant unique pour le processus en cours d'exécution.
Vous remarquerez que vous récupérez immédiatement votre invite de commande. C'est parce que le processus s'exécute en arrière-plan, vous permettant de continuer à utiliser votre terminal.
Maintenant, vérifions le statut de notre tâche en arrière-plan :
```
jobs
```
Cette commande liste toutes les tâches en arrière-plan actuelles. Vous devriez voir une sortie comme celle-ci :
```
[1]+  Running                 sleep 600 &
```
Cela vous indique que la tâche numéro 1 est en cours d'exécution et qu'il s'agit de la commande sleep 600 que nous venons de lancer.
Note importante : Les tâches en arrière-plan sont spécifiques à la session de terminal dans laquelle elles ont été lancées. Si vous ouvrez une nouvelle fenêtre ou un nouvel onglet de terminal, l'exécution de la commande jobs ne montrera pas les tâches en arrière-plan de votre terminal d'origine. C'est un concept clé pour comprendre le fonctionnement des tâches en arrière-plan sous Linux.

Exécution de plusieurs tâches en arrière-plan

Maintenant que nous avons exécuté une tâche en arrière-plan, essayons d'exécuter plusieurs tâches simultanément. Nous allons utiliser un mélange de différentes commandes pour démontrer la polyvalence des tâches en arrière-plan.

Commençons quelques autres tâches en arrière-plan. Entrez ces commandes les unes après les autres :
```
ping -c 100 google.com > ping_results.txt &
find /home -name "*.log" > log_files.txt &
sleep 1200 &
```
Chacune de ces commandes lancera une nouvelle tâche en arrière-plan. Vous verrez un numéro de tâche et un PID pour chacune d'elles.
Maintenant, vérifions le statut de toutes nos tâches en arrière-plan :
```
jobs
```
Vous devriez voir une sortie listant les quatre tâches (y compris celle de l'étape 1) :
```
[1]   Running                 sleep 600 &
[2]   Running                 ping -c 100 google.com > ping_results.txt &
[3]-  Running                 find /home -name "*.log" > log_files.txt &
[4]+  Running                 sleep 1200 &
```
Le symbole + à côté de la tâche 4 indique que c'est la tâche en arrière-plan la plus récemment lancée. Le symbole - à côté de la tâche 3 indique que celle-ci deviendrait la tâche actuelle si la tâche 4 devait se terminer.
Remarquez comment vous pouvez rapidement lancer plusieurs tâches en arrière-plan, et que votre terminal reste réactif pour d'autres commandes.

Rappeler une tâche en arrière-plan au premier plan

Parfois, vous pourriez vouloir rappeler une tâche en arrière-plan au premier plan, soit pour interagir avec elle, soit pour voir sa sortie. Apprenons comment faire cela.

Tout d'abord, liste les tâches actuelles :
```
jobs
```
Cela met à jour votre vue des tâches actuellement en cours d'exécution en arrière-plan.
Nous allons rappeler l'une des tâches de longue durée au premier plan. Choisissez un numéro de tâche dans la liste (disons que c'est le numéro de tâche 3, mais utilisez le numéro correspondant à une tâche encore en cours d'exécution dans votre liste). Pour la rappeler au premier plan, utilisez la commande fg suivie du numéro de tâche :
```
fg %3
```
Le %3 fait référence au numéro de tâche. Le symbole % indique au shell que vous faites référence à un numéro de tâche, pas à un identifiant de processus (PID).
Après avoir exécuté cette commande, vous verrez la commande s'exécuter au premier plan, et votre terminal sera "bloqué" jusqu'à ce qu'elle soit terminée ou que vous l'arrêtiez.
Pour arrêter la tâche et récupérer le contrôle de votre terminal, appuyez sur Ctrl+C. Cela envoie un signal d'interruption au processus en cours au premier plan.
Vérifions à nouveau nos tâches :
```
jobs
```
Vous devriez constater que la tâche que vous avez rappelée au premier plan n'est plus répertoriée car nous l'avons arrêtée.

Arrêt d'une tâche en arrière-plan

Maintenant, apprenons à arrêter une tâche en arrière-plan sans la rappeler au premier plan.

Tout d'abord, liste les tâches actuelles :
```
jobs
```
Cela vous montre quelles tâches sont encore en cours d'exécution.
Nous allons arrêter l'une des tâches en arrière-plan restantes. Choisissez un numéro de tâche dans la liste (disons que c'est le numéro de tâche 2, mais utilisez le numéro correspondant à une tâche encore en cours d'exécution dans votre liste). Pour l'arrêter, nous utilisons la commande kill suivie du numéro de tâche :
```
kill %2
```
Le %2 fait référence au numéro de tâche que vous avez choisi. Encore une fois, le symbole % indique que nous faisons référence à un numéro de tâche.
La commande kill envoie un signal de terminaison à la tâche spécifiée. Par défaut, elle envoie un signal qui permet au processus de se fermer proprement.
Vérifiez à nouveau les tâches :
```
jobs
```
Vous devriez constater que la tâche que vous avez arrêtée n'est plus répertoriée. Cela confirme qu'elle a été correctement terminée.

Utilisation de tâches en arrière-plan avec d'autres commandes

Maintenant que nous avons pratiqué avec diverses commandes, essayons d'utiliser les tâches en arrière-plan avec une autre commande pratique.

Nous allons utiliser la commande tar pour créer une archive compressée de votre répertoire personnel en arrière-plan :
```
tar -czf home_backup.tar.gz /home/labex &
```
Cette commande crée une archive tar compressée de votre répertoire personnel.
Vous verrez un numéro de tâche et un PID, tout comme avec nos commandes précédentes.
Vérifiez le statut de la tâche :
```
jobs
```
Vous devriez voir la commande tar répertoriée comme une tâche en cours d'exécution.
Pendant qu'elle s'exécute, vous pouvez continuer à utiliser votre terminal pour d'autres tâches. Voilà le pouvoir des tâches en arrière-plan!
Après un certain temps, vérifiez si la commande s'est terminée :
```
jobs
```
Si elle n'est plus répertoriée, elle a terminé.
Maintenant, vérifions que l'archive a été créée :
```
ls -l home_backup.tar.gz
```
Cela vous montrera les détails du fichier d'archive s'il a été créé avec succès.

Résumé

Dans ce laboratoire (lab), vous avez appris les compétences essentielles pour gérer les tâches en arrière-plan sous Linux :

Exécuter des commandes en arrière-plan en utilisant l'opérateur &
Lister et surveiller les tâches en arrière-plan avec la commande jobs
Rappeler les tâches en arrière-plan au premier plan avec fg
Arrêter les tâches en arrière-plan en utilisant kill
Appliquer ces concepts à des scénarios pratiques, comme les diagnostics réseau, les recherches de fichiers et la création d'archives

Vous avez également appris un concept important : les tâches en arrière-plan sont spécifiques à la session de terminal dans laquelle elles ont été lancées. Cela signifie que chaque fenêtre ou onglet de terminal maintient son propre ensemble de tâches en arrière-plan.

Ces compétences vous aideront à effectuer plusieurs tâches de manière efficace dans un environnement Linux, vous permettant d'exécuter plusieurs processus simultanément et de les gérer efficacement. N'oubliez pas que les tâches en arrière-plan sont particulièrement utiles pour les tâches de longue durée qui ne nécessitent pas d'interaction constante, libérant ainsi votre terminal pour d'autres travaux.