Écrire vos premiers scripts bash : variables, tests et boucles

À la fin de ce tutoriel bash scripting, vous saurez créer un script débutant avec shebang, variables, arguments, if/for/while, fonctions, redirections et codes de sortie — puis un mini healthcheck (ping ou curl) loggé dans /tmp.

Niveau : Débutant · Temps estimé : 50–60 min · Versions testées : Ubuntu 22.04 / 24.04, Debian 12 ; notes Rocky/Alma 9 · Dernière vérification : 2026-09-10

Slug proposé : linux-bash-scripting · Série : P5 Linux Basics · Remplace / fusionne : N/A — création

Prérequis

• Avoir suivi Diagnostiquer le réseau Linux avec ip, ss et curl (ping, curl, lecture de codes HTTP)
• Une VM ou WSL jetable (Ubuntu/Debian ou Rocky/Alma 9) avec bash
• Éditeur de texte (nano, vim, VS Code Distant) ; aucune clé / secret / mot de passe dans les scripts
• Connaître chemins, permissions (chmod) et redirection de base (>, |)

Coût estimé : 0 €. Lab entièrement dans /tmp — jetable et sans effet de bord.

Ce que nous allons construire (bash scripting)

Shebang + chmod +x + ./script.sh
  → Variables, quotes, $1 / $#
  → if / then / fi · for · while
  → Exit codes + set -euo pipefail (avec mesure)
  → Fonctions basiques
  → Redirection & pipes dans un script
  → Lab healthcheck (curl/ping → log /tmp)
  → Erreurs fréquentes · quiz · FAQ

(Schéma à remplacer par une image locale Excalidraw / draw.io, alt : « Bash scripting : shebang, variables, if, for, exit codes — lab junior DevOps ».)

Septième chapitre de Linux Basics. Les scripts automatisent les checks réseau du chapitre précédent. Pour multi-machines : Ansible. Évitez les provisioners shell opaques dans Terraform (remote-exec en prod : rarement une bonne idée).

Étape 1 — Shebang, permissions et exécution

Un fichier texte devient un script quand (1) la première ligne indique l’interpréteur (shebang) et (2) le bit exécutable est posé.

mkdir -p /tmp/lab-bash
cat > /tmp/lab-bash/hello.sh << 'SCRIPT'
#!/usr/bin/env bash
# Premier script — lab Linux Basics
echo "Bonjour depuis bash : $(date -Iseconds)"
SCRIPT
chmod +x /tmp/lab-bash/hello.sh
/tmp/lab-bash/hello.sh
# Ou depuis le dossier :
cd /tmp/lab-bash && ./hello.sh

Élément	Rôle
#!/usr/bin/env bash	Cherche bash dans le PATH (portable Ubuntu/Debian et Rocky)
chmod +x	Ajoute le droit d’exécution pour le propriétaire
./hello.sh	Exécute le fichier du répertoire courant (. n’est pas dans le PATH)

Pourquoi env bash plutôt que #!/bin/bash ? Sur la plupart des distros modernes /bin/bash existe, mais env reste le réflexe portable (surtout hors Debian). Rocky/Alma : même shebang ; vérifiez bash --version (souvent 5.x).

Sans chmod +x, vous pouvez toujours lancer : bash /tmp/lab-bash/hello.sh — utile pour tester avant de rendre exécutable.

Étape 2 — Bases du bash scripting : variables, quotes, $1 et $#

On commence souvent le bash scripting par « stocker une valeur et la réutiliser ».

cat > /tmp/lab-bash/vars.sh << 'SCRIPT'
#!/usr/bin/env bash
NOM="lab-devops"
CIBLE="$1"
NB="$#"
echo "Projet : $NOM"
echo "Argument 1 : ${CIBLE:-"(aucun)"}"
echo "Nombre d'arguments : $NB"
# Quotes : double = expansion ; simple = littéral
echo "Double : $NOM"
echo 'Simple : $NOM'
SCRIPT
chmod +x /tmp/lab-bash/vars.sh
./vars.sh example.com
./vars.sh

Règles courtes :

• VAR=valeur (pas d’espace autour de =)
• "$VAR" : expansion ; '$VAR' : littéral (affiche $VAR)
• $1, $2, … : arguments positionnels ; $# : nombre d’arguments ; $@ : tous les args
• ${CIBLE:-défaut} : valeur de repli si vide / non définie

Pas de secrets dans un script versionné — environnement ou coffre, hors lab.

Étape 3 — if / then, for, while (exemples courts)

Les tests ([[ … ]]) et les boucles transforment un one-liner en outil réutilisable.

