Primo script Bash su Linux: guida pratica passo passo - Orvieto Linux User Group

Dal comando allo script: creare il primo script Bash per automatizzare Linux

Quando utilizziamo Linux, capita spesso di ripetere le stesse operazioni: controllare la versione del sistema, verificare lo spazio disponibile sul disco, consultare la memoria utilizzata o raccogliere informazioni utili per diagnosticare un problema.

Possiamo eseguire ogni comando manualmente, uno alla volta. Ma quando queste operazioni diventano abituali, c’è un modo più comodo: riunirle in un unico file ed eseguirle con un solo comando.

È proprio questo lo scopo di uno script Bash. Non serve essere programmatori esperti e non dobbiamo imparare subito un linguaggio complesso. Possiamo iniziare con pochi comandi che già conosciamo, organizzandoli in una sequenza che Linux eseguirà per noi.

In questa guida costruiremo uno script semplice ma realmente utile: un piccolo rapporto con le informazioni principali del sistema. Vedremo come scriverlo, come eseguirlo e come migliorarlo gradualmente.

Che cos’è uno script Bash?

Bash è una shell, cioè un programma che interpreta i comandi impartiti al terminale. Oltre a permetterci di lavorare in modo interattivo, può leggere ed eseguire una sequenza di istruzioni salvate in un file: quel file è uno script.

Immaginiamo di voler conoscere il nome del computer, la versione del kernel e lo spazio disponibile sul disco. Potremmo eseguire tre comandi separati, ricordandoci ogni volta quali utilizzare. Oppure possiamo scriverli in un file e lasciare che Bash li esegua nell’ordine stabilito.

Il vantaggio non è soltanto risparmiare qualche pressione sulla tastiera. Uno script rende le operazioni ripetibili e più facili da condividere, documentare e modificare. Lo stesso principio può essere applicato in futuro alla manutenzione di un server, alla raccolta di informazioni diagnostiche o ad attività periodiche del nostro homelab.

Se non hai ancora familiarità con la shell, puoi partire dalla nostra guida introduttiva allo scripting Bash, che presenta i concetti di base. Qui passiamo direttamente alla pratica.

Prepariamo il nostro primo script

Per lavorare con ordine, creiamo una directory dedicata ai nostri esperimenti. Apriamo il terminale e digitiamo:

mkdir -p ~/script-linux
cd ~/script-linux

Il comando mkdir -p crea la directory se non esiste già, mentre cd ci porta al suo interno. Utilizziamo ~ per indicare la nostra directory personale, così non dobbiamo scrivere ogni volta il percorso completo.

Ora creiamo il file che conterrà il programma:

nano info-sistema.sh

Si apre l’editor di testo Nano. Inseriamo queste righe:

#!/usr/bin/env bash

echo "Rapporto sul sistema Linux"
echo "--------------------------"

echo "Computer: $(hostname)"
echo "Data: $(date)"
echo "Kernel: $(uname -r)"

echo
echo "Spazio disponibile:"
df -h /

Salviamo il file con Ctrl+O, confermiamo il nome con Invio e usciamo con Ctrl+X.

Abbiamo appena creato il nostro primo script. Prima di eseguirlo, però, vale la pena capire cosa abbiamo scritto: comprendere ogni istruzione è molto più utile che copiare un esempio senza sapere come funziona.

Leggiamo il codice, una riga alla volta

La prima riga è:

#!/usr/bin/env bash

Viene chiamata shebang e indica al sistema quale interprete utilizzare quando avviamo lo script direttamente. In questo caso cerchiamo Bash attraverso env, evitando di presumere che il programma si trovi sempre nello stesso percorso.

Le righe che iniziano con echo stampano un messaggio sul terminale. Per esempio, echo "Rapporto sul sistema Linux" mostra semplicemente il titolo del nostro rapporto.

Le espressioni racchiuse in $(...), invece, vengono eseguite come comandi e sostituite con il risultato ottenuto. Quando Bash incontra $(hostname), esegue hostname e inserisce nel messaggio il nome del computer. Lo stesso meccanismo ci permette di mostrare la data corrente con date e la versione del kernel con uname -r.

Infine, df -h / mostra lo spazio utilizzato e disponibile nel filesystem che contiene la directory principale /. L’opzione -h rende i valori più leggibili, utilizzando unità come GB e MB quando opportuno.

La riga echo senza argomenti inserisce una riga vuota, separando visivamente le informazioni dal risultato successivo.

Notiamo una caratteristica importante: dentro lo script utilizziamo praticamente gli stessi comandi che potremmo lanciare a mano nel terminale. Bash li esegue in sequenza, dall’alto verso il basso.

Come eseguire lo script

Salvare il file non significa ancora averlo eseguito. Abbiamo due modalità semplici per provarlo.

La prima consiste nel richiamare Bash esplicitamente:

bash info-sistema.sh

