Maîtriser Bash Linux : Exercices Pas à Pas pour Débutants

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

Maîtriser Bash Linux : Exercices Pas à Pas pour Débutants

Bash (Bourne-Again SHell) est un outil indispensable pour les développeurs, administrateurs systèmes et professionnels du DevOps. Que vous souhaitiez automatiser des tâches, gérer des serveurs ou déployer des applications, savoir écrire des scripts Bash vous fera gagner un temps précieux. Dans ce tutoriel, vous allez apprendre à créer vos premiers scripts, manipuler des fichiers et des données, et éviter les pièges courants. Grâce aux 871 labs interactifs de LabsDevOps, vous pourrez pratiquer directement dans votre navigateur, sans installation complexe.

À la fin de ce guide, vous serez capable de :

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

Avant de plonger dans les exercices, assurez-vous de maîtriser les bases suivantes. Si certains points vous semblent flous, pas de panique : LabsDevOps propose des parcours complets pour vous mettre à niveau, notamment sur Linux et Docker.

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

1. Connaissances de base en Linux

2. Outils nécessaires

3. Concepts de programmation utiles

Vous n'avez pas besoin d'être un expert, mais connaître ces notions facilitera votre apprentissage :

Si ces concepts vous sont étrangers, les 27 parcours techniques de LabsDevOps incluent des modules dédiés à la programmation shell et à l'automatisation.

Étape 1 : Créer et exécuter votre premier script Bash

Un script Bash est un simple fichier texte contenant des commandes Linux. Pour commencer, nous allons créer un script qui affiche "Bonjour, DevOps !" à l'écran. Suivez ces étapes :

1.1. Créer le fichier script

Ouvrez votre terminal et créez un fichier nommé `bonjour.sh` avec la commande suivante :

nano bonjour.sh

Cela ouvre l'éditeur `nano`. Ajoutez le contenu suivant :

#!/bin/bash
# Mon premier script Bash
echo "Bonjour, DevOps !"

Explications :

Enregistrez le fichier avec Ctrl + O, puis quittez `nano` avec Ctrl + X.

1.2. Rendre le script exécutable

Par défaut, un fichier n'a pas les permissions d'exécution. Pour les ajouter, utilisez la commande :

chmod +x bonjour.sh

Vérifiez les permissions avec :

ls -l bonjour.sh

Vous devriez voir quelque chose comme :

-rwxr-xr-x 1 utilisateur utilisateur 42 juin  10 10:00 bonjour.sh

Le `x` dans `-rwxr-xr-x` indique que le fichier est exécutable.

1.3. Exécuter le script

Pour exécuter votre script, utilisez l'une de ces méthodes :

Si tout se passe bien, vous devriez voir s'afficher :

Bonjour, DevOps !

Astuce : Tester vos scripts dans un lab interactif

Sur LabsDevOps, vous pouvez tester vos scripts dans un environnement Docker isolé, sans risque pour votre machine. Voici comment :

  1. Connectez-vous à votre compte (formule Pro à 19,90€/mois pour un accès complet).
  2. Accédez au lab "Bash - Premiers Pas".
  3. Copiez-collez votre script dans l'éditeur intégré.
  4. Exécutez-le directement dans le navigateur et observez les résultats.

Étape 2 : Manipuler des fichiers et des répertoires

Bash excelle pour automatiser la gestion de fichiers. Dans cette étape, vous allez apprendre à créer, déplacer, supprimer et rechercher des fichiers avec des commandes avancées. Ces compétences sont essentielles pour des tâches comme le nettoyage de logs ou la préparation d'environnements de déploiement.

2.1. Créer et supprimer des fichiers

Voici les commandes de base pour manipuler des fichiers :

Commande Description Exemple
touch Crée un fichier vide ou met à jour sa date de modification. touch fichier.txt
rm Supprime un fichier. Utilisez -i pour demander une confirmation. rm -i fichier.txt
rm -r Supprime un répertoire et son contenu de manière récursive. rm -r mon_repertoire/
cp Copie un fichier ou un répertoire. Ajoutez -r pour les répertoires. cp fichier.txt copie.txt
mv Déplace ou renomme un fichier ou un répertoire. mv fichier.txt nouveau_nom.txt

