Quand j’ai commencé à enseigner en BTS SIO, j’ai rapidement constaté que mes étudiants passaient un temps considérable sur des tâches répétitives : sauvegarder des fichiers, vérifier l’état d’un serveur, nettoyer des répertoires temporaires. Chaque semaine, les mêmes manipulations, les mêmes clics, les mêmes commandes tapées une par une. C’est exactement pour résoudre ce problème que le Bash scripting existe.

Le Bash (Bourne Again SHell) est bien plus qu’un simple interpréteur de commandes. C’est un véritable langage de programmation intégré nativement à la quasi-totalité des systèmes Linux. Si vous maîtrisez déjà les commandes Linux de base, vous êtes prêt à franchir l’étape suivante : les combiner dans des scripts pour automatiser vos tâches sous Linux de manière fiable et reproductible.

Dans ce guide, je vous accompagne pas à pas, de votre tout premier script jusqu’à des automatisations complètes que vous pourrez réutiliser dans vos projets BTS SIO et au-delà.

Pourquoi automatiser avec Bash en 2026

Avant de plonger dans le code, posons la question essentielle : pourquoi choisir Bash plutôt qu’un autre langage pour l’automatisation système ? La réponse tient en plusieurs points concrets.

Bash est disponible partout. Sur Ubuntu, Debian, Fedora, CentOS, Arch Linux ou même macOS, Bash est préinstallé. Pas besoin d’installer un runtime Python ou Node.js pour exécuter un script d’automatisation. Sur un serveur fraîchement déployé, Bash est déjà là, prêt à travailler. Si vous utilisez l’une des distributions Linux populaires pour étudiants, vous avez déjà tout ce qu’il faut.

Bash excelle pour l’orchestration système. La gestion de fichiers, les opérations réseau, le monitoring de services, la manipulation de logs : tout cela se fait naturellement en Bash. Chaque commande Linux devient une brique que vous assemblez dans vos scripts.

En tant que future administratrice système ou développeuse, l’automatisation Bash est une compétence que les recruteurs recherchent activement. Selon le référentiel du BTS SIO option SISR, la capacité à scripter des tâches d’administration fait partie des compétences évaluées à l’examen.

Voici les cas d’usage où Bash brille particulièrement :

• Sauvegardes automatisées de bases de données et fichiers de configuration
• Monitoring système : espace disque, charge CPU, services actifs
• Déploiement d’applications : mise à jour de code, redémarrage de services
• Nettoyage automatique de fichiers temporaires et de logs anciens
• Provisioning de serveurs : installation et configuration initiale

En revanche, pour des traitements de données complexes ou du développement web, Python sera plus adapté. Bash et Python sont complémentaires, pas concurrents.

Les bases du Bash scripting : syntaxe et premiers scripts

Créons ensemble votre tout premier script Bash. Ouvrez votre éditeur de code favori ou simplement le terminal, et suivez le guide.

Créer et exécuter un script

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

#!/bin/bash
# Mon premier script Bash
# Auteur : votre nom
# Date : 2026-04-18

echo "Bonjour ! Ce script fonctionne parfaitement."
echo "Nous sommes le $(date '+%d/%m/%Y à %H:%M')"
echo "Utilisateur connecté : $(whoami)"
echo "Répertoire actuel : $(pwd)"

Enregistrez ce fichier sous le nom premier_script.sh, puis rendez-le exécutable et lancez-le :

chmod +x premier_script.sh
./premier_script.sh

Le chmod +x ajoute la permission d’exécution au fichier. Sans cette étape, le système refusera de lancer votre script. C’est un point que mes étudiants oublient systématiquement la première fois.

La substitution de commandes

Vous avez remarqué la syntaxe $(commande) dans l’exemple précédent. C’est la substitution de commandes : elle exécute la commande entre parenthèses et insère le résultat à la place. C’est l’un des mécanismes les plus puissants de Bash.

#!/bin/bash
# Exemple de substitution de commandes
nombre_fichiers=$(ls -1 | wc -l)
espace_disque=$(df -h / | tail -1 | awk '{print $4}')

