Script Shell Linux : Exercice Corrigé Pas à Pas (2026)

Publie le 15/08/2026 | 2331 mots | Mis a jour regulierement

Script Shell Linux : Exercice Corrigé Pas à Pas (2026)

Vous souhaitez automatiser des tâches sous Linux mais les scripts shell vous semblent complexes ? Ce tutoriel vous guide étape par étape à travers un exercice corrigé, du script basique à l'automatisation avancée. Que vous soyez développeur, administrateur système ou étudiant en reconversion DevOps, vous allez apprendre à créer des scripts robustes et maintenables.

Sur labsdevops.fr, plateforme française 100% pratique, vous trouverez 871 labs interactifs pour appliquer ces concepts directement dans votre navigateur, sans installation. Avec l'agent IA Alex intégré, vous bénéficiez d'un accompagnement personnalisé pour progresser plus vite.

Ce que vous allez apprendre

À la fin de ce tutoriel, vous serez capable de concevoir des scripts pour sauvegarder des fichiers, analyser des logs ou déployer des applications – des compétences essentielles pour tout professionnel DevOps.

👉 À lire aussi : Créer un shell script Linux en ligne : tutoriel pas à pas

Prérequis : ce qu'il faut savoir avant de commencer

Pour tirer pleinement profit de ce tutoriel, voici les connaissances de base requises :

Si ces notions vous sont étrangères, labsdevops.fr propose des labs gratuits pour vous mettre à niveau. Par exemple, le lab "Linux Basics" couvre toutes ces commandes en 30 minutes.

Voici un tableau récapitulatif des commandes utiles pour ce tutoriel :

Commande Description Exemple
#!/bin/bash Déclare l'interpréteur Bash pour le script #!/bin/bash echo "Hello World"
chmod +x script.sh Rend le script exécutable chmod +x mon_script.sh
./script.sh Exécute le script ./mon_script.sh
$1, $2, ... Arguments passés au script echo "Premier argument : $1"

Étape 1 : Créer votre premier script shell

Un script shell est un fichier texte contenant des commandes Linux exécutées séquentiellement. Voici comment en créer un :

1.1 Ouvrir un éditeur de texte

Utilisez votre éditeur préféré (nano, vim, VS Code) ou directement le terminal :

nano mon_premier_script.sh

Sur labsdevops.fr, vous pouvez ouvrir un terminal directement dans votre navigateur grâce aux environnements Docker isolés. Cliquez sur "Lancer un lab Linux" pour commencer.

1.2 Écrire le script de base

Ajoutez ces lignes dans votre fichier :

#!/bin/bash
# Mon premier script shell
echo "Bonjour, $(whoami) !"
echo "Nous sommes le $(date)"

1.3 Rendre le script exécutable

Par défaut, un fichier texte n'est pas exécutable. Utilisez cette commande :

chmod +x mon_premier_script.sh

