Écrire des scripts en Linux Bash : un guide complet pour les débutants et les administrateurs système

La création de scripts Bash est l’une des compétences les plus puissantes qu’un utilisateur Linux, un développeur ou un administrateur système puisse développer. Que vous gériez un seul serveur ou que vous orchestriez des flux de travail automatisés complexes sur l’ensemble d’une infrastructure, maîtriser la création de scripts Bash réduit considérablement les efforts manuels, minimise les erreurs humaines et libère tout le potentiel de votre environnement Linux.

Dans ce guide complet, nous vous expliquerons tout ce que vous devez savoir sur l’écriture de scripts Bash — de la création de votre tout premier fichier à l’utilisation des variables, des conditions, des boucles, des fonctions, des arguments et des techniques de débogage. Des exemples pratiques, prêts à être copiés-collés, sont inclus tout au long du guide.

Qu’est-ce qu’un script Bash ?

Un script Bash est un fichier texte brut contenant une séquence ordonnée de commandes interprétées et exécutées par le shell Bash (Bourne Again SHell). Bash est le shell interactif par défaut sur la grande majorité des distributions Linux, ce qui le rend universellement disponible et immédiatement pratique.

Plutôt que de saisir la même séquence de commandes à plusieurs reprises dans un terminal, vous les écrivez une seule fois dans un fichier script et vous l’exécutez à la demande — ou vous le planifiez pour qu’il s’exécute automatiquement.

Cas d’utilisation courants des scripts Bash

• Gestion de fichiers — copier, déplacer, renommer, archiver et supprimer des fichiers en masse
• Administration système — surveiller les processus, gérer les utilisateurs, vérifier l’utilisation du disque
• Automatisation de logiciels — installer des paquets, configurer des services, déployer des applications
• Sauvegarde et récupération — créer des sauvegardes planifiées, incrémentielles ou complètes du système
• Analyse et rapport de journaux — filtrer et résumer les données de journaux pour analyse
• Provisionnement de serveurs — automatiser la configuration initiale d’un nouvel environnement VPS Hosting ou de serveur dédié

Prérequis

Pour suivre ce guide, vous avez besoin de :

• Un système Linux (machine locale, VM ou serveur distant)
• Un accès au terminal avec un compte utilisateur (privilèges root ou sudo pour certaines opérations)
• Une connaissance de base de la ligne de commande Linux

Si vous travaillez sur un serveur distant, les offres VPS Hosting d’AlexHost vous donnent un accès SSH root complet, ce qui les rend idéales pour pratiquer et déployer des scripts Bash dans un environnement réel.

Étape 1 : Créer un fichier de script Bash

Ouvrez votre terminal et utilisez n’importe quel éditeur de texte pour créer un nouveau fichier avec l’extension .sh. L’extension .sh est une convention largement adoptée qui indique que le fichier est un script shell, bien qu’elle ne soit pas techniquement requise par l’interpréteur.

nano myscript.sh

Vous pouvez remplacer nano par vim, gedit, micro ou tout autre éditeur que vous préférez.

