Surveiller les processus sous Red Hat Enterprise Linux

Introduction

Dans ce laboratoire, vous acquerrez une expérience pratique dans la surveillance et la gestion des processus Linux, une compétence fondamentale pour tout administrateur système ou développeur. Vous apprendrez à comprendre les états et les cycles de vie des processus à l'aide de ps et top, à contrôler les tâches en arrière-plan et en premier plan, et à terminer les processus efficacement avec kill, killall et pkill. De plus, vous explorerez comment surveiller la charge du système et l'utilisation du processeur à l'aide de uptime et lscpu, et analyserez en détail l'activité des processus avec top. Ce laboratoire vous fournira les outils et les connaissances essentiels pour gérer efficacement les processus et maintenir la santé du système sur RHEL.

Comprendre les états et le cycle de vie des processus avec ps et top

Dans cette étape, vous apprendrez les états des processus Linux et leur cycle de vie. Comprendre les états des processus est crucial pour surveiller et gérer efficacement les ressources système. Vous utiliserez les commandes ps et top pour observer les processus et leurs états.

Chaque processus dans Linux possède un état qui décrit son activité actuelle. Ces états sont définis par le noyau et indiquent si un processus est en cours d'exécution, en veille, arrêté ou dans d'autres conditions.

Commençons par examiner les états des processus à l'aide de la commande ps. La commande ps fournit une capture instantanée des processus en cours.

Tout d'abord, ouvrez votre terminal. Vous pouvez le faire en cliquant sur l'icône du terminal sur le bureau ou en appuyant sur Ctrl+Alt+T. Votre répertoire de travail par défaut est ~/project.

Pour voir tous les processus en cours d'exécution sur votre système, y compris ceux sans terminal de contrôle, utilisez la commande ps aux. Les options aux affichent les processus appartenant à tous les utilisateurs (a), les processus sans terminal de contrôle (x), et présentent un format orienté utilisateur (u).

ps aux

Vous verrez une longue liste de processus. Faites attention à la colonne STAT, qui indique l'état de chaque processus. Les états courants que vous pourriez observer incluent :

