09 · Scripting Bash

Passer du mode "je tape des commandes une par une" au mode "j'automatise des tâches". Tu vas apprendre à écrire des scripts shell qui enchaînent des commandes, prennent des décisions et répètent des actions.

Le shell scripting est la compétence la plus rentable de l'administration Linux. Un script de 20 lignes peut remplacer une heure de travail manuel.

Ce tutoriel utilise /bin/sh (POSIX, portable) mais tout fonctionne aussi avec bash.

Un script shell est un simple fichier texte contenant une suite de commandes. La première ligne, appelée shebang, indique quel interpréteur utiliser :

#!/bin/sh

ou, pour Bash spécifiquement :

#!/bin/bash

Anatomie d'un script minimal

#!/bin/sh
# Ceci est un commentaire
echo "Bonjour"
echo "Il est $(date +%H:%M)"

Rendre le script exécutable et le lancer

chmod +x mon_script.sh
./mon_script.sh

Une variable stocke une valeur. En shell, pas de type : tout est une chaîne de caractères (ou un nombre, selon l'usage).

Définir et utiliser

nom="Alice"
age=30

echo "Bonjour $nom"
echo "Tu as $age ans"
echo "Bonjour ${nom}, tu as ${age} ans"

Accolades pour éviter les ambiguïtés

fichier="notes"
echo "$fichier.txt"     # → ".txt" (la variable fichier.txt n'existe pas)
echo "${fichier}.txt"   # → "notes.txt"

Variables spéciales

$0        → nom du script
$1, $2    → arguments passés au script
$#        → nombre d'arguments
$@        → tous les arguments
$?        → code retour de la dernière commande
$$        → PID du script
$USER     → utilisateur courant
$HOME     → dossier personnel
$PWD      → dossier courant

Calculs arithmétiques

a=5
b=3
somme=$((a + b))
echo "Somme : $somme"

echo "Multiplication : $((a * b))"
echo "Division entière : $((a / b))"

#!/bin/sh
echo -n "Ton prénom : "
read prenom
echo "Bonjour $prenom !"

Avec invite intégrée

read -p "Ton âge : " age
echo "Tu as $age ans"

Lire plusieurs valeurs

read -p "Prénom et nom : " prenom nom
echo "Prénom : $prenom / Nom : $nom"

Lire en silence (mot de passe)

read -s -p "Mot de passe : " mdp
echo
echo "Mot de passe reçu (${#mdp} caractères)"

Structure de base

if [ condition ]; then
    # instructions si vrai
fi

Avec else et elif

if [ "$age" -lt 18 ]; then
    echo "Mineur"
elif [ "$age" -lt 65 ]; then
    echo "Majeur actif"
else
    echo "Senior"
fi

Opérateurs de comparaison numérique

-eq    égal à
-ne    différent de
-lt    inférieur à
-le    inférieur ou égal
-gt    supérieur à
-ge    supérieur ou égal

Opérateurs de comparaison de chaînes

=      égal
!=     différent
-z     chaîne vide
-n     chaîne non vide

Tests sur les fichiers

-e fichier    → existe
-f fichier    → existe et est un fichier normal
-d fichier    → existe et est un dossier
-r fichier    → lisible
-w fichier    → modifiable
-x fichier    → exécutable
-s fichier    → existe et non vide

Exemples combinés

if [ -f /etc/passwd ]; then
    echo "Fichier présent"
fi

if [ ! -d /tmp/mondossier ]; then
    echo "Le dossier n'existe pas, je le crée"
    mkdir /tmp/mondossier
fi

if [ "$USER" = "root" ]; then
    echo "Attention : tu es root !"
fi

Conditions multiples

if [ "$age" -gt 18 ] && [ "$age" -lt 65 ]; then
    echo "Actif"
fi

if [ "$nom" = "Alice" ] || [ "$nom" = "Bob" ]; then
    echo "Bienvenue"
fi

Boucle for sur une liste

for fruit in pomme banane cerise; do
    echo "J'aime la $fruit"
done

Boucle for sur une plage numérique

for i in 1 2 3 4 5; do
    echo "Tour n°$i"
done

Boucle for avec séquence

for i in $(seq 1 10); do
    echo "$i"
done

Boucle for sur des fichiers

for f in *.txt; do
    echo "Fichier trouvé : $f"
done

Boucle while

compteur=1
while [ $compteur -le 5 ]; do
    echo "Compteur : $compteur"
    compteur=$((compteur + 1))
done

Boucle infinie avec break

while true; do
    echo -n "Tape 'quit' pour sortir : "
    read reponse
    if [ "$reponse" = "quit" ]; then
        break
    fi
    echo "Tu as tapé : $reponse"
done

Boucle until

compteur=1
until [ $compteur -gt 5 ]; do
    echo "Compteur : $compteur"
    compteur=$((compteur + 1))
done

Un script peut recevoir des arguments en ligne de commande :

./mon_script.sh arg1 arg2 arg3

Les récupérer

#!/bin/sh
echo "Nom du script : $0"
echo "Premier argument : $1"
echo "Deuxième argument : $2"
echo "Nombre d'arguments : $#"
echo "Tous les arguments : $@"

Vérifier qu'il y a bien des arguments

#!/bin/sh
if [ $# -eq 0 ]; then
    echo "Usage : $0 <nom>"
    exit 1
fi

echo "Bonjour $1"

Une fonction regroupe des commandes réutilisables :

#!/bin/sh

dire_bonjour() {
    echo "Bonjour $1"
}

dire_bonjour "Alice"
dire_bonjour "Bob"

Avec valeur de retour (via echo)

addition() {
    echo $(( $1 + $2 ))
}

resultat=$(addition 3 5)
echo "3 + 5 = $resultat"

Avec code retour

est_pair() {
    if [ $(($1 % 2)) -eq 0 ]; then
        return 0    # vrai
    else
        return 1    # faux
    fi
}

if est_pair 4; then
    echo "4 est pair"
fi

Arrêter le script à la première erreur

#!/bin/sh
set -e

cd /dossier/inexistant    # erreur → script s'arrête
echo "Jamais atteint"

Alternative locale avec ||

mkdir /tmp/test || echo "Échec création"
mkdir /tmp/test || { echo "Échec"; exit 1; }

Alternative avec &&

mkdir /tmp/test && cd /tmp/test && echo "OK"

Ne pas afficher les erreurs

rm /inexistant 2>/dev/null

Un script complet qui combine tout ce qu'on a vu :

#!/bin/sh
set -e

# Variables
DOSSIER_SOURCE="${1:-$HOME/projet}"
DOSSIER_DEST="${2:-$HOME/backups}"
DATE=$(date +%Y-%m-%d_%H-%M-%S)

# Vérifications
if [ ! -d "$DOSSIER_SOURCE" ]; then
    echo "Erreur : $DOSSIER_SOURCE n'existe pas"
    exit 1
fi

mkdir -p "$DOSSIER_DEST"

# Création de l'archive
NOM_ARCHIVE="backup_${DATE}.tar.gz"
echo "Création de $NOM_ARCHIVE..."

tar -czf "$DOSSIER_DEST/$NOM_ARCHIVE" -C "$(dirname "$DOSSIER_SOURCE")" "$(basename "$DOSSIER_SOURCE")"

# Vérification
if [ -f "$DOSSIER_DEST/$NOM_ARCHIVE" ]; then
    TAILLE=$(du -h "$DOSSIER_DEST/$NOM_ARCHIVE" | cut -f1)
    echo "✅ Sauvegarde réussie : $NOM_ARCHIVE ($TAILLE)"
else
    echo "❌ Échec de la sauvegarde"
    exit 1
fi

Utilisation :

chmod +x backup.sh
./backup.sh                          # utilise les valeurs par défaut
./backup.sh /etc /tmp/sauvegardes    # dossiers personnalisés

Ce que fait ce script

• Utilise des variables avec valeurs par défaut (${1:-valeur})
• Vérifie que la source existe
• Crée le dossier de destination si besoin
• Génère un nom horodaté
• Crée l'archive avec tar
• Vérifie que tout s'est bien passé

Structure

#!/bin/sh              → shebang
chmod +x script.sh     → rendre exécutable
./script.sh            → lancer

Variables

nom="Alice"            → affecter
$nom, ${nom}           → utiliser
$1, $2, $#             → arguments
$?, $$                 → code retour, PID
$((a + b))             → calcul

Saisie

read var               → lire dans var
read -p "prompt" var   → avec invite
read -s var            → silencieux

Conditions

if [ cond ]; then ... fi
if [ cond ]; then ... else ... fi
if [ cond ]; then ... elif ... else ... fi

-eq -ne -lt -le -gt -ge       → numériques
= != -z -n                    → chaînes
-e -f -d -r -w -x             → fichiers

Boucles

for i in liste; do ... done
for i in $(seq 1 10); do ... done
while [ cond ]; do ... done
until [ cond ]; do ... done
break / continue

Fonctions

nom() { commandes; }
resultat=$(nom arg)

Bonnes pratiques

set -e              → arrêt à la 1re erreur
"$variable"         → toujours entre guillemets
exit 0 / exit 1     → code de sortie explicite
${1:-défaut}        → valeur par défaut

Crée un script menu.sh qui affiche un menu, demande un choix, et exécute l'action correspondante.

#!/bin/sh

while true; do
    echo ""
    echo "=== MENU ==="
    echo "1) Afficher la date"
    echo "2) Afficher qui je suis"
    echo "3) Lister les fichiers"
    echo "4) Quitter"
    echo -n "Choix : "
    read choix

    case "$choix" in
        1) date ;;
        2) whoami ;;
        3) ls -la ;;
        4) echo "Au revoir !"; exit 0 ;;
        *) echo "Choix invalide" ;;
    esac
done

La structure case

case "$variable" in
    motif1) commandes ;;
    motif2) commandes ;;
    *) commandes par défaut ;;
esac

Aller plus loin

Ajoute ces fonctionnalités au menu :

1. Option 5 : créer une archive de $HOME/projet
2. Option 6 : afficher l'espace disque (df -h)
3. Option 7 : compter les fichiers dans le dossier courant
4. Vérifier que le choix est bien numérique

• Arrays Bash : tableau=(a b c); echo ${tableau[0]}
• Regex avec =~ dans [[ ]]
• Substitution de commandes : $(commande) vs `commande`
• Process substitution : diff <(cmd1) <(cmd2)
• Trap : capturer Ctrl+C pour nettoyer
• ShellCheck : analyseur statique qui détecte les erreurs de script (apk add shellcheck)

shellcheck est ton meilleur ami. Il détecte les erreurs que tu ne verras qu'à l'exécution.