Bonnes pratiques de script Bash pour une automatisation fiable

L'écriture de scripts Bash est souvent l'épine dorsale de l'automatisation des systèmes, des pipelines DevOps et des tâches administratives courantes. Alors que les scripts simples peuvent tolérer une structure bâclée, une automatisation fiable exige l'adhésion à des meilleures pratiques robustes. Des scripts défectueux peuvent entraîner une perte de données, des vulnérabilités de sécurité ou des échecs silencieux qui ne se manifestent que lors d'un événement critique.

Ce guide fournit des techniques essentielles et exploitables pour transformer des scripts Bash rudimentaires en outils d'automatisation professionnels, maintenables et tolérants aux pannes. En intégrant une gestion d'erreurs solide, une structure réfléchie et un guillemet méticuleux, vous pouvez garantir que votre automatisation fonctionne de manière fiable dans toutes les circonstances.

1. Établir une base solide : Gestion des erreurs

L'aspect le plus critique d'un script Bash fiable est une gestion d'erreurs appropriée. Par défaut, Bash est permissif ; il continue souvent l'exécution même après l'échec d'une commande. Ce comportement doit être explicitement annulé pour garantir un échec immédiat lors de la rencontre d'une erreur.

La Règle d'Or : La commande `set`

Chaque script Bash non trivial doit commencer par activer le mode strict à l'aide de la commande set. Cette seule ligne augmente considérablement la fiabilité de votre code.

#!/usr/bin/env bash

set -euo pipefail
# set -E pour les environnements où l'héritage des signaux est crucial
# set -euo pipefail

Signification des indicateurs :

-e (errexit) : Sortir immédiatement si une commande se termine avec un statut différent de zéro. Cela empêche la continuation silencieuse après un échec. Exception : commandes dans des conditions if, while ou until, ou commandes précédées de !.
-u (nounset) : Traiter les variables et les paramètres non définis comme une erreur. Cela détecte les fautes de frappe et les erreurs de logique où une variable était censée être définie.
-o pipefail : Si une commande dans un pipeline échoue, le statut de sortie de l'ensemble du pipeline est celui de la dernière commande à avoir échoué, plutôt que le statut de sortie de la dernière commande du pipeline (qui pourrait réussir même si une étape précédente a échoué).

Gérer le nettoyage du script avec `trap`

La commande trap vous permet d'exécuter des commandes lorsque des signaux spécifiques sont reçus (par exemple, interruptions, sorties ou erreurs). Ceci est crucial pour nettoyer les fichiers ou ressources temporaires, même si le script échoue de manière inattendue.

# Définir le chemin du répertoire temporaire
TMP_DIR=$(mktemp -d)

# Fonction pour nettoyer le répertoire temporaire
cleanup() {
    if [[ -d "$TMP_DIR" ]]; then
        rm -rf "$TMP_DIR"
        echo "Répertoire temporaire nettoyé : $TMP_DIR"
    fi
}

# Exécuter la fonction de nettoyage lorsque le script se termine (0, 1, 2, etc.) ou est interrompu (SIGINT)
trap cleanup EXIT HUP INT QUIT TERM

# Exemple d'utilisation du répertoire temporaire
echo "Travail en cours dans $TMP_DIR"
# ... logique du script ...

2. Prévenir les pièges : Guillemets et variables

La source la plus courante de comportement imprévisible dans Bash est le placement incorrect des guillemets autour des variables.

Toujours mettre les variables entre guillemets

Chaque fois que vous utilisez une variable qui se développe en argument de commande, entourez-la toujours de guillemets doubles ("$VARIABLE"). Cela empêche la division de mots (word splitting) et le globbing (expansion de chemins), surtout si la variable contient des espaces ou des caractères spéciaux.

La différence de guillemetage

Scénario	Commande	Résultat
Non guillemeté (Mauvais)	`rm $FILE_LIST`	Si `$FILE_LIST` contient `"fichier un.txt"`, `rm` voit deux arguments : `fichier` et `un.txt`.
Guillemeté (Bon)	`rm "$FILE_LIST"`	Si `$FILE_LIST` contient `"fichier un.txt"`, `rm` voit un seul argument : `fichier un.txt`.

Utiliser les accolades pour la clarté

Utilisez des accolades ({}) lors de l'expansion des variables pour délimiter clairement le nom de la variable du texte environnant, ou pour accéder en toute sécurité aux éléments d'un tableau.

LOG_FILE="backup_$(date +%Y%m%d).log"
echo "Journalisation vers : ${LOG_FILE}"

Préférer les variables locales dans les fonctions

Lors de la définition de variables à l'intérieur d'une fonction, utilisez le mot-clé local pour vous assurer qu'elles n'écrasent pas accidentellement les variables globales, réduisant ainsi les effets secondaires et améliorant la modularité.

process_data() {
    local input_data="$1"
    local processed_count=0
    # ... logique ...
}

3. Bonnes pratiques structurelles et maintenabilité

Les scripts bien structurés sont plus faciles à déboguer, à tester et à maintenir avec le temps.

Modéliser la logique avec des fonctions

