RousselTMLEARNING

Article · Administration Linux : de la découverte à l'expertise

Scripts Bash robustes

1. Les bases #

Un script, c'est une suite de commandes.

Squelette #

Structure d'un script Bash
Toujours la même organisation : on retrouve vite ce que l'on cherche.
#!/usr/bin/env bash
# backup-etc.sh : archive /etc dans /var/backups
set -euo pipefail

readonly DEST=/var/backups
readonly STAMP=$(date +%F_%H%M)

main() {
    mkdir -p "$DEST"
    tar -czf "$DEST/etc_$STAMP.tar.gz" /etc
    echo "Archive créée : $DEST/etc_$STAMP.tar.gz"
}

main "$@"
chmod +x backup-etc.sh && sudo ./backup-etc.sh
bash -x backup-etc.sh   # exécuter en traçant chaque commande
OptionEffet
set -earrête le script à la première commande en échec
set -uerreur si une variable n'est pas définie
set -o pipefailun pipe échoue si une de ses commandes échoue

Variables et guillemets #

nom="web 01"
echo "$nom"          # guillemets doubles : la variable est développée, les espaces préservés
echo '$nom'          # guillemets simples : texte littéral
fichiers=$(ls /etc)  # substitution de commande
echo "${nom:-defaut}"     # valeur par défaut
echo "${#nom}"            # longueur
echo "${fichier%.log}.gz" # remplacer un suffixe
(( total = 3 * 7 )) ; echo "$total" 
Bonne Pratique : Mettez toujours les variables entre guillemets doubles ("$var") : sans eux, un nom de fichier avec un espace devient deux arguments.

2. Les différents shells : sh, bash, ksh, zsh, dash… #

Choisir le bon interpréteur pour l'usage interactif et pour les scripts.

Qu'est-ce qu'un shell ? #

Le shell entre l’utilisateur et le noyau

Le shell est le programme qui lit vos commandes, les interprète (variables, jokers, redirections, pipes) et demande au noyau d'exécuter les programmes. C'est à la fois une interface interactive et un langage de script. Plusieurs shells existent ; ils partagent une base commune héritée du Bourne shell, mais diffèrent par leurs extensions et leur confort.

echo $0              # shell courant (ex. : -bash ; le tiret indique un shell de connexion)
echo $SHELL          # shell de connexion défini pour l'utilisateur
cat /etc/shells      # shells autorisés sur la machine
ls -l /bin/sh        # vers quoi pointe sh (dash sur Debian/Ubuntu, bash sur RHEL)
getent passwd $USER | cut -d: -f7
chsh -s /usr/bin/zsh # changer son shell de connexion (effectif à la prochaine connexion)

Une brève histoire #

Généalogie des shells

Le Bourne shell (sh, Stephen Bourne, 1979) a fixé la syntaxe des scripts : if … then … fi, case … esac, for … do … done. Le C shell (BSD) a apporté l'historique et les alias avec une syntaxe proche du C. Le Korn shell a réuni les deux mondes, et la norme POSIX (1992) a défini un « sh » standard largement inspiré de ksh. bash (Bourne Again SHell), écrit pour le projet GNU, est devenu le shell par défaut de la plupart des distributions Linux.