Étape 2 : Ajouter la ligne shebang (#!)

La toute première ligne de chaque script Bash doit être le shebang — une directive spéciale qui indique au système d’exploitation quel interpréteur utiliser lors de l’exécution du fichier.

#!/bin/bash

Cette ligne indique au noyau de transmettre le script à /bin/bash pour exécution, quel que soit le shell que l’utilisateur actuel a défini comme shell par défaut. Incluez-la toujours — omettre le shebang peut entraîner un comportement imprévisible des scripts dans différents environnements.

> Conseil : Sur certains systèmes modernes, vous pouvez également voir #!/usr/bin/env bash, qui est une alternative plus portable qui localise dynamiquement le binaire Bash via PATH.

Étape 3 : Écrire vos commandes

Après le shebang, ajoutez les commandes que vous souhaitez que le script exécute. Voici un exemple simple qui salue l’utilisateur actuel et affiche des informations système utiles :

#!/bin/bash

# A simple script to greet the user and display system info
echo "Hello, $USER! Welcome back."
echo "Today's date and time: $(date)"
echo "Your current working directory: $(pwd)"
echo "System hostname: $(hostname)"

Explication des éléments clés

Étape 4 : Rendre le script exécutable

Avant de pouvoir exécuter le script directement, vous devez lui accorder des permissions d’exécution à l’aide de la commande chmod :

chmod +x myscript.sh

Cela définit le bit d’exécution pour le propriétaire du fichier. Pour vérifier que les permissions ont été appliquées correctement, exécutez :

ls -l myscript.sh

Vous devriez voir quelque chose comme -rwxr-xr-x, où les caractères x confirment la permission d’exécution.

Étape 5 : Exécuter le script

Exécutez le script depuis le même répertoire en utilisant la syntaxe suivante :

./myscript.sh

Le préfixe ./ indique au shell de rechercher le fichier dans le répertoire actuel plutôt que de parcourir le PATH système. Vous devriez voir la sortie s’afficher directement dans votre terminal.

Vous pouvez également l’invoquer explicitement avec l’interpréteur :

bash myscript.sh

Les variables dans les scripts Bash

Les variables vous permettent de stocker et de réutiliser des données tout au long de votre script. Elles peuvent contenir des chaînes de caractères, des entiers, des chemins de fichiers ou la sortie de commandes.

Définir et utiliser des variables

#!/bin/bash

# Define variables
server_name="web-server-01"
max_connections=500
backup_dir="/var/backups"

# Use variables
echo "Server: $server_name"
echo "Max connections allowed: $max_connections"
echo "Backup directory: $backup_dir"

Règles importantes pour les variables

• Pas d’espaces autour du signe = lors de l’attribution d’une valeur (name="value" est correct ; name = "value" ne l’est pas)
• Préfixez le nom de la variable avec $ lors de la lecture de sa valeur : $variable_name
• Utilisez des accolades pour plus de clarté dans les chaînes complexes : ${variable_name}
• Les noms de variables sont sensibles à la casse : $Name et $name sont des variables différentes

Capturer la sortie d’une commande dans une variable

#!/bin/bash

current_date=$(date +"%Y-%m-%d")
disk_usage=$(df -h / | awk 'NR==2 {print $5}')

echo "Date: $current_date"
echo "Root partition usage: $disk_usage"

Les instructions conditionnelles en Bash

La logique conditionnelle permet à votre script de prendre des décisions et d’exécuter différents chemins de code en fonction des conditions évaluées.

Structure de base if / elif / else

#!/bin/bash

echo "Enter a number between 1 and 100:"
read user_input

if [ "$user_input" -ge 1 ] && [ "$user_input" -le 50 ]; then
    echo "Your number is in the lower half (1–50)."
elif [ "$user_input" -ge 51 ] && [ "$user_input" -le 100 ]; then
    echo "Your number is in the upper half (51–100)."
else
    echo "Your number is outside the valid range."
fi

Opérateurs de comparaison courants

Vérifier si un fichier existe

#!/bin/bash

config_file="/etc/nginx/nginx.conf"

if [ -f "$config_file" ]; then
    echo "Configuration file found: $config_file"
else
    echo "ERROR: Configuration file not found at $config_file"
    exit 1
fi

Les boucles dans les scripts Bash

Les boucles vous permettent de répéter un bloc de commandes plusieurs fois, soit sur une plage définie, une liste d’éléments, soit jusqu’à ce qu’une condition change.

Boucle for — Itération sur une plage

#!/bin/bash

echo "Counting from 1 to 5:"
for i in {1..5}; do
    echo "  Iteration: $i"
done

Boucle for — Itération sur une liste d’éléments

#!/bin/bash

servers=("web-01" "web-02" "db-01" "cache-01")

for server in "${servers[@]}"; do
    echo "Pinging server: $server"
    ping -c 1 "$server" &>/dev/null && echo "  ✔ $server is reachable" || echo "  ✘ $server is unreachable"
done

Boucle while — Exécution jusqu’à ce qu’une condition soit fausse

#!/bin/bash

counter=1

while [ $counter -le 5 ]; do
    echo "Counter value: $counter"
    counter=$((counter + 1))
done

echo "Loop complete."

Boucle until — Exécution jusqu’à ce qu’une condition devienne vraie

#!/bin/bash

attempts=0

until [ $attempts -ge 3 ]; do
    echo "Attempt $((attempts + 1))..."
    attempts=$((attempts + 1))
done

echo "Maximum attempts reached."

Les fonctions dans les scripts Bash

Les fonctions vous permettent d’encapsuler des blocs de logique réutilisables, rendant vos scripts plus propres, plus modulaires et plus faciles à maintenir — surtout à mesure qu’ils gagnent en complexité.

Définir et appeler une fonction

#!/bin/bash

# Define the function
greet_user() {
    local username="$1"
    echo "Hello, $username! Your session started at $(date +"%H:%M:%S")."
}

# Call the function with arguments
greet_user "Alice"
greet_user "Bob"

Une fonction pratique : vérifier l’état d’un service

#!/bin/bash

check_service() {
    local service_name="$1"
    if systemctl is-active --quiet "$service_name"; then
        echo "✔ $service_name is running."
    else
        echo "✘ $service_name is NOT running. Attempting to start..."
        systemctl start "$service_name" && echo "  Started successfully." || echo "  Failed to start $service_name."
    fi
}

check_service "nginx"
check_service "mysql"
check_service "ssh"

> Remarque : Le mot-clé local limite la portée d’une variable à l’intérieur de la fonction, évitant ainsi des effets secondaires non intentionnels dans les scripts plus importants.

Travailler avec les arguments de ligne de commande

Les scripts Bash peuvent accepter des entrées directement depuis la ligne de commande lors de leur invocation, permettant des scripts flexibles et réutilisables qui se comportent différemment selon les paramètres fournis.

Variables d’arguments spéciales

Exemple : un script qui accepte des arguments

#!/bin/bash

# Validate that exactly two arguments were provided
if [ $# -ne 2 ]; then
    echo "Usage: $0 <source_directory> <destination_directory>"
    exit 1
fi

source_dir="$1"
dest_dir="$2"

# Check that the source directory exists
if [ ! -d "$source_dir" ]; then
    echo "ERROR: Source directory '$source_dir' does not exist."
    exit 1
fi

echo "Copying files from '$source_dir' to '$dest_dir'..."
cp -r "$source_dir" "$dest_dir" && echo "Copy completed successfully." || echo "Copy failed."

Exécutez-le ainsi :

./myscript.sh /var/www/html /var/backups/html_backup

Codes de sortie et gestion des erreurs

Les scripts Bash robustes gèrent toujours les erreurs de manière appropriée. Chaque commande sous Linux renvoie un code de sortie : 0 indique un succès, et toute valeur non nulle indique une erreur.

Utiliser exit et $?

#!/bin/bash

# Attempt to create a directory
mkdir /tmp/test_directory

if [ $? -eq 0 ]; then
    echo "Directory created successfully."
else
    echo "Failed to create directory."
    exit 1
fi

Utiliser set -e pour la gestion automatique des erreurs

Ajouter set -e en haut de votre script le fait se terminer immédiatement si une commande renvoie un code de sortie non nul — une bonne pratique pour les scripts en production :

#!/bin/bash
set -e          # Exit on any error
set -u          # Treat unset variables as errors
set -o pipefail # Catch errors in pipelines

echo "Starting deployment..."
cd /var/www/html
git pull origin main
systemctl reload nginx
echo "Deployment complete."

Déboguer les scripts Bash

Même les développeurs expérimentés écrivent des scripts avec des bogues. Bash fournit des outils intégrés pour vous aider à tracer et corriger les problèmes efficacement.

Méthode 1 : Exécuter avec le flag -x (mode trace)

bash -x myscript.sh

Cela affiche chaque commande dans le terminal au fur et à mesure de son exécution, préfixée par +, ainsi que les valeurs des variables développées. C’est la technique de débogage la plus couramment utilisée.

Méthode 2 : Ajouter set -x dans le script

Vous pouvez activer et désactiver le traçage pour des sections spécifiques de votre script :

#!/bin/bash

echo "Normal execution..."

set -x  # Enable tracing
cp /source/file /destination/
chmod 644 /destination/file
set +x  # Disable tracing

echo "Tracing disabled again."

Méthode 3 : Utiliser des instructions echo comme points de contrôle

Des instructions echo placées stratégiquement vous aident à vérifier les valeurs des variables et à confirmer que l’exécution a atteint un point spécifique dans le script :

echo "DEBUG: backup_dir = $backup_dir"
echo "DEBUG: Reached checkpoint before rsync"

Exemple pratique concret : script de sauvegarde automatisée

Voici un script Bash complet, prêt pour la production, qui illustre de nombreux concepts abordés dans ce guide :

#!/bin/bash
set -euo pipefail

# ============================================================
# Automated Backup Script
# Description: Backs up a specified directory with a timestamp
# ============================================================

# Configuration
SOURCE_DIR="/var/www/html"
BACKUP_ROOT="/var/backups/web"
TIMESTAMP=$(date +"%Y%m%d_%H%M%S")
BACKUP_NAME="backup_${TIMESTAMP}.tar.gz"
BACKUP_PATH="${BACKUP_ROOT}/${BACKUP_NAME}"
RETENTION_DAYS=7
LOG_FILE="/var/log/backup.log"

# Logging function
log() {
    echo "[$(date +"%Y-%m-%d %H:%M:%S")] $1" | tee -a "$LOG_FILE"
}

# Validate source directory
if [ ! -d "$SOURCE_DIR" ]; then
    log "ERROR: Source directory '$SOURCE_DIR' not found. Aborting."
    exit 1
fi

# Create backup root if it doesn't exist
mkdir -p "$BACKUP_ROOT"

log "Starting backup of '$SOURCE_DIR'..."

# Create compressed archive
tar -czf "$BACKUP_PATH" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")"

log "Backup created: $BACKUP_PATH ($(du -sh "$BACKUP_PATH" | cut -f1))"

# Remove backups older than retention period
log "Removing backups older than ${RETENTION_DAYS} days..."
find "$BACKUP_ROOT" -name "backup_*.tar.gz" -mtime +"$RETENTION_DAYS" -delete

log "Backup process completed successfully."

Ce type de script est indispensable sur tout serveur en production. Si vous exploitez un site web ou une application sur des Serveurs Dédiés ou un VPS, automatiser vos sauvegardes avec un script comme celui-ci — combiné à une tâche cron — garantit que vos données sont toujours protégées sans intervention manuelle.

Planifier des scripts Bash avec Cron

Pour exécuter vos scripts Bash automatiquement selon un calendrier, utilisez cron, le planificateur de tâches Linux. Modifiez votre crontab avec :

crontab -e

Ajoutez une ligne au format suivant :

# Run backup script every day at 2:00 AM
0 2 * * * /path/to/backup.sh >> /var/log/backup_cron.log 2>&1

Syntaxe Cron : minute hour day-of-month month day-of-week command

Bonnes pratiques pour l’écriture de scripts Bash

Suivre ces conventions rendra vos scripts plus fiables, lisibles et maintenables :

1. Incluez toujours le shebang (#!/bin/bash) sur la première ligne
2. Utilisez set -euo pipefail dans les scripts en production pour détecter les erreurs rapidement
3. Mettez vos variables entre guillemets ("$variable") pour éviter les problèmes de découpage de mots et de globbing
4. Utilisez des noms de variables significatifs — backup_directory est plus clair que bd
5. Commentez votre code — expliquez le *pourquoi*, pas seulement le *quoi*
6. Validez les entrées — vérifiez que les arguments et fichiers requis existent avant de continuer
7. Utilisez des fonctions pour organiser la logique complexe en blocs nommés et réutilisables
8. Testez dans un environnement sûr avant d’exécuter des scripts sur des systèmes en production
9. Utilisez des variables local dans les fonctions pour éviter de polluer la portée globale
10. Journalisez les actions importantes dans un fichier afin de pouvoir auditer le comportement du script ultérieurement

Aller plus loin avec Bash

Une fois que vous maîtrisez les fondamentaux, envisagez d’explorer ces sujets avancés :

• Les expressions régulières avec grep, sed et awk pour un traitement de texte puissant
• Les here documents (heredoc) pour intégrer des chaînes multi-lignes dans les scripts
• La substitution de processus et les pipes nommés pour des pipelines de données complexes
• La gestion des signaux avec trap pour une terminaison gracieuse des scripts
• Les tableaux associatifs (Bash 4+) pour les structures de données clé-valeur
• Les bibliothèques de scripts — sourcer des fonctions communes depuis un fichier partagé avec source

Si vous gérez des applications web, des bases de données ou une infrastructure de messagerie, les scripts Bash s’associent naturellement à des services comme l’Hébergement Web Mutualisé pour les projets de petite taille, ou un VPS avec cPanel entièrement géré pour les environnements où vous souhaitez une interface graphique en plus de l’accès shell.

Pour les équipes exécutant des charges de travail intensives en données ou des pipelines d’apprentissage automatique, les scripts Bash sont tout aussi précieux pour orchestrer des tâches sur une infrastructure GPU Hosting — automatisant les exécutions d’entraînement de modèles, gérant les ensembles de données et prenant en charge la configuration de l’environnement.

Conclusion

La création de scripts Bash est une compétence indispensable pour quiconque travaille avec Linux — que vous soyez un débutant automatisant votre première tâche répétitive ou un administrateur système senior gérant une infrastructure serveur complexe. Les concepts abordés dans ce guide — création de fichiers, variables, conditions, boucles, fonctions, gestion des arguments, gestion des erreurs et débogage — constituent la base complète dont vous avez besoin pour écrire des scripts fiables et de qualité production.

Commencez petit : automatisez une tâche que vous effectuez manuellement chaque jour. À mesure que votre confiance grandit, combinez ces blocs de construction en outils de plus en plus sophistiqués qui vous font gagner des heures de travail, réduisent le risque d’erreur humaine et vous donnent un contrôle précis et reproductible sur vos systèmes.

Pour le meilleur environnement pour pratiquer et déployer vos scripts Bash, explorez la gamme d’offres VPS Hosting Linux d’AlexHost — avec accès root complet, stockage SSD et configurations flexibles conçues pour les développeurs et les administrateurs système.