Script bash pour débutants : premier script, variables, conditions, boucles et cron

Un script bash est un simple fichier texte contenant des commandes que vous taperiez autrement une par une dans le terminal. Le script commence par la ligne shebang #!/bin/bash, reçoit le droit d'exécution avec chmod +x et se lance par ./script.sh. Ce guide du script bash pour débutants vous accompagne de la première ligne jusqu'à l'exécution planifiée : variables, arguments, conditions, boucles, gestion des erreurs et cron.

Votre premier script bash en une minute

Créez un fichier dans l'éditeur de votre choix, par exemple nano :

nano bonjour.sh

#!/bin/bash
# Premier script : un message d'accueil et quelques informations sur le système
echo "Bonjour, $USER !"
echo "Aujourd'hui : $(date +%Y-%m-%d)"
echo "Vous êtes dans : $(pwd)"

Enregistrez (Ctrl+O, Entrée, Ctrl+X), donnez le droit d'exécution et lancez le script :

$ chmod +x bonjour.sh
$ ./bonjour.sh
Bonjour, alice !
Aujourd'hui : 2026-10-12
Vous êtes dans : /home/alice

Les lignes commençant par # sont des commentaires. $(commande) insère directement dans une ligne la sortie d'une commande.

Shebang : à quoi sert la première ligne

La ligne #!/bin/bash indique au système quel interpréteur doit exécuter le fichier. Sans elle, le script s'exécute avec le shell disponible ; sur certains systèmes, /bin/sh n'est pas bash mais le plus simple dash, où certaines constructions ne fonctionnent pas.

La variante #!/usr/bin/env bash est également fréquente : elle cherche bash dans le PATH, pratique lorsque bash n'est pas installé dans /bin.

Comment lancer un script et pourquoi ./

Il y a deux façons de faire :

• ./bonjour.sh — nécessite le shebang et le droit x. Le préfixe ./ est obligatoire, car le répertoire courant ne fait pas partie du PATH.
• bash bonjour.sh — pas besoin de droit d'exécution, l'interpréteur est indiqué explicitement.

Si vous voyez command not found sans ./, ou Permission denied sans chmod +x, ce sont exactement les deux causes possibles. Pour appeler vos scripts par leur nom depuis n'importe où, placez-les dans ~/bin ou /usr/local/bin.

Variables

Une variable s'affecte sans espaces autour du = et se lit avec $ :

#!/bin/bash
nom="sauvegarde"
dossier="/var/backups"
aujourdhui=$(date +%F)

echo "Fichier : ${dossier}/${nom}-${aujourdhui}.tar.gz"

Les accolades séparent le nom de la variable du texte qui l'entoure. La ligne nom = "sauvegarde" avec des espaces est une erreur : bash essaiera d'exécuter une commande nommée nom.

Les guillemets comptent

Entre guillemets doubles, les variables sont remplacées ; entre guillemets simples, non. Il faut presque toujours mettre les variables entre guillemets doubles, sinon un nom de fichier contenant un espace sera découpé en deux arguments.

fichier="mon rapport.txt"
rm $fichier      # erreur : tente de supprimer « mon » et « rapport.txt »
rm "$fichier"    # correct
echo '$HOME'     # affiche littéralement $HOME
echo "$HOME"     # affiche /home/alice

Variables d'environnement

Des variables comme $HOME, $USER et $PATH sont définies par le système. Votre propre variable est transmise aux processus enfants avec export. Les réglages permanents de l'environnement vont dans ~/.bashrc ou ~/.profile.

Arguments du script

Les valeurs passées au lancement sont accessibles sous la forme $1, $2, etc.

#!/bin/bash
echo "Le script $0 a reçu $# argument(s)"
echo "Le premier : $1"

$ ./arguments.sh nginx 80
Le script ./arguments.sh a reçu 2 argument(s)
Le premier : nginx

La saisie de l'utilisateur se lit avec la commande read : read -p "Saisissez le nom : " nom.

Conditions if

Chaque commande renvoie un code de sortie : 0 signifie succès, toute autre valeur une erreur. La construction if teste précisément ce code. Pour les comparaisons, on utilise [[ ... ]] ; les espaces à l'intérieur des crochets sont obligatoires.

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

if [[ -d "$1" ]]; then
    echo "Le dossier $1 existe"
elif [[ -f "$1" ]]; then
    echo "$1 est un fichier, pas un dossier"
else
    echo "$1 introuvable"
fi

On peut aussi tester directement une commande :

if systemctl is-active --quiet nginx; then
    echo "nginx fonctionne"
else
    echo "nginx est arrêté"
fi

Pour de nombreux cas possibles, case est commode :

case "$1" in
    start)   echo "Démarrage" ;;
    stop)    echo "Arrêt" ;;
    *)       echo "Commande inconnue : $1"; exit 1 ;;
esac

Boucles for et while

for : parcourir une liste

for hote in web1 web2 db1; do
    echo "Vérification de $hote"
    ping -c 1 -W 1 "$hote" > /dev/null && echo "  joignable" || echo "  injoignable"
