Exercice 04 : Processus et Monitoring Système

🎯 Objectifs

À la fin de cet exercice, vous serez capable de :

• ✅ Lister les processus actifs avec ps et comprendre la sortie
• ✅ Lancer des processus en arrière-plan et les contrôler
• ✅ Envoyer des signaux aux processus (kill, killall)
• ✅ Surveiller les ressources système (CPU, RAM, disque)
• ✅ Utiliser top pour le monitoring en temps réel

Durée estimée : 20 minutes

Difficulté : ⭐⭐⭐☆☆ (Intermédiaire)

Prérequis :

• Avoir complété les exercices 01 à 03
• Un terminal Linux avec accès sudo

📖 Contexte

En DevOps, surveiller les processus et les ressources est une activité quotidienne :

• Un conteneur Docker consomme trop de mémoire → il faut identifier le processus responsable
• Un serveur web ne répond plus → il faut vérifier s'il tourne encore
• Un pipeline CI est lent → il faut regarder la charge CPU

Ce sont des compétences que vous utiliserez chaque jour en production.

📋 Énoncé

Vous allez simuler un serveur en production : lancer des processus, les surveiller, identifier ceux qui consomment trop de ressources, et les gérer. Vous apprendrez à diagnostiquer les problèmes de performance.

🧭 Déroulement de l'exercice

Voici les grandes étapes à réaliser dans l'ordre. Chaque étape décrit ce que vous devez accomplir - à vous de trouver la commande. La solution complète est disponible si vous êtes bloqué.

Tâche 1 : Lister les processus de votre session

Affichez les processus actifs de votre session courante. Identifiez votre shell et son PID.

Indice : La commande ps sans options montre peu de choses. Cherchez les options pour afficher : tous les utilisateurs (a), sans terminal (u), format complet (x). La combinaison aux est la plus courante.

Vérification : Sans options, vous voyez 2-3 processus. Avec les bonnes options, vous devez en voir des dizaines. Retrouvez le PID de votre shell bash.

Tâche 2 : Comprendre la sortie de ps aux

Analysez les colonnes de la sortie : PID, USER, %CPU, %MEM, COMMAND. Trouvez le processus avec le PID 1.

Indice : Le processus PID 1 est spécial - c'est le premier processus lancé par le noyau au démarrage. Sur les systèmes modernes, c'est systemd.

Question à se poser : Que se passerait-il si le processus PID 1 mourait ? Pourquoi tous les autres processus en dépendent-ils ?

Vérification : Vous devez identifier le nom du processus PID 1 sur votre système.

Tâche 3 : Lancer un processus en arrière-plan

Lancez une commande longue (ex: sleep 300) en arrière-plan pour libérer le terminal, puis listez les processus en arrière-plan.

Indice : Le caractère & à la fin d'une commande la lance en arrière-plan. La commande jobs liste les processus en arrière-plan de votre session. fg ramène le dernier processus au premier plan.

Vérification : Après avoir lancé la commande en arrière-plan, vous devez pouvoir continuer à taper d'autres commandes. jobs doit lister votre processus.

Tâche 4 : Surveiller les ressources en temps réel

Ouvrez le moniteur de processus interactif. Identifiez les processus qui consomment le plus de CPU et de RAM.

Indice : Il existe une commande qui affiche en temps réel les processus classés par consommation de ressources, avec mise à jour automatique. Elle s'appelle top. Une version améliorée, htop, peut nécessiter une installation.

Vérification : L'affichage doit se mettre à jour automatiquement. Vous devez voir les pourcentages CPU et mémoire. Quittez avec q.

Tâche 5 : Terminer un processus par son PID

Trouvez le PID du processus sleep 300 lancé précédemment et terminez-le proprement. Vérifiez qu'il a bien disparu.

Indice : kill PID envoie le signal TERM (15) qui demande une fermeture propre. kill -9 PID force l'arrêt immédiat. Préférez toujours le signal 15 d'abord - le signal 9 ne laisse pas au processus le temps de se nettoyer.

Question à se poser : Pourquoi est-il risqué d'utiliser kill -9 sur une base de données en cours d'écriture ?

Vérification : jobs ou ps aux | grep sleep ne doit plus afficher votre processus.

Tâche 6 : Surveiller la mémoire et le disque

Affichez l'utilisation actuelle de la RAM et l'espace disque disponible sur chaque partition, avec des tailles lisibles.

Indice : free affiche l'utilisation mémoire. df affiche l'utilisation des partitions disque. L'option -h rend les tailles lisibles (Ko, Mo, Go).