echo "Ce répertoire contient $nombre_fichiers fichiers."
echo "Espace disque disponible sur / : $espace_disque"

Variables, arguments et entrées utilisateur

Les variables sont le cœur de tout script. Elles vous permettent de stocker des valeurs, de les réutiliser et de rendre vos scripts flexibles et paramétrables.

Déclarer et utiliser des variables

#!/bin/bash
# Variables en Bash : attention, PAS d'espace autour du =
nom="Lucie"
age=35
repertoire_backup="/home/$nom/sauvegardes"

echo "Je suis $nom, j'ai $age ans."
echo "Mes sauvegardes sont dans : $repertoire_backup"

# Variables en lecture seule
readonly VERSION="1.0"
echo "Version du script : $VERSION"

Attention : en Bash, il ne faut jamais mettre d’espace autour du signe égal lors de l’affectation. nom = "Lucie" provoquera une erreur, car Bash interprétera nom comme une commande.

Arguments de ligne de commande

Les arguments passés au script sont accessibles via des variables spéciales. C’est ce qui rend vos scripts réutilisables dans différents contextes :

#!/bin/bash
# script_args.sh : démonstration des arguments
echo "Nom du script : $0"
echo "Premier argument : $1"
echo "Deuxième argument : $2"
echo "Nombre total d'arguments : $#"
echo "Tous les arguments : $@"

# Utilisation : ./script_args.sh fichier.txt /tmp/backup

Lire une entrée utilisateur

#!/bin/bash
# Interaction avec l'utilisateur
read -p "Entrez votre nom : " nom_utilisateur
read -sp "Entrez votre mot de passe : " mot_de_passe
echo ""  # Retour à la ligne après le mot de passe masqué
echo "Bienvenue, $nom_utilisateur !"

L’option -s de read masque la saisie, ce qui est indispensable pour les mots de passe. L’option -p affiche un message d’invite directement.

Structures de contrôle et boucles

C’est ici que vos scripts passent de simples séquences de commandes à de véritables programmes intelligents. Les conditions et les boucles sont les outils qui donnent à vos scripts la capacité de prendre des décisions et de traiter des ensembles de données.

Les conditions if/elif/else

#!/bin/bash
# Vérifier l'espace disque disponible
utilisation=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')

if [ "$utilisation" -gt 90 ]; then
    echo "ALERTE CRITIQUE : disque utilisé à ${utilisation}% !"
    # Envoyer une notification
elif [ "$utilisation" -gt 75 ]; then
    echo "AVERTISSEMENT : disque utilisé à ${utilisation}%."
else
    echo "OK : disque utilisé à ${utilisation}%." 
fi

Quelques points importants sur la syntaxe : les espaces à l’intérieur des crochets sont obligatoires, le then peut être sur la même ligne que le if à condition d’ajouter un point-virgule, et le bloc se termine toujours par fi.

Les opérateurs de comparaison

Bash utilise des opérateurs différents pour les nombres et les chaînes de caractères :

#!/bin/bash
# Comparaisons numériques
a=10
b=20
if [ "$a" -lt "$b" ]; then echo "$a est inférieur à $b"; fi
if [ "$a" -eq 10 ]; then echo "a vaut 10"; fi

# Comparaisons de chaînes
chaine="linux"
if [ "$chaine" = "linux" ]; then echo "Correspondance exacte"; fi
if [ -n "$chaine" ]; then echo "La chaîne n'est pas vide"; fi

# Tests sur les fichiers
if [ -f "/etc/passwd" ]; then echo "Le fichier existe"; fi
if [ -d "/home" ]; then echo "Le répertoire existe"; fi
if [ -w "/tmp" ]; then echo "Écriture autorisée dans /tmp"; fi

Les boucles for et while

Les boucles sont essentielles pour traiter des listes de fichiers, parcourir des résultats de commandes ou répéter une action un nombre défini de fois :

#!/bin/bash
# Boucle for : renommer des fichiers en masse
for fichier in *.log; do
    if [ -f "$fichier" ]; then
        nouveau_nom="archive_$(date +%Y%m%d)_$fichier"
        mv "$fichier" "$nouveau_nom"
        echo "Renommé : $fichier -> $nouveau_nom"
    fi
