Un servizio smette di rispondere, un avvio richiede più tempo del solito, un’applicazione fallisce senza spiegazioni visibili: spesso la prima traccia utile è nei log. Ma per trovarla bisogna rispondere a tre domande: dove vengono registrati gli eventi, quali messaggi riguardano il problema e per quanto tempo restano disponibili?
La rotazione dei log risponde soprattutto all’ultima domanda. Consente di continuare a registrare nuovi eventi senza lasciare crescere indefinitamente un unico archivio. Non è però sinonimo di cancellazione: prima si separa il contenuto corrente da quello storico, poi si applicano le regole di conservazione.
Questa lezione usa journalctl sui sistemi con systemd e tail nella versione GNU per i log testuali. I comandi di lettura non modificano i registri; le operazioni di pulizia sono invece indicate esplicitamente. I risultati descritti sono quelli attesi, non output raccolti su una macchina di prova.
Due sistemi di registrazione che possono convivere
In Linux non esiste un unico meccanismo che ruota tutti i log. È utile distinguere due casi.
- File di testo: un’applicazione o un demone di logging scrive messaggi in un file. L’utilità
logrotatepuò gestirne automaticamente rotazione, compressione e rimozione secondo una politica temporale o di dimensione. - Journal di systemd:
systemd-journaldconserva eventi strutturati, cioè messaggi accompagnati da campi come priorità, unità e identificativo dell’avvio. Gestisce direttamente i propri file e i relativi limiti di conservazione.
I due sistemi possono convivere: un demone syslog può ricevere eventi da journald o leggerne il journal. Non bisogna quindi presumere che un messaggio presente in un file testuale sia assente dal journal, né che ogni macchina produca gli stessi file.
Regola pratica: per il journal usa journalctl; per un log testuale usa strumenti di lettura dei file. Non trattare i file del journal come normali documenti di testo e non applicare loro una politica di rotazione pensata per i log applicativi.
Dove cercare: conta il tipo di problema, non soltanto il nome del file
/var/log è il punto di partenza abituale per orientarsi tra i registri, ma il contenuto effettivo dipende dalla distribuzione, dai pacchetti installati e dalla configurazione. Per il journal, le posizioni da conoscere sono precise:
/var/log/journal/: gerarchia usata per la conservazione persistente del journal./run/log/journal/: gerarchia usata per la conservazione volatile, in memoria; non è uno storico persistente tra i riavvii./etc/systemd/journald.confe/etc/systemd/journald.conf.d/: contengono configurazione, non eventi da leggere.
Con Storage=persistent, journald preferisce la conservazione su disco, ripiegando su quella volatile durante le prime fasi dell’avvio o quando il disco non è scrivibile. Con Storage=volatile usa soltanto la gerarchia sotto /run/log/journal/. Con Storage=auto, la presenza della directory /var/log/journal/ determina quale delle due modalità utilizzare. Non dare per scontato il valore predefinito del tuo sistema.
Per decidere quali registri controllare, parti invece da questa mappa:
- Problemi all’avvio: journal dell’avvio interessato, non soltanto quello corrente.
- Dischi, dispositivi e driver: messaggi del kernel.
- Servizio che non parte: eventi della specifica unità systemd e, se previsti dall’applicazione, i suoi file di log.
- Accessi e autenticazione: registri del servizio coinvolto e destinazioni configurate per gli eventi di sicurezza.
- Errori applicativi: log dell’applicazione, distinguendo gli eventi di errore dai semplici registri delle richieste o delle operazioni riuscite.
Non c’è dunque un elenco di file obbligatori presente su ogni Linux. Per i log applicativi, individua il percorso nella configurazione del servizio: un nome intuitivo non garantisce che quel file esista o che sia la destinazione effettivamente utilizzata.
Leggere il journal con e senza paginazione
Per aprire il journal accessibile al tuo utente:
journalctl
Senza filtri, la lettura parte dagli eventi più vecchi disponibili. In un terminale, normalmente l’output viene passato a un pager, un programma che permette di esplorare il testo una schermata alla volta, generalmente less. Le impostazioni dell’ambiente possono cambiare questo comportamento. Le righe molto lunghe possono essere tagliate alla larghezza dello schermo: nel pager predefinito puoi esplorarne la parte nascosta con le frecce orizzontali.
Per una lettura non paginata, limita prima la quantità di dati:
journalctl -n 100 --no-pager
Il risultato atteso sono gli ultimi cento eventi accessibili, o meno se non ce ne sono abbastanza. --no-pager evita l’apertura del lettore interattivo: è utile per un controllo rapido o per elaborazioni successive. Non rende però piccolo un risultato enorme; il limite è dato da -n 100.
Per vedere arrivare nuovi messaggi:
journalctl -f
Il comando mostra gli eventi recenti e continua a stampare quelli nuovi finché non lo interrompi con Ctrl+C. Questa è una lettura continua, diversa sia dalla consultazione paginata sia dalla stampa di un insieme finito di eventi.
La visibilità dipende dai permessi. Se il journal di sistema non è accessibile al tuo account, richiedi l’accesso secondo le regole amministrative della macchina: una vista incompleta non significa che il sistema non abbia registrato nulla.
Trovare errori e avvisi senza perdere il contesto
Nel journal la priorità è un campo strutturato. I livelli vanno da emerg, valore 0 e gravità massima, a debug, valore 7. Nel mezzo trovi alert, crit, err, warning, notice e info.
Per controllare avvisi ed eventi più gravi dell’avvio corrente:
journalctl -b -p warning
-p warning non significa “soltanto avvisi”: include anche errori, eventi critici, allarmi ed emergenze. Per restringere agli errori e ai livelli più gravi:
journalctl -b -p err
Se vuoi esclusivamente il livello di avviso, puoi specificare un intervallo con estremi uguali:
journalctl -b -p warning..warning
La priorità è un buon primo filtro, non una diagnosi. Il testo di un messaggio e il livello assegnato dal programma non sono la stessa cosa: cercare la parola “error” non equivale a filtrare la priorità err.
Quando conosci il servizio coinvolto, combina unità, periodo e priorità. Nell’esempio, nome-servizio.service va sostituito con l’unità reale:
journalctl -u nome-servizio.service --since today -p warning --no-pager
Ottieni gli eventi di oggi relativi all’unità, limitati agli avvisi e ai livelli più gravi. Se compare un errore interessante, ripeti la lettura senza il filtro di priorità e restringi l’intervallo temporale:
journalctl -u nome-servizio.service --since "2026-10-24 14:00:00" --until "2026-10-24 14:10:00"
Le date sono dimostrative: sostituiscile con quelle dell’incidente. Questa seconda lettura serve a ricostruire la sequenza: un messaggio informativo può spiegare quale configurazione è stata caricata o quale operazione precede il guasto.
Per i messaggi del kernel:
journalctl -k -p warning
-k seleziona il kernel e, se non specifichi diversamente, implica l’avvio corrente. È un punto di osservazione utile quando il problema riguarda dispositivi o componenti gestiti dal kernel.
Il problema è avvenuto prima del riavvio?
Limitarsi all’avvio corrente può nascondere proprio gli eventi cercati. Elenca prima gli avvii ancora presenti nello storico:
journalctl --list-boots
Il risultato atteso è una tabella con identificativi e intervalli temporali degli avvii disponibili. Per consultare quello precedente:
journalctl -b -1 -p warning
Funziona soltanto se quei dati sono ancora conservati e accessibili. Una configurazione volatile o una politica di rimozione già intervenuta possono rendere indisponibile lo storico. La rotazione non recupera informazioni che non sono state conservate.
Leggere i file testuali e seguirli durante la rotazione
Una volta individuato un vero file di log testuale, puoi leggerne la parte finale senza paginazione. Nei comandi seguenti sostituisci il percorso dimostrativo:
tail -n 100 /percorso/del/file.log
Il risultato atteso sono le ultime cento righe del file. È una vista rapida, ma riguarda soltanto quel file: non comprende automaticamente eventuali archivi precedenti.
Per osservare il log mentre riproduci un problema:
tail -n 100 -F /percorso/del/file.log
In GNU tail, -F equivale a seguire il nome del file e riprovare ad aprirlo quando diventa temporaneamente indisponibile. Questa distinzione conta durante la rotazione: il file associato a quel nome può essere sostituito.
Il comune tail -f, invece, segue per impostazione predefinita il descrittore del file già aperto. Se quel file viene rinominato, può continuare a osservare il vecchio oggetto anziché il nuovo log attivo. Per seguire un percorso soggetto a rotazione, -F è quindi generalmente la scelta più adatta. Interrompi la lettura continua con Ctrl+C.
Che cosa succede quando i log ruotano
Immagina un registro come un quaderno: a un certo punto quello corrente viene chiuso e la scrittura continua in un altro. Il quaderno precedente resta consultabile finché la politica di conservazione non ne prevede la rimozione. La compressione, quando prevista, serve a ridurre lo spazio occupato dallo storico.
Per i file testuali, logrotate permette di impostare politiche basate sul tempo o sulla dimensione. Frequenza, quantità di storico e compressione non sono proprietà automatiche di qualsiasi file con estensione .log: dipendono dalle regole applicate a quel registro. Inoltre, il criterio scelto non dimostra da solo quando il controllo verrà eseguito: va considerata anche la modalità con cui il sistema avvia logrotate.
Per il journal, invece, journald gestisce direttamente il passaggio dai file attivi a quelli archiviati. journalctl presenta insieme gli eventi dei file attivi e ruotati accessibili: normalmente non devi aprire a mano ogni archivio per ricostruire la sequenza.

