Gérer et surveiller les processus Linux

Introduction

Dans cet atelier, vous allez acquérir les compétences fondamentales pour gérer et surveiller les processus sur un système Linux. Vous explorerez comment interagir avec les processus s'exécutant aussi bien en avant-plan qu'en arrière-plan, ce qui vous offrira un meilleur contrôle sur votre environnement en ligne de commande et sur les ressources du système. Cette expérience pratique est indispensable pour toute personne travaillant sous Linux, des administrateurs système aux développeurs.

Vous commencerez par lancer une tâche en arrière-plan à l'aide de l'opérateur & et par vérifier son état avec jobs. Vous inspecterez ensuite les processus en cours avec ps, surveillerez l'activité du système en temps réel avec top, et pratiquerez le contrôle des tâches à l'aide de fg, bg et Ctrl-Z. Pour terminer l'atelier, vous apprendrez à ajuster la priorité d'un processus avec renice et à l'arrêter à l'aide de la commande kill, couvrant ainsi tout le cycle de vie de la gestion des processus.

Lancer et visualiser un processus en arrière-plan avec `&` et `jobs`

Dans cette étape, vous apprendrez à exécuter une commande en arrière-plan et à consulter l'état des tâches en cours. 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 en avant-plan. Cependant, pour les tâches de longue durée, il est souvent préférable de les lancer en arrière-plan afin de pouvoir continuer à utiliser votre terminal pour d'autres commandes.

Pour exécuter une commande en arrière-plan, il suffit d'ajouter une esperluette (&) à la fin de la ligne de commande. Essayons cela avec la commande sleep, un utilitaire simple qui met le système en pause pendant une durée déterminée.

Exécutez la commande suivante pour lancer sleep pendant 300 secondes en arrière-plan. Cela nous permettra de manipuler ce processus lors des étapes suivantes.

sleep 300 &

Après avoir appuyé sur Entrée, vous verrez un message similaire à celui-ci, et l'invite de commande réapparaîtra 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 de fond. La sortie fournit deux informations clés :

[1] : Il s'agit de l'identifiant de tâche (job ID). Le shell attribue un identifiant unique à chaque processus en arrière-plan.
12345 : Il s'agit de l'identifiant 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 celui de l'exemple.

Maintenant que le processus tourne en arrière-plan, comment vérifier son état ? Vous pouvez utiliser la commande jobs, qui liste toutes les tâches s'exécutant en arrière-plan dans la session shell actuelle.

Lancez la commande jobs dans votre terminal :

jobs

Le résultat affichera la commande sleep que nous venons de lancer, ainsi que son identifiant de tâche et son état actuel.

[1]+  Running                 sleep 300 &

Vous avez réussi à lancer un processus en arrière-plan et vous savez comment vérifier son état. C'est une compétence de base pour gérer les tâches longues sur un système Linux. Dans les étapes suivantes, nous verrons comment interagir avec cette tâche.

Inspecter les processus en cours avec `ps`

Dans l'étape précédente, vous avez utilisé la commande jobs pour voir le processus en arrière-plan de votre shell actuel. Cependant, jobs se limite à votre session. Pour obtenir une vue d'ensemble de tous les processus s'exécutant sur le système, vous avez besoin d'un outil plus puissant : ps (process status). La commande ps fournit un instantané des processus au moment précis où vous l'exécutez.

Commençons par lancer ps sans aucune option. Cette commande donne un aperçu des processus appartenant à l'utilisateur actuel et rattachés au terminal actif.

ps

Le résultat sera minimal, affichant probablement uniquement votre shell (zsh) et la commande ps que vous venez de lancer. 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 du système, et pas 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 (utilisateur, % CPU, % MEM, etc.).
x : inclut les processus qui ne sont pas rattachés à un terminal.

Une longue liste de processus n'est pas très utile si vous cherchez quelque chose de précis. Nous pouvons combiner ps avec la commande grep pour filtrer les résultats. Cherchons le processus sleep lancé précédemment.

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. L'une correspond à votre processus sleep 300. L'autre est la commande grep sleep elle-même, qui était en cours d'exécution au moment où ps a capturé la liste. Notez que le PID de sleep 300 (dans cet exemple, 23885) correspond à celui que vous avez vu lors du lancement en arrière-plan.

Un autre format populaire pour visualiser les processus est ps -ef.