cat > /tmp/lab-bash/control.sh << 'SCRIPT'
#!/usr/bin/env bash
HOTE="${1:-example.com}"

# if / then / else / fi
if [[ -n "$HOTE" ]]; then
  echo "Cible : $HOTE"
else
  echo "Pas de cible" >&2
  exit 1
fi

# for : itérer une liste
for i in 1 2 3; do
  echo "essai #$i"
done

# while : boucle bornée (évitez while true sans garde en lab)
n=0
while [[ $n -lt 3 ]]; do
  echo "while n=$n"
  n=$((n + 1))
done
SCRIPT
chmod +x /tmp/lab-bash/control.sh
./control.sh example.com

Tests utiles : -f, -d, -z / -n, ==, -eq/-lt/-gt. Préférez [[ à [ (moins de pièges de quoting).

Étape 4 — Exit codes et set -euo pipefail (sans dogmatisme)

Chaque commande renvoie un exit code : 0 = succès, ≠0 = échec. Un script propage le code de la dernière commande exécutée, sauf exit N explicite.

cat > /tmp/lab-bash/exits.sh << 'SCRIPT'
#!/usr/bin/env bash
# Mode strict utile en lab — à comprendre, pas à coller aveuglément partout
set -euo pipefail

curl -sS -o /dev/null -w "%{http_code}n" --max-time 5 "https://example.com/" || {
  echo "curl a échoué (réseau / DNS)" >&2
  exit 2
}
echo "OK — fin script"
SCRIPT
chmod +x /tmp/lab-bash/exits.sh
./exits.sh ; echo "exit du script = $?"

Option	Effet	Quand c’est utile
set -e	Quitte si une commande échoue	Scripts courts où chaque étape doit réussir
set -u	Erreur si variable non définie	Évite $typo silencieux
set -o pipefail	Le pipeline échoue si un maillon échoue	cmd | grep ne masque plus l’échec de cmd

Sans dogmatisme : set -e a des cas subtils (if cmd; then, cmd || true). Sur des scripts linéaires, activez-le ; sinon testez explicitement (cmd || exit 2) et documentez vos codes.

Étape 5 — Fonctions basiques

Les fonctions évitent de dupliquer un bloc (log, check HTTP).

cat > /tmp/lab-bash/funcs.sh << 'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail

log() {
  # $1 = message
  echo "[$(date -Iseconds)] $*"
}

http_code() {
  local url="$1"
  curl -sS -o /dev/null -w "%{http_code}" --max-time 8 "$url"
}

log "début"
code="$(http_code "https://example.com/")"
log "example.com → HTTP $code"
[[ "$code" == "200" || "$code" == "301" || "$code" == "302" ]] || exit 3
log "fin OK"
SCRIPT
chmod +x /tmp/lab-bash/funcs.sh
./funcs.sh

local limite la portée. Pour retransmettre les args : "$@" (pas "$*").

Étape 6 — Redirection et pipes dans un script

Même syntaxe qu’en interactif : > écrase, >> ajoute, 2> stderr, | pipe, tee pour écran + fichier.

# Aperçu (le lab complet est à l’étape 7)
{
  echo "=== snapshot ==="
  date -Iseconds
  hostname
} | tee /tmp/lab-bash/snapshot.txt
wc -l /tmp/lab-bash/snapshot.txt

En monitoring réel on journalise parfois sous /var/log/ (droits root) — restez sur /tmp en lab.

Étape 7 — Lab : healthcheck ping/curl + log /tmp

Objectif : un petit outil qui (1) teste une URL, (2) optionnellement un ping ICMP, (3) append un log horodaté, (4) renvoie un exit code exploitable par cron ou CI.

cat > /tmp/lab-bash/healthcheck.sh << 'SCRIPT'
#!/usr/bin/env bash
set -euo pipefail

URL="${1:-https://example.com/}"
LOG="${LOG:-/tmp/lab-bash/healthcheck.log}"
mkdir -p "$(dirname "$LOG")"

ts() { date -Iseconds; }

log() { echo "[$(ts)] $*" | tee -a "$LOG"; }

# HTTP : code + temps total
code="$(curl -sS -o /dev/null -w "%{http_code}" --max-time 10 "$URL" || echo "000")"
log "HTTP $code  url=$URL"

# Ping optionnel (ICMP peut être bloqué — ne pas en faire l’unique critère)
host="${URL#https://}"; host="${host#http://}"; host="${host%%/*}"
if ping -c 1 -W 3 "$host" &>/dev/null; then
  log "PING ok    host=$host"
else
  log "PING fail  host=$host (ICMP filtré ? continuer sur HTTP)"
fi

if [[ "$code" =~ ^(200|301|302)$ ]]; then
  log "RESULT OK"
  exit 0
fi
log "RESULT FAIL"
exit 1
SCRIPT
chmod +x /tmp/lab-bash/healthcheck.sh

# Exécutions lab
./healthcheck.sh https://example.com/
./healthcheck.sh https://httpbin.org/status/200
# Lire le journal
tail -n 20 /tmp/lab-bash/healthcheck.log

Ubuntu/Debian : sudo apt install -y curl iputils-ping si besoin. Rocky/Alma : sudo dnf install -y curl iputils. Validé : log rempli, exit 0 sur 200/3xx, aucun secret dans /tmp/lab-bash/.

Nettoyage

rm -rf /tmp/lab-bash
echo "lab bash nettoyé — OK"

Erreurs fréquentes

Symptôme	Cause	Correction
bashr: No such file or directory / shebang bizarre	Fins de ligne CRLF (fichier édité sous Windows)	sed -i 's/r$//' script.sh ou « LF » dans l’éditeur
Permission denied	Pas de +x	chmod +x script.sh ou bash script.sh
./script.sh: command not found	Oubli de ./ ou PATH	Lancez ./script.sh depuis le dossier
unbound variable / exit immédiat	set -u + variable non définie	Initialisez (VAR="${1:-}") ou testez avant usage
command not found sur une ligne VAR = value	Espaces autour de =	VAR=value strict
Script OK en interactif, KO en cron	PATH minimal / shebang manquant	Shebang + chemins absolus (/usr/bin/curl)

Quiz (3 questions)

1. À quoi sert #!/usr/bin/env bash ?
– A. À commenter le fichier
– B. À indiquer au noyau d’exécuter le script avec bash trouvé via PATH
– C. À installer bash automatiquement

2. Comment rendre un script exécutable ?
– A. chmod +x script.sh puis ./script.sh
– B. Uniquement chown root
– C. curl -I script.sh

3. Différence entre "$VAR" et '$VAR' ?
– A. Aucune
– B. Double quotes : expansion de la variable ; simple quotes : littéral (affiche $VAR)
– C. Simple quotes exécutent la commande

Réponses : 1‑B · 2‑A · 3‑B

FAQ

À quoi sert #!/usr/bin/env bash ?
C’est le shebang : la première ligne dit au système quel interpréteur utiliser. env résout bash dans le PATH, ce qui reste portable entre Ubuntu/Debian et Rocky/Alma. Sans shebang (ou sans +x), lancez explicitement bash script.sh.

Comment rendre un script exécutable ?
chmod +x /chemin/script.sh, puis exécutez-le avec ./script.sh (ou le chemin absolu). Vérifiez avec ls -l : un x doit apparaître dans les droits. Alternative de test : bash script.sh sans bit exécutable.

Différence ” et ‘ en bash ?
Doubles quotes : expansion ($VAR, $(…)). Simples quotes : littéral. En bash scripting, quotez les expansions ("$1", "$URL") pour gérer les espaces.

Pour aller plus loin

• man bash (sections PARAMETERS, CONDITIONAL EXPRESSIONS), help [[, help set
• Suite série : SSH & clés pour lancer vos scripts sur une machine distante
• Au-delà du one-host : Ansible ; côté IaC, préférez des ressources déclaratives à des provisioners shell opaques (Terraform overview)

Maillage série Linux Basics (P5)

← Précédent	Diagnostiquer le réseau Linux avec ip, ss et curl
→ Suivant	Se connecter en SSH avec des clés : ssh-keygen, agent et config
Hub	Linux Basics
Aussi	Terraform overview (éviter provisioners shell lourds) · Ansible (suite logique multi-hosts)

---

Meta publication (à remplir dans Rank Math / SEO)

• Title SEO : Bash scripting débutant : shebang, variables, if, for (2026)
• Meta description (≤ 155) : Créez des scripts bash utiles : shebang, variables, tests, boucles, exit codes. Automatisez vos labs Linux DevOps.
• Focus keyphrase : bash scripting
• KW secondaires : script bash débutant, shebang, variables bash, if then fi, boucle for bash
• Schemas Rank Math : Article + HowTo (étapes lab) + FAQ (3 questions ci-dessus)
• Image mise en avant : assets/web/devopelastichayway/cover-linux-bash-scripting-1200x630.webp (Visuels Linux — WebP 1200×630)
• Catégorie : Linux · Niveau : Débutant
• Slug : linux-bash-scripting