Automazione Server Bash — Backup, Deploy e Monitoraggio che Funzionano Davvero

Il tuo server è in produzione. I backup li fai a mano quando ti ricordi. Il deploy lo fai con FTP e speri che non si rompa niente. Il monitoraggio? Se arriva una notifica di disco pieno alle 3 di notte, lo scopri la mattina dopo, quando il sito è già down. Questa non è gestione server: è una scommessa. Noi, di Meteora Web, vediamo ogni giorno aziende che perdono dati, clienti e soldi perché l’automazione server con Bash è considerata un lusso. Non lo è. È una linea di difesa che costa zero in licenze e si ripaga al primo guasto. Andiamo dritti al punto: tre script che ti cambiano la giornata.

Perché Automatizzare Backup e Deploy con Bash Invece di Usare Strumenti Grafici?

Ogni volta che apriamo una console su un server nuovo, la prima cosa che controlliamo è se esiste una cron job per i backup. Nella metà dei casi non c’è. Il motivo è semplice: molti pensano che serva un pannello, un plugin a pagamento, un servizio cloud. La verità è che Bash, rsync, tar e cron fanno tutto, gratis, e con controllo totale. Niente canoni, niente dipendenze da terze parti, niente dati in ostaggio.

Noi abbiamo automatizzato decine di server clienti con script che partono da righe di codice che puoi scrivere in dieci minuti. Il ritorno? Se un server crasha, recuperi i dati in pochi passi. Se un deploy rompe tutto, torni indietro con un comando. Se il disco si riempie, lo scopri prima che diventi un problema.

Esempio concreto: un cliente e-commerce aveva immagini da diversi MB. Ottimizzandole con uno script automatizzato abbiamo ridotto il peso del 60% senza perdita di qualità e schedulato il backup incrementale ogni notte. Il costo? Zero. Il risultato? Disco più leggero, restore più veloce.

Come Impostare un Backup Automatizzato con Bash e Cron

Partiamo da uno script base per backup di database e file. Lo salvi in /usr/local/bin/backup.sh, lo rendi eseguibile (chmod +x /usr/local/bin/backup.sh) e lo aggiungi al crontab.

#!/bin/bash
# Backup automatizzato Meteora Web
# Configurazione
BACKUP_DIR="/var/backups/$(date +%Y-%m-%d)"
DB_NAME="miodb"
DB_USER="root"
DB_PASS="password_sicura"
SITE_DIR="/var/www/miosito"

# Crea directory giornaliera
mkdir -p "$BACKUP_DIR"

# Backup database
mysqldump -u $DB_USER -p$DB_PASS $DB_NAME | gzip > "$BACKUP_DIR/db.sql.gz"

# Backup file (escludi cache e log)
tar -czf "$BACKUP_DIR/files.tar.gz" \
    --exclude="$SITE_DIR/wp-content/cache" \
    --exclude="$SITE_DIR/var/log" \
    "$SITE_DIR"

# Elimina backup più vecchi di 7 giorni
find /var/backups/ -type d -mtime +7 -exec rm -rf {} \;

echo "Backup completato: $(date)"

Cosa fa: crea una cartella con la data, esporta il database, comprime i file del sito (escludendo cache e log), cancella i backup più vecchi di 7 giorni. Azioni immediate: sostituisci le variabili con i tuoi dati, testalo con bash backup.sh, poi aggiungi 0 3 * * * /usr/local/bin/backup.sh a crontab (esegue ogni notte alle 3).

Backup Incrementale con rsync per Risparmiare Spazio

Se il sito è grande, un backup completo ogni giorno può riempire il disco. Usa rsync per copiare solo i file modificati. Ecco una variante per backup remoto su un secondo server o su un NAS:

#!/bin/bash
# Backup incrementale rsync
SRC="/var/www/miosito"
DEST="utente@backup-server:/backups/miosito/"

rsync -avz --delete --exclude='wp-content/cache' --exclude='.git' "$SRC/" "$DEST"

# Backup database separato
mysqldump -u root -p$DB_PASS $DB_NAME | gzip | ssh utente@backup-server "cat > /backups/miosito/db_$(date +%Y-%m-%d).sql.gz"

Vantaggio: la prima esecuzione copia tutto, le successive solo le differenze. Con --delete i file cancellati in locale vengono rimossi anche sul backup. Avvertenza: configura chiave SSH senza password per l'accesso automatico.

Come Automatizzare il Deploy con Bash per Evitare il “Funziona in Locale”?

Quante volte hai caricato un file con FTP e ti sei accorto di aver sovrascritto quello giusto? O hai fatto un deploy manuale e dimenticato di aggiornare le dipendenze? Noi usiamo uno script Bash che tira l’ultima versione da git, installa le dipendenze, esegue le migration, cancella la cache, e tiene traccia di ogni revisione. Se qualcosa va storto, un rollback è a un comando.

Script di Deploy con Rollback

#!/bin/bash
# Deploy script Meteora Web
set -e  # Esci se un comando fallisce

APP_DIR="/var/www/miosito"
RELEASE_DIR="$APP_DIR/releases/$(date +%Y%m%d%H%M%S)"
CURRENT_LINK="$APP_DIR/current"
REPO_URL="git@github.com:tuo/miosito.git"
BRANCH="main"

