Gestion des processus en arrière-plan sous Linux

Introduction

Linux offre des capacités puissantes pour gérer plusieurs processus simultanément. L'une de ses fonctionnalités clés est la capacité d'exécuter des processus en arrière-plan, ce qui vous permet de continuer à utiliser le terminal pour d'autres tâches pendant que des processus longs s'exécutent.

Dans ce labo (LabEx), vous apprendrez des techniques essentielles pour gérer les processus en arrière-plan dans les systèmes Linux. Ces compétences sont cruciales pour un multitâche efficace dans les environnements en ligne de commande et sont régulièrement utilisées par les administrateurs système et les développeurs.

À la fin de ce labo (LabEx), vous comprendrez comment démarrer des processus en arrière-plan, surveiller leur statut et les contrôler efficacement. Ces compétences vous aideront à mieux utiliser les ressources système et à améliorer votre productivité lorsque vous travaillez avec des systèmes Linux.

Démarrer un processus en arrière-plan

Sous Linux, vous pouvez exécuter une commande en arrière-plan en ajoutant un astérisque (&) à la fin de votre commande. Cela indique au shell d'exécuter le processus en arrière-plan, vous permettant de continuer à utiliser votre terminal pendant que la commande s'exécute.

Créons et exécutons un script simple qui simule un processus long.

Tout d'abord, assurez-vous d'être dans le répertoire du projet :

cd ~/project

Maintenant, créons un fichier de script nommé long_running.sh en utilisant l'éditeur de texte nano :

nano ~/project/long_running.sh

Lorsque l'éditeur nano s'ouvre, entrez le code suivant :

#!/bin/bash
echo "Starting a long process..."
sleep 15
echo "Process completed"

Ce script :

1. Affiche un message de démarrage
2. Pause pendant 15 secondes (simulant une tâche longue)
3. Affiche un message de fin

Pour enregistrer le fichier dans nano :

1. Appuyez sur Ctrl + O pour écrire le fichier
2. Appuyez sur Entrée pour confirmer le nom de fichier
3. Appuyez sur Ctrl + X pour quitter nano

Ensuite, nous devons rendre le script exécutable :

chmod +x ~/project/long_running.sh

Maintenant, exécutons le script au premier plan pour voir comment il fonctionne :

./long_running.sh

Vous verrez :

Starting a long process...

Notez que votre terminal est maintenant occupé pendant 15 secondes jusqu'à la fin de l'exécution du script. Vous ne pouvez pas entrer de nouvelles commandes pendant ce temps.

Maintenant, exécutons le même script en arrière-plan en ajoutant un astérisque (&) à la fin :

./long_running.sh &

Vous verrez une sortie similaire à :

[1] 1234
Starting a long process...

La sortie montre :

• [1] - le numéro de tâche attribué par le shell
• 1234 - l'identifiant de processus (PID), qui sera un nombre différent sur votre système
• Le message de démarrage du script

Même si le script est toujours en cours d'exécution, votre invite de shell revient immédiatement, vous permettant d'entrer de nouvelles commandes. Après 15 secondes, vous verrez le message de fin apparaître :

Process completed
[1]+  Done                    ./long_running.sh

Cela confirme que le processus en arrière-plan a terminé son exécution.

Afficher les processus en arrière-plan

Après avoir démarré des processus en arrière-plan, vous devez savoir comment les suivre. Linux propose la commande jobs pour afficher tous les processus en arrière-plan en cours d'exécution dans votre session de terminal actuelle.

Démarrons plusieurs processus en arrière-plan, puis affichons-les :

## Start the first background process
./long_running.sh &

Vous verrez une sortie similaire à :

[1] 1234
Starting a long process...

Maintenant, démarrons un deuxième processus en arrière-plan :

## Start the second background process
./long_running.sh &

Vous verrez une sortie similaire à :

[2] 1235
Starting a long process...

Pour afficher tous vos processus en arrière-plan (tâches), utilisez la commande jobs :

jobs

Vous devriez voir une sortie similaire à :

[1]  Running                 ./long_running.sh &
[2]- Running                 ./long_running.sh &

Cela indique que vous avez deux tâches en arrière-plan en cours d'exécution. Les nombres entre crochets sont les identifiants de tâches (job IDs) que vous pouvez utiliser pour faire référence à des tâches spécifiques avec d'autres commandes.

La commande jobs prend en charge plusieurs options utiles :

• jobs -l - affiche les identifiants de processus (PIDs) en plus des informations sur les tâches
• jobs -p - affiche uniquement les identifiants de processus des tâches

Essayez l'option -l pour voir plus de détails :

jobs -l

La sortie inclura les identifiants de processus :

[1]  1234 Running                 ./long_running.sh &
[2]- 1235 Running                 ./long_running.sh &

Attendez que les deux processus se terminent avant de passer à l'étape suivante. Vous verrez des messages tels que :

Process completed
[1]+  Done                    ./long_running.sh
Process completed
[2]+  Done                    ./long_running.sh

Déplacer des processus entre premier plan et arrière-plan

Linux vous permet de déplacer des processus entre les états de premier plan et d'arrière-plan. Cela est particulièrement utile lorsque :

