Introduction
Dans ce laboratoire, vous apprendrez les compétences essentielles pour gérer et surveiller les processus sur un système Linux. Vous découvrirez comment interagir avec les processus s'exécutant à la fois au premier plan et en arrière-plan, ce qui vous donnera un meilleur contrôle sur votre environnement en ligne de commande et sur les ressources système. Cette expérience pratique est fondamentale pour toute personne travaillant avec Linux, qu'il s'agisse d'administrateurs système ou de développeurs.
Vous commencerez par lancer une tâche en arrière-plan à l'aide de l'opérateur & et à afficher son statut avec jobs. Vous inspecterez ensuite les processus en cours d'exécution avec ps, surveillerez l'activité du système en temps réel avec top, et pratiquerez le contrôle des tâches (job control) en utilisant fg, bg et Ctrl-Z. Pour terminer ce laboratoire, vous apprendrez à ajuster la priorité d'un processus avec renice et à le stopper à l'aide de la commande kill, couvrant ainsi l'ensemble du cycle de vie de la gestion des processus.
Démarrer et afficher un processus en arrière-plan avec & et jobs
Dans cette étape, vous apprendrez à exécuter une commande en arrière-plan et à afficher le statut des tâches en arrière-plan. Dans un shell Linux, vous exécutez généralement une commande et attendez qu'elle se termine avant que l'invite de commande ne réapparaisse. C'est ce qu'on appelle l'exécution d'un processus au premier plan (foreground). Cependant, pour des tâches de longue durée, vous préférerez peut-être les exécuter en arrière-plan (background) afin de pouvoir continuer à utiliser votre terminal pour d'autres commandes.
Pour exécuter une commande en arrière-plan, il vous suffit d'ajouter une esperluette (&) à la fin de la ligne de commande. Essayons cela avec la commande sleep, qui est un utilitaire simple permettant de faire une pause pendant une durée déterminée.
Exécutez la commande suivante pour exécuter sleep pendant 300 secondes en arrière-plan. Cela nous permettra de travailler avec ce processus lors des prochaines étapes.
sleep 300 &
Après avoir appuyé sur Entrée, vous verrez un affichage similaire au suivant, et l'invite de commande reviendra immédiatement, vous permettant de saisir de nouvelles commandes.
[1] 12345
Le shell a démarré la commande sleep 300 en tant que tâche en arrière-plan. La sortie fournit deux informations clés :
[1]: Il s'agit du numéro de tâche (job ID). Le shell attribue un identifiant unique de tâche à chaque processus en arrière-plan.12345: Il s'agit du numéro de processus (PID). Le système d'exploitation attribue un PID unique à chaque processus en cours d'exécution. Votre PID sera différent de cet exemple.
Maintenant que le processus s'exécute en arrière-plan, comment vérifier son statut ? Vous pouvez utiliser la commande jobs, qui liste toutes les tâches en cours d'exécution en arrière-plan pour la session de shell actuelle.
Exécutez la commande jobs dans votre terminal :
jobs
La sortie affichera la commande sleep que nous venons de lancer, ainsi que son identifiant de tâche et son statut actuel.
[1]+ Running sleep 300 &
Vous avez démarré avec succès un processus en arrière-plan et savez désormais comment vérifier son statut. Il s'agit d'une compétence fondamentale pour gérer des tâches de longue durée sur un système Linux. Dans les étapes suivantes, nous explorerons comment interagir avec cette tâche en arrière-plan.
Inspecter les processus en cours avec ps
Dans cette étape, vous utiliserez la commande ps pour inspecter les processus en cours d'exécution. Lors de l'étape précédente, vous avez utilisé la commande jobs pour voir le processus en arrière-plan dans votre shell actuel. Cependant, jobs se limite à votre session. La commande ps fournit un aperçu plus global des processus en cours au moment précis où vous l'exécutez.
Commençons par exécuter ps sans aucune option. Cette commande fournit un instantané des processus appartenant à l'utilisateur actuel et rattachés au terminal actif.
ps
Le résultat sera minimal, affichant probablement seulement votre shell (zsh) et la commande ps que vous venez d'exécuter. Les PID seront différents sur votre système.
PID TTY TIME CMD
23882 pts/0 00:00:00 zsh
23953 pts/0 00:00:00 ps
Pour voir tous les processus en cours sur le système, et non seulement ceux de votre terminal, vous pouvez utiliser ps avec des options. Une combinaison très courante et utile est ps aux.
a: affiche les processus de tous les utilisateurs.u: affiche les informations dans un format orienté utilisateur (montrant l'utilisateur, le pourcentage de CPU, de mémoire, etc.).x: inclut les processus qui ne sont pas attachés à un terminal.
Une longue liste de processus n'est pas très utile si vous recherchez quelque chose de spécifique. Nous pouvons combiner ps avec la commande grep pour filtrer la sortie. Trouvons le processus sleep que vous avez démarré à l'étape précédente.
ps aux | grep sleep
Cette commande filtre la sortie de ps aux et n'affiche que les lignes contenant le mot "sleep".
labex 23885 0.0 0.0 7264 868 pts/0 S 11:50 0:00 sleep 300
labex 23962 0.0 0.0 10788 2240 pts/0 S+ 11:52 0:00 grep --color=auto sleep
Vous verrez probablement deux lignes dans le résultat. L'une correspond à votre processus sleep 300. L'autre est la commande grep sleep elle-même, qui s'exécutait au moment exact où ps a capturé la liste des processus. Remarquez que le PID de sleep 300 (dans cet exemple, 23885) correspond à celui que vous aviez vu lorsque vous aviez lancé la commande en arrière-plan.
Un autre format populaire pour afficher les processus est ps -ef.
-e: sélectionne tous les processus du système.-f: affiche un format de liste "complet" (full), qui inclut des informations utiles telles que l'identifiant du processus parent (PPID).
Essayons-le, toujours en utilisant grep pour trouver notre processus sleep.
ps -ef | grep sleep
Le format de sortie est différent, mais il fournit des informations similaires. Cette vue est particulièrement utile pour observer la hiérarchie des processus via les colonnes PID et PPID.
UID PID PPID C STIME TTY TIME CMD
labex 23885 23882 0 11:50 pts/0 00:00:00 sleep 300
labex 23964 23882 0 11:53 pts/0 00:00:00 grep --color=auto sleep
Vous avez désormais vu comment utiliser ps pour obtenir un instantané des processus du système. En le combinant avec des outils comme grep, vous pouvez rapidement trouver et inspecter des processus spécifiques.
Surveiller les ressources du système avec top
Dans cette étape, vous apprendrez à utiliser top, un outil puissant de surveillance du système en temps réel. Alors que ps vous donne un instantané statique des processus, top fournit une vue dynamique et mise à jour en continu de l'activité du système, ce qui le rend inestimable pour identifier instantanément les processus gourmands en ressources.
Pour commencer, tapez simplement top dans votre terminal et appuyez sur Entrée.
top
L'intégralité de votre fenêtre de terminal sera occupée par l'interface de top. Elle ressemblera à ceci, les données s'actualisant toutes les quelques secondes.
top - 12:05:15 up 15 min, 1 user, load average: 0.00, 0.01, 0.00
Tasks: 115 total, 1 running, 114 sleeping, 0 stopped, 0 zombie
%Cpu(s): 0.1 us, 0.1 sy, 0.0 ni, 99.8 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st
MiB Mem : 1987.2 total, 985.4 free, 501.8 used, 500.0 buff/cache
MiB Swap: 2048.0 total, 2048.0 free, 0.0 used. 1325.4 avail Mem
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
1 root 20 0 167900 12936 8488 S 0.0 0.6 0:01.15 systemd
2 root 20 0 0 0 0 S 0.0 0.0 0:00.00 kthreadd
...
L'interface de top est divisée en deux parties principales :
- La zone de résumé (summary area) en haut affiche des statistiques globales sur le système, telles que le temps de fonctionnement (uptime), le nombre de tâches, la charge du processeur (
%Cpu(s)) et l'utilisation de la mémoire (MiB Mem). - La liste des processus en dessous affiche les processus individuels, triés par défaut par utilisation du processeur (
%CPU).
La commande top est interactive. Vous pouvez utiliser différentes touches pour modifier son comportement. Essayons-en quelques-unes :
Appuyez sur M (majuscule 'm') pour trier par utilisation de la mémoire. La liste sera re-triée en fonction de la colonne %MEM, plaçant les processus les plus gourmands en mémoire tout en haut.
Appuyez sur P (majuscule 'p') pour trier par utilisation du processeur. Cela remettra la liste dans l'ordre par défaut, basé sur la colonne %CPU.
Essayez de repérer le processus sleep que vous avez démarré plus tôt. Il se trouvera probablement loin dans la liste car il n'utilise aucun processeur. Vous pouvez utiliser les touches Flèche Bas et Flèche Haut pour faire défiler la liste des processus.
Lorsque vous avez fini d'observer, vous pouvez quitter top à tout moment.
Appuyez sur q pour quitter l'interface de top et revenir à votre invite de commande.
Vous avez désormais utilisé top pour obtenir une vue en temps réel des processus de votre système et de leur utilisation des ressources. C'est la commande incontournable pour tout administrateur système qui résout des problèmes de performance.
Gérer le contrôle des tâches avec fg, bg et Ctrl-Z
Dans cette étape, vous apprendrez à gérer l'état de vos tâches en cours d'exécution. Vous savez déjà comment lancer une tâche en arrière-plan, mais que se passe-t-il si vous lancez une commande de longue durée au premier plan et réalisez ensuite que vous avez besoin de récupérer votre terminal ? Le contrôle des tâches (job control) vous permet de déplacer des processus entre le premier plan et l'arrière-plan, ainsi que de les suspendre (arrêter) et de les reprendre.
Travaillons avec le processus sleep 300 que vous avez lancé précédemment. Tout d'abord, vérifiez son statut avec la commande jobs pour vous assurer qu'il est toujours en cours d'exécution.
jobs
Vous devriez voir votre tâche sleep s'exécuter en arrière-plan.
[1] + running sleep 300
Maintenant, ramenons cette tâche au premier plan. Pour ce faire, utilisez la commande fg (foreground) suivie de l'identifiant de la tâche préfixé par %. Comme notre ID de tâche est 1, la commande est :
fg %1
Le shell affichera le nom de la commande avec des informations supplémentaires sur la tâche, et votre invite de commande disparaîtra. Le terminal est désormais "occupé" par la commande sleep 300, qui attend qu'elle se termine.
[1] + 394 running sleep 300
Pour récupérer votre terminal sans tuer le processus, vous pouvez le suspendre. Appuyez sur la combinaison de touches Ctrl-Z (maintenez la touche Ctrl enfoncée et appuyez sur Z).
Cette action envoie un signal spécial (SIGTSTP) au processus, ce qui met en pause son exécution. Le processus n'est pas terminé ; il est simplement suspendu. Vous verrez un message le confirmant, et votre invite de commande réapparaîtra.
[1] + 394 suspended sleep 300
Vérifiez à nouveau le statut de vos tâches :
jobs
La sortie indique désormais que le statut de la tâche est "suspendu" (suspended).
[1] + suspended sleep 300
Une tâche arrêtée peut être reprise. Vous pouvez la reprendre au premier plan avec fg ou en arrière-plan avec bg. Reprenons-la en arrière-plan à l'aide de la commande bg.
bg %1
Le shell confirmera que la tâche s'exécute à nouveau en arrière-plan.
[1] + 394 continued sleep 300
Vous pouvez vérifier son statut une dernière fois avec jobs pour constater qu'elle est repassée à l'état "Running". Vous avez désormais réussi à déplacer un processus de l'arrière-plan vers le premier plan, à le suspendre, puis à le reprendre en arrière-plan.
Ajuster la priorité des processus avec renice
Dans cette étape, vous apprendrez à influencer la priorité d'ordonnancement d'un processus en cours d'exécution. Sous Linux, le niveau de "gentillesse" (niceness) d'un processus détermine la quantité de temps processeur (CPU) qu'il obtient par rapport aux autres processus. La valeur de gentillesse va de -20 (priorité la plus haute) à +19 (priorité la plus basse). Par défaut, la plupart des processus démarrent avec une valeur de gentillesse de 0. Une valeur de niceness élevée signifie que le processus est "plus gentil" avec les autres processus, en leur cédant plus facilement du temps processeur.
Nous allons ajuster la priorité du processus sleep sur lequel vous travaillez. Pour ce faire, vous avez d'abord besoin de son identifiant de processus (PID). Vous pouvez le retrouver à l'aide de ps et grep.
ps aux | grep sleep
Recherchez la ligne correspondant à sleep 300 (et non la commande grep elle-même) et notez son PID situé dans la deuxième colonne.
labex 23885 0.0 0.0 7264 868 pts/0 S 11:50 0:00 sleep 300
labex 24101 0.0 0.0 10788 2240 pts/0 S+ 12:15 0:00 grep --color=auto sleep
Dans cet exemple, le PID est 23885. Vous devez utiliser le PID provenant de votre propre sortie dans les commandes suivantes.
Vérifions maintenant la valeur de gentillesse actuelle (NI) du processus. La commande ps avec l'option -o vous permet de spécifier des colonnes de sortie personnalisées.
ps -o pid,ni,cmd -p <YOUR_PID>
Remplacez <YOUR_PID> par le PID réel de votre processus sleep. Par exemple : ps -o pid,ni,cmd -p 23885.
PID NI CMD
23885 0 sleep 300
Comme prévu, la valeur de gentillesse par défaut (NI) est 0.
Modifions maintenant cette valeur à l'aide de la commande renice. Nous allons augmenter la valeur de gentillesse à 10, ce qui abaissera la priorité du processus. Les utilisateurs ordinaires ne peuvent augmenter que la valeur de gentillesse de leurs propres processus (ce qui réduit leur priorité).
renice -n 10 -p <YOUR_PID>
Encore une fois, remplacez <YOUR_PID> par le PID de votre processus. La commande indiquera l'ancienne et la nouvelle priorité.
23885 (process ID) old priority 0, new priority 10
Enfin, vérifiez que la modification a bien pris effet en réexécutant la commande ps :
ps -o pid,ni,cmd -p <YOUR_PID>
La sortie devrait maintenant afficher la nouvelle valeur de gentillesse.
PID NI CMD
23885 10 sleep 300
Vous avez modifié avec succès la priorité d'un processus en cours d'exécution. C'est une technique utile pour s'assurer que les tâches d'arrière-plan de longue durée et non critiques ne perturbent pas le travail plus important au premier plan.
Terminer un processus avec kill
Dans cette étape, vous apprendrez à terminer un processus. Bien que certains processus se terminent d'eux-mêmes, vous aurez souvent besoin d'arrêter manuellement un processus qui n'est plus nécessaire, qui se comporte mal ou qui a été démarré à des fins temporaires, comme notre commande sleep. L'outil principal pour cela est la commande kill.
La commande kill envoie un signal à un processus spécifié. Par défaut, elle envoie le signal SIGTERM (terminate), qui demande poliment au processus de s'arrêter, lui permettant d'effectuer d'éventuelles opérations de nettoyage avant de se fermer.
Vous pouvez cibler un processus en utilisant soit son numéro de processus (PID), soit, pour les tâches en arrière-plan de votre shell actuel, son identifiant de tâche (job ID). Utiliser l'identifiant de tâche est souvent plus pratique.
Tout d'abord, vérifions que notre tâche sleep est toujours en cours d'exécution.
jobs
Vous devriez voir le processus sleep listé.
[1]+ Running sleep 300 &
Maintenant, utilisez la commande kill avec l'identifiant de tâche (%1) pour le terminer.
kill %1
Après avoir exécuté la commande, le shell affichera probablement un message dans le terminal indiquant que la tâche a été terminée. Ce message peut apparaître immédiatement ou après avoir appuyé à nouveau sur Entrée.
[1]+ Terminated sleep 300
Vérifions que le processus a complètement disparu. Exécutez à nouveau la commande jobs.
jobs
La commande ne devrait plus produire aucun affichage, puisqu'il n'y a plus de tâches actives dans cette session de shell. Vous pouvez également utiliser ps pour double-vérifier.
ps aux | grep sleep
La seule ligne que vous pourriez voir est la commande grep sleep elle-même. Le processus d'origine sleep 300 ne s'exécute plus.
Dans les cas où un processus ne répond pas et ne réagit pas au signal par défaut SIGTERM, vous pouvez envoyer un signal plus radical, SIGKILL (signal numéro 9), qui termine immédiatement le processus sans lui laisser la chance de se nettoyer. La commande serait kill -9 %1. Cela doit être utilisé en dernier recours.
Félicitations ! Vous avez désormais pratiqué le cycle de vie complet de la gestion de base des processus sous Linux : démarrer un processus en arrière-plan, l'inspecter avec ps et top, le gérer via le contrôle des tâches, ajuster sa priorité et enfin, le terminer.
Résumé
Dans ce laboratoire, vous avez appris les compétences fondamentales pour gérer et surveiller les processus dans un environnement Linux. Vous avez commencé par exécuter un processus en arrière-plan à l'aide de l'opérateur & et avez affiché son statut avec la commande jobs. Vous avez ensuite exploré comment inspecter tous les processus en cours avec ps pour trouver des détails tels que le numéro de processus (PID), et comment utiliser top pour surveiller en temps réel l'utilisation des ressources système et les processus actifs.
De plus, vous avez pratiqué le contrôle des tâches en suspendant un processus de premier plan avec Ctrl-Z, en le déplaçant en arrière-plan avec bg, et en le ramenant au premier plan avec fg. Vous avez également appris à ajuster la priorité d'ordonnancement d'un processus à l'aide de renice et à terminer un processus proprement à l'aide de la commande kill en utilisant son PID.