2.2. Rechercher des fichiers avec `find`

La commande `find` est puissante pour localiser des fichiers selon divers critères (nom, taille, date, etc.). Voici quelques exemples :

2.3. Exercice pratique : Script de nettoyage de logs

Écrivez un script qui supprime tous les fichiers de logs dans `/var/log` vieux de plus de 30 jours. Voici comment procéder :

  1. Créez un fichier `nettoyer_logs.sh` : 
    nano nettoyer_logs.sh
  2. Ajoutez le contenu suivant : 
    #!/bin/bash
# Script pour supprimer les logs vieux de plus de 30 jours
find /var/log -name "*.log" -mtime +30 -exec rm {} \;
echo "Nettoyage des logs terminé."
  3. Rendez le script exécutable et testez-le : 
    chmod +x nettoyer_logs.sh
sudo ./nettoyer_logs.sh

    Note : Utilisez `sudo` car `/var/log` nécessite des droits administrateur.

Astuce : Utiliser `grep` pour filtrer le contenu des fichiers

La commande `grep` permet de rechercher des motifs dans des fichiers. Par exemple, pour trouver toutes les occurrences de "error" dans les logs :

grep -r "error" /var/log/

Combinez `grep` avec d'autres commandes pour des résultats encore plus puissants :

grep "error" /var/log/syslog | cut -d' ' -f1-5

Cette commande affiche uniquement les 5 premiers champs de chaque ligne contenant "error".

Étape 3 : Utiliser des variables et des arguments

Les variables et les arguments rendent vos scripts dynamiques et réutilisables. Dans cette étape, vous allez apprendre à les utiliser pour créer des scripts flexibles, comme ceux utilisés en CI/CD ou pour la gestion de serveurs.

3.1. Déclarer et utiliser des variables

En Bash, les variables sont déclarées sans espace autour du signe `=`. Voici un exemple :

#!/bin/bash
# Script avec variables
nom="DevOps"
age=5
echo "Bienvenue dans le monde $nom, qui a $age ans !"

Exécutez ce script pour voir le résultat :

chmod +x variables.sh
./variables.sh

Résultat attendu :

Bienvenue dans le monde DevOps, qui a 5 ans !

3.2. Passer des arguments à un script

Les arguments permettent de personnaliser l'exécution d'un script. Voici comment les utiliser :

#!/bin/bash
# Script avec arguments
echo "Le premier argument est : $1"
echo "Le deuxième argument est : $2"
echo "Tous les arguments : $@"
echo "Nombre d'arguments : $#"

Exécutez le script avec des arguments :

./arguments.sh Bonjour LabsDevOps

Résultat :

Le premier argument est : Bonjour
Le deuxième argument est : LabsDevOps
Tous les arguments : Bonjour LabsDevOps
Nombre d'arguments : 2

Explications :

3.3. Exercice pratique : Script de sauvegarde

Écrivez un script qui sauvegarde un répertoire en le compressant avec `tar`. Le script doit accepter deux arguments : le répertoire source et le nom du fichier de sauvegarde.

  1. Créez le fichier `sauvegarde.sh` : 
    nano sauvegarde.sh
  2. Ajoutez le contenu suivant : 
    #!/bin/bash
# Script de sauvegarde avec arguments
source=$1
destination=$2.tar.gz
tar -czvf $destination $source
echo "Sauvegarde de $source terminée. Fichier : $destination"
  3. Rendez le script exécutable et testez-le : 
    chmod +x sauvegarde.sh
./sauvegarde.sh /home/utilisateur/mon_dossier sauvegarde_$(date +%Y%m%d)

Ce script crée une archive compressée du répertoire source avec un nom incluant la date du jour.

Astuce : Valider les arguments avec des conditions

Pour rendre votre script plus robuste, vérifiez que les arguments sont fournis :

