Vai al contenuto
GLGiuseppe Lanza Scrivimi

Uno script per analizzare i log di Ubuntu in un colpo d’occhio

Come leggere i log di Ubuntu 24.04 con journalctl e uno script pronto che in pochi secondi riassume errori, servizi falliti, memoria, dischi, accessi SSH e sudo, aggiornamenti, con un rapporto giornaliero automatico.

Sistemi: Ubuntu 24.04 LTS · systemd-journald · BashLivello: BaseTempo: 30 minutiAggiornata: novembre 2026

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.

CHI SCRIVE Kernel Servizi systemd SSH e sudo apt, cron, altri Journal systemd-journald analizza-log journalctl + Bash A schermo quando serve Ogni mattina timer systemd Migliaia di righe in ingresso, una pagina di rapporto in uscita
Tutti i componenti del sistema scrivono nel journal; lo script lo interroga e restituisce un rapporto breve, a schermo o in un file giornaliero.

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.

DoveChe cosa contiene
journal, letto con journalctlTutto: kernel, servizi, accessi, con data, priorità e nome del programma
/var/log/syslogCopia testuale dei messaggi generali
/var/log/auth.logAccessi, SSH, sudo
/var/log/kern.logMessaggi del kernel
/var/log/apt/history.logPacchetti 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.

Leggere il journal senza sudo

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.

NumeroNomeSignificato
0emergIl sistema è inutilizzabile
1alertServe un intervento immediato
2critCondizione critica
3errErrore
4warningAvviso
5noticeNormale ma significativo
6infoInformativo
7debugDettagli per lo sviluppo
-k guarda solo l’avvio corrente

journalctl -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:

  1. Sistema: versione, da quanto è acceso, carico, riavvii nel periodo, riavvio richiesto dagli aggiornamenti.
  2. Errori: quanti messaggi con priorità err o superiore, quali programmi li producono, gli ultimi cinque.
  3. Servizi: unità di systemd in stato failed.
  4. 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.
  5. Accessi: tentativi SSH falliti e da quali indirizzi, accessi SSH riusciti, comandi eseguiti con sudo, password sudo sbagliate, utenti creati.
  6. Aggiornamenti: ultima operazione apt e aggiornamenti in attesa, con evidenza di quelli di sicurezza.
  7. 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.

/usr/local/sbin/analizza-log
#!/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() chiama journalctl --since "$DA" --no-pager -q più i filtri richiesti. Tutte le sezioni guardano così lo stesso periodo.
  • Contare senza errori. conta() usa grep -c ., che conta le righe non vuote. Il || true serve perché grep esce con errore quando non trova nulla, e con pipefail questo verrebbe preso per un guasto.
  • I messaggi del kernel su più avvii. Come detto sopra, lo script usa _TRANSPORT=kernel e non -k. I riavvii si contano dal messaggio Linux version, che il kernel scrive a ogni avvio.
  • Cercare senza distinguere maiuscole. Con -g journalctl ignora maiuscole e minuscole se il testo cercato è tutto in minuscolo. Per questo 'out of memory' trova anche Out of memory: Killed process.
  • Gli indirizzi SSH. L’espressione \S+(?= port \d+) prende la parola che precede port: 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.

/etc/systemd/system/analizza-log.service
[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
/etc/systemd/system/analizza-log.timer
[Unit]
Description=Rapporto dei log ogni mattina alle 7

[Timer]
OnCalendar=*-*-* 07:00:00
Persistent=true

[Install]
WantedBy=timers.target
sudo 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
  • %%F nel file del servizio è voluto: systemd usa % per le sue variabili, quindi per passare %F al comando date bisogna raddoppiarlo.
  • SuccessExitStatus=1 evita 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=true fa 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

SintomoCausa e soluzione
Eseguilo con sudoLo script ha bisogno di leggere tutto il journal: avvialo con sudo.
Periodo non validoIl 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 attivoIl 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 tentativiSu 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 problemiAlcuni 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 settimanaSu 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.

Prima di andare in produzione

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.