Exécution en arrière-plan sous Linux

LinuxBeginner
Pratiquer maintenant

Introduction

Linux offre de puissantes capacités 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 pour traiter des tâches longues qui ne nécessitent pas une surveillance constante. Dans ce laboratoire, 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 Linux et offrent une plus grande flexibilité lors du travail dans des 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 est celui qui occupe votre terminal jusqu'à ce qu'il se termine, vous empêchant d'exécuter d'autres commandes. Un processus en arrière-plan, quant à lui, s'exécute sans bloquer votre terminal, vous permettant de continuer à utiliser la ligne de commande.

Créons d'abord un script simple qui simule une tâche de longue durée. Cela nous aidera à démontrer les processus en arrière-plan.

Naviguez vers le répertoire du projet :

cd ~/project

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

nano long-task.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash
## This script simulates a long-running task
echo "Starting long task..."
for i in {1..20}; do
  echo "Processing step $i..."
  sleep 5
done
echo "Long task completed."

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

Rendez le script exécutable en modifiant ses permissions :

chmod +x long-task.sh

Exécutez maintenant le script au premier plan :

./long-task.sh

Vous verrez le script afficher chaque étape avec un délai de 5 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 soit achevé.

Exécuter des processus en arrière-plan

Pour exécuter un processus en arrière-plan, ajoutez simplement une esperluette (&) à 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 à la suivante :

[1] 1234
Starting long task...
Processing step 1...

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

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

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

echo "I can do other work while the script runs" > 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. Ceci est très utile pour exécuter des tâches longues sans bloquer votre session de terminal.

Note importante : Il est tout à fait normal de voir la sortie du processus en arrière-plan apparaître dans votre terminal. Lorsque vous exécutez un processus en arrière-plan à l'aide de &, le processus s'exécute en arrière-plan, mais ses flux de sortie (stdout et stderr) sont toujours connectés à votre terminal. Cela signifie que :

  • Le processus s'exécute en arrière-plan (vous pouvez entrer d'autres commandes)
  • Le processus continue de s'exécuter sans bloquer votre terminal
  • La sortie apparaît toujours sur votre écran (ce qui peut se mélanger avec vos autres commandes)

Ce comportement est attendu et démontre que le processus en arrière-plan s'exécute activement et produit une sortie.

Vérifier les processus en arrière-plan

Linux fournit 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 tous les jobs en arrière-plan dans la session shell actuelle :

jobs

Vous devriez voir une sortie similaire à :

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

Le signe + indique qu'il s'agit du job par défaut actuel, ce qui signifie qu'il sera opéré si vous utilisez des commandes comme fg ou bg sans spécifier de numéro de job.

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 pouvoir voir plusieurs jobs :

cd ~/project
nano another-task.sh

Ajoutez le contenu suivant :

#!/bin/bash
## This script simulates another task
echo "Starting another task..."
for i in {1..20}; do
  echo "Another task - step $i..."
  sleep 5
done
echo "Another task completed."

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 jobs en arrière-plan :

jobs

Vous devriez voir les deux jobs listés :

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

Gérer les 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 fournit plusieurs commandes pour contrôler les processus en arrière-plan :

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

La commande fg ramène un processus en arrière-plan au premier plan. Si vous avez plusieurs jobs en arrière-plan, vous pouvez spécifier lequel en utilisant son numéro de job.

Ramener notre premier job au premier plan :

fg %1

Le %1 fait référence au job numéro 1. Vous verrez la sortie du script long-task.sh apparaître dans votre terminal, et votre invite de commande sera indisponible jusqu'à ce que le processus se termine ou que vous l'arrêtiez.

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. D'abord, suspendez le processus au premier plan avec Ctrl+Z, puis utilisez la commande bg pour le continuer en arrière-plan.

Lancez 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, continuez-le 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 les processus en arrière-plan

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

kill %1

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

kill 1234

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

jobs

Vous pourriez voir un message indiquant que le job a été terminé :

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

Exécuter des processus après déconnexion

Parfois, vous avez besoin qu'un processus continue de s'exécuter même après vous être déconnecté du 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 longtemps :

cd ~/project
nano persistent-task.sh

Ajoutez le contenu suivant :

#!/bin/bash
## This script runs for a very long time
echo "Starting persistent task at $(date)" > persistent-output.log
for i in {1..100}; do
  echo "Iteration $i at $(date)" >> persistent-output.log
  sleep 10
done
echo "Persistent task completed at $(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 irait normalement au terminal est redirigée vers un fichier appelé nohup.out.

Astuce pour gérer la sortie : Si vous ne voulez pas que la sortie du processus en arrière-plan apparaisse dans votre terminal et interfère potentiellement avec votre travail, vous pouvez rediriger la sortie vers un fichier :

## Rediriger la sortie vers un fichier spécifique
./long-task.sh > task-output.log 2>&1 &

## Ou rediriger vers /dev/null pour ignorer complètement la sortie
./long-task.sh > /dev/null 2>&1 &

Le 2>&1 redirige à la fois la sortie standard et la sortie d'erreur. De cette façon, le processus en arrière-plan s'exécute silencieusement sans encombrer votre terminal.

Vous pouvez vérifier si le processus est en cours d'exécution :

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ébut et les itérations de la tâche persistante.

La commande disown

Une autre façon de maintenir les processus en cours d'exécution 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 lors de l'exécution de tâches sur des serveurs distants où vous avez besoin que les processus continuent après la déconnexion.

Résumé

Dans ce laboratoire, vous avez acquis des compétences essentielles sous Linux pour la gestion des processus en arrière-plan. Vous avez pratiqué :

  1. La création et l'exécution de scripts en mode premier plan et arrière-plan
  2. L'exécution de processus en arrière-plan à l'aide de l'opérateur &
  3. La vérification de l'état des processus en arrière-plan à l'aide de 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 à l'aide de la commande kill
  6. L'exécution de processus qui continuent après la déconnexion à l'aide de nohup et disown

Ces compétences sont fondamentales pour travailler efficacement dans les environnements Linux, en particulier lors du traitement de tâches de longue durée ou lors du travail 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.