-e : sélectionne tous les processus du système.
-f : affiche un format de liste "complet" (full), incluant des informations utiles comme le PID du processus parent (PPID).

Essayons-le, en utilisant à nouveau 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 maintenant vu comment utiliser ps pour obtenir un instantané des processus système. En le combinant avec des outils comme grep, vous pouvez rapidement localiser et inspecter des processus spécifiques.

Surveiller les ressources système avec `top`

Dans cette étape, vous allez apprendre à utiliser top, un outil puissant pour la surveillance du système en temps réel. Alors que ps vous donne un instantané statique, top offre une vue dynamique et continuellement mise à jour de l'activité du système, ce qui est inestimable pour identifier les processus gourmands en ressources au moment où cela se produit.

Pour commencer, tapez simplement top dans votre terminal et appuyez sur Entrée.

top

L'interface de top va occuper toute la fenêtre de votre terminal. 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é en haut affiche des statistiques globales du système comme le temps de fonctionnement (uptime), le nombre de tâches, la charge CPU (%Cpu(s)) et l'utilisation de la mémoire (MiB Mem).
La liste des processus en dessous montre les processus individuels, triés par défaut par utilisation du processeur (%CPU).

La commande top est interactive. Vous pouvez utiliser plusieurs touches pour modifier son comportement. Essayons-en quelques-unes :

Trier par utilisation de la mémoire : Appuyez sur M (majuscule). La liste sera réorganisée en fonction de la colonne %MEM, affichant les processus les plus gourmands en mémoire en haut.
Trier par utilisation du processeur : Appuyez sur P (majuscule). Cela rétablira le tri par défaut selon la colonne %CPU.
Trouver votre processus sleep : Vous pouvez essayer de repérer le processus sleep lancé plus tôt. Il sera probablement loin dans la liste car il ne consomme pas de CPU. Vous pouvez utiliser les touches Flèche Bas et Flèche Haut pour faire défiler la liste.

Lorsque vous avez terminé vos observations, vous pouvez quitter top à tout moment.

Quitter top : Appuyez sur q pour fermer l'interface et revenir à l'invite de commande.

Vous avez maintenant utilisé top pour obtenir une vue en temps réel des processus et de l'utilisation des ressources de votre système. C'est la commande de référence pour tout administrateur système cherchant à diagnostiquer 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. Vous savez déjà comment lancer une tâche en arrière-plan, mais que se passe-t-il si vous lancez une commande longue en avant-plan et réalisez ensuite que vous avez besoin de récupérer la main sur votre terminal ? Le contrôle des tâches vous permet de déplacer des processus entre l'avant-plan et l'arrière-plan, ainsi que de les mettre en pause (stop) et de les reprendre.

Travaillons avec le processus sleep 300 lancé précédemment. Tout d'abord, vérifiez son état avec la commande jobs pour vous assurer qu'il est toujours actif.

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 tâche précédé d'un %. Comme notre identifiant est 1, la commande est :

fg %1

Le shell affichera le nom de la commande avec des informations supplémentaires, et votre invite de commande disparaîtra. Le terminal est maintenant "occupé" par la commande sleep 300, en attendant 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 interrompt son exécution. Le processus n'est pas arrêté définitivement ; il est simplement suspendu. Vous verrez un message confirmant cela, et votre invite de commande réapparaîtra.

[1]  + 394 suspended  sleep 300

Maintenant, vérifiez à nouveau l'état de vos tâches :

jobs

Le résultat indique désormais que l'état de la tâche est "suspended" (suspendu).

[1]  + suspended  sleep 300

Une tâche suspendue peut être reprise. Vous pouvez la relancer en avant-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 état une dernière fois avec jobs pour constater qu'elle est revenue à l'état "Running". Vous avez maintenant réussi à déplacer un processus de l'arrière-plan vers l'avant-plan, à le suspendre, puis à le relancer en arrière-plan.

Ajuster la priorité d'un processus avec `renice`

Dans cette étape, vous apprendrez à influencer la priorité d'ordonnancement d'un processus en cours d'exécution. Sous Linux, la "gentillesse" (niceness) d'un processus détermine la quantité de temps CPU qu'il reçoit par rapport aux autres. La valeur de "nice" varie de -20 (priorité la plus haute) à +19 (priorité la plus basse). Par défaut, la plupart des processus commencent avec une valeur de 0. Une valeur plus élevée signifie que le processus est plus "gentil" envers les autres, cédant plus facilement du temps CPU.

