0Pricing
Linux Server Deployment & SSH Mastery · Leçon

Gestion des erreurs et journalisation dans les scripts

Mettez en œuvre une gestion robuste des erreurs, redirigez la sortie des scripts et générez des journaux pertinents pour surveiller leur exécution et résoudre les problèmes.

Gestion des erreurs et journalisation dans les scripts est une leçon Linux Server Deployment & SSH Mastery gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Linux Server Deployment & SSH Mastery, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Linux Server Deployment & SSH Mastery comprend 4 leçons au total.

Rendez vos scripts fiables

Imaginez votre script s'exécutant sur un serveur et effectuant une tâche importante. Que se passe-t-il si quelque chose tourne mal ?

  • Échoue-t-il silencieusement ?
  • Laisse-t-il des éléments indésirables derrière lui ?
  • Pouvez-vous savoir quand et pourquoi il a échoué ?

Les scripts robustes gèrent les erreurs avec élégance et fournissent des journaux clairs. Cette leçon vous apprend comment faire !

Comprendre les codes de sortie

Chaque commande et chaque script Linux renvoie un code de sortie (ou statut de sortie) lorsqu'il se termine. Ce nombre vous indique s'il a réussi ou échoué.

  • 0 : indique une réussite ! Tout s'est bien passé.
  • 1-255 : indique un échec. Un nombre précis peut indiquer le type d'erreur.

Voyons cela en pratique :

#!/bin/bash
# This script demonstrates exit codes

echo "Attempting a successful command..."
ls /tmp
echo "Exit code for 'ls /tmp': $?"

echo

echo "Attempting a failing command..."
ls /nonexistent_directory
echo "Exit code for 'ls /nonexistent_directory': $?"

Vérifier l'état d'une commande

Après l'exécution d'une commande, vous pouvez vérifier son code de sortie à l'aide de la variable spéciale $?. Cela est très utile pour prendre des décisions dans votre script.

Vous pouvez utiliser une instruction if pour réagir à une réussite ou à un échec :

#!/bin/bash
# Check if a file exists before trying to read it

FILENAME="test_file.txt"
touch $FILENAME # Create it for success case

if [ -f "$FILENAME" ]; then
  echo "File '$FILENAME' exists. Processing..."
  # ... do something with the file ...
  rm $FILENAME # Clean up
else
  echo "Error: File '$FILENAME' not found!"
  exit 1
fi

echo "Script finished."

`set -e` : quitter en cas d'erreur

Pour les scripts simples, vérifier manuellement $? partout peut être fastidieux. La commande set -e modifie le comportement de votre script :

  • Si une commande renvoie un statut différent de zéro (échoue), le script se termine immédiatement.
  • Cela empêche votre script de continuer avec des données potentiellement corrompues ou un état invalide.

Essayez d'exécuter ce script. Que se passe-t-il si la commande cp échoue ?

#!/bin/bash
set -e

echo "Starting important operations..."
mkdir my_temp_dir
cp /nonexistent_source my_temp_dir/target # This will fail

echo "This line will not be reached if cp fails."
rmdir my_temp_dir
echo "Script finished successfully."

`trap` pour le nettoyage

Parfois, même si un script échoue, vous devez effectuer des tâches de nettoyage, comme supprimer des fichiers temporaires. La commande trap vous permet d'intercepter des signaux (comme une sortie ou une erreur) et d'exécuter une commande.

  • EXIT : s'exécute lorsque le script se termine, qu'il réussisse ou échoue.
  • ERR : s'exécute lorsqu'une commande renvoie un statut différent de zéro (si set -e est actif).

Ici, nous garantissons la suppression systématique d'un répertoire temporaire :

#!/bin/bash

TEMP_DIR="/tmp/my_script_temp_$(date +%s)"

function cleanup {
  echo "Cleaning up temporary directory: $TEMP_DIR"
  rm -rf "$TEMP_DIR"
}

trap cleanup EXIT

mkdir "$TEMP_DIR"
echo "Working in $TEMP_DIR..."
# Simulate some work, maybe it fails
# cp /nonexistent_file "$TEMP_DIR/" # Uncomment to test failure

echo "Script completed."

Rediriger la sortie

Lorsque votre script s'exécute, il affiche souvent des messages. Ceux-ci appartiennent principalement à deux catégories :

  • Sortie standard (stdout) : messages normaux (descripteur de fichier 1).
  • Erreur standard (stderr) : messages d'erreur (descripteur de fichier 2).

Vous pouvez rediriger ces flux vers des fichiers plutôt que vers l'écran :

  • command > file : redirige stdout vers file.
  • command 2> file : redirige stderr vers file.

Enregistrons séparément les messages de réussite et d'erreur.

#!/bin/bash
# Redirect stdout to success.log and stderr to error.log

echo "This is a success message." > success.log
ls /nonexistent_path 2> error.log

echo "Check success.log and error.log files."
# To view them after running:
# cat success.log
# cat error.log

Toute la sortie dans un seul fichier

