Cos’è Journalctl e a cosa serve?

Journalctl è uno strumento versatile per gestire e analizzare in modo efficace i registri di sistema su Linux. Grazie alle sue funzioni avanzate consente il monitoraggio delle attività di sistema, l’analisi dei problemi, il tracciamento dei registri in tempo reale e la visione dettagliata dei dati di registro. In poche parole: è utilissimo per diagnosticare con efficacia i problemi di sistema.

Cos’è Journalctl?

Journalctl è un potente strumento in grado di interrogare e visualizzare i registri ovvero i file di log su Linux. Parte integrante della suite di strumenti systemd per la gestione dei sistemi e dei servizi, viene usato per impostazione predefinita in numerose distribuzioni Linux moderne, tra cui Ubuntu, Fedora e Arch Linux. Il nome “journalctl” è composto dai termini “journal” (registro) e “ctl” (control) e fa riferimento alla sua funzione di strumento di controllo e di analisi dei registri.

Journalctl consente l’accesso al registro di sistema, gestito da systemd-journald. Il registro di sistema è una lista centralizzata di messaggi ed eventi che si producono durante il funzionamento del sistema. A differenza del classico log di testo, Journalctl consente di eseguire la ricerca, il filtraggio e la visualizzazione in tempo reale dei dati di registro. Queste azioni possono tornare utili per diagnosticare problemi o monitorare lo stato del sistema.

Journalctl salva i file di log in formato binario perché sono più compatti e funzionano meglio rispetto ai file di testo. Considerando la grande quantità di dati contenuti nei registri, in questo modo i file possono essere filtrati più rapidamente ed efficacemente secondo criteri specifici. Inoltre, i file di log binari sono più sicuri perché crittografati e quindi più difficili da manipolare rispetto ai log di testo.

Impostare lo spazio occupato su disco dai file di log

Grazie alle impostazioni del servizio systemd-journald, Journalctl consente di gestire e configurare lo spazio di archiviazione occupato dai file di log sul disco rigido. Queste configurazioni sono memorizzate nel file /etc/systemd/journald.conf dove sono incluse le seguenti voci:

• SystemMaxUse: limita lo spazio di archiviazione dei registri nella directory di sistema.
• RuntimeMaxUse: limita lo spazio di archiviazione dei registri nella directory temporanea.

Per impostare i limiti di archiviazione è possibile aggiungere o modificare le seguenti righe nel file in base alle proprie esigenze:

[Journal]
SystemMaxUse=50M
RuntimeMaxUse=50M

I valori di questo esempio, come 50M, possono essere modificati a piacere. È possibile usare anche unità diverse, come K (kilobyte), M (megabyte), G (gigabyte) o T (terabyte). Dopo aver modificato il file di configurazione è necessario riavviare il systemd-journald:

sudo systemctl restart systemd-journald

Ora systemd-journald è configurato in modo tale da limitare lo spazio di archiviazione dei file di log. È necessario assicurarsi che il limite stabilito sia sufficiente per salvare i file di log più importanti, ma che allo stesso tempo consenta di evitare di occupare troppo spazio sul disco rigido. Fai attenzione: quando si raggiunge il limite, i registri più vecchi vengono automaticamente cancellati per garantire la gestione efficace dello spazio di archiviazione.

Determinare lo spazio occupato su disco

Prima di adattare lo spazio disponibile per i file di registro puoi verificare quanto spazio viene occupato da Journal. Per farlo puoi usare il flag --disk-usage:

journalctl --disk-usage
Journals take up 8.0M on disk.

Cancellare tutti i file di log

Se Journal occupa troppo spazio è semplicemente possibile cancellare i vecchi file di log. A questo proposito ci sono due possibilità:

Con --vacuum-size è possibile ridurre le dimensioni di Journal specificando una quantità. In questo caso si eliminano i vecchi log, finché lo spazio totale occupato da Journal sul disco assume le dimensioni desiderate.

sudo journalctl --vacuum-size=1G

In alternativa, con l’opzione --vacuum-time è possibile diminuire le dimensioni di Journal specificando un periodo di blocco. In questo modo, tutti i file che sforano questo lasso di tempo vengono eliminati. Se ad esempio desideri conservare solo i file di log dell’ultimo anno, puoi digitare il seguente comando:

