0Pricing
Linux Command Line & Bash Scripting Mastery · Leçon

Projet de script avancé

Réalisez un projet complet intégrant tous les concepts appris, des outils de ligne de commande aux techniques avancées de script Bash.

Projet de script avancé est une leçon Linux Command Line & Bash Scripting Mastery gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Linux Command Line & Bash Scripting Mastery, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Linux Command Line & Bash Scripting Mastery comprend 4 leçons au total.

Début du projet : le défi

Bienvenue dans notre projet final ! Tout au long de ce cours, vous avez appris de nombreuses commandes Linux puissantes et techniques d'écriture de scripts Bash. Il est maintenant temps de les réunir.

Dans cette leçon, nous allons créer un script Bash pratique et avancé, en partant de zéro. Ce projet vous mettra au défi d'intégrer tout ce que vous avez appris dans une solution unique et fonctionnelle.

Définir l'objectif de notre projet

Notre objectif est de créer un script de surveillance et d'archivage de fichiers. Imaginez que vous disposez d'un serveur qui génère des fichiers journaux et que vous devez les traiter régulièrement sans intervention manuelle.

Voici ce que fera notre script :

  • Surveiller en continu un répertoire précis à la recherche de nouveaux fichiers texte.
  • Traiter chaque nouveau fichier (par exemple, compter ses lignes).
  • Déplacer le fichier traité vers un répertoire d'archives.
  • Journaliser toutes les activités, y compris les horodatages et les éventuelles erreurs.

Fondations du script : Shebang et variables

Tout bon script commence par une base claire. Nous commencerons par définir son shebang et configurer les variables clés. Ces variables rendront notre script flexible et facile à configurer.

Nous définirons les chemins de notre répertoire à surveiller, de notre répertoire d'archives et d'un fichier journal.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

Vérifier l'existence des répertoires

Avant que notre script puisse surveiller ou archiver des fichiers, nous devons vérifier que les répertoires nécessaires existent. L'utilisation de mkdir -p est essentielle ici, car elle crée les répertoires uniquement lorsqu'ils n'existent pas déjà et ne provoque pas d'erreur s'ils existent.

Nous ajouterons également une gestion élémentaire des erreurs afin de quitter proprement si la création des répertoires échoue.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

La boucle de surveillance

Notre script doit s'exécuter en continu pour surveiller l'arrivée de nouveaux fichiers. Une boucle while true convient parfaitement. À l'intérieur de la boucle, nous utiliserons sleep pour faire une pause de quelques secondes entre les vérifications, afin d'éviter qu'elle ne consomme trop de ressources.

Nous journaliserons également chaque vérification pour suivre l'activité.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # File processing will go here
  sleep 5 # Check every 5 seconds
done

Rechercher et traiter des fichiers

Dans notre boucle, nous devons rechercher les nouveaux fichiers texte. La commande find est idéale pour cela, associée à une boucle for afin de traiter chaque fichier trouvé. Nous utiliserons wc -l pour compter les lignes de chaque fichier lors de cette étape de traitement.

Cela montre comment combiner des outils en ligne de commande dans un script.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  # Find new .txt files and process them
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then # Double-check if it's a regular file
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      # Archiving will go here
    fi
  done
  sleep 5 # Check every 5 seconds
done

Archiver les fichiers traités

Après avoir traité un fichier, nous devons le déplacer vers notre répertoire d'archives. La commande mv sert à cela. Nous ajouterons également une instruction if pour vérifier le statut de sortie de mv, afin de nous assurer que le déplacement a réussi et de consigner les échecs éventuels.

Cela rend notre script plus robuste.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Ajouter une sortie propre avec Trap

Un script exécuté pendant longtemps doit pouvoir s'arrêter proprement. La commande trap permet d'intercepter des signaux, comme SIGINT (déclenché par Ctrl+C), et d'exécuter une fonction de nettoyage avant de quitter. Ainsi, notre script consigne sa fermeture.

C'est une étape essentielle pour créer des scripts prêts pour la production.

#!/bin/bash

# --- Configuration Variables ---
MONITOR_DIR="/tmp/coddykit_monitor"
ARCHIVE_DIR="/tmp/coddykit_archive"
LOG_FILE="/tmp/coddykit_script.log"

# --- Functions ---
cleanup() {
  echo "$(date): Script received stop signal. Exiting gracefully." >> "$LOG_FILE"
  exit 0 # Exit with success status
}

# --- Trap Signals ---
# Trap SIGINT (Ctrl+C) and call the cleanup function
trap cleanup SIGINT

# Log script start
echo "$(date): Script initialized." >> "$LOG_FILE"