Astuce : Vérifiez les permissions avec ls -l. Le fichier doit afficher -rwxr-xr-x (le x indique qu'il est exécutable).

1.4 Exécuter le script

Deux méthodes possibles :

Résultat attendu :

Bonjour, utilisateur !
Nous sommes le lun. 15 sept. 2026 14:30:22 CEST

Étape 2 : Manipuler les variables et les arguments

Les variables permettent de stocker des données et de rendre vos scripts dynamiques. Voici comment les utiliser :

2.1 Déclarer et utiliser des variables

Modifiez votre script comme suit :

#!/bin/bash
# Script avec variables
NOM="DevOps"
ANNEE=2026

echo "Bienvenue dans le monde $NOM en $ANNEE !"
echo "Ce script s'appelle $0"

2.2 Passer des arguments au script

Les scripts peuvent accepter des arguments depuis la ligne de commande. Voici un exemple :

#!/bin/bash
# Script avec arguments
echo "Premier argument : $1"
echo "Deuxième argument : $2"
echo "Nombre total d'arguments : $#"
echo "Tous les arguments : $@"

Exécutez-le avec :

./script.sh Linux DevOps

Résultat :

Premier argument : Linux
Deuxième argument : DevOps
Nombre total d'arguments : 2
Tous les arguments : Linux DevOps

Tableau des variables spéciales :

Variable Description
$0 Nom du script
$1, $2, ... Arguments passés au script
$# Nombre total d'arguments
$@ Tous les arguments sous forme de liste
$$ PID du processus courant

2.3 Astuce : Vérifier les arguments

Pour éviter les erreurs, vérifiez que les arguments sont bien passés :

#!/bin/bash
if [ $# -eq 0 ]; then
  echo "Erreur : aucun argument fourni."
  echo "Usage : $0 <nom> <année>"
  exit 1
fi

echo "Bonjour $1, nous sommes en $2 !"

Explications :

Étape 3 : Utiliser les conditions et boucles

Les structures de contrôle (conditions, boucles) rendent vos scripts intelligents. Voici comment les maîtriser :

3.1 Les conditions (if/else)

Exemple : vérifier si un fichier existe :

#!/bin/bash
FICHIER="mon_fichier.txt"

if [ -f "$FICHIER" ]; then
  echo "Le fichier $FICHIER existe."
else
  echo "Le fichier $FICHIER n'existe pas."
  touch "$FICHIER"  # Crée le fichier s'il n'existe pas
fi

Opérateurs de test courants :

3.2 Les boucles (for, while)

Boucle for : parcourir une liste de fichiers :

#!/bin/bash
# Liste tous les fichiers .txt dans le répertoire courant
for fichier in *.txt; do
  echo "Fichier trouvé : $fichier"
  # Ajoutez ici des traitements sur chaque fichier
  # Exemple : wc -l "$fichier" pour compter les lignes

Boucle while : lire un fichier ligne par ligne :

#!/bin/bash
FICHIER="log.txt"

while IFS= read -r ligne; do
  echo "Ligne lue : $ligne"
  # Traitement de chaque ligne
  # Exemple : grep "erreur" <<< "$ligne" pour filtrer les erreurs

Astuce : Utilisez IFS= pour préserver les espaces en début/fin de ligne et -r pour éviter l'interprétation des backslashes.

3.3 Exercice pratique : script de sauvegarde

Voici un script complet qui sauvegarde un répertoire :

#!/bin/bash
# Script de sauvegarde avec conditions et boucles
SOURCE="/home/utilisateur/documents"
DESTINATION="/home/utilisateur/sauvegardes"
DATE=$(date +%Y%m%d_%H%M%S)
NOM_SAUVEGARDE="sauvegarde_$DATE.tar.gz"

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

# Créer le répertoire de destination s'il n'existe pas
mkdir -p "$DESTINATION"

# Créer l'archive
echo "Création de la sauvegarde $NOM_SAUVEGARDE..."
tar -czf "$DESTINATION/$NOM_SAUVEGARDE" "$SOURCE"

# Vérifier que la sauvegarde a réussi
if [ -f "$DESTINATION/$NOM_SAUVEGARDE" ]; then
  echo "Sauvegarde terminée avec succès : $DESTINATION/$NOM_SAUVEGARDE"
  echo "Taille : $(du -h "$DESTINATION/$NOM_SAUVEGARDE" | cut -f1)"
else
  echo "Erreur : la sauvegarde a échoué."
  exit 1
fi

Pour tester ce script :

  1. Créez un répertoire de test : mkdir -p ~/test_sauvegarde/documents.
  2. Ajoutez des fichiers : touch ~/test_sauvegarde/documents/fichier{1..5}.txt.
  3. Modifiez les variables SOURCE et DESTINATION dans le script.
  4. Exécutez-le : ./sauvegarde.sh.

Étape 4 : Gérer les entrées/sorties et les fichiers

Un script utile doit souvent lire ou écrire des fichiers. Voici les techniques essentielles :

4.1 Lire un fichier

Deux méthodes principales :

📖 Découvrez également : Formation cybersécurité en ligne : prix et options 2026

while IFS= read -r ligne; do
  echo "Traitement de : $ligne"
done < "fichier.txt"
for ligne in $(cat fichier.txt); do
  echo "Ligne : $ligne"
done

4.2 Écrire dans un fichier

Trois opérateurs pour rediriger la sortie :

Exemple :

#!/bin/bash
# Script qui enregistre les processus en cours
echo "Liste des processus à $(date)" > processus.log
ps aux >> processus.log

echo "Les processus ont été enregistrés dans processus.log"

4.3 Astuce : Vérifier les erreurs

Pour capturer les erreurs et les afficher :

#!/bin/bash
# Script avec gestion des erreurs
FICHIER="inexistant.txt"

if ! grep "motif" "$FICHIER" > resultat.txt 2> erreurs.txt; then
  echo "Une erreur est survenue :"
  cat erreurs.txt
  exit 1
fi

echo "Résultat enregistré dans resultat.txt"

4.4 Exercice pratique : analyseur de logs

Voici un script qui analyse un fichier de logs et compte les erreurs :

#!/bin/bash
# Script d'analyse de logs
LOG_FILE="/var/log/syslog"  # Modifiez ce chemin selon votre système
OUTPUT_FILE="analyse_logs.txt"

# Vérifier que le fichier de logs existe
iif [ ! -f "$LOG_FILE" ]; then
  echo "Erreur : le fichier $LOG_FILE n'existe pas."
  exit 1
fi

# Initialiser les compteurs
declare -i erreurs=0
declare -i warnings=0

# Lire le fichier ligne par ligne
while IFS= read -r ligne; do
  if [[ "$ligne" == *"ERROR"* ]]; then
    ((erreurs++))
  elif [[ "$ligne" == *"WARNING"* ]]; then
    ((warnings++))
  fi
done < "$LOG_FILE"

# Enregistrer les résultats
echo "Analyse des logs du fichier $LOG_FILE" > "$OUTPUT_FILE"
echo "----------------------------------------" >> "$OUTPUT_FILE"
echo "Nombre d'erreurs : $erreurs" >> "$OUTPUT_FILE"
echo "Nombre de warnings : $warnings" >> "$OUTPUT_FILE"

# Afficher un résumé
echo "Analyse terminée. Résultats enregistrés dans $OUTPUT_FILE"
echo "Erreurs : $erreurs | Warnings : $warnings"

Pour tester ce script :

  1. Créez un fichier de logs de test : echo -e "ERROR: Problème 1\nWARNING: Attention\nERROR: Problème 2" > test.log.
  2. Modifiez la variable LOG_FILE pour pointer vers test.log.
  3. Exécutez le script : ./analyse_logs.sh.
  4. Vérifiez le fichier analyse_logs.txt.

Étape 5 : Déboguer et optimiser vos scripts

Même les scripts bien écrits peuvent rencontrer des problèmes. Voici comment les identifier et les résoudre :

5.1 Techniques de débogage

bash -x mon_script.sh
bash -v mon_script.sh
echo "DEBUG: Variable NOM = $NOM"

5.2 Bonnes pratiques pour des scripts robustes

Voici une checklist pour écrire des scripts maintenables :

Exemple de script optimisé :

#!/bin/bash
# Script optimisé avec gestion des erreurs
set -e  # Quitte en cas d'erreur

# Variables
SOURCE="$1"
DESTINATION="$2"

# Vérifications
if [ $# -ne 2 ]; then
  echo "Usage : $0 <source> <destination>"
  exit 1
fi

if [ ! -d "$SOURCE" ]; then
  echo "Erreur : $SOURCE n'existe pas ou n'est pas un répertoire."
  exit 1
fi

# Corps du script
echo "Copie de $SOURCE vers $DESTINATION..."
cp -r "$SOURCE" "$DESTINATION" 2> erreur.log

if [ $? -ne 0 ]; then
  echo "Erreur lors de la copie. Détails dans erreur.log"
  exit 1
fi

echo "Copie terminée avec succès."

5.3 Outils pour aller plus loin

5.4 Exercice pratique : script de monitoring

Voici un script qui surveille l'espace disque et envoie une alerte si un seuil est dépassé :

#!/bin/bash
# Script de monitoring de l'espace disque
SEUIL=90  # Seuil en pourcentage
EMAIL="admin@example.com"  # Modifiez avec votre email

# Récupérer l'utilisation disque
df -h | grep -vE '^Filesystem|tmpfs|cdrom' | awk '{ print $5 " " $1 }' | while read output; do
  usage=$(echo $output | awk '{ print $1}' | cut -d'%' -f1)
  partition=$(echo $output | awk '{ print $2 }')
  
  if [ $usage -ge $SEUIL ]; then
    echo "Alerte : La partition $partition est à $usage% d'utilisation !" >> alertes.log
    # Décommentez la ligne suivante pour envoyer un email (nécessite mailutils)
    # echo "Alerte disque : $partition à $usage%" | mail -s "Alerte disque" $EMAIL
  fi
done

# Afficher un résumé
echo "Monitoring terminé. Vérifiez alertes.log pour les détails."

Pour tester ce script :

  1. Enregistrez-le sous monitoring.sh.
  2. Rendez-le exécutable : chmod +x monitoring.sh.
  3. Exécutez-le : ./monitoring.sh.
  4. Vérifiez le fichier alertes.log.

Erreurs fréquentes à éviter

Voici les pièges courants et comment les éviter :

Récapitulatif : ce que vous avez appris

Félicitations ! Vous maîtrisez désormais les bases des scripts shell Linux. Voici un récapitulatif des compétences acquises :

Pour aller plus loin, explorez les 27 parcours techniques de labsdevops.fr, dont un parcours complet sur Linux couvrant :

Avec la formule Pro à 19,90€/mois, vous accédez à tous les labs, dont 871 interactifs, et bénéficiez de l'agent IA Alex pour vous guider. Des labs gratuits sont également disponibles pour découvrir la plateforme.

Questions fréquentes

Quels sont les prérequis pour suivre ce tutoriel ?

Il est recommandé d'avoir une connaissance basique de Linux (commandes comme cd, ls, grep) et d'un éditeur de texte (nano, vim). Aucune expertise en programmation n'est nécessaire. Sur labsdevops.fr, vous trouverez des labs gratuits pour vous familiariser avec ces concepts avant de commencer.

Puis-je tester ces scripts directement dans mon navigateur ?

Oui ! La plateforme labsdevops.fr propose des environnements Docker isolés par utilisateur, accessibles via navigateur. Vous pouvez ainsi pratiquer ces scripts sans installation locale, avec un terminal Linux prêt à l'emploi et même l'agent IA Alex pour vous guider.

Quelle est la différence entre #!/bin/bash et #!/bin/sh ?

#!/bin/bash utilise l'interpréteur Bash, plus riche en fonctionnalités (tableaux, expressions régulières étendues). #!/bin/sh pointe souvent vers un shell minimal (comme Dash), compatible POSIX mais moins puissant. Pour les scripts complexes, privilégiez Bash.

Comment déboguer un script shell qui ne fonctionne pas ?

Utilisez l'option -x (bash -x script.sh) pour afficher chaque commande exécutée. Vérifiez aussi les permissions (chmod +x) et les chemins relatifs/absolus. LabsDevOps propose un lab dédié au débogage avec des cas pratiques et des solutions détaillées.

Existe-t-il des parcours complets sur les scripts shell ?

Absolument. LabsDevOps inclut un parcours complet 'Linux' parmi ses 27 parcours techniques, couvrant les scripts shell avancés, la gestion des processus et l'automatisation. La formule Pro à 19,90€/mois donne accès à tous les labs, dont 871 interactifs.

Articles connexes

Une question ? Parlez a notre assistant

Notre agent IA repond instantanement a vos questions, 24h/24 et 7j/7.

Discuter sur WhatsApp