Bash legge il file ed esegue le istruzioni contenute al suo interno. Questo metodo è comodo per i primi test perché non richiede di modificare i permessi del file.

Se tutto funziona, vedremo il titolo, il nome del computer, la data, la versione del kernel e lo spazio disponibile sulla partizione principale.

Possiamo anche rendere lo script eseguibile:

chmod +x info-sistema.sh

Il comando chmod +x aggiunge il permesso di esecuzione. A questo punto possiamo avviarlo direttamente dalla directory corrente:

./info-sistema.sh

Il prefisso ./ indica che il file si trova nella directory in cui stiamo lavorando. Linux non cerca normalmente i programmi nella directory corrente quando digitiamo soltanto il loro nome: specificare il percorso evita ambiguità.

Le due modalità sono entrambe corrette. La differenza è che bash info-sistema.sh chiede esplicitamente a Bash di leggere il file, mentre ./info-sistema.sh utilizza i permessi di esecuzione e la shebang per individuare l’interprete.

Salviamo il rapporto in un file

Finora il nostro script mostra i risultati sul terminale. Possiamo renderlo ancora più utile salvando l’output in un file di testo, così da poterlo consultare in seguito o allegarlo a una richiesta di assistenza.

Per farlo, eseguiamo:

./info-sistema.sh > rapporto-sistema.txt

Il simbolo > reindirizza l’output verso il file indicato. Se il file non esiste, viene creato; se esiste già, il contenuto precedente viene sostituito.

Per leggere il rapporto possiamo utilizzare:

cat rapporto-sistema.txt

Se preferiamo conservare i rapporti precedenti e aggiungere nuove informazioni in fondo al file, possiamo usare >> al posto di >:

./info-sistema.sh >> rapporto-sistema.txt

È una distinzione semplice ma importante: > sostituisce il contenuto, mentre >> aggiunge il nuovo output. Quando lavoriamo con file che contengono informazioni importanti, è sempre bene verificare quale comportamento vogliamo ottenere prima di eseguire il comando.

Miglioriamo lo script con un controllo semplice

Un buon script non deve limitarsi a eseguire comandi: può anche verificare se un’operazione è riuscita. Bash mette a disposizione diversi strumenti per farlo, ma non è necessario affrontarli tutti nella prima esperienza.

Possiamo cominciare aggiungendo una riga conclusiva:

echo "Rapporto completato."

Inseriamola alla fine del file, salviamo ed eseguiamo nuovamente lo script. Il messaggio ci conferma che l’esecuzione è arrivata a quel punto.

Naturalmente, questa frase non garantisce da sola che ogni comando precedente abbia funzionato correttamente. Per gestire gli errori in modo più rigoroso dovremo imparare a controllare i codici di uscita dei comandi e a utilizzare strutture condizionali come if.

È meglio introdurre questi concetti gradualmente. Per ora abbiamo costruito uno script leggibile, facile da modificare e privo di operazioni distruttive.

Le buone abitudini da adottare fin dall’inizio

Anche un programma breve merita un minimo di attenzione. È buona norma scegliere nomi che descrivano lo scopo del file, mantenere il codice leggibile e aggiungere commenti quando un passaggio potrebbe non essere immediato.

In Bash i commenti iniziano con #, fatta eccezione per la shebang iniziale, che ha una funzione specifica. Possiamo quindi documentare una parte dello script così:

echo "Rapporto completato."# Mostra il nome del computer
echo "Computer: $(hostname)"

Un’altra abitudine importante è provare gli script con un utente normale e concedere privilegi amministrativi soltanto quando sono davvero necessari. Il nostro rapporto usa comandi di sola lettura e non richiede sudo: eseguirlo con privilegi elevati non offrirebbe alcun vantaggio.

Prima di automatizzare attività più delicate, come cancellare file o modificare configurazioni di sistema, conviene verificare ogni comando separatamente e prevedere controlli adeguati. L’automazione riduce il lavoro ripetitivo, ma un errore inserito in uno script può essere ripetuto ogni volta che lo eseguiamo.

Dal primo script alle automazioni di Linux

Abbiamo trasformato alcuni comandi del terminale in un piccolo programma capace di raccogliere informazioni e salvarle in un rapporto. Il principio è semplice: una volta verificato che una sequenza di comandi funziona, possiamo organizzarla in uno script e riutilizzarla quando serve.

Da qui possiamo proseguire in molte direzioni. Possiamo imparare a utilizzare variabili per personalizzare i percorsi, condizioni per reagire agli errori, cicli per elaborare più file e argomenti per passare opzioni allo script quando lo avviamo.

Più avanti potremo applicare queste tecniche alla gestione dei file, all’analisi dei log e alla manutenzione di un homelab. Per il momento, il risultato più importante è aver compreso il passaggio dal comando eseguito manualmente a una procedura ripetibile.

È così che comincia l’automazione: un problema concreto, pochi comandi ben compresi e uno script alla volta.