sudo journalctl --vacuum-time=1years

Cos’è Journalctl?

Una delle funzioni più utili di Journalctl è la possibilità di filtrare le voci di log in base a vari criteri. Questa funzione consente di cercare le informazioni rilevanti in modo mirato e quindi di identificare più rapidamente eventuali problemi. Di seguito presentiamo alcuni dei filtri più comuni di Journalctl.

Visualizzare i registri

Digitando il comando journalctl, le voci di registro del sistema attuale sono visualizzate in ordine cronologico inverso. Digitando journalctl -f o journalctl --follow, le voci sono visualizzate in tempo reale. Le nuove voci sono visualizzate automaticamente nell’ordine in cui vengono salvate.

A seconda da quanto tempo systemd è già presente sul tuo sistema, la quantità di dati visualizzata ti potrebbe sembrare più o meno infinita e potrebbe situarsi nell’ordine di decine o centinaia di migliaia di righe. Per trovare più velocemente quello che stai cercando, puoi filtrare ulteriormente i registri mediante diversi comandi Linux.

Filtri temporali

Con Journalctl è possibile filtrare i registri dopo un determinato periodo di tempo per poter così trovare informazioni rilevanti in modo più efficace.

Filtrare per processi di avvio

Filtrare i registri in base ai processi di avvio risulta particolarmente utile per monitorare eventi specifici del sistema in un determinato momento o durante uno specifico scenario di avvio. Questo approccio semplifica la diagnosi dei problemi in quanto le voci di registro possono essere limitate a uno stato o a una configurazione specifica del sistema.

1. Sessione di avvio attuale: digitando journalctl -b è possibile visualizzare tutte le voci di registro raccolte a partire dall’ultimo riavvio.
2. Sessioni di avvio passate: digitando -b seguito da un numero è possibile visualizzare tutte le voci per una sessione di avvio passata. Ad esempio, specificando journalctl -b 1 viene visualizzata la sessione di avvio precedente.
3. Lista di tutte le sessioni di avvio disponibili: digitando il comando journalctl --list-boots viene visualizzato un elenco dei processi di avvio disponibili con i rispettivi ID. Per visualizzare i registri di un processo di avvio specifico è possibile utilizzare il relativo ID di avvio.

Mentre su alcune distribuzioni Linux i processi di avvio passati vengono salvati per impostazione predefinita, su altre questa funzione deve essere appositamente attivata. Per farlo, è possibile creare una directory in cui salvare il registro digitando sudo mkdir -p /var/log/journal.

In alternativa, è possibile modificare il file di configurazione di Journal mediante il comando sudo nano /etc/systemd/journald.conf. Quindi, per abilitare la registrazione persistente è necessario impostare l’opzione Storage= su persistent alla voce [Journal]:

. . .
[Journal]
Storage=persistent

Filtrare per finestre di tempo

A volte può essere necessario visualizzare le voci di registro filtrandole secondo un periodo di tempo specifico. Journalctl offre le opzioni --since e --until, che servono a delimitare le voci secondo uno specifico periodo di tempo. A questo proposito è possibile utilizzare il formato temporale YYYY-MM-DD HH:MM:SS. Ad esempio, se si desidera visualizzare tutte le voci di registro tra il 1° gennaio 2024 alle 12:00 e il 2 gennaio 2024 alle 12:00, è possibile digitare il seguente comando:

journalctl --since "2024-01-01 12:00:00" --until "2024-01-02 12:00:00"

Con la combinazione di questi due comandi è anche possibile impostare una finestra di tempo più limitata:

journalctl --since 09:00 --until "1 hour ago"

In alternativa c’è la possibilità di omettere parti della formula precedente. Ad esempio, è possibile visualizzare tutte le voci a partire da un determinato periodo di tempo:

journalctl --since "2023-11-16 15:25:00"

Journalctl è in grado di comprendere anche valori relativi come yesterday (ieri), today (oggi) o tomorrow (domani). Per poter visualizzare le voci di ieri, puoi digitare il seguente comando:

journalctl --since yesterday

Filtri per interesse