done

# Boucle while : surveiller un service
while true; do
    if ! systemctl is-active --quiet nginx; then
        echo "$(date) : Nginx est arrêté, redémarrage..." >> /var/log/watchdog.log
        systemctl restart nginx
    fi
    sleep 60
done

La boucle for est idéale quand vous connaissez la liste d’éléments à parcourir. La boucle while convient mieux aux situations où vous attendez qu’une condition change. Si vous gérez un serveur Linux personnel, ces boucles de surveillance deviendront vite indispensables.

Scripts d’automatisation concrets pour le quotidien

Passons maintenant à la pratique avec des scripts directement utilisables. Je les utilise moi-même dans mes cours et sur mes propres serveurs.

Script 1 : sauvegarde automatique avec rotation

#!/bin/bash
# backup.sh : sauvegarde avec rotation sur 7 jours
# Usage : ./backup.sh /chemin/source /chemin/destination

SOURCE="${1:?Erreur : spécifiez le répertoire source}"
DEST="${2:?Erreur : spécifiez le répertoire destination}"
DATE=$(date +%Y%m%d_%H%M%S)
NOM_ARCHIVE="backup_${DATE}.tar.gz"
RETENTION=7

# Créer le répertoire de destination si nécessaire
mkdir -p "$DEST"

# Créer l'archive compressée
echo "Sauvegarde de $SOURCE en cours..."
tar -czf "${DEST}/${NOM_ARCHIVE}" -C "$(dirname "$SOURCE")" "$(basename "$SOURCE")" 2>/dev/null

if [ $? -eq 0 ]; then
    taille=$(du -h "${DEST}/${NOM_ARCHIVE}" | cut -f1)
    echo "Sauvegarde réussie : ${NOM_ARCHIVE} ($taille)"
else
    echo "Erreur lors de la sauvegarde !" >&2
    exit 1
fi

# Rotation : supprimer les sauvegardes de plus de 7 jours
echo "Nettoyage des sauvegardes de plus de $RETENTION jours..."
find "$DEST" -name "backup_*.tar.gz" -mtime +"$RETENTION" -delete
nb_restantes=$(find "$DEST" -name "backup_*.tar.gz" | wc -l)
echo "Sauvegardes restantes : $nb_restantes"

Script 2 : monitoring système complet

#!/bin/bash
# monitoring.sh : rapport d'état du système
# Génère un rapport lisible de l'état du serveur

RAPPORT="/tmp/rapport_systeme_$(date +%Y%m%d).txt"

{
    echo "======================================="
    echo " Rapport système du $(date '+%d/%m/%Y à %H:%M')"
    echo "======================================="
    echo ""
    
    echo "--- Informations système ---"
    echo "Hostname : $(hostname)"
    echo "Uptime : $(uptime -p)"
    echo "Kernel : $(uname -r)"
    echo ""
    
    echo "--- Utilisation CPU ---"
    top -bn1 | head -3 | tail -1
    echo ""
    
    echo "--- Mémoire ---"
    free -h | head -2
    echo ""
    
    echo "--- Espace disque ---"
    df -h | grep -E '^/dev/'
    echo ""
    
    echo "--- Services critiques ---"
    for service in nginx apache2 mysql postgresql ssh; do
        if systemctl is-active --quiet "$service" 2>/dev/null; then
            echo "  [OK] $service est actif"
        elif systemctl list-unit-files | grep -q "$service"; then
            echo "  [KO] $service est ARRÊTÉ"
        fi
    done
    echo ""
    
    echo "--- Dernières connexions ---"
    last -5 | head -5

} > "$RAPPORT"

echo "Rapport généré : $RAPPORT"
cat "$RAPPORT"

Ce type de script est exactement ce que l’on attend d’un technicien SISR en situation professionnelle. Si vous configurez un homelab étudiant, c’est l’un des premiers scripts à mettre en place.

Script 3 : nettoyage de logs et fichiers temporaires

