# 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](https://www.ionos.it/digitalguide/online-marketing/analisi-web/log-il-registro-eventi-dei-processi-informatici/) su [Linux](https://www.ionos.it/digitalguide/server/know-how/linux-lalternativa-conveniente-a-windows/). 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: ```bash [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: ```bash 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`: ```bash 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. ```bash 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: ```bash 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](https://www.ionos.it/digitalguide/online-marketing/analisi-web/log-il-registro-eventi-dei-processi-informatici/). ## 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]`: ```bash . . . [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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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: ```bash 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à: ```bash 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: ```bash id -u www-data 33 ``` Ora che conosci l’ID, puoi filtrare le voci di Journal: ```bash 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”: ```bash 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: ```bash 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`: ```bash 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: ```bash 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`: ```bash journalctl --no-full ``` In alternativa è possibile espanderlo mediante il flag `-a`: ```bash 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: ```bash 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: ```bash 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: ```bash journalctl -n ``` Il numero di voci da visualizzare può essere impostato individualmente, ad esempio a 20: ```bash journalctl -n 20 ``` This is a markdown version of: [https://www.ionos.it/digitalguide/server/tools-o-strumenti/journalctl/](https://www.ionos.it/digitalguide/server/tools-o-strumenti/journalctl/) for AI/LLM consumption.