Filtrare le voci di registro con journalctl in base a criteri di interesse è particolarmente utile perché consente di individuare informazioni rilevanti concentrandosi su aspetti specifici dei registri di sistema. Questo facilita, tra l’altro, la rapida diagnosi di errori consentendo di individuare tempestivamente problemi di sicurezza e di monitorare le prestazioni in modo rapido ed efficace.

Filtrare per priorità

Per filtrare i registri con Journalctl in base a specifici criteri di interesse è possibile sfruttare le priorità delle voci di registro. A tal proposito, è sufficiente utilizzare il nome della rispettiva priorità o il corrispondente valore numerico. Più basso è il numero, più importante è il messaggio:

• 0: emerg (emergenza)
• 1: alert (allarme)
• 2: crit (criticità)
• 3: err (errore)
• 4: warning (avvertenza)
• 5: notice (notifica)
• 6: info (informazione)
• 7: debug (ricerca di errore)

Gli avvisi con una determinata priorità possono essere filtrati mediante l’opzione -p. Ad esempio, usando il comando sottostante si visualizzano solo voci di protocollo con la priorità “err” (errore) e superiori:

journalctl -p err

Filtrare per unità

Con Journalctl, filtrare i registri per unità ti può tornare particolarmente utile se desideri concentrarti su specifici servizi o processi. Questi possono essere individuati mediante l’opzione -u. Ad esempio, se desideri visualizzare le voci di protocollo per il server web Apache, puoi digitare quanto segue:

journalctl -u apache2

È possibile raffinare ulteriormente la ricerca mediante dei valori temporali relativi. Ad esempio, se desideri sapere se oggi il servizio è già stato avviato, puoi digitare il seguente comando:

journalctl -u apache2 --since today

Journalctl può essere utilizzato anche per unire record di dati provenienti da unità diverse. Ad esempio, se il processo Nginx è collegato a un’unità PHP FPM, le voci di entrambe possono essere combinate in ordine cronologico. In questo caso si usa il comando:

journalctl -u nginx.service -u php-fpm.service --since today-u apache2 --since today

Filtrare per processi, utenti o ID di gruppo

Con Journalctl è possibile filtrare le voci di protocollo in base al processo, all’utente o all’ID di gruppo. Se conosci il PID specifico del processo da cercare, puoi filtrarlo mediante l’opzione _PID. Se, ad esempio, il PID corrisponde a 8088, il comando sarà:

journalctl _PID=8088

In alternativa, con i filtri _UID o _GID è possibile visualizzare tutte le voci registrate da un determinato utente o gruppo. Se, ad esempio, il server web si chiama “www-data”, è possibile individuare l’ID utente come segue:

id -u www-data
33

Ora che conosci l’ID, puoi filtrare le voci di Journal:

journalctl _UID=33 --since today

Per vedere per quali voci sono state realizzate all’interno di un determinato ID di gruppo, è possibile usare l’opzione -F. Questo mostra tutti i valori salvati per il campo “ID di gruppo”:

journalctl -F _GID
32
99
102
133
81
84
100
0
124
87

Filtrare per campi componente

Il filtro basato sul campo componente è estremamente utile quando esaminiamo applicazioni, servizi o processi specifici. Il campo componente viene normalmente utilizzato da diversi servizi o componenti software per identificare informazioni specifiche nei log. Questo tipo di filtro consente di limitare le voci di registro a un componente, un’applicazione o un’unità di servizio specifici. Ad esempio, per filtrare le voci che contengono il file eseguibile bash, è sufficiente digitare il seguente comando:

journalctl /usr/bin/bash

Visualizzare i messaggi del kernel

Con Journalctl, filtrare le voci di registro in base ai messaggi del kernel è un modo efficace per ottenere informazioni specifiche sul funzionamento del kernel nei sistemi Linux. I messaggi del kernel possono offrire indicazioni su problemi hardware, conflitti di driver o altri eventi di sistema.

I messaggi del kernel presenti nell’output dmesg possono essere filtrati anche dal Journal e visualizzati utilizzando i flag -k o --dmesg:

journalctl -k