• Vous avez démarré un processus au premier plan et avez besoin d'utiliser le terminal pour autre chose
• Vous souhaitez amener un processus en arrière-plan au premier plan pour interagir avec lui

Apprenons à faire cela en utilisant les commandes fg (premier plan) et bg (arrière-plan), ainsi que la suspension de processus.

Tout d'abord, démarrons notre script long en premier plan (sans le &) :

./long_running.sh

Vous verrez :

Starting a long process...

Notez que votre invite de shell ne revient pas - le terminal est maintenant occupé par ce processus en cours d'exécution au premier plan.

Pour suspendre (mettre en pause) ce processus et reprendre le contrôle de votre terminal :

1. Appuyez sur Ctrl + Z

Vous verrez une sortie similaire à :

^Z
[1]+  Stopped                 ./long_running.sh

Le processus est maintenant suspendu et n'est plus en cours d'exécution. Vous pouvez le confirmer avec la commande jobs :

jobs

Sortie :

[1]+  Stopped                 ./long_running.sh

Pour reprendre le processus suspendu en arrière-plan, utilisez la commande bg :

bg %1

Le %1 fait référence au numéro de tâche 1. Vous verrez :

[1]+ ./long_running.sh &

Le processus est maintenant en cours d'exécution en arrière-plan. Confirmez avec jobs :

jobs

Sortie :

[1]+  Running                 ./long_running.sh &

Pour amener un processus en arrière-plan au premier plan, utilisez la commande fg :

fg %1

Le processus va maintenant s'exécuter à nouveau au premier plan, et votre terminal sera occupé jusqu'à sa fin :

./long_running.sh
Process completed

Après la fin du processus, votre invite de shell reviendra.

Faire continuer l'exécution des processus après la fermeture du terminal

Lorsque vous exécutez un processus en arrière-plan avec &, il se terminera si vous fermez le terminal. Pour faire continuer l'exécution d'un processus même après la fermeture du terminal, vous pouvez utiliser la commande nohup.

nohup (abréviation de "no hang up", c'est-à-dire "pas de déconnexion") empêche le processus de recevoir le signal SIGHUP (déconnexion), qui est envoyé aux processus lorsque le terminal se ferme.

Modifions notre script pour le faire s'exécuter plus longtemps :

nano ~/project/long_running.sh

Mettez à jour le contenu comme suit :

#!/bin/bash
echo "Starting a very long process..."
sleep 60
echo "Process completed" > ~/project/completed.txt

Enregistrez et quittez nano (Ctrl+O, Entrée, Ctrl+X).

Maintenant, exécutons le script avec nohup :

nohup ./long_running.sh &

Vous verrez une sortie similaire à :

[1] 1234
nohup: ignoring input and appending output to 'nohup.out'

La sortie du script ne sera pas affichée dans le terminal. Au lieu de cela, elle est redirigée vers un fichier appelé nohup.out. Vous pouvez vérifier ce fichier :

cat nohup.out

Vous devriez voir :

Starting a very long process...

Même si vous fermiez votre terminal maintenant, le processus continuerait à s'exécuter. Lorsqu'il se terminera, il écrira à la fois dans nohup.out et completed.txt.

Pour voir les processus en cours d'exécution en arrière-plan sur tous les terminaux, utilisez la commande ps :

ps aux | grep long_running.sh

Vous verrez quelque chose comme :

labex     1234  0.0  0.0   8160   736 pts/0    S    12:34   0:00 /bin/bash ./long_running.sh
labex     1235  0.0  0.0  14428  1020 pts/0    S+   12:34   0:00 grep --color=auto long_running.sh

Attendez que le processus se termine (ou le terminez si vous le souhaitez) :

## If you want to terminate the process:
kill %1

Résumé

Dans ce laboratoire, vous avez appris des techniques essentielles pour gérer les processus en arrière-plan sous Linux :

1. Démarrer des processus en arrière-plan : Vous avez appris à démarrer des processus en arrière-plan en utilisant l'opérateur &, ce qui vous permet de continuer à utiliser votre terminal pendant que le processus s'exécute.

2. Voir les processus en arrière-plan : Vous avez utilisé la commande jobs pour afficher tous les processus en arrière-plan en cours d'exécution dans votre session de terminal actuelle.

3. Déplacer des processus entre premier plan et arrière-plan : Vous avez pratiqué l'utilisation de Ctrl+Z pour suspendre un processus, bg pour le faire continuer en arrière-plan et fg pour le ramener au premier plan.

4. Faire continuer l'exécution des processus après la fermeture du terminal : Vous avez utilisé la commande nohup pour faire continuer l'exécution des processus même si la session de terminal se termine.

Ces compétences sont essentielles pour un multitâche efficace dans les environnements Linux. Elles vous permettent d'exécuter plusieurs processus simultanément, d'utiliser efficacement les ressources du terminal, de maintenir des processus de longue durée sans garder les terminaux ouverts et de gérer les états d'exécution des processus.

Avec ces techniques, vous pouvez travailler plus efficacement et plus productivité dans les environnements de ligne de commande Linux, que vous gériez des serveurs, développiez des applications ou effectuiez des tâches d'administration système.