Utilisez des fonctions pour décomposer les tâches complexes en blocs plus petits et réutilisables. Les fonctions garantissent une meilleure séparation des préoccupations et améliorent considérablement la lisibilité du script.

check_prerequisites() {
    if ! command -v git &> /dev/null; then
        echo "Erreur : Git est requis mais non installé." >&2
        exit 1
    fi
}

main() {
    check_prerequisites
    # ... logique principale du script ...
}

# L'exécution commence ici
main "$@"

Utiliser des noms descriptifs et des commentaires

Variables : Utilisez MAJUSCULES_UNIQUES pour les constantes globales (ou variables de configuration) et snake_case ou lower_case pour les variables locales. Soyez explicite (par exemple, TOTAL_RECORDS au lieu de T).
Commentaires : Utilisez des commentaires pour expliquer le pourquoi derrière une logique complexe, pas seulement le quoi. Incluez un bloc d'en-tête complet détaillant l'objectif, l'utilisation, l'auteur et la version du script.

Validation des entrées et gestion des arguments

Validez toujours les entrées utilisateur, en vous assurant que le nombre d'arguments requis est fourni et que ces arguments sont dans le format attendu.

#!/usr/bin/env bash
set -euo pipefail

# Vérifier si le nombre correct d'arguments est fourni
if [[ $# -ne 2 ]]; then
    echo "Usage: $0 <chemin_source> <chemin_destination>" >&2
    exit 1
fi

SRC="$1"
DEST="$2"

# Vérifier si le chemin source existe et est lisible
if [[ ! -d "$SRC" ]]; then
    echo "Erreur : Le répertoire source '$SRC' est introuvable." >&2
    exit 1
fi

4. Portabilité et sélection du shell

Lors du choix de votre shell et de vos commandes, réfléchissez à qui exécutera le script et où.

Choisir un shebang spécifique

Utilisez la ligne shebang (#!) pour déclarer explicitement l'interpréteur. L'utilisation de /usr/bin/env bash est souvent préférée à /bin/bash car elle permet au système de trouver l'exécutable bash correct en fonction du PATH de l'utilisateur.

Si vous avez besoin de fonctionnalités avancées (tableaux, syntaxe moderne, mathématiques strictes), utilisez :
#!/usr/bin/env bash
Si vous avez besoin d'une portabilité maximale sur les systèmes Unix (en évitant les fonctionnalités spécifiques à Bash), utilisez :
#!/bin/sh (Note : /bin/sh est souvent lié à dash ou à un shell minimal sur de nombreux systèmes Linux).

Éviter les utilitaires non standard

Dans la mesure du possible, utilisez les utilitaires standard POSIX. Si vous avez besoin de fonctionnalités avancées, documentez clairement la dépendance externe.

À éviter (Non standard)	À préférer (Standard/Courant)
`gdate` (BSD/macOS)	`date`
Extensions GNU `sed`	Syntaxe `sed` standard
Expressions régulières en ligne (`=~` dans Bash)	Outils externes comme `grep` ou `awk`

Utiliser `[[ ... ]]` plutôt que `[ ... ]`

Bash fournit la construction conditionnelle [[ ... ]] (souvent appelée nouvelle syntaxe de test), qui est généralement plus sûre et plus puissante que la commande [ ... ] traditionnelle (la commande test POSIX standard).

[[ ... ]] ne nécessite pas de guillemets autour des variables.
Elle prend en charge des fonctionnalités puissantes telles que la correspondance de motifs (==, !=) et la correspondance regex (=~).

5. Bonnes pratiques de débogage et de test

Des tests approfondis sont essentiels pour une automatisation fiable.

Tester tôt et souvent

Utilisez des fonctions petites et atomiques qui peuvent être testées individuellement. Rédigez des tests unitaires si la complexité le justifie (des outils comme Bats ou ShellSpec sont excellents pour cela).

Utiliser les indicateurs de débogage

Pour le débogage interactif, vous pouvez activer des indicateurs spécifiques pendant l'exécution :

Activer le traçage verbeux (-x) : Affiche les commandes et leurs arguments au fur et à mesure de leur exécution, précédés de +.

bash -x your_script.sh
# Ou ajoutez cette ligne temporairement dans votre script :
# set -x

Activer les vérifications d'exécution à blanc (-n) : Lit les commandes mais ne les exécute pas. Utile pour les vérifications de syntaxe avant d'exécuter un script complexe ou destructeur.

bash -n your_script.sh

Assurer la vérification du statut de sortie

Lors de l'appel de programmes externes, vérifiez toujours leur statut de sortie si vous n'utilisez pas set -e. Utilisez $? immédiatement après la commande pour capturer son statut.

copy_files data/* /tmp/backup
if [[ $? -ne 0 ]]; then
    echo "La copie de fichiers a échoué !" >&2
    exit 1
fi

Résumé

L'automatisation Bash fiable repose sur une base de normes d'exécution strictes, une structure soignée et un codage défensif. En appliquant systématiquement set -euo pipefail, en mettant toujours vos variables entre guillemets, en utilisant des fonctions pour la modularité et en effectuant la validation des entrées nécessaires, vous garantissez que vos scripts échouent rapidement, échouent en toute sécurité et sont facilement maintenables pour les améliorations ou le dépannage futurs.