1. Les bases #
Un script, c'est une suite de commandes.
Squelette #
#!/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| Option | Effet |
|---|---|
set -e | arrête le script à la première commande en échec |
set -u | erreur si une variable n'est pas définie |
set -o pipefail | un 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 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 #
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/shest 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/shdoit 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/shpour 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ère | sh (POSIX) / dash | bash | ksh93 | zsh | fish |
|---|---|---|---|---|---|
| Compatibilité POSIX | référence | oui (+ extensions) | oui (+ extensions) | presque (mode emulate sh) | non |
| Tableaux | non | indexés et associatifs (indice 0) | indexés et associatifs | oui (indice 1) | listes |
[[ ]], (( )) | non | oui | oui | oui | non (test, math) |
| Confort interactif | minimal | bon | bon | excellent | excellent, sans configuration |
| Vitesse de démarrage | très rapide | moyenne | rapide | moyenne | moyenne |
| Fichier de configuration | ~/.profile, $ENV | ~/.bashrc, ~/.bash_profile | ~/.kshrc | ~/.zshrc, ~/.zprofile | ~/.config/fish/config.fish |
| Pour les scripts | portables, systèmes, conteneurs | administration Linux | Unix commerciaux, historique | personnels | à é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 &> log | cmd > log 2>&1 |
read -p "Nom ? " nom | printf 'Nom ? '; read -r nom |
set -o pipefail | POSIX depuis 2024 (dash ≥ 0.5.12) ; sinon absent |
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 avecshellcheck -s shoucheckbashisms.
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 » :
| Situation | Type de shell | Fichiers 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 commande | non interactif | aucun (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~/.profileou~/.bash_profile, les alias et le prompt dans~/.bashrc, et faites charger~/.bashrcpar~/.bash_profile. Dans un script ou une tâche cron, ne comptez sur aucun de ces fichiers : définissezPATHet les variables nécessaires dans le script.
Commandes à connaître #
| Action | Commande |
|---|---|
| Shell courant | echo $0 ; ps -p $$ |
| Shells installés | cat /etc/shells |
| Cible de /bin/sh | readlink -f /bin/sh |
| Changer de shell de connexion | chsh -s /bin/zsh |
| Version de bash | bash --version ; echo $BASH_VERSION |
| Lancer bash en mode POSIX | bash --posix script.sh |
| Tester avec dash | dash -n script.sh && dash script.sh |
| Détecter les bashismes | checkbashisms script.sh ; shellcheck -s sh script.sh |
| Installer ksh, zsh, fish | sudo apt install ksh zsh fish # ou dnf |
TP : un même script, cinq shells #
- Installez
dash,ksh,zshetfish, puis vérifiezcat /etc/shellsetreadlink -f /bin/sh. - Écrivez
info.shqui affiche le nom d'hôte, compte les fichiers de/etcavec une boucle, utilise un tableau et un test[[ … ]]. - Exécutez-le avec
bash,dash,kshetzsh; notez les erreurs et les résultats différents (indice des tableaux sous zsh). - Passez
checkbashismsetshellcheck -s sh, puis réécrivez le script en POSIX pur jusqu'à ce qu'il donne le même résultat dans les quatre shells. - 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 ;;
esacTests utiles #
| Test | Vrai si |
|---|---|
-f / -d / -e | fichier / répertoire / existe |
-r -w -x | lisible, modifiable, exécutable |
-z / -n | chaîne vide / non vide |
-eq -ne -lt -gt | comparaisons 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; doneFonctions 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.
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
doneQualité #
- 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.
Mon suivi
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.
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...