Leçon 04 : Processus et Services

Un processus est un programme en cours d'exécution. Dans cette leçon, tu vas maîtriser la gestion des processus sous Linux : voir, surveiller, gérer les priorités et contrôler les services.

1. Comprendre les processus

Qu'est-ce qu'un processus ?

Un processus est une instance d'un programme en cours d'exécution. Chaque processus possède :

Un **PID** unique (Process ID)
Un **PPID** (Parent PID - processus qui l'a lancé)
Un utilisateur propriétaire
Des ressources (CPU, mémoire, fichiers ouverts)

Types de processus

Type	Description
Processus interactif	Démarré par l'utilisateur, attaché au terminal
Daemon	Service en arrière-plan, au démarrage du système
Processus enfant	Créé par un autre processus (fork)
Processus zombie	Processus terminé mais pas encore nettoyé par le parent
Processus orphelin	Processus dont le parent est mort

2. Voir les processus

Commande PS

ps                    # Vos processus du terminal courant
ps -e                 # Tous les processus du système
ps aux                # Format BSD (tous utilisateurs)
ps -ef                # Format UNIX (plus détaillé)

ps -eo pid,ppid,user,cmd,%cpu,%mem # Colonnes personnalisées

Comprendre la sortie de `ps aux`

USER       PID  %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND

david 1234 10.5 5.2 524288 102400 ? S 10:00 2:30 firefox

Colonne	Signification
USER	Propriétaire du processus
PID	Numéro unique du processus
%CPU	Pourcentage CPU utilisé
%MEM	Pourcentage mémoire utilisée
VSZ	Taille virtuelle (Ko)
RSS	Mémoire résidente (Ko)
TTY	Terminal associé (? = pas de terminal)
STAT	État du processus
START	Heure de démarrage
TIME	Temps CPUcumulé
COMMAND	Commande exécutée

États des processus (colonne STAT)

État	Signification
`R`	Running (en cours d'exécution)
`S`	Sleeping (en attente)
`D`	Disk sleep (IO)
`Z`	Zombie (terminé mais non nettoyé)
`T`	Stopped (arrêté)
`I`	Idle (inactif)

Commandes TOP et HTOP

# top - surveiller les processus en temps réel
top                  # Vue basique
top -u david         # Processus d'un utilisateur
top -p 1234          # Surveiller un processus spécifique
# Touches interactives:
#   q = quitter
#   M = trier par mémoire
#   P = trier par CPU
#   k = tuer un processus
#   r = changer la priorité (nice)
# htop - version améliorée (doit être installé)
htop                  # Plus visuel et ergonomique
htop -u david         # Filtrer par utilisateur

htop -p 1234,5678 # Surveiller plusieurs PIDs

3. Rechercher des processus

grep et ps

ps aux | grep firefox        # Trouver firefox
ps aux | grep -v grep       # Exclure grep lui-même

ps aux | grep -i chrome # Insensible à la casse

pgrep - recherche simplifiée

pgrep firefox               # Retourne juste les PIDs
pgrep -a firefox           # Avec la commande complète
pgrep -u david chrome      # Processus d'un utilisateur
pgrep -f "python.*script"  # Recherche dans les arguments
pgrep -n firefox           # Le plus récent

pgrep -o firefox # Le plus ancien

pidof - trouver par nom de programme

pidof firefox              # Retourne tous les PIDs

pidof -s firefox # Un seul PID (le plus ancien)

4. Signaux et gestion des processus

La commande KILL

kill <PID>                 # Envoyer signal TERM (15)
kill -L                    # Liste des signaux disponibles
kill -SIGTERM 1234         # Signal terme (propre)
kill -SIGKILL 1234         # Signal KILL (forcement)
kill -STOP 1234            # Suspendre le processus

kill -CONT 1234 # Reprendre le processus

Les signaux importants

Signal	Numéro	Description	Usage normal
SIGTERM	15	Terminaison normale	`kill 1234`
SIGKILL	9	Terminaison forcée	`kill -9 1234`
SIGSTOP	19	Suspendre	`kill -STOP 1234`
SIGCONT	18	Reprendre	`kill -CONT 1234`
SIGHUP	1	Hangup (reload)	`kill -HUP 1234`
SIGINT	2	Interruption (Ctrl+C)	`kill -INT 1234`

###killall - tuer par nom

killall firefox            # Tuer tous les firefox
killall -i firefox        # Mode interactif
killall -9 firefox        # Forcé

killall -u david chrome # Tous lesprocessus d'un utilisateur

pkill - tuer avec pattern

pkill firefox              # Tuer par nom
pkill -f "python"         # Par argument
pkill -u david            # Tous lesprocessus d'un utilisateur

pkill -9 -f "zombie" # Forcé avec pattern

5. Contrôle des tâches (Job Control)

Commandes de job

# Lancer en arrière-plan
commande &                 # & à la fin
# Contrôler les jobs
jobs                      # Liste des jobs
fg %1                     # Mettre au premier plan
bg %1                     # Reprendre en arrière-plan
# Suspendre (Ctrl+Z dans le terminal)
Ctrl+Z                    # Suspendre leprocessus actuel
# Tuer le job actuel

Ctrl+C # Interruption

Exemple pratique

# 1. Lancer une commande longue
sleep 100 &
# 2. Voir les jobs
jobs
# [1]+  Running                 sleep 100 &
# 3. Suspendre (Ctrl+Z)
# [1]+  Stopped                 sleep 100
# 4. Relancer en arrière-plan
bg %1
# 5. Tuer le job
kill %1
# ou

kill $(jobs -p)

6. Priorités et Nice

Comprendre les priorités

Linux attribue une priorité -20 (plus prioritaire) à +19 (moins prioritaire).

nice - lancer avec priorité

nice -n 10 commande        # Priorité basse (10)
nice -n -5 commande       # Priorité haute (-5, nécessite root)
nice --10 commande         # Équivalent à -n -10

nice commande # Priorité par défaut (0)

renice - changer la priorité

renice 10 -p 1234          # Mettre priorité 10
renice -5 -p 1234          # Mettre priorité -5 (root uniquement)

renice 5 -u david # Tous lesprocessus de david à priorité 5

htop pour gérer les priorités

htop

# Appuyer sur 'r' puis sélectionner le processus

7. Services et Daemons (systemd)

Introduction à systemd

systemd est le système d'initialisation moderne de Linux. Il gère les services (daemons).

Commandes systemctl

# Status et informations
systemctl status nginx           # Statut du service
systemctl is-active nginx        # Actif ? (active/inactive)
systemctl is-enabled nginx       # Au démarrage ? (enabled/disabled)
systemctl list-units --type=service  # Tous les services
systemctl list-unit-files        # Tous les services configurés
# Gestion
systemctl start nginx            # Démarrer
systemctl stop nginx            # Arrêter
systemctl restart nginx         # Redémarrer
systemctl reload nginx          # Recharger config
systemctl reload-or-restart nginx  # Recharger ou redémarrer
systemctl enable nginx          # Activer au boot
systemctl disable nginx         # Désactiver au boot
systemctl mask nginx            # Masquer (empêcher lancement)
systemctl unmask nginx          # Démasquer
# Journal
journalctl -u nginx             # Logs du service
journalctl -u nginx -f          # Logs en temps réel

journalctl --since "1 hour ago" # Logs dernière heure

Exemples pratiques

# Voir tous les services actifs
systemctl list-units --type=service --state=running
# Voir les services qui ont échoué
systemctl --failed
# Statut détaillé avec logs
systemctl status nginx -l
# Redémarrer un service qui a échoué

systemctl restart nginx

8. Surveillance avancée

Commandes utiles

# voir les ressources
free -h                  # Mémoire
df -h                    # Disque
uptime                   # Charge système
# Surveillance réseau des processus
lsof -p 1234             # Fichiers ouverts par processus
lsof -i                  # Connexions réseau
ss -tulnp               # Ports en écoute
# Statistiques temps réel
vmstat 1                 # Statistiques système

iostat -x 1 # I/O disque

9. Exercices pratiques

Exercice 1 : Surveillance

# Ouvrir htop et observer les processus
htop
# Identifier les processus qui utilisent le plus de CPU

# Taper 'P' pour trier par CPU

Exercice 2 : Gestion de processus

# Créer un processus
sleep 60 &
# Trouver son PID
pgrep -a sleep
# Le tuer
kill <PID>
# Vérifier

pgrep sleep

Exercice 3 : Service nginx

# Installer nginx
sudo apt install nginx
# Démarrer le service
sudo systemctl start nginx
# Vérifier le statut
sudo systemctl status nginx
# Arrêter

sudo systemctl stop nginx

10. Tableau résumé

Commande	Description
`ps aux`	Liste des processus
`top`	Moniteur temps réel
`htop`	Moniteur amélioré
`pgrep`	Rechercher par nom
`kill`	Envoyer un signal
`pkill`	Tuer par nom
`jobs`	Liste des jobs
`fg/bg`	Premier/arrière-plan
`nice`	Lancer avec priorité
`renice`	Changer priorité
`systemctl`	Gérer les services

Maîtrise ces commandes pour devenir un pro de l'administration Linux ! 💪

Complément: Jobs et arrière-plan

Introduction

Quand vous lancez une commande dans le terminal, elle s'exécute au premier plan (foreground) par défaut. Mais Linux vous permet de gérer plusieurs tâches simultanément : envoyer un processus en arrière-plan, le ramener au premier plan, ou encore l'arrêter proprement. C'est ce que nous allons voir dans cette leçon.

Comprendre les jobs (tâches)

Un job est une commande qui s'exécute dans votre terminal. shell maintient une liste des jobs actifs. Chaque job a un numéro (job ID) que vous pouvez utiliser pour le manipuler.

Les signaux de base

Avant de parler des commandes, voici les signaux les plus importants que vous pouvez envoyer aux processus :

Ctrl+C — Interrompre un processus

Pour envoyer un signal d'interruption à un processus en cours d'exécution au premier plan :

Ctrl+Z — Suspendre un processus

Pour suspendre un processus et le mettre en arrière-plan suspendu :

jobs — Lister les jobs actifs

La commande jobs affiche tous les jobs du terminal actuel :

fg — Remettre un job au premier plan

fg (foreground) ramène un job suspendu ou en arrière-plan au premier plan :

bg — Reprendre un job en arrière-plan

bg (background) reprend un job suspendu et le fait tourner en arrière-plan :

kill — Envoyer des signaux aux processus

kill envoie un signal à un processus. Par défaut, il envoie SIGTERM (demande d'arrêt) :

Pour tuer tous les processus d'une commande spécifique :

killall — Tuer par nom de commande

killall tue tous les processus correspondant à un nom :

wait — Attendre la fin d'un job

La commande wait attend qu'un job spécifique se termine :

nohup — Protéger contre la déconnexion

nohup permet à une commande de continuer après déconnexion du terminal :

disown — Détacher un job du shell

disown retire un job de la table des jobs, le protégeant contre les effets de la déconnexion :

trap — Intercepter les signaux dans les scripts

trap permet de définir des actions à exécuter quand un signal est reçu (très utile dans les scripts) :

Pour nettoyer avant de quitter :

Exemple pratique : gestionnaire de tâches

Voici un script qui gère plusieurs tâches en arrière-plan :

Résumé

Ctrl+C interrompt un processus au premier plan

Ctrl+Z suspend un processus et le met en pause

jobs liste les jobs actifs du terminal

fg ramène un job au premier plan

bg reprend un job suspendu en arrière-plan

kill envoie un signal à un processus (par PID)

killall tue tous les processus d'une commande

nohup protège contre la déconnexion

disown détache un job du shell

trap intercepte les signaux dans les scripts