Vérification : Vous devez voir la RAM totale, utilisée et disponible, ainsi que le pourcentage d'utilisation de votre disque principal.

� Mini-Projet : Diagnostiquer un serveur lent

Vous allez simuler le diagnostic d'un serveur qui se comporte anormalement, en utilisant les outils de gestion des processus.

Scénario : On vous signale qu'un serveur répond lentement. Vous vous connectez et devez identifier les processus responsables, les gérer, et produire un rapport de l'état des ressources.

Ce que vous devez réaliser :

1. Lancez 3 processus en arrière-plan pour simuler de l'activité : sleep 500 &, sleep 600 &, sleep 700 &
2. Vérifiez avec jobs que les 3 processus sont bien en arrière-plan
3. Identifiez leurs PIDs avec ps aux | grep sleep
4. Utilisez top (ou htop si disponible) pendant 10 secondes pour observer la charge - notez mentalement le processus le plus gourmand en CPU
5. Terminez le processus sleep 500 proprement via son PID (signal 15)
6. Terminez sleep 600 par son numéro de job (avec kill %N)
7. Vérifiez qu'il reste uniquement sleep 700
8. Affichez l'utilisation actuelle de la mémoire RAM
9. Affichez l'utilisation de chaque partition disque
10. Terminez sleep 700 et vérifiez qu'aucun sleep ne subsiste

Checkpoints de validation :

• ps aux | grep sleep | grep -v grep ne retourne aucun résultat à la fin
• jobs retourne une liste vide à la fin
• Vous avez utilisé au moins deux méthodes différentes pour terminer un processus (par PID et par numéro de job)
• free -h affiche les informations mémoire avec des unités lisibles (Mo/Go)
• df -h affiche au moins une partition avec son pourcentage d'utilisation
• Vous avez observé top en temps réel (pas seulement la sortie statique de ps)

�📚 Étapes Détaillées

Étape 1 : Lister les Processus

Objectif : Utiliser ps pour voir ce qui tourne

Instructions :

1. Voir les processus de votre session :

ps

Résultat attendu :

  PID TTY          TIME CMD
 1234 pts/0    00:00:00 bash
 5678 pts/0    00:00:00 ps

• PID : Identifiant unique du processus
• TTY : Terminal associé
• TIME : Temps CPU utilisé
• CMD : Commande qui a lancé le processus

1. Voir tous les processus du système :

ps aux

1. Comprendre la sortie de ps aux :

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root         1  0.0  0.1 169284 13264 ?        Ss   Apr10   0:02 /sbin/init

1. Compter le nombre total de processus :

ps aux | wc -l

1. Chercher un processus spécifique :

ps aux | grep bash

Étape 2 : Lancer des Processus en Arrière-Plan

Objectif : Gérer les processus d'avant-plan et d'arrière-plan

Instructions :

1. Lancez un processus simulé en arrière-plan :

sleep 300 &

Le & à la fin lance le processus en arrière-plan et vous rend le contrôle du terminal.

Résultat attendu :

[1] 12345

[1] est le numéro du job, 12345 est le PID.

1. Lancez-en un deuxième :

sleep 600 &

1. Listez les jobs en arrière-plan :

jobs

Résultat attendu :

[1]-  Running                 sleep 300 &
[2]+  Running                 sleep 600 &

1. Ramenez le job 1 au premier plan :

fg %1

Le terminal est maintenant "bloqué" par le processus.

1. Mettez-le en pause et renvoyez-le en arrière-plan :

Appuyez sur Ctrl+Z pour le suspendre :

[1]+  Stopped                 sleep 300

Puis relancez-le en arrière-plan :

bg %1

1. Vérifiez :

jobs

Les deux processus doivent être Running.

Étape 3 : Envoyer des Signaux aux Processus

Objectif : Utiliser kill pour contrôler les processus

Instructions :

1. Trouvez le PID d'un de vos processus sleep :

ps aux | grep "sleep 300"

Notez le PID (deuxième colonne).

1. Envoyez un signal d'arrêt propre (SIGTERM, signal 15) :

kill <PID>

Remplacez <PID> par le vrai numéro.

1. Vérifiez qu'il a été arrêté :

jobs

Un des processus devrait être Terminated.

1. Pour le deuxième, utilisez kill par nom :

killall sleep

1. Vérifiez que tout est nettoyé :

jobs
ps aux | grep sleep

Les signaux importants :

