Exécution en arrière-plan sous Linux

LinuxLinuxBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

Linux offre des capacités puissantes pour la gestion des processus, permettant aux utilisateurs d'exécuter des commandes en arrière-plan tout en continuant à travailler dans le terminal. Cette fonctionnalité est essentielle lorsqu'il s'agit de tâches chronophages qui ne nécessitent pas de surveillance constante. Dans ce laboratoire (lab), vous apprendrez à exécuter des processus en arrière-plan, à vérifier leur statut et à les gérer efficacement. Ces compétences sont fondamentales pour tout utilisateur de Linux et offrent une plus grande flexibilité lors de l'utilisation d'environnements en ligne de commande.

Comprendre les processus en arrière-plan

Sous Linux, les processus peuvent s'exécuter soit au premier plan (foreground) soit en arrière-plan (background). Un processus au premier plan occupe votre terminal jusqu'à sa fin, vous empêchant d'exécuter d'autres commandes. En revanche, un processus en arrière-plan s'exécute sans bloquer votre terminal, vous permettant de continuer à utiliser la ligne de commande.

Commençons par créer un simple script qui simule une tâche longue. Cela nous aidera à démontrer les processus en arrière-plan.

Accédez au répertoire du projet :

cd ~/project

Créez un fichier appelé long-task.sh en utilisant l'éditeur nano :

nano long-task.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## Ce script simule une tâche longue
echo "Démarrage de la longue tâche..."
for i in {1..10}; do
  echo "Traitement de l'étape $i..."
  sleep 3
done
echo "Longue tâche terminée."

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

Rendez le script exécutable en modifiant ses permissions :

chmod +x long-task.sh

Maintenant, exécutez le script au premier plan :

./long-task.sh

Vous verrez le script afficher chaque étape avec un délai de 3 secondes. Notez que pendant ce temps, vous ne pouvez pas entrer d'autres commandes dans le terminal car le processus s'exécute au premier plan.

Appuyez sur Ctrl+C pour terminer le script avant qu'il ne se termine.

Exécution de processus en arrière-plan

Pour exécuter un processus en arrière-plan, il suffit d'ajouter un astérisque commercial (&) à la fin de la commande. Cela indique au shell d'exécuter la commande en arrière-plan.

Exécutons notre script long-task.sh en arrière-plan :

cd ~/project
./long-task.sh &

Vous devriez voir une sortie similaire à ce qui suit :

[1] 1234
Démarrage de la longue tâche...
Traitement de l'étape 1...

Ici, [1] est le numéro de tâche (job number) attribué par le shell, et 1234 est l'identifiant de processus (PID, process ID). Le numéro de tâche est utilisé pour faire référence à ce processus en arrière-plan dans le shell, tandis que le PID est utilisé par le système d'exploitation pour identifier le processus.

Notez qu'après la sortie initiale, vous récupérez votre invite de commande. Vous pouvez maintenant continuer à entrer d'autres commandes tandis que le script s'exécute en arrière-plan.

Par exemple, essayez de créer un autre fichier :

echo "Je peux faire d'autres travaux pendant que le script s'exécute" > background-demo.txt
cat background-demo.txt

Vous verrez que vous pouvez continuer à travailler dans le terminal tout en voyant occasionnellement la sortie du script en arrière-plan. Cela est très utile pour exécuter des tâches chronophages sans bloquer votre session terminal.

Vérification des processus en arrière-plan

Linux propose plusieurs commandes pour vérifier quels processus s'exécutent en arrière-plan. Les deux plus courantes sont jobs et ps.

Utilisation de la commande jobs

La commande jobs affiche l'état de toutes les tâches en arrière-plan dans la session shell actuelle :

jobs

Vous devriez voir une sortie similaire à :

[1]+  Running    ./long-task.sh &

Le signe + indique que c'est la tâche par défaut actuelle, ce qui signifie qu'elle sera traitée si vous utilisez des commandes comme fg ou bg sans spécifier de numéro de tâche.

Utilisation de la commande ps

Alors que jobs n'affiche que les processus démarrés depuis le shell actuel, la commande ps peut afficher tous les processus en cours d'exécution sur le système :

ps aux | grep long-task.sh

La sortie devrait inclure une ligne pour votre script en arrière-plan :

labex     1234  0.0  0.0   4508  1996 pts/0    S    12:34   0:00 /bin/bash ./long-task.sh

Créons un autre processus en arrière-plan pour voir plusieurs tâches :

cd ~/project
nano another-task.sh

Ajoutez le contenu suivant :

#!/bin/bash
## Ce script simule une autre tâche
echo "Démarrage d'une autre tâche..."
for i in {1..20}; do
  echo "Autre tâche - étape $i..."
  sleep 5
done
echo "Autre tâche terminée."

Enregistrez et quittez nano (Ctrl+O, Entrée, Ctrl+X), puis rendez le script exécutable :

chmod +x another-task.sh

Exécutez également ce script en arrière-plan :

./another-task.sh &

Vérifiez maintenant à nouveau vos tâches en arrière-plan :

jobs

Vous devriez voir les deux tâches répertoriées :