done

for fichier in /var/log/*.log; do
    echo "$fichier : $(wc -l < "$fichier") lignes"
done

for i in {1..5}; do
    echo "Tentative $i"
done

while : tant que la condition est vraie

Un exemple classique est la lecture ligne par ligne d'un fichier :

while read -r utilisateur; do
    echo "Utilisateur : $utilisateur"
done < utilisateurs.txt

Et l'attente qu'un service soit prêt :

compteur=0
until curl -sf http://localhost:8080/health > /dev/null; do
    compteur=$((compteur + 1))
    if [[ $compteur -ge 10 ]]; then
        echo "Le service n'a pas démarré"
        exit 1
    fi
    sleep 3
done
echo "Le service est prêt"

L'arithmétique en bash s'écrit entre doubles parenthèses : $((a + b)). Elle ne fonctionne qu'avec des entiers.

Fonctions

On regroupe le code répétitif dans des fonctions. À l'intérieur d'une fonction, les arguments sont les mêmes $1, $2, et local empêche une variable de sortir de la fonction.

journal() {
    local niveau="$1"; shift
    echo "$(date '+%F %T') [$niveau] $*"
}

journal INFO "Début de la sauvegarde"
journal ERROR "Plus d'espace disque"

Gestion des erreurs : set -euo pipefail

Par défaut, bash continue après l'échec d'une commande — un script de sauvegarde peut ainsi se terminer « avec succès » sans rien copier. On ajoute donc souvent un mode strict en début de script :

#!/bin/bash
set -euo pipefail

• -e — s'arrêter à la première erreur.
• -u — considérer l'utilisation d'une variable non définie comme une erreur (protège contre rm -rf "$DOSSIER/" avec un DOSSIER vide).
• -o pipefail — un pipeline échoue si l'une de ses parties échoue.

Pour le débogage, lancez le script avec bash -x script.sh : bash affiche chaque commande avant de l'exécuter. L'utilitaire shellcheck repère les erreurs typiques avant le lancement.

Exemple pratique : un script de sauvegarde

#!/bin/bash
set -euo pipefail

SOURCE="${1:-/var/www}"
DESTINATION="/var/backups/site"
JOURS_CONSERVATION=7
HORODATAGE=$(date +%F_%H-%M)

mkdir -p "$DESTINATION"
tar -czf "$DESTINATION/site-$HORODATAGE.tar.gz" -C "$(dirname "$SOURCE")" "$(basename "$SOURCE")"
echo "Archive créée : $DESTINATION/site-$HORODATAGE.tar.gz"

# supprimer les archives plus anciennes que JOURS_CONSERVATION jours
find "$DESTINATION" -name "site-*.tar.gz" -mtime +"$JOURS_CONSERVATION" -delete

L'expression ${1:-/var/www} signifie « le premier argument, ou /var/www s'il n'y en a pas ». Enregistrez le script sous /usr/local/bin/backup-site.sh et rendez-le exécutable : sudo chmod +x /usr/local/bin/backup-site.sh.

Exécution planifiée : cron

Cron est le service qui lance des commandes selon un calendrier. Les tâches d'un utilisateur se modifient avec crontab -e, s'affichent avec crontab -l, celles de root avec sudo crontab -e.

Une ligne de tâche se compose de cinq champs horaires et de la commande :

# minute heure jour_du_mois mois jour_de_la_semaine commande
30 2 * * * /usr/local/bin/backup-site.sh >> /var/log/backup.log 2>&1

Pourquoi un script fonctionne à la main mais pas dans cron

• Environnement différent. Cron lance les tâches avec un PATH minimal et sans votre ~/.bashrc. Écrivez les chemins complets des commandes et des fichiers, ou définissez PATH en tête de la crontab.
• Répertoire courant différent. La tâche démarre dans le répertoire personnel, et non là où se trouve le script. Utilisez des chemins absolus.
• Le caractère %. Dans une crontab, le signe % signifie un saut de ligne ; date +%F écrit directement dans la tâche doit donc être échappé en \%. Le plus simple est de placer la commande dans un script.
• La sortie se perd. Redirigez la sortie vers un journal (>> fichier 2>&1), sinon vous ne verrez pas les erreurs. Les exécutions de cron apparaissent dans journalctl -u cron (sur les systèmes de type RHEL, le service s'appelle crond).

Sur les systèmes avec systemd, les timers sont une alternative à cron : ils écrivent leur sortie dans le journal et peuvent rattraper les exécutions manquées.

Synthèse

Un script bash pour débutants est un fichier commençant par le shebang #!/bin/bash, doté du droit d'exécution et d'une suite de commandes. Ajoutez des variables entre guillemets, une vérification des arguments avec if, les boucles for et while, le mode strict set -euo pipefail — et vous obtenez un outil d'automatisation fiable que cron peut exécuter selon un calendrier. Les scripts bash, l'environnement et cron sont traités pas à pas et en pratique dans notre cours sur Linux.