Il est souvent utile de réunir la sortie standard et l'erreur standard dans un seul fichier journal afin de faciliter la consultation. Il existe plusieurs façons de procéder :

  • command > file 2>&1 : redirige stdout vers file, puis redirige stderr vers l'endroit où va stdout (le fichier).
  • command &> file : une syntaxe plus courte et plus moderne pour obtenir le même résultat.

C'est idéal pour créer un journal complet de l'exécution de votre script.

#!/bin/bash
# Redirect both stdout and stderr to a single log file

LOG_FILE="combined_script.log"

echo "Starting script..." &> "$LOG_FILE"
echo "This message goes to stdout." &>> "$LOG_FILE"
ls /nonexistent_dir 2>&1 | tee -a "$LOG_FILE"
echo "Script finished." &>> "$LOG_FILE"

echo "Check the '$LOG_FILE' file for all output."

Ajouter un horodatage à vos journaux

Lors du débogage, il est essentiel de savoir quand un événement s'est produit. Ajouter des horodatages à vos messages de journal les rend beaucoup plus utiles.

Vous pouvez ajouter la date et l'heure actuelles au début de chaque entrée du journal à l'aide de la commande date. Cela permet de suivre les événements dans l'ordre chronologique.

#!/bin/bash

LOG_FILE="timestamped_script.log"

function log_message {
  echo "$(date +%Y-%m-%d_%H:%M:%S) - $1" &>> "$LOG_FILE"
}

log_message "Script started."
sleep 1
log_message "Performing task A..."
# Simulate an error
ls /no_such_place || log_message "Error: Command failed."
sleep 1
log_message "Script finished."

echo "Check '$LOG_FILE' for timestamped entries."

Envoyer des messages aux journaux système avec `logger`

Pour les événements importants, vous pouvez souhaiter envoyer des messages directement au système de journalisation (syslog). La commande logger fait exactement cela.

  • Les journaux système sont souvent gérés par des outils comme journalctl (sur les systèmes systemd).
  • Cela centralise les messages importants de votre script avec les autres événements système.
  • C'est utile pour les erreurs critiques ou les pistes d'audit.

Les messages envoyés avec logger peuvent être consultés à l'aide de journalctl -f ou de tail -f /var/log/syslog (selon votre système).

#!/bin/bash
# Send a message to system logs

SCRIPT_NAME="MyBackupScript"

logger -t "$SCRIPT_NAME" "Starting daily backup operation."

# Simulate a task
sleep 2
if [ $(($RANDOM % 2)) -eq 0 ]; then
  logger -t "$SCRIPT_NAME" -p user.info "Backup successful."
else
  logger -t "$SCRIPT_NAME" -p user.err "Backup failed: Disk full."
fi

echo "Messages sent to system logs. Check with 'journalctl -t $SCRIPT_NAME'."

Vérification de la gestion des erreurs

Vous avez écrit un script Bash pour traiter des fichiers. Vous voulez que le script se termine immédiatement si une commande qu'il contient échoue, et vous souhaitez également garantir le nettoyage d'un répertoire temporaire, quelle que soit la façon dont le script se termine.

Quelles sont les deux commandes Bash que vous utiliseriez principalement pour y parvenir ?

Récapitulatif et prochaines étapes

Vous avez appris à rendre vos scripts Bash plus robustes et plus faciles à déboguer !

  • Codes de sortie : comprendre la réussite ou l'échec des commandes.
  • set -e : quitter automatiquement en cas d'erreur.
  • trap : effectuer des opérations de nettoyage à la fin du script.
  • Redirection de la sortie : contrôler la destination de stdout et de stderr.
  • Horodatages : ajouter du contexte à vos journaux.
  • logger : intégrer la journalisation du script à celle du système.

En appliquant ces techniques, vos tâches automatisées seront plus fiables et plus faciles à gérer. Continuez à vous entraîner pour créer une automatisation véritablement résiliente !

Questions Fréquemment Posées

La leçon « Gestion des erreurs et journalisation dans les scripts » est-elle gratuite ?

Oui — le texte complet de « Gestion des erreurs et journalisation dans les scripts » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Linux Server Deployment & SSH Mastery, passe à CoddyKit PRO. Le cours Linux Server Deployment & SSH Mastery comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Gestion des erreurs et journalisation dans les scripts » ?

Mettez en œuvre une gestion robuste des erreurs, redirigez la sortie des scripts et générez des journaux pertinents pour surveiller leur exécution et résoudre les problèmes. Tu pratiques Linux Server Deployment & SSH Mastery avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Linux Server Deployment & SSH Mastery ?

Aucune expérience préalable n'est requise. Linux Server Deployment & SSH Mastery sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Gestion des erreurs et journalisation dans les scripts » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Linux Server Deployment & SSH Mastery ?

Oui. Chaque leçon Linux Server Deployment & SSH Mastery inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Introduction aux scripts Bash
  2. Automatiser les tâches du serveur
  3. Gestion des erreurs et journalisation dans les scripts
  4. Fonctions, arguments et scripts réutilisables
← Retour à Linux Server Deployment & SSH Mastery