• R : En cours d'exécution ou exécutable (sur le processeur ou en attente d'exécution)
• S : Sommeil interruptible (en attente d'un événement à terminer)
• D : Sommeil non interruptible (en attente d'E/S, ne peut pas être interrompu)
• T : Arrêté (suspendu par un signal)
• Z : Zombi (processus terminé, mais le processus parent n'a pas récupéré son statut de sortie)

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.2 171820 16140 ?        Ss   HH:MM   0:01 /usr/lib/systemd/systemd ...
root           2  0.0  0.0      0     0 ?        S    HH:MM   0:00 [kthreadd]
labex       3448  0.0  0.2 266904  3836 pts/0    R+   HH:MM   0:00 ps aux
...sortie omise...

Ensuite, utilisons la commande ps -ef. Cette commande fournit une liste complète (f) de tous les processus (e), affichant plus de détails comme l'ID du processus parent (PPID), l'utilisation du processeur (C), l'heure de démarrage (STIME) et la commande (CMD).

ps -ef

Cette sortie est souvent utilisée pour voir les relations parent-enfant entre les processus, bien qu'elle n'affiche pas explicitement une structure arborescente.

UID        PID  PPID  C STIME TTY          TIME CMD
root           1       0  0 HH:MM ?        00:00:01 /usr/lib/systemd/systemd ...
root           2       0  0 HH:MM ?        00:00:00 [kthreadd]
root           3       2  0 HH:MM ?        00:00:00 [rcu_gp]
...sortie omise...

Pour visualiser la hiérarchie des processus, vous pouvez utiliser l'option ps --forest. Cela affiche les processus sous forme d'arbre, ce qui facilite la compréhension de la façon dont les processus ont été créés.

ps --forest

Cette commande est particulièrement utile pour le débogage et la compréhension de la structure des différents services et applications sur votre système.

  PID TTY          TIME CMD
 2768 pts/0    00:00:00 bash
 5947 pts/0    00:00:00  \_ sleep 10000
 6377 pts/0    00:00:00  \_ ps --forest
...sortie omise...

Maintenant, explorons la commande top, qui fournit une vue dynamique en temps réel d'un système en cours d'exécution. Elle affiche un résumé des informations système et une liste des processus ou threads actuellement gérés par le noyau Linux.

Exécutez la commande top :

top

Vous verrez une affichage interactif. La partie supérieure fournit des informations de résumé système, y compris le temps de fonctionnement, la charge moyenne, le résumé des tâches, les statistiques du processeur et l'utilisation de la mémoire. La partie inférieure liste les processus individuels, triés par défaut par utilisation du processeur.

Dans la sortie top, observez la colonne S pour les états des processus, similaire à ps. Vous pouvez également voir %CPU (pourcentage d'utilisation du processeur) et %MEM (pourcentage d'utilisation de la mémoire) pour chaque processus.

top - HH:MM:SS up DD min,  X users,  load average: X.XX, X.XX, X.XX
Tasks: XXX total,   X running, XXX sleeping,   X stopped,   X zombie
%Cpu(s):  X.X us,  X.X sy,  X.X ni, XX.X id,  X.X wa,  X.X hi,  X.X si,  X.X st
MiB Mem :   XXXX.X total,   XXXX.X free,    XXX.X used,    XXX.X buff/cache
MiB Swap:   XXXX.X total,   XXXX.X free,      X.X used.   XXXX.X avail Mem

PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
XXXX labex     20   0  XXXXXX   XXXX   XXXX R   X.X   X.X   0:00.0X top
...sortie omise...

Pendant que top est en cours d'exécution, vous pouvez appuyer sur q pour quitter et revenir à votre invite de terminal.

La compréhension de ces commandes et des informations qu'elles fournissent est fondamentale pour la surveillance et le dépannage des processus sur un système Linux.

Contrôler les tâches en arrière-plan et en premier plan

Dans cette étape, vous apprendrez à gérer les tâches en arrière-plan et en premier plan au sein de votre session de shell. Il s'agit d'une compétence fondamentale pour une utilisation efficace de la ligne de commande, vous permettant d'exécuter des tâches longues sans bloquer votre terminal.

Une « tâche » dans le contexte d'un shell fait référence à une commande ou à un pipeline de commandes que le shell gère. Vous pouvez exécuter des tâches en arrière-plan, les ramener en premier plan ou les suspendre.

Commençons par exécuter une commande simple en arrière-plan. Nous utiliserons la commande sleep, qui attend simplement une durée spécifiée.

Pour exécuter sleep 10000 (qui attend 10 000 secondes) en arrière-plan, ajoutez un signe d'ampersand (&) à la commande :

sleep 10000 &

Lorsque vous appuyez sur Entrée, le shell reviendra immédiatement à l'invite, et la commande sleep s'exécutera en arrière-plan. Vous verrez une sortie similaire à ceci, indiquant le numéro de tâche et son ID de processus (PID) :

[1] 5947

[1] indique qu'il s'agit de la tâche numéro 1 dans votre session de shell actuelle, et 5947 est le PID du processus sleep.

Pour afficher la liste de toutes les tâches actuellement gérées par votre shell, utilisez la commande jobs :

jobs

Vous devriez voir la commande sleep répertoriée comme une tâche en arrière-plan en cours d'exécution :

[1]+ Running    sleep 10000 &

Le + à côté de [1] indique qu'il s'agit de la tâche courante (celle qui serait traitée par défaut si vous n'avez pas spécifié de numéro de tâche).

Maintenant, ramenons cette tâche en arrière-plan en premier plan. Cela signifie que la tâche reprendra le contrôle de votre terminal. Utilisez la commande fg suivie du numéro de tâche (préfixé par %) :

fg %1

La commande sleep 10000 sera maintenant en premier plan. Votre terminal sera occupé par cette commande, et vous n'obtiendrez pas d'invite jusqu'à ce qu'elle soit terminée ou suspendue.

sleep 10000

Lorsqu'une commande s'exécute en premier plan, vous pouvez la déplacer en arrière-plan et la suspendre en appuyant sur Ctrl+Z. Cela envoie un signal SIGTSTP au processus.

Appuyez sur Ctrl+Z maintenant :

^Z

Vous verrez une sortie indiquant que la tâche a été arrêtée et déplacée en arrière-plan :

[1]+  Stopped                 sleep 10000

Maintenant, si vous exécutez à nouveau jobs, vous verrez que la commande sleep est dans un état Stopped :

jobs

[1]+ Stopped                 sleep 10000

Pour reprendre une tâche en arrière-plan arrêtée, vous pouvez utiliser la commande bg suivie du numéro de tâche. Cela redémarrera la tâche en arrière-plan.

bg %1

La tâche sera à nouveau en cours d'exécution en arrière-plan :

[1]+ sleep 10000 &

Enfin, nettoyons la tâche en arrière-plan. Vous pouvez terminer une tâche en arrière-plan en utilisant la commande kill avec son PID, ou en la ramenant en premier plan puis en la terminant (par exemple, avec Ctrl+C). Pour l'instant, ramenons-la en premier plan et terminons-la.

fg %1

Maintenant que sleep 10000 est en premier plan, appuyez sur Ctrl+C pour la terminer. Cela envoie un signal SIGINT au processus.

^C

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

[1]+  Terminated              sleep 10000

Si vous exécutez à nouveau jobs, vous devriez constater qu'il n'y a plus de tâches répertoriées :

jobs

(aucune sortie)

Ceci démontre le flux de travail de base de la gestion des tâches en arrière-plan et en premier plan, essentiel pour le multitâche dans le terminal.

Terminer les processus avec kill, killall et pkill

Dans cette étape, vous apprendrez à terminer les processus à l'aide des commandes kill, killall et pkill. Ces commandes sont essentielles pour gérer les ressources système et arrêter les applications malveillantes.

Les processus Linux répondent aux signaux. Un signal est une interruption logicielle envoyée à un processus. Différents signaux ont des significations différentes, telles que la terminaison d'un processus, sa suspension ou le rechargement de sa configuration.

Commençons par comprendre quelques signaux de gestion de processus fondamentaux :

• SIGTERM (15) : Le signal par défaut envoyé par kill. Il s'agit d'une demande « poli » de terminaison. Le processus peut intercepter ce signal, effectuer des opérations de nettoyage, puis quitter.
• SIGKILL (9) : Un signal « non blocable » qui force une terminaison immédiate. Le processus ne peut pas ignorer ou gérer ce signal. Utilisez-le en dernier recours.
• SIGHUP (1) : Souvent utilisé pour indiquer à un processus de recharger ses fichiers de configuration sans redémarrer.
• SIGINT (2) : Envoyé en appuyant sur Ctrl+C, généralement utilisé pour interrompre un processus en premier plan.
• SIGSTOP (19) : Suspend un processus. Il ne peut pas être bloqué ou géré.
• SIGCONT (18) : Reprend un processus arrêté.

Vous pouvez lister tous les signaux disponibles et leurs numéros à l'aide de kill -l :

kill -l

Vous verrez une liste de signaux comme celle-ci :

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
...sortie omise...

Utilisation de kill

La commande kill envoie un signal spécifié à un processus identifié par son ID de processus (PID).

Créons quelques processus en arrière-plan pour pratiquer leur terminaison. Nous utiliserons à nouveau les commandes sleep.

sleep 300 &
sleep 301 &
sleep 302 &

Maintenant, utilisez jobs pour voir leurs numéros de tâche et leurs PID :

jobs

[1] 1234
[2] 1235
[3] 1236

(Remarque : vos PID seront différents.)

Trouvons le PID du premier processus sleep. Vous pouvez utiliser ps aux | grep sleep et rechercher le PID associé à sleep 300.

ps aux | grep sleep

Vous verrez une sortie similaire à celle-ci. Identifiez le PID pour sleep 300. Par exemple, si le PID est 1234 :

labex       1234  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 300
labex       1235  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 301
labex       1236  0.0  0.0   2200   680 pts/0    S    HH:MM   0:00 sleep 302
labex       1237  0.0  0.0   6000  1000 pts/0    S+   HH:MM   0:00 grep sleep

Pour terminer sleep 300 en utilisant le signal SIGTERM par défaut, utilisez kill suivi de son PID. Remplacez 1234 par le PID réel que vous avez trouvé :

kill 1234

Vous pourriez voir un message comme [1]+ Terminated sleep 300. Vérifiez qu'il est parti à l'aide de jobs ou ps aux | grep sleep :

jobs

[2]- Running    sleep 301 &
[3]+ Running    sleep 302 &

Maintenant, terminons de force sleep 301 en utilisant SIGKILL. Trouvez son PID (par exemple, 1235) et utilisez kill -9 ou kill -SIGKILL :

kill -9 1235

Vous verrez probablement [2]- Killed sleep 301. Vérifiez à nouveau :

jobs

[3]+ Running    sleep 302 &

(Les sections suivantes sur killall et pkill sont similaires à la section précédente.)

Utilisation de killall et pkill (contenu similaire à la section précédente)

Ces commandes offrent des manières flexibles de gérer et de terminer les processus, de cibler un seul processus par son PID à terminer plusieurs processus en fonction de leur nom ou d'autres attributs. Soyez toujours prudent lorsque vous utilisez kill -9 ou SIGKILL, car cela peut entraîner une perte de données si le processus n'a pas la possibilité de nettoyer.

Surveiller la charge système et l'utilisation du processeur avec uptime et lscpu

Dans cette étape, vous apprendrez à surveiller la charge moyenne du système et l'utilisation du processeur à l'aide des commandes uptime et lscpu. Comprendre ces métriques est crucial pour évaluer les performances du système et identifier les goulots d'étranglement potentiels.

Comprendre la charge moyenne avec uptime

La commande uptime fournit un aperçu rapide du temps d'exécution du système, du nombre d'utilisateurs connectés et, plus important encore, de la charge moyenne du système. La charge moyenne indique le nombre moyen de processus qui sont soit en état d'exécution, soit en état non interruptible sur une période donnée.

Exécutez la commande uptime :

uptime

Vous verrez une sortie similaire à ceci :

 HH:MM:SS up DD min,  X users,  load average: X.XX, X.XX, X.XX

Décomposons la sortie :

• HH:MM:SS : L'heure actuelle.
• up DD min : Le temps d'exécution du système (uptime).
• X users : Le nombre d'utilisateurs actuellement connectés.
• load average: X.XX, X.XX, X.XX : Ces trois nombres représentent la charge moyenne du système au cours des 1, 5 et 15 dernières minutes, respectivement.

Une charge moyenne de 1.00 sur un processeur monocœur signifie que le processeur est pleinement utilisé. Sur un processeur multi-cœurs, une charge moyenne égale au nombre de cœurs de processeur signifie que le système est pleinement utilisé. Par exemple, sur un processeur quadricœur, une charge moyenne de 4.00 indique une utilisation complète. Si la charge moyenne dépasse constamment le nombre de cœurs de processeur, cela suggère que votre système est surchargé et que les processus attendent du temps de processeur.

Déterminer les cœurs de processeur avec lscpu

Pour interpréter correctement la charge moyenne, vous devez connaître le nombre de cœurs de processeur logiques de votre système. La commande lscpu fournit des informations détaillées sur l'architecture du processeur.

Exécutez la commande lscpu :

lscpu

Vous verrez une sortie étendue. Recherchez la ligne CPU(s):, qui vous indique le nombre total de processeurs logiques disponibles. De plus, Core(s) per socket: et Socket(s): peuvent vous aider à comprendre la disposition physique.

Architecture :        x86_64
CPU op-mode(s) :      32-bit, 64-bit
Ordre des octets :          Little Endian
CPU(s) :              4
Liste des CPU en ligne : 0-3
Threads par cœur :  2
Cœurs par socket :  2
Sockets :           1
Noeuds NUMA :        1
...sortie omise...

Dans l'exemple ci-dessus, CPU(s): 4 indique que ce système possède 4 cœurs de processeur logiques.

Interpréter la charge moyenne et les cœurs de processeur

Combinons les informations de uptime et lscpu. Supposons que votre sortie uptime affiche une charge moyenne de 2.92, 4.48, 5.20 et que lscpu affiche CPU(s): 4.

Pour obtenir la charge moyenne par processeur, divisez chaque nombre de charge moyenne par le nombre total de processeurs logiques :

• Dernière minute : 2.92 / 4 = 0.73
• Dernières 5 minutes : 4.48 / 4 = 1.12
• Dernières 15 minutes : 5.20 / 4 = 1.30

D'après ces calculs :

• Au cours de la dernière minute, les processeurs ont été utilisés à environ 73 % de leur capacité.
• Au cours des 5 dernières minutes, le système était surchargé d'environ 12 % (1.12 - 1.00 = 0.12). Cela signifie que les processus attendaient du temps de processeur.
• Au cours des 15 dernières minutes, le système était surchargé d'environ 30 % (1.30 - 1.00 = 0.30).

Cette analyse suggère que le système a été soumis à une charge importante au cours des 5 et 15 dernières minutes, mais que la charge a diminué au cours de la dernière minute. Ce type d'analyse de tendance est crucial pour comprendre l'état du système.

Ces deux commandes, uptime et lscpu, sont des outils simples mais puissants pour évaluer rapidement l'état général et les performances de votre système Linux.

Analyser l'activité des processus avec top

Dans cette étape, vous approfondirez l'utilisation de la commande top pour analyser l'activité des processus. Bien que top fournisse une vue en temps réel, il offre également des fonctionnalités interactives puissantes pour trier, filtrer et gérer les processus.

Rappelez-vous de l'étape précédente que top fournit une vue dynamique de votre système. Démarrons à nouveau top :

top

Vous verrez l'interface familière de top. La section supérieure fournit des statistiques système globales, et la section inférieure liste les processus.

Comprendre les colonnes de top

Passons en revue les colonnes par défaut dans la liste des processus :

• PID : ID du processus.
• USER : Le propriétaire du processus.
• PR : Priorité du processus.
• NI : Valeur Nice du processus (une valeur Nice plus faible signifie une priorité plus élevée).
• VIRT : Mémoire virtuelle utilisée par le processus.
• RES : Mémoire résidente (RAM physique) utilisée par le processus.
• SHR : Mémoire partagée utilisée par le processus.
• S : État du processus (R=Exécution, S=Sommeil, D=Sommeil non interruptible, T=Arrêté, Z=Zombie).
• %CPU : Pourcentage d'utilisation du processeur depuis la dernière mise à jour.
• %MEM : Pourcentage d'utilisation de la mémoire (RES / mémoire physique totale).
• TIME+ : Temps de processeur total utilisé par le processus depuis son démarrage.
• COMMAND : Le nom de la commande qui a lancé le processus.

Touches interactives dans top

top est très interactif. Vous pouvez appuyer sur différentes touches pour modifier son affichage et interagir avec les processus.

1. Trier les processus :

   • Appuyez sur Maj+P (P majuscule) pour trier les processus par utilisation du processeur (%CPU), ce qui est souvent le tri par défaut.
   • Appuyez sur Maj+M (M majuscule) pour trier les processus par utilisation de la mémoire (%MEM).
   • Appuyez sur Maj+T (T majuscule) pour trier les processus par TIME+.

   Essayez d'appuyer sur Maj+M maintenant pour trier par utilisation de la mémoire. Observez comment la liste des processus se réordonne. Ensuite, appuyez sur Maj+P pour revenir au tri par utilisation du processeur.

2. Filtrer par utilisateur :

   • Appuyez sur u (u minuscule). top vous demandera un nom d'utilisateur. Tapez labex et appuyez sur Entrée.
   • Maintenant, top affichera uniquement les processus appartenant à l'utilisateur labex. Ceci est très utile pour se concentrer sur vos propres processus.
   • Pour effacer le filtre et afficher tous les utilisateurs à nouveau, appuyez sur u, puis appuyez sur Entrée sans saisir de nom d'utilisateur.

3. Modifier l'intervalle de mise à jour :

   • Par défaut, top se met à jour toutes les 3 secondes. Vous pouvez modifier cet intervalle.
   • Appuyez sur s (s minuscule). top vous demandera un délai. Entrez 1 (pour 1 seconde) et appuyez sur Entrée.
   • Observez comment l'affichage se met à jour plus fréquemment.
   • Vous pouvez le modifier à nouveau sur 3 secondes en appuyant à nouveau sur s et en saisissant 3.

4. Tuer un processus :

   • Vous pouvez terminer un processus directement à partir de top.
   • Tout d'abord, créons un processus sleep en arrière-plan dans un nouvel onglet ou une nouvelle fenêtre de terminal, ou en appuyant sur Ctrl+Z dans votre terminal actuel, puis bg pour mettre top en arrière-plan, puis exécutez sleep 600 &, puis fg pour ramener top au premier plan.
   • Alternativement, vous pouvez ouvrir un nouvel onglet de terminal (par exemple, Ctrl+Shift+T dans de nombreux terminaux) et exécuter sleep 600 & là-bas.
   • Une fois que vous avez un processus sleep en cours d'exécution, revenez à votre terminal top.
   • Appuyez sur k (k minuscule). top vous demandera le PID du processus à tuer.
   • Trouvez le PID de votre processus sleep 600 dans la liste top. Saisissez ce PID et appuyez sur Entrée.
   • top vous demandera ensuite le signal à envoyer. La valeur par défaut est 15 (SIGTERM). Appuyez sur Entrée pour envoyer SIGTERM.
   • Le processus sleep devrait disparaître de la liste. Si ce n'est pas le cas, vous pouvez essayer k à nouveau et envoyer le signal 9 (SIGKILL).

5. Modifier la priorité d'un processus (renicing) :

   • La modification de la priorité d'un processus change sa priorité. Une valeur Nice plus faible signifie une priorité plus élevée.
   • Appuyez sur r (r minuscule). top vous demandera un PID, puis une valeur Nice (par exemple, -10 pour une priorité plus élevée, 10 pour une priorité plus faible).
   • Il s'agit d'une fonctionnalité avancée pour gérer les ressources système. Pour cet exercice, appuyez simplement sur r, puis sur Entrée deux fois pour annuler l'opération sans rien modifier.

6. Quitter top :

   • Lorsque vous avez terminé, appuyez sur q (q minuscule) pour quitter top et revenir à votre invite de terminal.

top est un outil indispensable pour les administrateurs système et les utilisateurs. Maîtriser ses fonctionnalités interactives permet un diagnostic rapide et efficace des problèmes de performance du système et de la gestion des processus.

Résumé

Dans ce laboratoire, vous avez appris les concepts fondamentaux de la gestion des processus Linux. Vous avez commencé par comprendre les états des processus et leur cycle de vie à l'aide des commandes ps et top, en observant comment les processus passent d'un état à un autre, comme l'exécution (R), le sommeil interruptible (S) et l'arrêt (T). Vous avez pratiqué l'identification des états de processus courants et l'interprétation des sorties de ps aux et ps -ef pour obtenir des informations sur les processus système.

De plus, vous avez exploré les méthodes de contrôle des tâches en arrière-plan et en premier plan, ce qui est crucial pour une utilisation efficace du terminal. Vous avez également maîtrisé la terminaison des processus à l'aide de différentes commandes telles que kill, killall et pkill, en comprenant leurs différentes applications pour une terminaison normale ou forcée. Enfin, vous avez appris à surveiller la charge système et l'utilisation du processeur avec uptime et lscpu, et à analyser l'activité détaillée des processus à l'aide de top, offrant une vue d'ensemble complète des performances du système et de l'utilisation des ressources.