La distinzione importante è tra rotazione, che chiude un file attivo e ne apre uno nuovo, e conservazione, che stabilisce quali archivi mantenere. Ridurre lo storico libera spazio, ma riduce anche la possibilità di investigare problemi passati. Non è un backup.
Controllare lo spazio e capire i limiti del journal
Per conoscere l’occupazione complessiva dei file del journal:
journalctl --disk-usage
Il conteggio comprende file attivi e archiviati. Nella configurazione di journald, alcune impostazioni rispondono a esigenze diverse:
SystemMaxUse=: limita lo spazio utilizzabile dal journal persistente.SystemKeepFree=: indica lo spazio da lasciare libero per altri usi.SystemMaxFileSize=: limita la dimensione dei singoli file e influenza la granularità della rotazione.MaxFileSec=: limita il periodo coperto da un singolo file prima della rotazione.MaxRetentionSec=: imposta un criterio temporale di rimozione dello storico.
Per la conservazione volatile esistono i corrispondenti limiti con prefisso Runtime, come RuntimeMaxUse=. Le opzioni appartengono alla sezione [Journal]; per le personalizzazioni locali sono preferibili i frammenti di configurazione sotto /etc/systemd/journald.conf.d/.
Questi limiti non garantiscono di conservare un numero minimo di giorni: se i log aumentano e si raggiunge prima il limite di spazio, lo storico disponibile può accorciarsi. Inoltre, journald rimuove gli archivi, non i file ancora attivi; l’occupazione osservata non va interpretata come un valore che debba coincidere esattamente con il limite configurato.
Rotazione manuale e pulizia: operazioni diverse
La rotazione manuale del journal richiede privilegi amministrativi:
journalctl --rotate
I file attivi vengono marcati come archiviati e rinominati; nuovi file prendono il loro posto. Questo comando non è, da solo, una richiesta di cancellare lo storico.
Se hai già valutato quali informazioni conservare, puoi rimuovere gli archivi più vecchi di un intervallo:
journalctl --vacuum-time=14days
Attenzione: è una cancellazione reale. Il comando opera sui file archiviati e non rappresenta un ritaglio preciso di ogni singolo evento al confine dei quattordici giorni. Non eseguirlo durante un’indagine senza prima preservare i dati necessari.
Un’alternativa è un obiettivo di spazio per gli archivi:
journalctl --vacuum-size=500M
Anche questa operazione elimina storico. Poiché --disk-usage include pure i file attivi, dopo la pulizia il totale può restare superiore a 500 M. Non significa automaticamente che il comando abbia fallito.
Un metodo ripetibile per controllare gli avvisi
- Definisci il periodo: avvio corrente, avvio precedente o intervallo dell’incidente.
- Individua il componente: kernel, unità systemd o file applicativo.
- Parti dagli avvisi: usa
-p warningnel journal per ridurre il rumore iniziale. - Recupera il contesto: rimuovi il filtro di priorità attorno all’evento interessante.
- Osserva la ricorrenza: se puoi riprodurre il problema in sicurezza, segui il journal con
-fo il file con GNUtail -F. - Rimanda la pulizia: prima raccogli le informazioni, poi valuta la conservazione.
L’assenza di risultati non dimostra da sola l’assenza di problemi: possono intervenire permessi, filtri troppo stretti, storico rimosso o limiti di registrazione. Journald può anche scartare messaggi quando un servizio supera i limiti di frequenza configurati, registrando un avviso sulla quantità scartata. Prima di concludere, verifica quindi anche quanto è completa la tua finestra di osservazione.
Compatibilità: i riferimenti systemd usati per questa lezione descrivono la versione 262, non necessariamente quella installata. In particolare, --list-boots è disponibile da systemd 209, le opzioni di pulizia mostrate da 218 e --rotate da 227. Puoi conoscere la versione locale con journalctl --version e consultarne le opzioni con journalctl --help. La spiegazione di tail -F riguarda GNU Coreutils; implementazioni alternative vanno controllate separatamente.
Riferimenti
- https://github.com/logrotate/logrotate
- https://www.freedesktop.org/software/systemd/man/latest/journalctl.html
- https://www.freedesktop.org/software/systemd/man/latest/journald.conf.html
- https://www.freedesktop.org/software/systemd/man/latest/file-hierarchy.html
- https://www.gnu.org/software/coreutils/manual/html_node/tail-invocation.html
AUTORE
Redazione ThreatHunting.it
Da piu' di 30 anni sono appassionato di computer e tecnologia. il mio primo programma lo sviluppai in Basic nel 1989, non era un gran che :).. ma quella voglia di scrivere codici non mi ha piu' lasciato …
COMMUNITY
Non ci sono ancora commenti. Puoi iniziare tu la conversazione.