# Ensure monitoring and archive directories exist
mkdir -p "$MONITOR_DIR" || { echo "$(date): ERROR: Cannot create $MONITOR_DIR. Exiting." >> "$LOG_FILE"; exit 1; }
mkdir -p "$ARCHIVE_DIR" || { echo "$(date): ERROR: Cannot create $ARCHIVE_DIR. Exiting." >> "$LOG_FILE"; exit 1; }

echo "$(date): Directories checked/created." >> "$LOG_FILE"

# --- Main Monitoring Loop ---
while true; do
  echo "$(date): Checking for new files in $MONITOR_DIR..." >> "$LOG_FILE"
  for file in $(find "$MONITOR_DIR" -maxdepth 1 -type f -name "*.txt"); do
    if [ -f "$file" ]; then
      LINE_COUNT=$(wc -l < "$file")
      echo "$(date): Found '$file'. Lines: $LINE_COUNT." >> "$LOG_FILE"
      
      mv "$file" "$ARCHIVE_DIR/"
      if [ $? -eq 0 ]; then
        echo "$(date): Moved '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      else
        echo "$(date): ERROR: Failed to move '$file' to '$ARCHIVE_DIR'." >> "$LOG_FILE"
      fi
    fi
  done
  sleep 5
done

Tester votre script avancé

Maintenant que notre script est terminé, il est temps de le tester ! Vous l'exécuteriez généralement en arrière-plan (par exemple, ./monitor.sh &), puis vous créeriez des fichiers de test dans $MONITOR_DIR et observeriez $LOG_FILE ainsi que $ARCHIVE_DIR.

Voici un petit script que vous pouvez exécuter pour créer facilement un fichier de test destiné à votre outil de surveillance.

#!/bin/bash
# create_test_file.sh

MONITOR_DIR="/tmp/coddykit_monitor"
mkdir -p "$MONITOR_DIR" # Ensure dir exists for this test script

# Create a unique test file
TEST_FILE="$MONITOR_DIR/test_log_$(date +%Y%m%d_%H%M%S).txt"
echo "This is a test entry." > "$TEST_FILE"
echo "Another line for testing." >> "$TEST_FILE"
echo "Created new test file: $TEST_FILE"

Révision de la logique du script

Notre script avancé combine de nombreux concepts. Révisons rapidement certaines des commandes et structures principales que nous avons utilisées.

Réfléchissez au rôle de chaque commande pour atteindre l'objectif de notre projet.

Pour aller plus loin : planification et personnalisation

Ce script est conçu pour s'exécuter en continu. Dans un contexte réel, vous pourriez l'exécuter en arrière-plan avec nohup ./script.sh & ou, plus couramment, planifier son exécution périodique avec Cron.

N'oubliez pas que Cron est idéal pour automatiser ce type de tâches. Vous pourriez planifier son exécution toutes les quelques minutes afin de vérifier le répertoire et de traiter les fichiers selon les besoins.

Envisagez de le personnaliser pour :

  • Traiter différents types de fichiers.
  • Effectuer différentes actions (par exemple, compresser des fichiers ou les téléverser dans le cloud).
  • Ajouter des rapports d'erreurs plus avancés (par exemple, des alertes par e-mail).

Bilan du projet et prochaines étapes

Félicitations ! Vous venez de terminer un projet avancé de script Bash, intégrant un large éventail de commandes Linux et de techniques de script.

Vous avez appris à :

  • Structurer un script robuste exécuté pendant longtemps.
  • Utiliser des variables pour la configuration.
  • Mettre en œuvre des boucles pour une surveillance continue.
  • Combiner des commandes comme find, wc et mv.
  • Gérer les erreurs et effectuer des sorties propres avec trap.

Ce projet constitue une base solide pour créer des solutions d'automatisation plus complexes. Continuez à expérimenter et à construire !

Questions Fréquemment Posées

La leçon « Projet de script avancé » est-elle gratuite ?

Oui — le texte complet de « Projet de script avancé » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Linux Command Line & Bash Scripting Mastery, passe à CoddyKit PRO. Le cours Linux Command Line & Bash Scripting Mastery comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Projet de script avancé » ?

Réalisez un projet complet intégrant tous les concepts appris, des outils de ligne de commande aux techniques avancées de script Bash. Tu pratiques Linux Command Line & Bash Scripting Mastery avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Linux Command Line & Bash Scripting Mastery ?

Aucune expérience préalable n'est requise. Linux Command Line & Bash Scripting Mastery sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Projet de script avancé » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Linux Command Line & Bash Scripting Mastery ?

Oui. Chaque leçon Linux Command Line & Bash Scripting Mastery inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Planification des tâches avec Cron
  2. Automatisation de l’administration système
  3. Projet de script avancé
  4. Rotation et nettoyage automatisés des journaux
← Retour à Linux Command Line & Bash Scripting Mastery