Perché uno script
Un server Ubuntu scrive ogni giorno migliaia di righe di log. Dentro c’è tutto quello che serve per accorgersi in tempo dei problemi: un disco che dà errori, un servizio che non riparte, la memoria che finisce, qualcuno che prova a entrare. Il guaio è che nessuno ha il tempo di leggerle tutte.
In questa guida vediamo prima i comandi essenziali di journalctl, poi uno script, analizza-log, che in pochi secondi produce un rapporto di una pagina con quello che conta davvero. Alla fine lo facciamo girare da solo ogni mattina, in modo da avere un rapporto pronto per ogni giorno.
Dove sono i log su Ubuntu
Su Ubuntu 24.04 il punto di raccolta è il journal di systemd (systemd-journald): riceve i messaggi del kernel, di tutti i servizi e dei programmi. Sulla versione Server c’è anche rsyslog, che copia gli stessi messaggi nei classici file di testo.
| Dove | Che cosa contiene |
|---|---|
journal, letto con journalctl | Tutto: kernel, servizi, accessi, con data, priorità e nome del programma |
/var/log/syslog | Copia testuale dei messaggi generali |
/var/log/auth.log | Accessi, SSH, sudo |
/var/log/kern.log | Messaggi del kernel |
/var/log/apt/history.log | Pacchetti installati, aggiornati e rimossi |
/var/log/nginx/, /var/log/apache2/ | Log dei server web, che scrivono nei propri file |
I file di testo vengono ruotati ogni settimana e compressi (syslog.2.gz e così via): per cercarci dentro senza decomprimerli si usa zgrep. Il journal invece si interroga con journalctl, che permette di filtrare per periodo, priorità e servizio. Lo script usa il journal; i file restano utili per chi è abituato a grep.
Un utente normale vede solo i propri messaggi. Per leggere tutto serve sudo, oppure appartenere al gruppo adm o systemd-journal: sudo usermod -aG adm $USER, poi esci e rientra.
journalctl in cinque minuti
# gli ultimi 50 messaggi
journalctl -n 50
# seguire i log in tempo reale (come tail -f)
journalctl -f
# solo dall'ultimo avvio, oppure dall'avvio precedente
journalctl -b
journalctl -b -1
# un periodo preciso
journalctl --since "1 hour ago"
journalctl --since "2026-11-15 08:00" --until "2026-11-15 12:00"
# un servizio
journalctl -u ssh
journalctl -u nginx --since today
# solo gli errori (e le priorità più gravi)
journalctl -p err --since today
# i messaggi del kernel dell'avvio corrente
journalctl -k
# cercare un testo (minuscole = senza distinzione di maiuscole)
journalctl --since today -g "error|fail"
# solo il testo, senza data e nome del programma
journalctl -u ssh -o cat
Le priorità sono quelle classiche di syslog. Con -p si indica la soglia: -p err mostra gli errori e tutto quello che è più grave.
| Numero | Nome | Significato |
|---|---|---|
| 0 | emerg | Il sistema è inutilizzabile |
| 1 | alert | Serve un intervento immediato |
| 2 | crit | Condizione critica |
| 3 | err | Errore |
| 4 | warning | Avviso |
| 5 | notice | Normale ma significativo |
| 6 | info | Informativo |
| 7 | debug | Dettagli per lo sviluppo |
-k guarda solo l’avvio correntejournalctl -k equivale a “messaggi del kernel di questo avvio”. Se vuoi i messaggi del kernel di un periodo che comprende dei riavvii, usa il filtro _TRANSPORT=kernel: journalctl _TRANSPORT=kernel --since "7 days ago". Lo script fa così.
Quanto spazio occupa il journal
journalctl --disk-usage
sudo journalctl --vacuum-time=30d # cancella i messaggi più vecchi di 30 giorni
sudo journalctl --vacuum-size=1G # oppure tiene al massimo 1 GB
Per fissare un limite permanente, imposta SystemMaxUse=1G in un file come /etc/systemd/journald.conf.d/limite.conf (sotto una riga [Journal]) e riavvia il servizio con sudo systemctl restart systemd-journald.
Lo script analizza-log
Lo script controlla, nel periodo che scegli, sette aree:
- Sistema: versione, da quanto è acceso, carico, riavvii nel periodo, riavvio richiesto dagli aggiornamenti.
- Errori: quanti messaggi con priorità
erro superiore, quali programmi li producono, gli ultimi cinque. - Servizi: unità di systemd in stato failed.
- Memoria, dischi e kernel: processi chiusi per mancanza di memoria, errori di disco e di file system, crash dei programmi, spazio libero, spazio occupato dal journal.
- Accessi: tentativi SSH falliti e da quali indirizzi, accessi SSH riusciti, comandi eseguiti con sudo, password sudo sbagliate, utenti creati.
- Aggiornamenti: ultima operazione apt e aggiornamenti in attesa, con evidenza di quelli di sicurezza.
- Chi scrive di più: i programmi più “rumorosi”, utile per scoprire un servizio che va in errore in continuazione.
Ogni riga è marcata con ok (tutto bene), ! (da guardare) o !! (problema). In fondo c’è uno stato riassuntivo.
#!/bin/bash
# analizza-log: rapporto rapido sui log di un server Ubuntu.
# Uso: sudo analizza-log [-d PERIODO] [-o FILE]
# -d da quando analizzare, nel formato di journalctl (predefinito: "24 hours ago")
# esempi: "1 hour ago", "today", "yesterday", "2026-11-01"
# -o scrive il rapporto in un file invece che a schermo
set -uo pipefail
DA="24 hours ago"
USCITA=""
while getopts "d:o:h" opt; do
case $opt in
d) DA=$OPTARG ;;
o) USCITA=$OPTARG ;;
*) sed -n '2,6p' "$0"; exit 0 ;;
esac
done
[[ $EUID -eq 0 ]] || { echo "Eseguilo con sudo: alcuni log sono leggibili solo da root." >&2; exit 2; }
journalctl --since "$DA" -n 0 -q &> /dev/null || { echo "Periodo non valido: $DA" >&2; exit 2; }
[[ -n $USCITA ]] && exec > "$USCITA"
if [[ -t 1 ]]; then
ROSSO=$'\e[1;31m'; GIALLO=$'\e[1;33m'; VERDE=$'\e[1;32m'; GRASS=$'\e[1m'; NORM=$'\e[0m'
else
ROSSO=""; GIALLO=""; VERDE=""; GRASS=""; NORM=""
fi
PROBLEMI=0
titolo() { printf '\n%s== %s ==%s\n' "$GRASS" "$1" "$NORM"; }
problema() { printf '%s!! %s%s\n' "$ROSSO" "$1" "$NORM"; PROBLEMI=$((PROBLEMI + 1)); }
attenzione() { printf '%s! %s%s\n' "$GIALLO" "$1" "$NORM"; }
ok() { printf '%sok %s%s\n' "$VERDE" "$1" "$NORM"; }
conta() { grep -c . || true; } # righe non vuote, 0 se non ce ne sono
j() { journalctl --since "$DA" --no-pager -q "$@"; }
programma() { awk '{print $3}' | sed -E 's/\[[0-9]+\]//; s/:$//'; } # da output short-iso
printf '%sRapporto log di %s%s\nPeriodo: da "%s" · generato il %s\n' \
"$GRASS" "$(hostname)" "$NORM" "$DA" "$(date '+%d/%m/%Y %H:%M')"
# --- 1. Sistema --------------------------------------------------------------------------
titolo "Sistema"
. /etc/os-release
echo "Sistema: $PRETTY_NAME, kernel $(uname -r)"
echo "Acceso: $(uptime -p | sed 's/^up //')"
echo "Carico: $(cut -d' ' -f1-3 /proc/loadavg) (processori: $(nproc))"
avvii=$(j _TRANSPORT=kernel -g '^Linux version' -o cat | conta)
if (( avvii > 0 )); then attenzione "Avvii del sistema nel periodo: $avvii"; else ok "Nessun riavvio nel periodo"; fi
if [[ -f /run/reboot-required ]]; then attenzione "Gli aggiornamenti chiedono un riavvio"; else ok "Nessun riavvio in sospeso"; fi
# --- 2. Errori ---------------------------------------------------------------------------
titolo "Errori (priorità err e superiori)"
n=$(j -p err -o cat | conta)
if (( n > 0 )); then
problema "$n messaggi di errore"
echo "Programmi che ne hanno prodotti di più:"
j -p err -o short-iso | programma | sort | uniq -c | sort -rn | head -8
echo "Ultimi 5:"
j -p err -o short-iso -n 5 | cut -c1-170
else
ok "Nessun messaggio di errore"
fi
# --- 3. Servizi --------------------------------------------------------------------------
titolo "Servizi"
falliti=$(systemctl list-units --state=failed --no-legend --plain | awk '{print $1}')
if [[ -n $falliti ]]; then
problema "Servizi in errore: $(echo $falliti)"
echo " Per i dettagli: systemctl status <nome> · journalctl -u <nome> -n 50"
else
ok "Nessun servizio in errore"
fi
# --- 4. Memoria, dischi, kernel ----------------------------------------------------------
titolo "Memoria, dischi e kernel"
oom=$(j _TRANSPORT=kernel -g 'out of memory' -o cat | conta)
oomd=$(j -u systemd-oomd -g 'killed' -o cat | conta)
if (( oom + oomd > 0 )); then problema "Processi chiusi per mancanza di memoria: $((oom + oomd))"; else ok "Nessun problema di memoria"; fi
io=$(j _TRANSPORT=kernel -g 'i/o error|ext4-fs error|btrfs error|xfs .*error|medium error' -o cat | conta)
if (( io > 0 )); then
problema "Errori di disco o di file system: $io"
j _TRANSPORT=kernel -g 'i/o error|ext4-fs error|btrfs error|xfs .*error|medium error' -o short-iso -n 3 | cut -c1-170
else
ok "Nessun errore di disco"
fi
seg=$(j _TRANSPORT=kernel -g 'segfault at' -o cat | conta)
if (( seg > 0 )); then attenzione "Programmi andati in crash (segfault): $seg"; fi
FS=(-x tmpfs -x devtmpfs -x squashfs -x overlay -x efivarfs)
df -hP "${FS[@]}" | awk 'NR>1 {printf " %-24s %5s usato di %s\n", $6, $5, $2}'
pieni=$(df -P "${FS[@]}" | awk 'NR>1 && $5+0 >= 90 {print $6}')
if [[ -n $pieni ]]; then problema "Dischi oltre il 90%: $(echo $pieni)"; else ok "Spazio su disco sufficiente"; fi
echo " Spazio occupato dal journal: $(journalctl --disk-usage | grep -oE '[0-9.]+[KMGT]?B?' | head -1)"
# --- 5. Accessi ---------------------------------------------------------------------------
titolo "Accessi"
ssh=$(j -u ssh -o cat)
ip_falliti=$(grep -E 'Failed password|Invalid user|invalid user|authenticating user' <<< "$ssh" \
| grep -oP '\S+(?= port \d+)')
nf=$(conta <<< "$ip_falliti")
if (( nf > 0 )); then
attenzione "SSH: $nf tentativi falliti da $(sort -u <<< "$ip_falliti" | conta) indirizzi diversi"
echo " I più insistenti:"
sort <<< "$ip_falliti" | uniq -c | sort -rn | head -5
else
ok "SSH: nessun tentativo fallito"
fi
riusciti=$(grep -oP 'Accepted \S+ for \S+ from \S+' <<< "$ssh")
if [[ -n $riusciti ]]; then
echo " Accessi SSH riusciti (controlla di riconoscerli tutti):"
sort <<< "$riusciti" | uniq -c
else
echo " Nessun accesso SSH riuscito"
fi
sudo_log=$(j _COMM=sudo -o cat)
comandi=$(grep 'COMMAND=' <<< "$sudo_log" | grep -v 'incorrect password' | sed -E 's/^ *([^ ]+) : .*COMMAND=(.*)/\1: \2/')
echo " Comandi eseguiti con sudo: $(conta <<< "$comandi")"
tail -n 5 <<< "$comandi" | sed 's/^/ /' | cut -c1-160
sbagliate=$(grep -c 'incorrect password' <<< "$sudo_log" || true)
if (( sbagliate > 0 )); then attenzione "sudo: tentativi con password sbagliata: $sbagliate"; fi
nuovi=$(j -g 'new user:|new group:' -o cat)
if [[ -n $nuovi ]]; then attenzione "Utenti o gruppi creati nel periodo:"; sed 's/^/ /' <<< "$nuovi"; fi
# --- 6. Aggiornamenti ----------------------------------------------------------------------
titolo "Aggiornamenti"
if [[ -r /var/log/apt/history.log ]]; then
ultimo=$(grep '^End-Date' /var/log/apt/history.log | tail -1 | cut -d' ' -f2-)
echo " Ultima operazione apt: ${ultimo:-nessuna nel log corrente}"
fi
lista=$(apt list --upgradable 2> /dev/null | grep 'upgradable from')
da_agg=$(conta <<< "$lista")
sicurezza=$(grep -c -- '-security' <<< "$lista" || true)
if (( sicurezza > 0 )); then
problema "Aggiornamenti di sicurezza da installare: $sicurezza (su $da_agg totali)"
elif (( da_agg > 0 )); then
attenzione "Aggiornamenti disponibili: $da_agg"
else
ok "Sistema aggiornato"
fi
# --- 7. Chi scrive di più ------------------------------------------------------------------
titolo "Chi scrive di più nel log"
j -o short-iso | programma | sort | uniq -c | sort -rn | head -5
# --- Riepilogo ------------------------------------------------------------------------------
titolo "Riepilogo"
if (( PROBLEMI == 0 )); then
printf '%sSTATO: OK, nessun problema rilevato%s\n' "$VERDE" "$NORM"
else
printf '%sSTATO: %d problemi da controllare (righe con !!)%s\n' "$ROSSO" "$PROBLEMI" "$NORM"
fi
exit $(( PROBLEMI > 0 ? 1 : 0 ))Installazione
sudo nano /usr/local/sbin/analizza-log # incolla lo script e salva
sudo chmod 755 /usr/local/sbin/analizza-log
Non servono pacchetti aggiuntivi: lo script usa solo strumenti già presenti in Ubuntu (journalctl, systemctl, grep, awk, sed, df, apt).
Come si usa
sudo analizza-log # ultime 24 ore
sudo analizza-log -d "1 hour ago" # ultima ora
sudo analizza-log -d today # da mezzanotte
sudo analizza-log -d "7 days ago" # ultima settimana
sudo analizza-log -d "2026-11-01" # da una data precisa
sudo analizza-log -o /root/rapporto.txt # nel file, senza colori
Un esempio di rapporto, su un server con qualche problema:
Rapporto log di server
Periodo: da "24 hours ago" · generato il 16/11/2026 07:00
== Sistema ==
Sistema: Ubuntu 24.04.1 LTS, kernel 6.8.0-48-generic
Acceso: 3 days, 4 hours
Carico: 0.42 0.37 0.30 (processori: 4)
ok Nessun riavvio nel periodo
ok Nessun riavvio in sospeso
== Errori (priorità err e superiori) ==
!! 5 messaggi di errore
Programmi che ne hanno prodotti di più:
2 nginx
2 kernel
1 systemd
Ultimi 5:
2026-11-16T03:10:00+0100 server kernel: Out of memory: Killed process 1234 (java) ...
...
== Servizi ==
!! Servizi in errore: backup.service
Per i dettagli: systemctl status <nome> · journalctl -u <nome> -n 50
== Memoria, dischi e kernel ==
!! Processi chiusi per mancanza di memoria: 1
!! Errori di disco o di file system: 1
2026-11-16T03:11:00+0100 server kernel: blk_update_request: I/O error, dev sda, sector 123
/ 93% usato di 40G
/dati 20% usato di 500G
!! Dischi oltre il 90%: /
Spazio occupato dal journal: 1.2G
== Accessi ==
! SSH: 3 tentativi falliti da 2 indirizzi diversi
I più insistenti:
2 203.0.113.45
1 198.51.100.7
Accessi SSH riusciti (controlla di riconoscerli tutti):
1 Accepted publickey for pino from 192.0.2.10
Comandi eseguiti con sudo: 1
pino: /usr/bin/apt update
== Aggiornamenti ==
Ultima operazione apt: 2026-11-15 06:01:10
!! Aggiornamenti di sicurezza da installare: 1 (su 2 totali)
== Chi scrive di più nel log ==
4 sshd
4 kernel
2 nginx
== Riepilogo ==
STATO: 6 problemi da controllare (righe con !!)
Da questo rapporto si capisce in pochi secondi che cosa fare: il disco sda dà errori (va controllato con smartctl prima che si guasti), la partizione / è quasi piena, un processo Java ha esaurito la memoria, il servizio di backup non è partito e c’è un aggiornamento di sicurezza da installare.
Il codice di uscita
Lo script termina con 0 se non ha trovato problemi, 1 se ce n’è almeno uno (righe !!), 2 se non può partire (manca sudo o il periodo non è valido). Così si può usare anche in altri script o da un sistema di monitoraggio:
sudo analizza-log -d "1 hour ago" -o /tmp/ultima-ora.txt || echo "Ci sono problemi da controllare"
Come funziona, parte per parte
Lo script è scritto per essere letto e modificato. Ecco i punti chiave.
- Una funzione per interrogare il journal.
j()chiamajournalctl --since "$DA" --no-pager -qpiù i filtri richiesti. Tutte le sezioni guardano così lo stesso periodo. - Contare senza errori.
conta()usagrep -c ., che conta le righe non vuote. Il|| trueserve perchégrepesce con errore quando non trova nulla, e conpipefailquesto verrebbe preso per un guasto. - I messaggi del kernel su più avvii. Come detto sopra, lo script usa
_TRANSPORT=kernele non-k. I riavvii si contano dal messaggioLinux version, che il kernel scrive a ogni avvio. - Cercare senza distinguere maiuscole. Con
-gjournalctl ignora maiuscole e minuscole se il testo cercato è tutto in minuscolo. Per questo'out of memory'trova ancheOut of memory: Killed process. - Gli indirizzi SSH. L’espressione
\S+(?= port \d+)prende la parola che precedeport: funziona con tutti i formati di messaggio di sshd, compresi quelli dei server che accettano solo le chiavi. - Colori solo a schermo.
[[ -t 1 ]]verifica se l’uscita è un terminale. Nei file e nelle email il rapporto esce senza codici di colore.
Aggiungere un controllo
Ogni sezione segue lo stesso schema: si conta qualcosa e si decide se è ok, attenzione o problema. Per esempio, per controllare gli errori di nginx basta aggiungere prima del riepilogo:
titolo "Server web"
e_web=$(grep -c "$(date +%Y/%m/%d)" /var/log/nginx/error.log 2>/dev/null || true)
if (( e_web > 50 )); then problema "nginx: $e_web errori oggi"; else ok "nginx: $e_web errori oggi"; fi
Il rapporto ogni mattina, da solo
Con un timer di systemd lo script gira ogni giorno alle 7 e salva il rapporto in /var/log/analisi-log/, uno per giorno, conservando gli ultimi 30.
[Unit]
Description=Rapporto giornaliero dei log
[Service]
Type=oneshot
# l'uscita 1 vuol dire "ci sono problemi", non che lo script sia fallito
SuccessExitStatus=1
ExecStartPre=/usr/bin/mkdir -p /var/log/analisi-log
ExecStart=/bin/sh -c '/usr/local/sbin/analizza-log -d "24 hours ago" -o /var/log/analisi-log/rapporto-$(date +%%F).txt'
ExecStartPost=/usr/bin/find /var/log/analisi-log -name 'rapporto-*.txt' -mtime +30 -delete[Unit]
Description=Rapporto dei log ogni mattina alle 7
[Timer]
OnCalendar=*-*-* 07:00:00
Persistent=true
[Install]
WantedBy=timers.targetsudo systemctl daemon-reload
sudo systemctl enable --now analizza-log.timer
systemctl list-timers analizza-log.timer
# prova subito, senza aspettare domattina
sudo systemctl start analizza-log.service
ls /var/log/analisi-log/
cat /var/log/analisi-log/rapporto-$(date +%F).txt
%%Fnel file del servizio è voluto: systemd usa%per le sue variabili, quindi per passare%Fal comandodatebisogna raddoppiarlo.SuccessExitStatus=1evita che il servizio risulti “fallito” nei giorni in cui il rapporto trova problemi. Altrimenti, il giorno dopo, lo script segnalerebbe come problema… sé stesso.Persistent=truefa partire il rapporto all’accensione se alle 7 il server era spento.
Riceverlo per email
Se sul server è già configurato l’invio della posta (per esempio postfix come relay verso il server di posta aziendale, con il pacchetto mailutils), aggiungi al servizio una riga che manda il rapporto:
ExecStartPost=/bin/sh -c 'mail -s "Log $(hostname) $(date +%%F)" admin@esempio.it < /var/log/analisi-log/rapporto-$(date +%%F).txt'
Configurare l’invio della posta da un server è un argomento a sé: se il server non ha ancora un relay, conviene leggere i rapporti dalla cartella, o raccoglierli con un sistema di monitoraggio.
Problemi comuni
| Sintomo | Causa e soluzione |
|---|---|
Eseguilo con sudo | Lo script ha bisogno di leggere tutto il journal: avvialo con sudo. |
Periodo non valido | Il valore di -d non è nel formato di journalctl. Usa per esempio "2 hours ago", today, yesterday o una data AAAA-MM-GG. |
| Le sezioni sono quasi vuote anche su un server attivo | Il journal potrebbe essere solo in memoria e perdersi a ogni riavvio. Controlla che esista /var/log/journal; se manca, crealo con sudo mkdir -p /var/log/journal e riavvia systemd-journald. |
| SSH risulta sempre senza tentativi | Su Ubuntu il servizio si chiama ssh. Se usi un’altra distribuzione o un server SSH diverso, cambia -u ssh in -u sshd. |
| Troppi “errori” che non sono veri problemi | Alcuni programmi registrano come errore cose normali. Individuali nella sezione “Errori” e, se sono innocui, escludili aggiungendo | grep -v nome-programma al conteggio. |
| Lo script è lento sulla settimana | Su server molto attivi un journal di giorni contiene milioni di righe. Per l’uso quotidiano bastano le 24 ore; per l’ultima settimana pazienta qualche secondo in più. |
Il passo successivo
Il rapporto ti dice che qualcosa non va; per approfondire servono gli strumenti specifici. Per gli accessi sospetti e il blocco automatico degli attaccanti vedi Rilevare le violazioni su Ubuntu e bloccare gli IP per 120 minuti; per capire chi è collegato e che traffico genera, Analizzare connessioni, porte e ban su un server Linux; per gli accessi SSH, SSH sicuro su Linux.
Prova sempre la configurazione in laboratorio, salva quella attuale prima di modificarla e tieni un accesso di emergenza (console o accesso fuori banda) quando lavori su firewall e VPN da remoto.