Bonne pratique : Essayez toujours kill (SIGTERM) avant kill -9 (SIGKILL). SIGTERM laisse au processus le temps de se fermer proprement (sauvegarder des données, fermer des connexions).

Étape 4 : Monitoring Interactif avec top

Objectif : Utiliser top pour surveiller en temps réel

Instructions :

1. Lancez quelques processus pour avoir de l'activité :

yes > /dev/null &
sleep 1000 &

yes > /dev/null génère une charge CPU (il écrit "y" en boucle).

1. Lancez top :

top

1. Observez l'affichage :

top - 14:30:00 up 2 days, 3:15,  1 user,  load average: 1.05, 0.70, 0.50
Tasks: 120 total,   2 running, 118 sleeping,   0 stopped,   0 zombie
%Cpu(s): 25.0 us,  2.0 sy,  0.0 ni, 72.0 id,  1.0 wa,  0.0 hi,  0.0 si
MiB Mem :   7953.5 total,   3200.0 free,   2500.0 used,   2253.5 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   5100.0 avail Mem

  PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
 5678 alice     20   0    6972    580    516 R  99.0   0.0   0:05.23 yes
    1 root      20   0  169284  13264   8456 S   0.0   0.2   0:02.15 systemd

Lignes du haut :

• load average : Charge moyenne sur 1, 5, 15 minutes (idéal : < nombre de CPUs)
• Tasks : Nombre de processus et leur état
• %Cpu : us=utilisateur, sy=système, id=idle (libre)
• MiB Mem : Utilisation de la mémoire

1. Raccourcis dans top :

1. Tuez le processus yes depuis top :

• Appuyez sur k
• Entrez le PID du processus yes
• Appuyez sur Entrée (signal 15 par défaut)

1. Quittez top avec q.

1. Nettoyez les jobs restants :

killall sleep 2>/dev/null
killall yes 2>/dev/null

Étape 5 : Surveiller les Ressources Système

Objectif : Utiliser les commandes de diagnostic système

Instructions :

1. Mémoire - free :

free -h

Résultat attendu (exemple) :

              total        used        free      shared  buff/cache   available
Mem:          7.8Gi       2.5Gi       3.1Gi       256Mi       2.2Gi       5.0Gi
Swap:         2.0Gi          0B       2.0Gi

• available est la mémoire réellement disponible (inclut le cache libérable)
• Si available est très bas → problème de mémoire

1. Espace disque - df :

df -h

Résultat attendu (exemple) :

Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   15G   33G  31% /
tmpfs           3.9G     0  3.9G   0% /dev/shm

• Surveillez la colonne Use%. Au-delà de 85-90%, il faut agir.

1. Taille des dossiers - du :

du -sh /var/log/
du -sh /tmp/

1. Charge système - uptime :

uptime

Résultat attendu :

 14:30:00 up 2 days,  3:15,  1 user,  load average: 0.15, 0.20, 0.18

Interpréter le load average :

• Nombre inférieur au nombre de CPUs → serveur à l'aise
• Nombre égal au nombre de CPUs → serveur chargé
• Nombre supérieur → serveur surchargé

1. Voir le nombre de CPUs :

nproc

Étape 6 : Cas Pratique - Diagnostiquer un Problème

Objectif : Simuler un problème et le résoudre

Instructions :

1. Lancez un "processus fou" qui mange du CPU :

yes > /dev/null &

1. Identifiez-le avec ps :

ps aux --sort=-%cpu | head -5

Le processus yes devrait être en tête avec un %CPU élevé.

1. Notez son PID et arrêtez-le :

kill $(pgrep yes)

pgrep cherche le PID par nom de commande.

1. Vérifiez que tout est revenu à la normale :

uptime
ps aux --sort=-%cpu | head -5

La charge devrait baisser rapidement.

✅ Vérification Finale

1. Comment voir tous les processus ? → ps aux
2. Comment lancer un processus en arrière-plan ? → commande &
3. Quelle est la différence entre kill et kill -9 ? → kill = arrêt propre (SIGTERM), kill -9 = arrêt forcé (SIGKILL)
4. Comment voir la mémoire disponible ? → free -h
5. Comment trouver le processus qui consomme le plus de CPU ? → ps aux --sort=-%cpu | head ou top puis P

📖 Pour Aller Plus Loin

• Installez htop pour un top amélioré : sudo apt install htop
• Essayez iotop pour surveiller les I/O disque : sudo apt install iotop
• Étudiez systemctl pour gérer les services système : systemctl status nginx
• Explorez /proc/ : cat /proc/loadavg, cat /proc/uptime