Per impostazione predefinita vengono visualizzati i messaggi del kernel relativi al processo di avvio corrente. È possibile filtrare i messaggi di un altro processo di avvio servendosi dei flag di selezione dell’avvio già noti. Ad esempio, se si desidera visualizzare i messaggi del kernel degli ultimi cinque processi di avvio, basta digitare quanto segue:

journalctl -k -b -5

Personalizzare la visualizzazione in Journalctl

Modificando la visualizzazione in Journalctl, gli utenti possono eseguire ricerche all’interno dei registri in modo più mirato, estraendo così più rapidamente le informazioni di cui hanno bisogno. Un esempio: visualizzare i dati di registro in un periodo di tempo specifico o in tempo reale consente di riconoscere rapidamente gli errori e i problemi del sistema.

Delimitare o ampliare l’output

È possibile personalizzare il modo in cui i dati vengono visualizzati in Journalctl, modificandone la lunghezza o l’estensione dell’output. Per impostazione predefinita, Journalctl visualizza l’intero file nel pager e scorre le voci sul lato destro dello schermo. È possibile accorciare l’output mediante l’opzione --no-full:

journalctl --no-full

In alternativa è possibile espanderlo mediante il flag -a:

journalctl -a

Impostare Journalctl su output standard

In Journalctl, l’output del log viene visualizzato per impostazione predefinita utilizzando un pager, ad esempio less. Il vantaggio di questo metodo è che l’output può essere esaminato riga per riga, semplificando la navigazione nei file di log molto lunghi. Tuttavia, a volte può essere necessario visualizzare i log direttamente con l’output standard. Per farlo basta digitare il seguente comando:

journalctl --no-pager

Impostare i formati di output

Se necessario, esistono numerose opzioni per personalizzare il formato di output dei log in Journalctl. A questo scopo è possibile usare l’opzione -o con il rispettivo identificatore di formato. In questo modo, le voci di registro possono essere emesse, ad esempio, in formato JSON:

journalctl -b -u nginx -o json
{ "__CURSOR" : “s=13a21661cf4948289c63075db6c25c00;i=116f1;b=81b58db8fd9046ab9f847ddb82a2fa2d;m=19f0daa;t=50e33c33587ae;x=e307daadb4858635", "__REALTIME_TIMESTAMP" : "1422990364739502", "__MONOTONIC_TIMESTAMP" : "27200938", "_BOOT_ID" : "81b58db8fd9046ab9f847ddb82a2fa2d", "PRIORITY" : “6", "_UID" : “0", "_GID" : “0", "_CAP_EFFECTIVE" : "3fffffffff", "_MACHINE_ID" : “752737531a9d1a9c1e3cb52a4ab967ee", "_HOSTNAME" : "desktop", "SYSLOG_FACILITY" : “3", "CODE_FILE" : “src/core/unit.c", "CODE_LINE" : "1402", "CODE_FUNCTION" :

In Journalctl possono essere usati i seguenti formati:

• cat: visualizza solo il campo messaggio.
• export: questo formato binario è adatto a spostare o salvare dati.
• json: formato JSON standard con una voce per riga.
• json-pretty: consente una maggiore leggibilità dei file JSON formattati.
• json-sse: output JSON formattato che consente di aggiungere eventi inviati dal server.
• short: output standard in stile syslog.
• short-iso: formato standard per visualizzare una marca temporale dell’orologio ISO-8601
• short-monotonic: formato standard con marche temporali monotone
• short-precise: formato standard con precisione al millisecondo
• verbose: visualizza il campo Journal disponibile per ciascuna voce

Monitoraggio attivo dei processi

Nel monitoraggio attivo dei processi con Journalctl si usa il programma a riga di comando tail, per seguire i registri in tempo reale e visualizzare solo le ultime voci. Questo semplifica il monitoraggio degli eventi di sistema in tempo reale e consente di reagire rapidamente a eventuali problemi.

Visualizzazione di protocolli attuali

L’opzione -n può essere usata per visualizzare un determinato numero di record di dati. Questa opzione funziona esattamente come tail -n. Il seguente comando consente di visualizzare le ultime 10 voci:

journalctl -n

Il numero di voci da visualizzare può essere impostato individualmente, ad esempio a 20:

journalctl -n 20