[1]-  Running    ./long-task.sh &
[2]+  Running    ./another-task.sh &

Gestion des processus en arrière-plan

Maintenant que nous avons des processus en cours d'exécution en arrière-plan, apprenons à les gérer. Linux propose plusieurs commandes pour contrôler les processus en arrière-plan :

Rappeler un processus en arrière-plan au premier plan

La commande fg rappelle un processus en arrière-plan au premier plan. Si vous avez plusieurs tâches en arrière-plan, vous pouvez spécifier laquelle en utilisant son numéro de tâche.

Rappelons notre première tâche au premier plan :

fg %1

Le %1 fait référence au numéro de tâche 1. Vous verrez la sortie du script long-task.sh apparaître maintenant dans votre terminal, et votre invite de commande ne sera pas disponible tant que le processus n'est pas terminé ou que vous ne l'avez pas arrêté.

Pour interrompre le processus et revenir à l'invite de commande, appuyez sur Ctrl+C.

Envoyer un processus au premier plan en arrière-plan

Vous pouvez également envoyer un processus au premier plan en arrière-plan. Tout d'abord, suspendez le processus au premier plan avec Ctrl+Z, puis utilisez la commande bg pour le faire continuer en arrière-plan.

Démarrez un nouveau processus au premier plan :

cd ~/project
./long-task.sh

Après quelques secondes, appuyez sur Ctrl+Z pour suspendre le processus. Vous verrez un message comme :

[1]+  Stopped    ./long-task.sh

Maintenant, faites-le continuer en arrière-plan :

bg

Le processus reprendra son exécution en arrière-plan, et vous verrez :

[1]+ ./long-task.sh &

Vous pouvez vérifier qu'il s'exécute avec :

jobs

Terminer des processus en arrière-plan

Pour terminer un processus en arrière-plan, vous pouvez utiliser la commande kill avec le numéro de tâche ou l'identifiant de processus (PID) :

kill %1

Ou en utilisant le PID (remplacez 1234 par le PID réel de la sortie de votre commande ps) :

kill 1234

Pour vérifier que le processus a été terminé :

jobs

Vous pourriez voir un message indiquant que la tâche a été terminée :

[1]+  Terminated    ./long-task.sh

Exécution de processus après la déconnexion

Parfois, vous avez besoin qu'un processus continue de s'exécuter même après avoir quitté le terminal. La commande nohup vous permet d'exécuter une commande qui continuera de s'exécuter même après avoir quitté le shell.

Créons un script qui s'exécutera pendant longtemps :

cd ~/project
nano persistent-task.sh

Ajoutez le contenu suivant :

#!/bin/bash
## Ce script s'exécute pendant un très long temps
echo "Démarrage de la tâche persistante à $(date)" > persistent-output.log
for i in {1..100}; do
  echo "Itération $i à $(date)" >> persistent-output.log
  sleep 10
done
echo "Tâche persistante terminée à $(date)" >> persistent-output.log

Enregistrez et quittez nano, puis rendez le script exécutable :

chmod +x persistent-task.sh

Maintenant, exécutez-le avec nohup et mettez-le en arrière-plan :

nohup ./persistent-task.sh &

Vous verrez une sortie similaire à :

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

Cela signifie que le processus s'exécute en arrière-plan et continuera même si vous vous déconnectez. La sortie qui serait normalement affichée dans le terminal est redirigée vers un fichier appelé nohup.out.

Vous pouvez vérifier si le processus s'exécute :

ps aux | grep persistent-task.sh

Et vous pouvez examiner le fichier de sortie :

cat persistent-output.log

La sortie montre l'heure de démarrage et les itérations de la tâche persistante.

La commande disown

Une autre façon de faire continuer les processus après la déconnexion est d'utiliser la commande disown. Tout d'abord, exécutez un processus en arrière-plan :

cd ~/project
./persistent-task.sh &

Ensuite, utilisez disown pour le détacher du terminal :

disown %1

Maintenant, ce processus continuera de s'exécuter même si vous fermez le terminal.

Ces commandes sont essentielles lorsqu'on exécute des tâches sur des serveurs distants où il est nécessaire que les processus continuent après la déconnexion.

Résumé

Dans ce laboratoire, vous avez appris les compétences essentielles en Linux pour gérer les processus en arrière-plan. Vous avez pratiqué :

  1. La création et l'exécution de scripts en mode premier plan et en mode arrière-plan
  2. L'exécution de processus en arrière-plan en utilisant l'opérateur &
  3. La vérification de l'état des processus en arrière-plan en utilisant les commandes jobs et ps
  4. La gestion des processus avec les commandes fg et bg pour les déplacer entre le premier plan et l'arrière-plan
  5. La terminaison des processus en arrière-plan en utilisant la commande kill
  6. L'exécution de processus qui continuent après la déconnexion en utilisant les commandes nohup et disown

Ces compétences sont fondamentales pour travailler efficacement dans des environnements Linux, en particulier lorsqu'il s'agit de tâches longues ou lorsqu'on travaille sur des serveurs distants. En exécutant des processus en arrière-plan, vous pouvez maximiser votre productivité en exécutant plusieurs tâches simultanément sans bloquer votre session de terminal.