#!/bin/bash
if [ $# -ne 2 ]; then
  echo "Usage : $0 <source> <destination>"
  exit 1
fi
source=$1
destination=$2.tar.gz
tar -czvf $destination $source
echo "Sauvegarde terminée."

Étape 4 : Automatiser avec des boucles et des conditions

Les boucles et les conditions sont au cœur de l'automatisation. Elles permettent de répéter des tâches ou de prendre des décisions en fonction de critères. Dans cette étape, vous allez apprendre à les utiliser pour créer des scripts puissants, comme ceux utilisés pour déployer des applications ou gérer des infrastructures.

4.1. Utiliser des boucles `for` et `while`

Boucle `for`

La boucle `for` permet de parcourir une liste d'éléments. Exemple :

#!/bin/bash
# Boucle for pour afficher les nombres de 1 à 5
for i in {1..5}; do
  echo "Nombre : $i"
done

Résultat :

Nombre : 1
Nombre : 2
Nombre : 3
Nombre : 4
Nombre : 5

Boucle `while`

La boucle `while` s'exécute tant qu'une condition est vraie. Exemple :

#!/bin/bash
# Boucle while pour compter jusqu'à 5
compteur=1
while [ $compteur -le 5 ]; do
  echo "Compteur : $compteur"
  ((compteur++))
done

4.2. Utiliser des conditions `if`, `else` et `elif`

Les conditions permettent d'exécuter du code en fonction de critères. Voici un exemple complet :

#!/bin/bash
# Script avec conditions
fichier="mon_fichier.txt"
if [ -f "$fichier" ]; then
  echo "Le fichier $fichier existe."
elif [ -d "$fichier" ]; then
  echo "$fichier est un répertoire."
else
  echo "Le fichier $fichier n'existe pas."
  touch $fichier
  echo "Fichier créé."
fi

Explications :

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

4.3. Exercice pratique : Script de déploiement

Écrivez un script qui vérifie si un fichier de configuration existe avant de déployer une application. Si le fichier n'existe pas, le script doit le créer avec des valeurs par défaut.

  1. Créez le fichier `deployer.sh` : 
    nano deployer.sh
  2. Ajoutez le contenu suivant : 
    #!/bin/bash
# Script de déploiement avec vérification de configuration
config_file="config.ini"
default_config="[settings]
host=localhost
port=8080
"
if [ ! -f "$config_file" ]; then
  echo "Fichier de configuration manquant. Création avec des valeurs par défaut..."
  echo -e "$default_config" > $config_file
  echo "Fichier $config_file créé."
fi

echo "Déploiement en cours..."
# Simuler un déploiement
sleep 2
echo "Application déployée avec succès !"
  3. Rendez le script exécutable et testez-le : 
    chmod +x deployer.sh
./deployer.sh

Ce script vérifie l'existence du fichier `config.ini`. S'il n'existe pas, il le crée avec des valeurs par défaut avant de simuler un déploiement.

Astuce : Utiliser `case` pour des conditions multiples

L'instruction `case` est utile pour gérer plusieurs conditions de manière lisible. Exemple :

#!/bin/bash
# Script avec case
read -p "Choisissez une option (1/2/3) : " choix
case $choix in
  1)
    echo "Option 1 sélectionnée."
    ;;
  2)
    echo "Option 2 sélectionnée."
    ;;
  3)
    echo "Option 3 sélectionnée."
    ;;
  *)
    echo "Option invalide."
    ;;
esac

Étape 5 : Déboguer vos scripts Bash

Même les développeurs expérimentés font des erreurs. Dans cette étape, vous allez apprendre à identifier et corriger les problèmes dans vos scripts Bash, une compétence essentielle pour travailler en DevOps où l'automatisation est reine.

5.1. Utiliser l'option `-x` pour le débogage

L'option `-x` affiche chaque commande exécutée par le script, ce qui permet de suivre son déroulement. Exemple :

bash -x mon_script.sh

Voici un exemple de sortie :

+ echo 'Bonjour, DevOps !'
Bonjour, DevOps !

Les lignes précédées de `+` montrent les commandes exécutées.

5.2. Vérifier les erreurs avec `set -e` et `set -u`

Ajoutez ces options en haut de votre script :

#!/bin/bash
set -eu
# Votre script ici
echo "Script exécuté avec succès."

5.3. Exercice pratique : Corriger un script buggé

Voici un script contenant des erreurs. Votre mission est de les identifier et de les corriger :