Nous allons ajuster la priorité du processus sleep sur lequel vous travaillez. Pour cela, vous avez d'abord besoin de son identifiant de processus (PID). Vous pouvez le retrouver avec ps et grep.

ps aux | grep sleep

Cherchez la ligne correspondant à sleep 300 (pas la commande grep elle-même) et notez son PID 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 issu de votre propre terminal dans les commandes suivantes.

Vérifions maintenant la valeur actuelle de "nice" (NI) du processus. La commande ps avec l'option -o permet de spécifier des colonnes de sortie personnalisées.

ps -o pid,ni,cmd -p <VOTRE_PID>

Remplacez <VOTRE_PID> par le PID réel de votre processus sleep. Par exemple : ps -o pid,ni,cmd -p 23885.

    PID  NI CMD
  23885   5 sleep 300

Comme prévu, la valeur par défaut est 5 (ou 0 selon la configuration du système).

Changeons maintenant cette valeur à l'aide de la commande renice. Nous allons augmenter la valeur à 10, ce qui abaissera la priorité du processus. Les utilisateurs réguliers ne peuvent qu'augmenter la valeur de "nice" de leurs propres processus (les rendant moins prioritaires).

renice -n 10 -p <VOTRE_PID>

Encore une fois, remplacez <VOTRE_PID> par le PID de votre processus. La commande indiquera l'ancienne et la nouvelle priorité.

23885 (process ID) old priority 5, new priority 10

Enfin, vérifiez que le changement a bien été pris en compte en relançant la commande ps :

ps -o pid,ni,cmd -p <VOTRE_PID>

Le résultat devrait maintenant afficher la nouvelle valeur de "nice".

    PID  NI CMD
  23885  10 sleep 300

Vous avez réussi à modifier la priorité d'un processus en cours. C'est une technique utile pour s'assurer que des tâches de fond longues et non critiques n'interfèrent pas avec un travail plus important en avant-plan.

Arrêter un processus avec `kill`

Dans cette dernière étape, vous apprendrez à arrêter un processus. Bien que certains processus se terminent d'eux-mêmes, vous devrez souvent arrêter manuellement un processus qui n'est plus nécessaire, qui se comporte mal ou qui a été lancé à 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 (terminer), qui demande poliment au processus de s'arrêter, lui permettant d'effectuer ses opérations de nettoyage avant de quitter.

Vous pouvez cibler un processus soit par son PID, soit, pour les tâches en arrière-plan de votre shell actuel, par son identifiant de tâche. Utiliser l'identifiant de tâche est souvent plus pratique.

Tout d'abord, confirmons que notre tâche sleep est toujours en cours.

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 l'arrêter.

kill %1

Après avoir exécuté la commande, le shell affichera probablement un message indiquant que la tâche a été arrêté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 bien disparu. Relancez la commande jobs.

jobs

La commande ne devrait plus rien afficher, car il n'y a plus de tâches actives dans cette session shell. Vous pouvez également vérifier avec ps.

ps aux | grep sleep

La seule ligne que vous pourriez voir est la commande grep sleep elle-même. Le processus sleep 300 d'origine n'existe plus.

Dans les cas où un processus ne répond plus et ne réagit pas au signal SIGTERM par défaut, vous pouvez envoyer un signal plus radical, SIGKILL (signal numéro 9), qui arrête le processus immédiatement sans lui laisser la possibilité de se nettoyer. La commande serait alors kill -9 %1. Cela doit être utilisé en dernier recours.

Félicitations ! Vous avez pratiqué le cycle de vie complet de la gestion de base des processus sous Linux : lancement en arrière-plan, inspection avec ps et top, manipulation via le contrôle des tâches, ajustement de la priorité et, enfin, arrêt du processus.

Résumé

Dans cet atelier, 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 consulté son état avec la commande jobs. Vous avez ensuite exploré comment inspecter tous les processus en cours avec ps pour trouver des détails tels que l'identifiant de processus (PID), et comment utiliser top pour une surveillance en temps réel de l'utilisation des ressources système et des processus actifs.

De plus, vous avez pratiqué le contrôle des tâches en suspendant un processus d'avant-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 à arrêter un processus proprement en utilisant la commande kill avec son PID.