#!/bin/bash
# nettoyage.sh : nettoyer les fichiers inutiles
SEUIL_JOURS=30
REPERTOIRES=("/tmp" "/var/tmp" "/var/log")
ESPACE_AVANT=$(df / | tail -1 | awk '{print $4}')

for rep in "${REPERTOIRES[@]}"; do
    if [ -d "$rep" ]; then
        echo "Nettoyage de $rep (fichiers > $SEUIL_JOURS jours)..."
        nb=$(find "$rep" -type f -mtime +"$SEUIL_JOURS" 2>/dev/null | wc -l)
        find "$rep" -type f -mtime +"$SEUIL_JOURS" -delete 2>/dev/null
        echo "  $nb fichiers supprimés."
    fi
done

# Compresser les logs actifs volumineux
find /var/log -name "*.log" -size +50M -exec gzip {} \;

ESPACE_APRES=$(df / | tail -1 | awk '{print $4}')
echo "Espace libéré : $((ESPACE_APRES - ESPACE_AVANT)) Ko"

Planifier l’exécution avec cron et systemd

Un script qui ne s’exécute que manuellement n’est qu’à moitié automatisé. La vraie puissance de l’automatisation Bash réside dans la planification. Deux outils principaux permettent de lancer vos scripts à intervalles réguliers.

Cron : le planificateur classique

Cron est le planificateur historique de Linux. La commande crontab -e ouvre votre table de planification personnelle :

# Format : minute heure jour_mois mois jour_semaine commande

# Sauvegarde quotidienne à 2h du matin
0 2 * * * /home/user/scripts/backup.sh /var/www /home/user/backups >> /var/log/backup.log 2>&1

# Monitoring toutes les 15 minutes
*/15 * * * * /home/user/scripts/monitoring.sh

# Nettoyage chaque dimanche à 3h
0 3 * * 0 /home/user/scripts/nettoyage.sh

# Rapport hebdomadaire le lundi à 8h
0 8 * * 1 /home/user/scripts/rapport_hebdo.sh | mail -s "Rapport serveur" [email protected]

La syntaxe cron peut sembler cryptique au début. Voici un aide-mémoire que je distribue à mes étudiants :

Systemd timers : l’alternative moderne

Les systemd timers offrent une alternative plus robuste à cron avec une meilleure gestion des logs et des dépendances :

# /etc/systemd/system/backup.service
[Unit]
Description=Sauvegarde automatique quotidienne

[Service]
Type=oneshot
ExecStart=/home/user/scripts/backup.sh /var/www /home/user/backups
User=user

# /etc/systemd/system/backup.timer
[Unit]
Description=Planification de la sauvegarde quotidienne

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true

[Install]
WantedBy=timers.target

Activez le timer avec sudo systemctl enable --now backup.timer. L’option Persistent=true garantit que si le serveur était éteint à l’heure prévue, la tâche sera exécutée au prochain démarrage. C’est un avantage majeur par rapport à cron.

Bonnes pratiques et sécurité des scripts Bash

Un script qui fonctionne n’est pas forcément un bon script. En contexte professionnel et surtout pour les épreuves du BTS SIO, la qualité et la sécurité de vos scripts comptent autant que leur fonctionnalité. Voici les règles que j’applique systématiquement.

L’en-tête de sécurité indispensable

#!/bin/bash
set -euo pipefail
IFS=$'\n\t'

# set -e : arrêter le script à la première erreur
# set -u : erreur si une variable n'est pas définie
# set -o pipefail : détecter les erreurs dans les pipes
# IFS : séparateur de champs sécurisé

Ces quatre lignes transforment le comportement par défaut de Bash. Sans set -e, un script continue de s’exécuter même après une erreur, ce qui peut provoquer des dégâts en cascade. Sans set -u, une variable non définie est silencieusement remplacée par une chaîne vide, ce qui est source de bugs difficiles à tracer. Je considère cet en-tête comme obligatoire pour tout script en production.

Valider les entrées et gérer les erreurs

#!/bin/bash
set -euo pipefail

