0Pricing
Linux Command Line & Bash Scripting Mastery · Lezione

Progetto di scripting avanzato

Realizzi un progetto completo che integri tutti i concetti appresi, dagli strumenti della riga di comando alle tecniche avanzate di scripting Bash.

Progetto di scripting avanzato è una lezione Linux Command Line & Bash Scripting Mastery gratuita su CoddyKit. Questa è la lezione 3 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Linux Command Line & Bash Scripting Mastery, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Linux Command Line & Bash Scripting Mastery include 4 lezioni in totale.

Inizio del progetto: la sfida

Benvenuto al nostro progetto finale! Durante questo corso ha imparato molti potenti comandi Linux e tecniche di scripting Bash. Ora è il momento di riunire tutto.

In questa lezione costruiremo da zero uno script Bash pratico e avanzato. Questo progetto la sfiderà a integrare tutto ciò che ha imparato in un'unica soluzione funzionale.

Definire l'obiettivo del progetto

Il nostro obiettivo è creare uno script per il monitoraggio e l'archiviazione dei file. Immagini di avere un server che genera file di log e di doverli elaborare regolarmente senza intervento manuale.

Ecco cosa farà il nostro script:

  • Monitorare continuamente una directory specifica alla ricerca di nuovi file di testo.
  • Elaborare ogni nuovo file, ad esempio contandone le righe.
  • Spostare il file elaborato in una directory di archivio.
  • Registrare tutte le attività, inclusi timestamp ed eventuali errori.

Fondamenta dello script: Shebang e variabili

Ogni buon script inizia da fondamenta chiare. Inizieremo definendo il nostro shebang e configurando le variabili principali. Queste variabili renderanno lo script flessibile e facile da configurare.

Definiremo i percorsi della directory da monitorare, della directory di archivio e di un file di log.

#!/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"

Verificare l'esistenza delle directory

Prima che lo script possa monitorare o archiviare i file, dobbiamo assicurarci che le directory necessarie esistano. In questo caso è fondamentale usare mkdir -p, perché crea le directory solo se non esistono già e non restituisce un errore se esistono.

Aggiungeremo anche una gestione di base degli errori, in modo da terminare correttamente se la creazione della directory non riesce.

#!/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"

Il ciclo di monitoraggio

Il nostro script deve essere eseguito continuamente per cercare nuovi file. Un ciclo while true è perfetto a questo scopo. All'interno del ciclo useremo sleep per mettere in pausa l'esecuzione per alcuni secondi tra un controllo e l'altro, evitando di consumare troppe risorse.

Registreremo inoltre ogni controllo per tenere traccia dell'attività.

#!/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

Ricerca ed elaborazione dei file

All'interno del ciclo, dobbiamo trovare nuovi file di testo. Il comando find è ideale a questo scopo, combinato con un ciclo for per elaborare ogni file trovato. Useremo wc -l per contare le righe di ogni file durante l'elaborazione.

Questo dimostra come combinare gli strumenti della riga di comando all'interno di uno 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

Archiviazione dei file elaborati

Dopo aver elaborato un file, dobbiamo spostarlo nella nostra directory di archivio. Per farlo si usa il comando mv. Aggiungeremo anche un'istruzione if per controllare lo stato di uscita di mv, verificando che lo spostamento sia riuscito e registrando eventuali errori.

In questo modo lo script diventa più robusto.

#!/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

Aggiunta di un'uscita controllata con trap

Uno script a esecuzione prolungata deve poter essere arrestato correttamente. Il comando trap consente di intercettare segnali come SIGINT (attivato da Ctrl+C) ed eseguire una funzione di pulizia prima dell'uscita. In questo modo lo script registra il proprio arresto.

Si tratta di un passaggio fondamentale per rendere gli script pronti per la produzione.

#!/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

Test dello script avanzato

Ora che lo script è completo, è il momento di testarlo. In genere lo si esegue in background (ad esempio, ./monitor.sh &), quindi si creano file di test in $MONITOR_DIR e si osservano $LOG_FILE e $ARCHIVE_DIR.

Ecco un piccolo script che può eseguire per creare facilmente un file di test per il monitor.

#!/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"

Revisione della logica dello script

Il nostro script avanzato combina molti concetti. Esaminiamo rapidamente alcuni dei comandi e delle strutture principali che abbiamo utilizzato.

Rifletta sul ruolo di ciascun comando nel raggiungimento dell'obiettivo del progetto.

Oltre: pianificazione e personalizzazione

Questo script è progettato per essere eseguito continuamente. In uno scenario reale, potrebbe eseguirlo in background usando nohup ./script.sh & oppure, più comunemente, pianificarne l'esecuzione periodica tramite Cron.

Ricordi che Cron è perfetto per automatizzare attività di questo tipo. Potrebbe pianificarne l'esecuzione ogni pochi minuti, controllando la directory ed elaborando i file quando necessario.

Valuti di personalizzarlo per:

  • Elaborare diversi tipi di file.
  • Eseguire azioni diverse (ad esempio, comprimere i file o caricarli sul cloud).
  • Aggiungere funzioni più avanzate di segnalazione degli errori (ad esempio, avvisi via e-mail).

Riepilogo del progetto e prossimi passi

Congratulazioni! Ha appena completato un progetto avanzato di scripting Bash, integrando un'ampia gamma di comandi Linux e tecniche di scripting.

Ha imparato a:

  • Strutturare uno script robusto a esecuzione prolungata.
  • Usare le variabili per la configurazione.
  • Implementare cicli per il monitoraggio continuo.
  • Combinare comandi come find, wc e mv.
  • Aggiungere la gestione degli errori e uscite controllate con trap.

Questo progetto costituisce una solida base per creare soluzioni di automazione più complesse. Continui a sperimentare e a creare!

Domande Frequenti

La lezione «Progetto di scripting avanzato» è gratuita?

Sì — il testo completo di «Progetto di scripting avanzato» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Linux Command Line & Bash Scripting Mastery, passa a CoddyKit PRO. Il corso Linux Command Line & Bash Scripting Mastery include 4 lezioni in totale.

Cosa imparerò in «Progetto di scripting avanzato»?

Realizzi un progetto completo che integri tutti i concetti appresi, dagli strumenti della riga di comando alle tecniche avanzate di scripting Bash. Eserciti Linux Command Line & Bash Scripting Mastery con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Linux Command Line & Bash Scripting Mastery?

Non è richiesta alcuna esperienza precedente. Linux Command Line & Bash Scripting Mastery su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 3 di 4.

Quanto tempo richiede la lezione «Progetto di scripting avanzato»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Linux Command Line & Bash Scripting Mastery?

Sì. Ogni lezione Linux Command Line & Bash Scripting Mastery include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Pianificazione delle attività con Cron
  2. Automazione dell’amministrazione di sistema
  3. Progetto di scripting avanzato
  4. Rotazione e pulizia automatizzate dei log
← Torna a Linux Command Line & Bash Scripting Mastery