Aller au contenu principal

Lab 4.2 - Contrôle des Processus

Objectifs​

À la fin de ce lab, vous serez capable de:

  • Démarrer des processus
  • Arrêter des processus (kill, killall, pkill)
  • Suspendre et reprendre des processus
  • Gérer les jobs en arrière-plan
  • Comprendre les signaux Linux

Prérequis​

  • Ubuntu 24.04 installé
  • Terminal ouvert
  • Accès utilisateur normal

Exercice 1: Démarrer des Processus​

Étape 1: Processus au Premier Plan​

# Lancer un processus simple
sleep 60

# Lancer un processus interactif
nano test.txt
# (Ctrl+X pour quitter)

Étape 2: Processus en Arrière-plan​

# Lancer en arrière-plan avec &
sleep 300 &

# Voir le PID
echo $!

# Voir les jobs
jobs

# Voir les processus en arrière-plan
ps aux | grep sleep

Étape 3: nohup​

# Lancer un processus qui continue après déconnexion
nohup sleep 600 > sleep.log 2>&1 &

# Vérifier
ps aux | grep sleep
cat sleep.log

Exercice 2: Signaux Linux​

Étape 1: Comprendre les Signaux​

# Voir tous les signaux
kill -l

# Signaux courants:
# SIGTERM (15): Terminaison gracieuse
# SIGKILL (9):  Terminaison forcée (ne peut être ignoré)
# SIGSTOP (19): Suspendre
# SIGCONT (18): Reprendre
# SIGHUP (1):   Hang up (redémarrer)

Étape 2: Envoyer des Signaux​

# Lancer un processus
sleep 300 &
PID=$!

# Envoyer SIGTERM (terminaison gracieuse)
kill $PID

# Ou avec le numéro
kill -15 $PID

# Vérifier
ps -p $PID

Exercice 3: kill, killall, pkill​

Étape 1: kill​

# Lancer plusieurs processus
sleep 100 &
PID1=$!
sleep 200 &
PID2=$!

# Tuer un processus spécifique
kill $PID1

# Tuer plusieurs processus
kill $PID1 $PID2

# Tuer avec force (SIGKILL)
kill -9 $PID1

Étape 2: killall​

# Lancer plusieurs instances
sleep 100 &
sleep 200 &
sleep 300 &

# Tuer tous les processus "sleep"
killall sleep

# Avec confirmation
killall -i sleep

# Vérifier
ps aux | grep sleep

Étape 3: pkill​

# Lancer des processus
sleep 100 &
sleep 200 &

# Tuer par nom (pattern)
pkill sleep

# Tuer par utilisateur
pkill -u $USER sleep

# Voir ce qui sera tué (dry-run)
pkill -l sleep

Exercice 4: Suspendre et Reprendre​

Étape 1: Suspendre un Processus​

# Lancer un processus
sleep 300 &

# Suspendre avec kill
kill -STOP $!

# Ou avec Ctrl+Z (si au premier plan)
# sleep 300
# [Appuyer Ctrl+Z]

# Voir l'état
ps aux | grep sleep
# Notez le "T" (stopped)

Étape 2: Reprendre un Processus​

# Reprendre en arrière-plan
kill -CONT $PID

# Reprendre au premier plan
fg

# Reprendre en arrière-plan
bg

Exercice 5: Gestion des Jobs​

Étape 1: Commandes Jobs​

# Lancer plusieurs jobs
sleep 100 &
sleep 200 &
sleep 300 &

# Voir les jobs
jobs

# Voir avec PID
jobs -l

# Amener un job au premier plan
fg %1  # Job numéro 1

# Mettre en arrière-plan
bg %1

# Tuer un job
kill %1

Étape 2: Script avec Jobs​

# Créer un script
cat > test-jobs.sh << 'EOF'
#!/bin/bash
sleep 10 &
JOB1=$!
sleep 20 &
JOB2=$!

echo "Jobs lancés: $JOB1, $JOB2"
jobs

# Attendre la fin
wait $JOB1
echo "Job 1 terminé"
wait $JOB2
echo "Job 2 terminé"
EOF

chmod +x test-jobs.sh
./test-jobs.sh

Exercice 6: Processus Zombie​

Étape 1: Créer un Zombie (pour test)​

# Script qui crée un zombie
cat > zombie.sh << 'EOF'
#!/bin/bash
# Fork un processus enfant qui meurt immédiatement
# Le parent ne fait pas wait()
(
    sleep 1
    exit
) &
# Parent ne fait pas wait, enfant devient zombie
sleep 10
EOF

chmod +x zombie.sh
./zombie.sh &

# Voir les zombies
ps aux | grep -w Z

Étape 2: Nettoyer les Zombies​

# Les zombies sont nettoyés automatiquement par init (PID 1)
# Mais on peut forcer avec kill du parent
ps aux | grep zombie
# Trouver le PID parent et le tuer

Exercice 7: Pratique Complète​

Étape 1: Scénario Réel​

# Lancer un serveur web de test
python3 -m http.server 8000 &
SERVER_PID=$!

# Vérifier qu'il tourne
ps -p $SERVER_PID
curl http://localhost:8000

# Arrêter gracieusement
kill $SERVER_PID

# Vérifier
ps -p $SERVER_PID

Étape 2: Script de Gestion​

# Script pour gérer un processus
cat > manage-process.sh << 'EOF'
#!/bin/bash
PROCESS="python3"
ACTION=$1

case $ACTION in
    start)
        python3 -m http.server 8000 > /dev/null 2>&1 &
        echo "Serveur démarré: $!"
        ;;
    stop)
        pkill -f "python3 -m http.server"
        echo "Serveur arrêté"
        ;;
    status)
        if pgrep -f "python3 -m http.server" > /dev/null; then
            echo "Serveur actif"
            ps aux | grep "python3 -m http.server" | grep -v grep
        else
            echo "Serveur inactif"
        fi
        ;;
    restart)
        $0 stop
        sleep 1
        $0 start
        ;;
    *)
        echo "Usage: $0 {start|stop|status|restart}"
        exit 1
        ;;
esac
EOF

chmod +x manage-process.sh

# Utiliser
./manage-process.sh start
./manage-process.sh status
./manage-process.sh stop

Vérification​

Checklist​

Vérifiez que vous pouvez:

  • Démarrer des processus (premier plan et arrière-plan)
  • Envoyer des signaux (kill, killall, pkill)
  • Suspendre et reprendre des processus
  • Gérer les jobs (jobs, fg, bg)
  • Comprendre les différents signaux
  • Gérer les processus de manière pratique

Questions de Réflexion​

  1. Quelle est la différence entre SIGTERM et SIGKILL?

    • SIGTERM: Terminaison gracieuse (peut être interceptée)
    • SIGKILL: Terminaison forcée (ne peut être ignorée)

  2. Pourquoi utiliser nohup?

    • Permet au processus de continuer après déconnexion du terminal
    • Utile pour les tâches longues

  3. Qu'est-ce qu'un processus zombie?

    • Processus terminé mais dont le parent n'a pas fait wait()
    • Nettoyé automatiquement par init

Prochaines Étapes​

  • Lab 4.3: Priorités et Nice Values
  • Lab 4.4: Jobs et Tâches en Arrière-plan
  • Chapitre 4.2: Visualisation des Processus

Lab créé le: Décembre 2024 - Testé sur Ubuntu 24.04