echo "Clonazione repository..."
git clone --depth 1 --branch $BRANCH $REPO_URL $RELEASE_DIR

echo "Installazione dipendenze..."
cd $RELEASE_DIR
composer install --no-dev --optimize-autoloader  # per Laravel/PHP
# npm ci --production  # per frontend

echo "Migrazioni database..."
php artisan migrate --force

echo "Aggiornamento link simbolico..."
ln -sfn $RELEASE_DIR $CURRENT_LINK

echo "Cache application..."
php artisan cache:clear
php artisan config:cache

echo "Deploy completato: $(basename $RELEASE_DIR)"

Come ripristinare: il link current punta all’ultima release. Per tornare indietro: ln -sfn /var/www/miosito/releases/20250301120000 current. Tieni le ultime 5 release e cancella le più vecchie con una cron job.

Deploy su Più Server (Senza Ansible)

Se hai più server, non serve un orchestratore complesso. Usa ssh e parallel per eseguire lo stesso comando su tutti i nodi:

#!/bin/bash
SERVERS=("web1.example.com" "web2.example.com")
for server in "${SERVERS[@]}"; do
    ssh deployer@$server 'bash -s' < /usr/local/bin/deploy.sh &
done
wait
echo "Deploy completato su tutti i server."

Azioni subito: crea un utente dedicato deployer con chiave SSH e permessi limitati. Non usare mai root per il deploy.

Come Monitorare il Server con Bash e Non Farti Svegliare alle 3 di Notte?

Il monitoraggio non è solo grafana e alert costosi. Con pochi script Bash e una riga in cron puoi controllare disco, RAM, CPU, stato dei servizi e certificati SSL. La differenza? Agisci prima che il problema diventi emergenza.

Script di Controllo Disco e Servizi

#!/bin/bash
# Monitoraggio Meteora Web
THRESHOLD=85  # percentuale disco
SERVICE="nginx"

disk_usage=$(df / | tail -1 | awk '{print $5}' | sed 's/%//')
if [ "$disk_usage" -gt "$THRESHOLD" ]; then
    echo "Disco / al $disk_usage% critico" | mail -s "Alert disco" admin@esempio.com
fi

# Controllo servizio
if ! systemctl is-active --quiet $SERVICE; then
    systemctl restart $SERVICE
    echo "$SERVICE riavviato" | mail -s "Alert servizio" admin@esempio.com
fi

# Controllo scadenza SSL (file der)
if [ -f /etc/ssl/certs/miosito.crt ]; then
    expiry=$(openssl x509 -enddate -noout -in /etc/ssl/certs/miosito.crt | cut -d= -f2)
    expiry_sec=$(date -d "$expiry" +%s)
    now_sec=$(date +%s)
    days_left=$(( ($expiry_sec - $now_sec) / 86400 ))
    if [ "$days_left" -lt 14 ]; then
        echo "SSL scade tra $days_left giorni" | mail -s "Alert SSL" admin@esempio.com
    fi
fi

Integrazione: aggiungi questo script a cron con */30 * * * * /usr/local/bin/monitor.sh. Invece di mail, puoi usare curl per inviare notifiche a Telegram, Slack o WhatsApp Business API.

Monitoraggio Log con Bash e grep

#!/bin/bash
# Rileva errori 500 nelle ultime 5 minuti
last_minutes=5
errors=$(journalctl -u nginx --since "$last_minutes min ago" --no-pager | grep -c " 500 ")
if [ "$errors" -gt 10 ]; then
    echo "Oltre $errors errori 500 in $last_minutes minuti" | mail -s "Possibile attacco o bug" admin@esempio.com
fi

Attenzione: imposta soglie ragionevoli per evitare falsi positivi. Noi, di Meteora Web, abbiamo visto troppi alert ignorati perché il server mandava decine di mail al giorno su cose non critiche.

Dove Salvare e Versionare i Tuoi Script?

Non tenere gli script solo sul server. Usa un repository Git privato (GitHub, GitLab, self-hosted). Così puoi tracciare le modifiche, testare in staging, e distribuirli su più macchine con un semplice git pull. Noi inseriamo anche una variabile d’ambiente ENVIRONMENT nello script per differenziare produzione da sviluppo.

Cosa Fare Adesso: Tre Azioni Immediati

1. Crea il tuo primo script di backup: copia quello sopra, personalizza le variabili, eseguilo a mano, poi schedulalo ogni notte con cron. Controlla dopo 24 ore che sia stato creato il file.
2. Imposta un monitoraggio base: prendi lo script di controllo disco, aggiungi una notifica via Telegram (esistono bot gratuiti). Fallo girare ogni 15 minuti.
3. Versiona il deploy: se ancora usi FTP, passa a uno script Bash che tira da git. Anche se sei da solo, il rollback ti salva la giornata.

L’automazione server con Bash non è un accessorio per sysadmin: è una pratica che separa chi subisce i guasti da chi li previene. Noi, di Meteora Web, abbiamo cominciato così oltre otto anni fa, e ancora oggi ogni server che configuriamo parte da uno script di backup e uno di monitoraggio. Il costo è zero. Il valore è tutto.