# Vérifier que le script est exécuté en root
if [ "$(id -u)" -ne 0 ]; then
    echo "Erreur : ce script doit être exécuté en tant que root." >&2
    exit 1
fi

# Vérifier le nombre d'arguments
if [ $# -lt 2 ]; then
    echo "Usage : $0  " >&2
    exit 1
fi

# Vérifier que le répertoire source existe
if [ ! -d "$1" ]; then
    echo "Erreur : le répertoire '$1' n'existe pas." >&2
    exit 1
fi

Redirigez toujours les messages d’erreur vers stderr avec >&2. Cela permet de séparer les sorties normales des erreurs lors de l’utilisation de pipes ou de redirections. C’est un réflexe professionnel que les examinateurs apprécient.

Permissions et sécurité des fichiers

Les permissions de vos scripts sont cruciales, surtout sur un serveur partagé. Un script contenant des mots de passe en clair avec des permissions trop ouvertes est une faille de sécurité majeure. Pour approfondir les enjeux de sécurité, consultez notre guide sur la formation cybersécurité.

# Permissions recommandées pour les scripts
chmod 700 mon_script.sh      # Seul le propriétaire peut lire, écrire, exécuter
chmod 750 script_partage.sh  # Le groupe peut lire et exécuter

# Ne JAMAIS stocker de mots de passe en clair dans un script
# Utiliser des variables d'environnement ou un fichier protégé
source /etc/mon_app/credentials.env  # Fichier en chmod 600

Déboguer et optimiser ses scripts

Même les développeurs expérimentés écrivent des scripts avec des bugs. Ce qui fait la différence, c’est la capacité à les diagnostiquer rapidement.

Le mode debug

# Activer le mode debug pour tout le script
bash -x mon_script.sh

# Ou activer/désactiver le debug sur une section précise
set -x  # Début du debug
# ... commandes à déboguer ...
set +x  # Fin du debug

Le mode -x affiche chaque commande avant son exécution, avec les variables déjà substituées. C’est extrêmement utile pour comprendre pourquoi une condition ne se comporte pas comme prévu.

Piège à erreurs avec trap

#!/bin/bash
set -euo pipefail

# Fichier temporaire
FICHIER_TEMP=$(mktemp)

# Nettoyer le fichier temporaire à la sortie du script
trap 'rm -f "$FICHIER_TEMP"' EXIT

# Gérer les interruptions (Ctrl+C)
trap 'echo "Script interrompu."; exit 130' INT

# Utiliser le fichier temporaire en toute sécurité
df -h > "$FICHIER_TEMP"
grep '/dev/' "$FICHIER_TEMP"
# Le fichier sera automatiquement supprimé à la sortie

La commande trap est un mécanisme élégant pour garantir le nettoyage des ressources. Sans elle, un script interrompu peut laisser des fichiers temporaires, des processus orphelins ou des verrous non libérés.

Mesurer les performances

# Mesurer le temps d'exécution d'un script
time ./mon_script.sh

# Mesurer une section spécifique dans un script
DEBUT=$(date +%s)
# ... opérations longues ...
FIN=$(date +%s)
echo "Durée : $((FIN - DEBUT)) secondes"

Aller plus loin : fonctions, logs et scripts avancés

Pour des scripts maintenables et réutilisables, structurez votre code avec des fonctions et une gestion de logs professionnelle.

Organiser son code avec des fonctions

#!/bin/bash
set -euo pipefail

# Fonction de logging avec horodatage
log() {
    local niveau="$1"
    shift
    echo "$(date '+%Y-%m-%d %H:%M:%S') [$niveau] $*" | tee -a /var/log/mon_script.log
}

# Fonction de vérification des prérequis
verifier_prerequis() {
    local outils=("tar" "gzip" "rsync")
    for outil in "${outils[@]}"; do
        if ! command -v "$outil" &> /dev/null; then
            log "ERREUR" "$outil n'est pas installé."
            exit 1
        fi
    done
    log "INFO" "Tous les prérequis sont satisfaits."
}

# Fonction de sauvegarde réutilisable
sauvegarder() {
    local source="$1"
    local dest="$2"
    log "INFO" "Sauvegarde de $source vers $dest"
    tar -czf "$dest/backup_$(date +%Y%m%d).tar.gz" "$source"
    log "INFO" "Sauvegarde terminée avec succès."
}

# Programme principal
verifier_prerequis
sauvegarder "/var/www" "/home/backups"

Les fonctions rendent votre code lisible, testable et réutilisable. Une bonne règle : si un bloc de code fait plus de 20 lignes ou est utilisé plus d’une fois, transformez-le en fonction.

Gestion avancée des logs

#!/bin/bash
# Système de logging avec niveaux et rotation
LOG_FILE="/var/log/automatisation.log"
LOG_LEVEL="INFO"  # DEBUG, INFO, WARN, ERROR

log_message() {
    local niveau="$1"
    local message="$2"
    local timestamp
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    echo "$timestamp [$niveau] $message" >> "$LOG_FILE"
    
    if [ "$niveau" = "ERROR" ]; then
        echo "$timestamp [$niveau] $message" >&2
    fi
}

# Rotation des logs si le fichier dépasse 10 Mo
if [ -f "$LOG_FILE" ] && [ $(stat -f%z "$LOG_FILE" 2>/dev/null || stat -c%s "$LOG_FILE") -gt 10485760 ]; then
    mv "$LOG_FILE" "${LOG_FILE}.old"
    gzip "${LOG_FILE}.old"
    log_message "INFO" "Rotation des logs effectuée."
fi

Un bon système de logs est ce qui distingue un script amateur d’un outil professionnel. Quand un problème survient à 3h du matin sur votre serveur, ce sont les logs qui vous permettront de comprendre ce qui s’est passé. Pour analyser le trafic réseau en complément, Wireshark est un excellent outil à maîtriser.

Script avancé : déploiement d’application web

#!/bin/bash
set -euo pipefail

APP_DIR="/var/www/mon-app"
BRANCH="main"
LOG="/var/log/deploy.log"

log() { echo "$(date '+%H:%M:%S') $*" | tee -a "$LOG"; }

log "Début du déploiement..."

# Sauvegarder la version actuelle
cp -r "$APP_DIR" "${APP_DIR}_backup_$(date +%Y%m%d%H%M)"

# Récupérer le nouveau code
cd "$APP_DIR"
git fetch origin
git checkout "$BRANCH"
git pull origin "$BRANCH"

# Installer les dépendances
if [ -f "package.json" ]; then
    npm ci --production
    log "Dépendances Node.js installées."
fi

# Redémarrer le service
systemctl restart mon-app
sleep 2

# Vérifier que l'application répond
if curl -sf http://localhost:3000/health > /dev/null; then
    log "Déploiement réussi !"
else
    log "ERREUR : l'application ne répond pas, rollback..."
    rm -rf "$APP_DIR"
    mv "${APP_DIR}_backup_$(date +%Y%m%d%H%M)" "$APP_DIR"
    systemctl restart mon-app
    log "Rollback effectué."
    exit 1
fi

Ce script intègre les bonnes pratiques que l’on retrouve dans les pipelines CI/CD professionnels : sauvegarde avant modification, vérification post-déploiement et rollback automatique en cas d’échec. Pour aller plus loin dans la gestion de versions, maîtrisez les commandes Git essentielles.

Si vous souhaitez exposer vos scripts via une interface web, créer une API REST en Python peut être une excellente extension de ce travail. Et pour le serveur web qui hébergera le tout, consultez notre comparatif Nginx vs Apache.

Enfin, n’oubliez pas que Bash n’est pas le seul langage de scripting système. Sous Windows, PowerShell offre des capacités similaires avec une approche orientée objet. Maîtriser les deux vous rendra polyvalent dans n’importe quel environnement professionnel. Et pour documenter votre parcours d’apprentissage, pensez à organiser votre veille technologique et à présenter vos projets sur un portfolio GitHub Pages.

Lucie Moreau

Formatrice IT indépendante depuis 2016, ancienne étudiante BTS SIO SLAM. 6 ans d'expérience en entreprise.