🧠Gestion des erreurs et débogage en Bash - Part 5

Introduction : Pourquoi l’erreur est la norme en prod ?

Un script Bash qui ne gère pas ses erreurs est une bombe à retardement. En production, un simple rm mal dirigé ou une variable vide peut faire tomber un service entier.
Ce projet t’apprend à maîtriser la gestion des erreurs Bash, du set -e au trap ERR, en passant par les redirections stderr, et à transformer ton terminal en véritable tableau de bord de debug.

Codes de retour & propagation des erreurs

Concept	Exemple concret / code
Chaque commande Bash renvoie un code de sortie (`exit code`) : 0 = succès, ≠ 0 = échec. Il est disponible via la variable spéciale `$?`.	`bash echo "Test" echo $? # 0 ls /dossier/inexistant echo $? # 2`
PIPESTATUS capture les codes d’un pipeline complet.	« `bash cat fichier.txt
`exit` termine un script avec un code précis ; `return` fait de même dans une fonction.	« `bash function check() { [ -f « $1 » ]

Mode strict : set -e, set -u, set -o pipefail

Concept	Exemple concret / code
`set -e` → arrêt immédiat en cas d’erreur (“fail fast”).	`bash set -e mkdir /data cd /data ls /inexistant echo "jamais affiché"`
`set -u` → détecte l’utilisation de variables non définies.	`bash set -u echo $VAR_NON_EXISTANTE # → erreur immédiate`
`set -o pipefail` → le code d’erreur du pipeline reflète la première commande échouée.	« `bash set -o pipefail cat inexistant
Combiner les trois = script quasi hermétique.	`bash set -euo pipefail IFS=$'\n\t'`

trap : capturer, enrichir, nettoyer

Concept	Exemple concret / code
`trap` intercepte un signal ou un événement. Idéal pour nettoyer avant sortie.	`bash trap 'echo "Interruption capturée" ; exit 1' INT`
Le signal ERR permet de gérer toute erreur.	`bash trap 'echo "Erreur sur $BASH_COMMAND (ligne $LINENO)"' ERR`
`EXIT` s’exécute toujours à la fin (succès ou non).	`bash trap 'echo "Fin du script : code $?"' EXIT`
Pour hériter du trap dans les fonctions, active `set -E`.	`bash set -E trap 'echo "Erreur dans $FUNCNAME"' ERR`

Redirections d’erreur : 2>, 2>&1, &>

Concept	Exemple concret / code
`stdout` = flux normal ; `stderr` = flux d’erreurs.	`cmd >out.log 2>err.log`
Rediriger les deux flux ensemble : `&>` (Bash >= 4).	`cmd &>tout.log`
Attention à l’ordre : `>fichier 2>&1` ≠ `2>&1 >fichier`.	Premier capture stdout + stderr, second redirige seulement stdout.
Logger proprement : `tee` affiche et écrit.	« `bash mycmd 2>&1

Outils de debug intégrés

Concept	Exemple concret / code
`set -x` : affiche chaque commande avant exécution.	`bash set -x echo "debug" set +x`
Personnaliser l’affichage avec PS4.	`bash PS4='+ ${BASH_SOURCE}:${LINENO}: ' ; set -x`
Envoyer la trace dans un fichier : `BASH_XTRACEFD`.	`bash exec 5>debug.log ; BASH_XTRACEFD=5 ; set -x`
Lancer un script complet en mode debug.	`bash -x script.sh`

Bonnes pratiques “prod-ready”

Concept	Exemple concret / code
Activer le mode strict et un IFS sécurisé.	`bash set -euo pipefail ; IFS=$'\n\t'`
Fonctions de sortie contrôlée : `die()` et `try()`.	« `bash die() { echo « Erreur : $* » >&2 ; exit 1 ;} try() { « $@ »
Nettoyage automatique avec trap.	`bash tmp=$(mktemp) ; trap 'rm -f "$tmp"' EXIT`
Outils QA : `shellcheck` et `bats`.	Vérifie syntaxe et tests unitaires de scripts Bash.

Cas réels : mini post-mortems

Cas	Analyse / correction
Un pipeline silencieux ne renvoyait pas d’erreur.	Solution : `set -o pipefail` et `echo ${PIPESTATUS[*]}`.
Script cron échouait car variable non chargée.	Ajouter `source /etc/profile` et `set -u` pour détection immédiate.
Fichiers temporaires non supprimés après CTRL-C.	`trap INT EXIT 'cleanup'` assure la suppression même en interruption.

💬 Retour d’expérience du lecteur

Avez-vous déjà vu un script planter silencieusement ?
Racontez vos mésaventures : quelles stratégies ou outils vous ont permis de déboguer plus vite ?

🧩 Atelier pratique — Grille 2×2 d’exercices

🧠 Exercice 1	🔧 Exercice 2
Un pipeline (`cat inexistant	grep() `masque l’erreur : corrige avec` pipefail`et vérifie` PIPESTATUS`.
⚙️ Exercice 3	🧪 Exercice 4
Active `PS4` et `BASH_XTRACEFD` pour rediriger le debug vers un fichier.	Écris un wrapper `run()` avec retry + backoff + timeout simulés.

🔗 Recommandations / Autres solutions

🧭 Pour aller plus loin avant ou après ce projet :

Avant de plonger dans les tableaux et structures, jette un œil à ces articles complémentaires :

🧠 Bases du scripting Bash — comprendre le shebang, les variables et la structure d’un script.
⚙️ Variables et opérateurs en Bash — tout sur les variables spéciales, d’environnement et les opérateurs.
🔁 Boucles et conditions en Bash — la logique répétitive : for, while, if, case.
🧩 Tableaux, dictionnaires – structures avancées en Bash – Part 4

Externes :

🏁 Conclusion

La gestion des erreurs Bash n’est pas qu’une formalité : c’est le gilet pare-balles de tout script en production.
Maîtriser set -euo pipefail, trap ERR, et les redirections rend tes automatismes plus fiables et ton diagnostic plus rapide.
Prochaine étape : intégrer ces pratiques dans ton pipeline CI/CD et partager tes templates d’erreur au sein de ton équipe.

Et toi, comment gères-tu tes erreurs ? Partage ton approche en commentaire !

🧩 Solutions des exercices

Exercice 1

set -o pipefail
cat inexistant | grep txt
echo "${PIPESTATUS[@]}"

Exercice 2

trap 'echo "$(date) | $BASH_SOURCE:$LINENO | $BASH_COMMAND" >> /tmp/errors.log' ERR

Exercice 3

exec 5>trace.log
PS4='+${BASH_SOURCE}:${LINENO}: '
BASH_XTRACEFD=5
set -x
# commands...
set +x

Exercice 4

run() {
  local retries=3 delay=2
  for ((i=1;i<=retries;i++)); do
    "$@" && return 0
    echo "Tentative $i échouée, nouvelle dans ${delay}s..."
    sleep $delay
    ((delay*=2))
  done
  echo "Échec définitif : $*"
  return 1
}