#!/bin/bash
# Script buggé à corriger
fichiers=$(ls *.txt)
for fichier in $fichiers; do
  if [ -f fichier ]; then
    echo "Traitement de $fichier"
    cat $fichier | grep "erreur"
  fi
done

Problèmes à corriger :

  1. La variable `fichier` dans la condition `if` n'est pas précédée de `$`.
  2. La commande `grep` n'affiche pas le nom du fichier. Utilisez `grep -H` pour cela.
  3. Le script ne gère pas le cas où aucun fichier `.txt` n'existe.

Version corrigée :

#!/bin/bash
set -eu
# Script corrigé
fichiers=$(ls *.txt 2>/dev/null || true)
if [ -z "$fichiers" ]; then
  echo "Aucun fichier .txt trouvé."
  exit 0
fi

for fichier in $fichiers; do
  if [ -f "$fichier" ]; then
    echo "Traitement de $fichier"
    grep -H "erreur" "$fichier"
  fi
done

Astuce : Utiliser `shellcheck` pour analyser vos scripts

ShellCheck est un outil en ligne qui analyse vos scripts Bash et détecte les erreurs courantes. Voici comment l'utiliser :

  1. Copiez votre script sur shellcheck.net.
  2. L'outil affiche les erreurs et des suggestions de correction.
  3. Appliquez les corrections pour améliorer la qualité de votre script.

Erreurs fréquentes à éviter

Voici une liste des erreurs les plus courantes en Bash et comment les éviter :

Récapitulatif : Ce que vous avez appris

Félicitations ! Vous avez maintenant les bases pour écrire des scripts Bash efficaces et automatiser des tâches sous Linux. Voici un récapitulatif des compétences acquises :

Pour aller plus loin, explorez les 27 parcours techniques de LabsDevOps, qui couvrent des sujets avancés comme :

Avec la formule Pro à 19,90€/mois, vous avez accès à tous les labs interactifs, y compris des exercices pratiques pour renforcer vos compétences en Bash et en DevOps. Plus de 500 utilisateurs font déjà confiance à LabsDevOps pour se former de manière 100% pratique.

Questions fréquentes

Quels sont les prérequis pour apprendre Bash sous Linux ?

Pour suivre ce tutoriel, vous devez connaître les bases de Linux (navigation dans le terminal, commandes simples comme `cd` ou `ls`). Une familiarité avec les concepts de programmation (variables, boucles) est utile mais pas obligatoire. Sur LabsDevOps, nos 871 labs interactifs incluent des parcours dédiés pour vous préparer, comme le parcours "Linux - Les Fondamentaux".

Puis-je pratiquer Bash sans installer Linux sur ma machine ?

Absolument ! Grâce à LabsDevOps, vous pouvez accéder à des environnements Docker isolés directement dans votre navigateur, sans installation. La formule Pro à 19,90€/mois donne accès à tous les labs, y compris ceux dédiés à Bash et aux scripts Linux. Vous pouvez aussi utiliser WSL sous Windows ou une machine virtuelle.

Quelle est la différence entre un script Bash et une commande Linux classique ?

Une commande Linux s'exécute ponctuellement dans le terminal, tandis qu'un script Bash est un fichier contenant plusieurs commandes séquencées. Les scripts permettent d'automatiser des tâches répétitives, comme le déploiement d'applications, la gestion de fichiers ou la configuration de serveurs, un atout clé en DevOps.

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

Utilisez l'option `-x` (`bash -x mon_script.sh`) pour afficher chaque commande exécutée et identifier où le script échoue. Vérifiez aussi les permissions avec `chmod +x`, les erreurs de syntaxe (guillemets, espaces) et les variables non définies. Les labs interactifs de LabsDevOps incluent des exercices dédiés au débogage pour vous entraîner.

Quels outils complémentaires à Bash sont utiles pour un DevOps ?

En plus de Bash, maîtrisez Git pour le versioning, Docker pour la conteneurisation, Ansible pour l'automatisation des configurations, et Terraform pour l'infrastructure as code. LabsDevOps propose 27 parcours complets couvrant ces outils, avec des labs pratiques pour chaque technologie, comme Kubernetes, Jenkins ou AWS.

Articles connexes

Une question ? Parlez a notre assistant

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

Discuter sur WhatsApp