Les shells un par un #

  • sh (POSIX) : ce n'est plus un programme précis mais une norme. /bin/sh est un lien vers un shell compatible : dash sur Debian et Ubuntu, bash en mode POSIX sur RHEL, Fedora et macOS, ash (BusyBox) sur Alpine et dans beaucoup de conteneurs. Un script #!/bin/sh doit donc se limiter à la syntaxe POSIX.
  • bash : shell par défaut de la plupart des distributions. Il ajoute au sh les tableaux (indexés et associatifs), [[ … ]], l'arithmétique (( … )), les développements {1..10} et ${var//a/b}, local, la substitution de processus <( … ), l'historique et la complétion programmable. C'est le standard de fait des scripts d'administration Linux.
  • dash (Debian Almquist shell) : shell minimal et strictement POSIX, plusieurs fois plus rapide à démarrer que bash. Debian et Ubuntu l'utilisent comme /bin/sh pour accélérer les scripts système. Il n'est pas fait pour l'usage interactif.
  • ksh (Korn shell) : précurseur de nombreuses fonctions reprises par bash (tableaux, [[ ]], arithmétique, édition de ligne). Encore très présent sur les Unix commerciaux (AIX, Solaris, HP-UX) et dans les anciens scripts d'entreprise et de banques. Deux variantes : ksh93 (AT&T, toujours maintenu) et mksh (MirBSD, utilisé par Android jusqu'à récemment).
  • zsh (Z shell) : shell interactif très riche, compatible avec la plupart de la syntaxe bash et ksh : complétion avancée, correction orthographique, jokers récursifs **/*.log, thèmes et plugins (Oh My Zsh, Prezto). Shell par défaut de macOS depuis Catalina (2019) et de Kali Linux. Attention aux différences pour les scripts : les tableaux commencent à l'indice 1 et une variable non entre guillemets n'est pas découpée en mots.
  • csh / tcsh : syntaxe proche du C (if (…) then … endif, setenv VAR valeur). tcsh, sa version améliorée, reste le shell par défaut de root sur FreeBSD. Déconseillé pour les scripts : gestion des erreurs et des redirections limitée.
  • fish (Friendly Interactive SHell) : pensé pour le confort interactif sans configuration (suggestions automatiques, coloration syntaxique, complétion issue des pages de manuel). Sa syntaxe n'est pas compatible POSIX (set var valeur, if …; end) : à réserver au terminal, pas aux scripts partagés.
  • Autres : BusyBox ash (systèmes embarqués, images Alpine), nushell et PowerShell (disponible sous Linux, manipule des objets plutôt que du texte), elvish, xonsh (mélange Python et shell).

Tableau comparatif #

Critèresh (POSIX) / dashbashksh93zshfish
Compatibilité POSIXréférenceoui (+ extensions)oui (+ extensions)presque (mode emulate sh)non
Tableauxnonindexés et associatifs (indice 0)indexés et associatifsoui (indice 1)listes
[[ ]], (( ))nonouiouiouinon (test, math)
Confort interactifminimalbonbonexcellentexcellent, sans configuration
Vitesse de démarragetrès rapidemoyennerapidemoyennemoyenne
Fichier de configuration~/.profile, $ENV~/.bashrc, ~/.bash_profile~/.kshrc~/.zshrc, ~/.zprofile~/.config/fish/config.fish
Pour les scriptsportables, systèmes, conteneursadministration LinuxUnix commerciaux, historiquepersonnelsà éviter

Écrire pour sh ou pour bash : les « bashismes » #

Un bashisme est une syntaxe propre à bash qui échoue sous un sh strict comme dash. Le shebang décide de l'interpréteur : #!/bin/sh promet la syntaxe POSIX, #!/usr/bin/env bash autorise les extensions de bash.

bashÉquivalent POSIX
[[ $a == x* ]]case $a in x*) … ;; esac
[[ -f $f && -r $f ]][ -f "$f" ] && [ -r "$f" ]
(( n++ ))n=$((n + 1))
for i in {1..5}for i in 1 2 3 4 5 ou $(seq 5)
tab=(a b c); echo ${tab[1]}set -- a b c; echo "$2" (pas de tableaux)
function f { … }f() { … }
echo -e "a\tb"printf 'a\tb\n'
source fichier. ./fichier
cmd &> logcmd > log 2>&1
read -p "Nom ? " nomprintf 'Nom ? '; read -r nom
set -o pipefailPOSIX depuis 2024 (dash ≥ 0.5.12) ; sinon absent
Un bashisme qui fonctionne avec bash et échoue avec dash
Erreur courante : Écrire #!/bin/sh en tête d'un script testé uniquement avec bash. Sur une machine RHEL tout fonctionne ; sur Debian, Ubuntu ou dans une image Alpine, le même script échoue. Soit vous ciblez bash et vous l'annoncez dans le shebang, soit vous testez avec dash.
Bonne pratique : Pour un script d'administration Linux, choisissez bash (#!/usr/bin/env bash) : il est présent partout et ses fonctions rendent les scripts plus sûrs. Visez POSIX sh pour les scripts qui doivent tourner dans des conteneurs minimaux, des systèmes embarqués, des initramfs ou sur plusieurs Unix. Vérifiez avec shellcheck -s sh ou checkbashisms.

Shell de connexion, interactif et fichiers de démarrage #

Le même shell ne lit pas les mêmes fichiers selon la façon dont il est lancé. C'est la cause classique du « ma variable marche dans le terminal mais pas dans cron » :

SituationType de shellFichiers lus par bash
Connexion SSH, console, su -connexion + interactif/etc/profile, puis le premier trouvé de ~/.bash_profile, ~/.bash_login, ~/.profile
Nouveau terminal graphique, bash tapéinteractif, non connexion/etc/bash.bashrc, ~/.bashrc
Script, cron, ssh hôte commandenon interactifaucun (sauf $BASH_ENV)

Équivalents : zsh lit ~/.zshenv (toujours), ~/.zprofile (connexion) et ~/.zshrc (interactif) ; ksh et dash lisent ~/.profile en connexion et le fichier désigné par $ENV en interactif.

Bonne pratique : Mettez les variables d'environnement dans ~/.profile ou ~/.bash_profile, les alias et le prompt dans ~/.bashrc, et faites charger ~/.bashrc par ~/.bash_profile. Dans un script ou une tâche cron, ne comptez sur aucun de ces fichiers : définissez PATH et les variables nécessaires dans le script.

Commandes à connaître #

ActionCommande
Shell courantecho $0 ; ps -p $$
Shells installéscat /etc/shells
Cible de /bin/shreadlink -f /bin/sh
Changer de shell de connexionchsh -s /bin/zsh
Version de bashbash --version ; echo $BASH_VERSION
Lancer bash en mode POSIXbash --posix script.sh
Tester avec dashdash -n script.sh && dash script.sh
Détecter les bashismescheckbashisms script.sh ; shellcheck -s sh script.sh
Installer ksh, zsh, fishsudo apt install ksh zsh fish # ou dnf

TP : un même script, cinq shells #

  1. Installez dash, ksh, zsh et fish, puis vérifiez cat /etc/shells et readlink -f /bin/sh.
  2. Écrivez info.sh qui affiche le nom d'hôte, compte les fichiers de /etc avec une boucle, utilise un tableau et un test [[ … ]].
  3. Exécutez-le avec bash, dash, ksh et zsh ; notez les erreurs et les résultats différents (indice des tableaux sous zsh).
  4. Passez checkbashisms et shellcheck -s sh, puis réécrivez le script en POSIX pur jusqu'à ce qu'il donne le même résultat dans les quatre shells.
  5. Essayez la même logique en fish et constatez les différences de syntaxe.

Résultat attendu : vous savez quel shell exécute réellement un script, reconnaître un bashisme et choisir entre bash et POSIX sh.

3. Contrôle de flux #

Conditions, boucles, fonctions.

Conditions #

if [[ -f /etc/nginx/nginx.conf ]]; then echo "nginx configuré"; fi
if ! systemctl is-active --quiet nginx; then
    systemctl restart nginx
fi
[[ $EUID -eq 0 ]] || { echo "À lancer en root" >&2; exit 1; }
[[ $usage -gt 90 && $env == prod ]] && alerte
case "$1" in
    start|stop) systemctl "$1" app ;;
    *) echo "Usage : $0 {start|stop}" >&2; exit 2 ;;
esac

Tests utiles #

TestVrai si
-f / -d / -efichier / répertoire / existe
-r -w -xlisible, modifiable, exécutable
-z / -nchaîne vide / non vide
-eq -ne -lt -gtcomparaisons numériques
== !=, =~comparaison de chaînes, expression régulière

Boucles #

for host in web01 web02 db01; do
    ssh "$host" uptime
done
for f in /var/log/app/*.log; do gzip "$f"; done
while read -r user shell; do
    echo "$user utilise $shell"
done < <(awk -F: '$3>=1000 {print $1, $7}' /etc/passwd)
for i in {1..5}; do curl -sf http://localhost:8080/health && break; sleep 2; done

Fonctions et codes de retour #

log() { echo "$(date '+%F %T') [$1] ${*:2}" | tee -a /var/log/monscript.log; }
check_disk() {
    local usage
    usage=$(df --output=pcent / | tail -1 | tr -dc '0-9')
    (( usage < ${1:-90} ))      # code retour 0 si OK
}
if ! check_disk 85; then log WARN "disque racine presque plein"; fi
echo $?   # code de retour de la dernière commande (0 = succès)

Un script doit renvoyer 0 en cas de succès et un code non nul en cas d'erreur : cron, systemd, Ansible et les pipelines CI s'en servent pour détecter l'échec.

Codes de retour
Un script qui renvoie toujours 0 rend ses échecs invisibles.

4. Rendre un script robuste #

Ce qui distingue un script de production.

trap, verrou et arguments #

#!/usr/bin/env bash
set -euo pipefail
TMP=$(mktemp -d)
trap 'rm -rf "$TMP"' EXIT                       # nettoyage, même en cas d'erreur
trap 'echo "Erreur ligne $LINENO" >&2' ERR

exec 9>/run/lock/backup.lock
flock -n 9 || { echo "Déjà en cours" >&2; exit 1; }   # empêcher deux exécutions

DRY_RUN=0 ; RETENTION=7
while getopts "nr:h" opt; do
    case $opt in
        n) DRY_RUN=1 ;;
        r) RETENTION=$OPTARG ;;
        h|*) echo "Usage : $0 [-n] [-r jours]"; exit 0 ;;
    esac
done

Qualité #

ShellCheck
ShellCheck repère les guillemets manquants et les commandes dangereuses.
  • Analysez chaque script avec ShellCheck (aussi en CI).
  • Rendez les scripts idempotents : les relancer ne doit rien casser (mkdir -p, tester avant de créer).
  • Proposez un mode simulation (-n) pour les actions destructrices.
  • Journalisez avec horodatage, sur stderr pour les erreurs.
  • Versionnez les scripts dans Git ; au-delà de ~200 lignes ou de logique complexe, passez à Python ou à Ansible.

Planifier #

Un script de maintenance se lance avec un timer systemd (journalisation, rattrapage, dépendances) ou cron. Testez-le d'abord avec l'environnement minimal : env -i /bin/bash --noprofile --norc ./script.sh.

📄 Scripts Bash pour l'administrateur : écrire des scripts robustes →

Mon suivi

  • ⏱ Durée estimée : ≈ 19 min

Connectez-vous pour suivre votre progression et prendre des notes. Se connecter

💬 Questions sur cette leçon

Aucune question pour l'instant : soyez le premier à demander de l'aide ou à partager votre configuration.

Poser une question sur cette leçon →

Articles recommandés

Le shell Bash et les fichiers : navigation, redirections, pipes et traitement de texte

Maîtriser la ligne de commande Linux : chemins, manipulation de fichiers, jokers, redirections, p...

Linux vs Unix : Le Guide Complet des Commandes et Distributions

Comprenez les différences entre Linux et Unix, explorez les distributions (serveur, desktop, ligh...

Paquets, services systemd, journaux et tâches planifiées

Installer et mettre à jour des logiciels avec apt et dnf, piloter les services avec systemctl, éc...

Bonnes pratiques d'administration Linux

Check-list pour administrer des serveurs Linux : comptes et sudo, SSH, mises à jour, services sys...

PowerShell pour l’administrateur Windows

Maîtriser PowerShell pour administrer Windows : cmdlets et aide, pipeline d'objets, filtres et fo...

Utilisateurs, groupes, sudo et permissions sous Linux

Gérer les comptes Linux (useradd, usermod, passwd, chage), les groupes, sudo et visudo, les permi...

Stockage sous Linux : disques, partitions, systèmes de fichiers et LVM

Administrer le stockage Linux : lsblk et blkid, partitionnement GPT, ext4 et XFS, montage et /etc...

Réseau sous Linux : configuration, diagnostic, pare-feu et SSH

Configurer et dépanner le réseau Linux : ip, ss, netplan et NetworkManager, DNS, diagnostic par c...

Sécurité et durcissement d'un serveur Linux

Durcir un serveur Linux : moindre privilège, mises à jour, SSH sécurisé, pare-feu, fail2ban, SELi...

Soutenir

♥ SOUTENIR

Soutenez RousselTM Learning

Les formations, articles, TP et attestations restent gratuits et sans publicité intrusive. Une contribution libre, du montant de votre choix, finance l’hébergement, les environnements de TP et l’écriture de nouveaux contenus.

Contribuer avec PayPal Montant libre · carte bancaire ou compte PayPalEn savoir plus
QR code PayPal
Ou scannez ce QR code avec votre téléphone

Merci, chaque contribution compte !