Écrire un premier script shell

Un script shell est un fichier texte contenant une suite de commandes que Bash exécute automatiquement. Au lieu de taper les mêmes commandes tous les jours, vous les écrivez une fois dans un fichier et vous le lancez en une seule commande. Ce guide vous accompagne dans la création de votre premier script fonctionnel, sans prérequis en programmation.

Ce que vous allez apprendre

Créer un script avec le shebang #!/bin/bash
Le rendre exécutable avec chmod +x
Utiliser des variables pour stocker des valeurs
Lire une entrée utilisateur avec read
Récupérer des arguments passés au script
Quitter proprement avec un code de sortie

Créer un script minimal

Créez un fichier nommé bonjour.sh :
Fenêtre de terminal
```
nano bonjour.sh
```

Écrivez ce contenu :

#!/bin/bash
echo "Bonjour, bienvenue sur $(hostname) !"

Enregistrez et quittez (Ctrl+O, Entrée, Ctrl+X).
Rendez le fichier exécutable :
Fenêtre de terminal
```
chmod +x bonjour.sh
```
Lancez le script :
Fenêtre de terminal
```
./bonjour.sh
```

Bonjour, bienvenue sur serveur01 !

Le shebang : #!/bin/bash

La première ligne d’un script doit être le shebang :

#!/bin/bash

Elle indique au système quel interpréteur utiliser pour exécuter le fichier. Sans cette ligne, le système ne sait pas qu’il s’agit d’un script Bash.

Rendre exécutable et lancer

Par défaut, un nouveau fichier n’est pas exécutable. Deux étapes sont nécessaires :

chmod +x mon-script.sh
./mon-script.sh

Le ./ indique au shell de chercher le fichier dans le répertoire courant.

Vous pouvez aussi lancer un script sans le rendre exécutable en appelant directement Bash :

bash mon-script.sh

Mais la méthode chmod +x est la pratique standard.

Les variables

Une variable stocke une valeur pour la réutiliser :

#!/bin/bash
NOM="Alice"
MACHINE=$(hostname)
echo "Bonjour $NOM, vous êtes sur $MACHINE"

Règles :

Pas d’espaces autour du =
Pour lire la valeur : $NOM
$(commande) capture le résultat d’une commande

Bonnes pratiques de nommage

Convention	Exemple
Majuscules pour les variables globales	`REPERTOIRE`, `NOM_FICHIER`
Nom descriptif	`FICHIER_LOG` plutôt que `F`
Pas de caractères spéciaux	Uniquement lettres, chiffres, `_`

Lire une entrée utilisateur

La commande read met le script en pause et attend que l’utilisateur tape quelque chose :

#!/bin/bash
echo "Quel est votre prénom ?"
read PRENOM
echo "Bonjour $PRENOM !"

Pour afficher le message et la saisie sur la même ligne :

read -p "Votre prénom : " PRENOM
echo "Bonjour $PRENOM !"

Les arguments

Un script peut recevoir des valeurs au moment du lancement :

./saluer.sh Alice Bob

Ces valeurs sont accessibles via des variables spéciales :

Variable	Contenu
`$1`	Premier argument (`Alice`)
`$2`	Deuxième argument (`Bob`)
`$#`	Nombre d’arguments (`2`)
`$@`	Tous les arguments (`Alice Bob`)
`$0`	Nom du script (`./saluer.sh`)

Exemple complet :

#!/bin/bash
echo "Script : $0"
echo "Argument 1 : $1"
echo "Argument 2 : $2"
echo "Nombre d'arguments : $#"

Vérifier qu’un argument est fourni

Un script robuste vérifie que les arguments nécessaires sont présents :

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

-z "$1" teste si le premier argument est vide. Si c’est le cas, le script affiche un message d’aide et s’arrête.

Les codes de sortie

Chaque commande (et chaque script) retourne un code de sortie :

Code	Signification
`0`	Succès
`1`	Erreur générale
`2`	Mauvaise utilisation (arguments incorrects)

Pour terminer un script avec un code précis :

exit 0   # tout s'est bien passé
exit 1   # une erreur s'est produite

Pour vérifier le code de sortie de la dernière commande :

echo $?

Les commentaires

Un commentaire commence par #. Le shell ignore tout ce qui suit sur la ligne :

#!/bin/bash
# Ce script affiche un message de bienvenue
NOM="Alice"    # Variable contenant le prénom
echo "Bonjour $NOM"

Commentez votre code pour expliquer pourquoi vous faites quelque chose, pas quoi (le code le montre déjà).

Exemple complet : rapport système

Voici un script concret qui rassemble des informations sur le système :

#!/bin/bash
# rapport-systeme.sh — Affiche un résumé de l'état du système

echo "=== Rapport système ==="
echo "Date    : $(date)"
echo "Machine : $(hostname)"
echo "Utilisateur : $USER"
echo "Répertoire  : $PWD"
echo ""
echo "Espace disque :"
df -h /
echo ""
echo "Mémoire :"
free -h
echo "=== Fin du rapport ==="

chmod +x rapport-systeme.sh
./rapport-systeme.sh

Ce script ne fait qu’enchaîner des commandes que vous connaissez déjà. C’est le principe d’un script : automatiser une séquence de tâches répétitives.

Dépannage

Symptôme	Cause probable	Solution
`Permission denied`	Script non exécutable	`chmod +x mon-script.sh`
`command not found` en lançant `script.sh`	`./` manquant devant le nom	Lancer avec `./script.sh`
`bad interpreter: No such file`	Shebang incorrect ou caractères Windows	Vérifier `#!/bin/bash` en première ligne, convertir avec `dos2unix`
Variable vide dans le script	Mauvais nom ou `$` oublié	Vérifier le nom exact et le `$` devant
`[: -z: unexpected operator`	Espaces manquants dans le test `[ ]`	Écrire `[ -z "$1" ]` avec des espaces
Script qui ne s’arrête pas	Boucle implicite ou `read` en attente	Ctrl+C pour interrompre

À retenir

Un script commence par #!/bin/bash (shebang) qui identifie l’interpréteur.
chmod +x rend le fichier exécutable, ./script.sh le lance.
Les variables (NOM="valeur") et arguments ($1, $2) rendent un script flexible.
read permet de demander une saisie, echo d’afficher un résultat.
exit 0 signale un succès, exit 1 une erreur — testable avec echo $?.
Commentez vos scripts pour les rendre compréhensibles.

Prochaines étapes

Écrire un script shell complet Variables, conditions, boucles, fonctions et débogage.

Écrire des scripts robustes set -euo pipefail, shellcheck et bonnes pratiques.