O que é o jour­nalctl e para que serve?

journalctl permite gerir e analisar os registos do sistema no Linux. A fer­ra­menta oferece fun­ci­o­na­li­da­des de mo­ni­to­ri­za­ção das ati­vi­da­des do sistema, resolução de problemas ou acom­pa­nha­mento de registos em tempo real, bem como uma visão detalhada dos dados de registo. Além disso, journalctl é in­dis­pen­sá­vel na hora de di­ag­nos­ti­car problemas do sistema.

O que é o jour­nalctl?

journalctl é uma fer­ra­menta eficiente para consultar e vi­su­a­li­zar registos de eventos ou ficheiros de log no Linux. journalctl constitui-se como um com­po­nente essencial do systemd, o gestor de sistemas e serviços que muitas dis­tri­bui­ções modernas de Linux, como o Ubuntu, o Fedora e o Arch Linux, utilizam por pre­de­fi­ni­ção. O nome «jour­nalctl» é composto por «journal» (registo) e «ctl» (controlo), termos que fazem re­fe­rên­cia à sua função de fer­ra­menta de controlo e análise de registos.

journalctl permite o acesso ao registo do sistema, gerido pelo systemd-journald. O registo do sistema é uma coleção cen­tra­li­zada de mensagens e eventos que ocorrem enquanto o sistema Linux está em fun­ci­o­na­mento. Ao contrário dos registos tra­di­ci­o­nais baseados em texto, journalctl oferece uma forma es­tru­tu­rada e eficiente de pesquisar, filtrar e apre­sen­tar dados de registo em tempo real. Graças a isso, é possível di­ag­nos­ti­car problemas ou mo­ni­to­ri­zar o estado do sistema.

journalctl armazena os ficheiros de registo em formato binário, uma vez que este tipo de ficheiro é mais compacto e eficiente do que o seu equi­va­lente em texto. Isto permite, apesar da grande quan­ti­dade de dados re­gis­ta­dos, pesquisas rápidas de eventos es­pe­cí­fi­cos ou de in­for­ma­ções. Além disso, a estrutura e a en­crip­ta­ção deste tipo de ficheiros oferecem maior segurança, pois di­fi­cul­tam a ma­ni­pu­la­ção dos dados de registo.

Per­so­na­li­zar o espaço de ar­ma­ze­na­mento dos ficheiros de registo

journalctl pode ser utilizado para limitar e con­fi­gu­rar o espaço ocupado pelos ficheiros de registo no disco rígido. Para efetuar essa con­fi­gu­ra­ção, é ne­ces­sá­rio utilizar as de­fi­ni­ções do serviço systemd-journald. As de­fi­ni­ções de con­fi­gu­ra­ção são guardadas em /etc/systemd/journald.conf, um ficheiro no qual é possível ver as seguintes entradas:

• SystemMaxUse: limita o espaço de ar­ma­ze­na­mento para registos no diretório do sistema.
• RuntimeMaxUse: limita o espaço de ar­ma­ze­na­mento para registos no diretório tem­po­rá­rio.

Para definir o limite de espaço de ar­ma­ze­na­mento, pode incluir as seguintes linhas, que pode ir mo­di­fi­cando conforme ne­ces­sá­rio:

[Journal]
SystemMaxUse=50M
RuntimeMaxUse=50M

Os valores deste exemplo (50M) podem ser alterados conforme ne­ces­sá­rio. Também é possível alterar as unidades: K (kilobytes), M (megabytes), G (gigabytes) ou T (terabytes). Após editar o ficheiro de con­fi­gu­ra­ção, é ne­ces­sá­rio reiniciar o systemd-journald para que as al­te­ra­ções entrem em vigor:

sudo systemctl restart systemd-journald

Ao seguir os passos an­te­ri­o­res, terá con­fi­gu­rado o systemd-journald para limitar o espaço de ar­ma­ze­na­mento dos ficheiros de registo. Cer­ti­fi­que-se de que o limite definido é su­fi­ci­ente para armazenar os dados de registo ne­ces­sá­rios, sem que isso ocupe demasiado espaço no disco rígido. Tenha em conta que os registos mais antigos são apagados au­to­ma­ti­ca­mente quando se atinge o limite definido.

De­ter­mi­nar a uti­li­za­ção do disco rígido

Antes de con­fi­gu­rar o espaço de ar­ma­ze­na­mento para os ficheiros de registo, pode verificar primeiro quanto espaço de ar­ma­ze­na­mento o «journal» ocupa atu­al­mente. Para tal, deve utilizar o argumento --disk-usage:

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

Apagar entradas antigas do registo

Se o Journal ocupar demasiado espaço no disco, pode eliminar as entradas antigas do registo. Para tal, existem duas formas de proceder:

Com --vacuum-size, pode reduzir o tamanho do Journal es­pe­ci­fi­cando um tamanho. Neste caso, todas as entradas antigas são eli­mi­na­das até que o Journal atinja o tamanho desejado.

sudo journalctl --vacuum-tamaño=1G

Em al­ter­na­tiva, é possível reduzir o tamanho do Journal es­pe­ci­fi­cando um período de ar­ma­ze­na­mento de ficheiros com a opção --vacuum-time. Todas as entradas an­te­ri­o­res ao período es­pe­ci­fi­cado serão eli­mi­na­das. Se pretender conservar as entradas do Journal do último ano, por exemplo, pode in­tro­du­zir:

sudo journalctl --vacuum-time=1years

Para que serve o jour­nalctl?

Uma das fun­ci­o­na­li­da­des mais im­por­tan­tes do journalctl é a filtragem de entradas do registo de acordo com vários critérios. Graças a ela, é possível procurar in­for­ma­ções es­pe­cí­fi­cas e iden­ti­fi­car problemas mais ra­pi­da­mente. A seguir, apre­sen­ta­mos algumas das opções de filtragem mais comuns do journalctl.

Mostrar registos

Com o comando journalctl, são apre­sen­ta­das as entradas do registo do sistema atual por ordem cro­no­ló­gica inversa. Se in­tro­du­zir journalctl -f ou journalctl --follow, poderá ver as entradas em tempo real. As novas entradas são apre­sen­ta­das au­to­ma­ti­ca­mente pela ordem em que chegam.

A quan­ti­dade de dados apre­sen­tada pode ser difícil de gerir (desde dezenas a centenas de linhas), embora isso dependa do tempo que o systemd já está a ser executado no seu sistema. Para encontrar o que procura de forma eficiente, pode filtrar ainda mais os registos uti­li­zando outros comandos do Linux.

Filtrar por data

O journalctl pode ser utilizado para filtrar os registos de um período de tempo es­pe­cí­fico, o que permite obter as in­for­ma­ções re­le­van­tes de forma mais eficiente.

Filtrar por sequên­cias de arranque

Filtrar os registos por processos de arranque é es­pe­ci­al­mente útil se se pretender verificar eventos es­pe­cí­fi­cos do sistema num de­ter­mi­nado momento ou durante um cenário de arranque es­pe­cí­fico. Isto facilita o di­ag­nós­tico de problemas, uma vez que as entradas de registo podem ser limitadas a um estado es­pe­cí­fico do sistema ou a uma con­fi­gu­ra­ção do sistema.

1. Arranque atual: utilize journalctl -b para apre­sen­tar todas as entradas de registo re­co­lhi­das desde o último arranque.
2. Arranques an­te­ri­o­res: utilize a opção -b seguida de um número para mostrar as entradas de registo cor­res­pon­den­tes a um arranque es­pe­cí­fico anterior. Por exemplo, se in­tro­du­zir journalctl -b 1, será apre­sen­tado o arranque ime­di­a­ta­mente anterior.
3. Lista de todas as sequên­cias de arranque dis­po­ní­veis: o comando journalctl --list-boots apresenta uma lista dos processos de arranque dis­po­ní­veis com as res­pe­ti­vas iden­ti­fi­ca­ções (ID). Pode utilizar um ID es­pe­cí­fico para aceder aos registos as­so­ci­a­dos a um processo de arranque concreto.

Enquanto em algumas dis­tri­bui­ções Linux o ar­ma­ze­na­mento de processos de arranque an­te­ri­o­res está ativado por pre­de­fi­ni­ção, noutras tem de ser ativado ma­nu­al­mente. Para tal, com o comando sudo mkdir -p /var/log/journal, pode criar um diretório onde os registos serão ar­ma­ze­na­dos.

Em al­ter­na­tiva, pode editar o ficheiro de con­fi­gu­ra­ção do Journal com o parâmetro sudo nano /etc/systemd/journald.conf. Em seguida, defina o parâmetro Storage= como persistent para ativar o registo per­sis­tente:

. . .
[Journal]
Storage=persistent

Filtrar por in­ter­va­los de tempo

Por vezes, pode ser ne­ces­sá­rio apre­sen­tar as entradas de registo de um período de tempo es­pe­cí­fico. journalctl oferece as opções --since e --until, que podem ser uti­li­za­das para res­trin­gir as entradas a um período de tempo concreto. Para tal, aplica-se o formato de data e hora YYYY-MM-DD HH:MM:SS. O comando para, por exemplo, apre­sen­tar todas as entradas de registo entre 1 de janeiro de 2023 às 12:00 e 2 de janeiro de 2023 às 12:00, teria o seguinte aspeto:

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

A com­bi­na­ção dos dois comandos também pode ser usada para filtrar um período de tempo mais curto:

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

Em al­ter­na­tiva, é possível omitir partes do formato anterior. Por exemplo, é possível aceder a todas as entradas a partir de um de­ter­mi­nado momento:

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

journalctl também pode ser usado com valores relativos, como yesterday (ontem), today (hoje) ou tomorrow (amanhã). Para vi­su­a­li­zar os registos de ontem, pode in­tro­du­zir o seguinte:

journalctl --since yesterday

Filtrar por tema das mensagens

A ca­pa­ci­dade de filtrar as entradas do registo por assunto com journalctl é também ex­tre­ma­mente útil, uma vez que permite procurar in­for­ma­ções re­le­van­tes e con­cen­trar-se em aspetos es­pe­cí­fi­cos dos registos do sistema. Desta forma, é possível, entre outras coisas, realizar um di­ag­nós­tico eficiente de erros, detetar problemas numa fase inicial e mo­ni­to­ri­zar o de­sem­pe­nho ra­pi­da­mente.

Filtrar por pri­o­ri­dade

Para filtrar os registos com journalctl de acordo com os teus in­te­res­ses es­pe­cí­fi­cos nas mensagens, podes utilizar os níveis de gravidade das mensagens. Para tal, podes utilizar o nome do nível em questão ou o seu valor numérico cor­res­pon­dente. Quanto menor for o número, mais im­por­tante é a mensagem:

• 0: emerg (emer­gên­cia)
• 1: alert (alarme)
• 2: crit (crítico)
• 3: err (erro)
• 4: warning (aviso)
• 5: notice (nota)
• 6: info (in­for­ma­ção)
• 7: debug (depuração)

Para filtrar as mensagens com base num de­ter­mi­nado nível de gravidade, pode utilizar a opção -p. O comando seguinte, por exemplo, mostra apenas as entradas de registo com pri­o­ri­dade «err» (erro) ou superior:

journalctl -p err

Filtrar por unidade

Filtrar os registos por unidade com journalctl é es­pe­ci­al­mente útil se pretender con­cen­trar-se em serviços ou processos es­pe­cí­fi­cos. Para tal, utilize a opção -u. Por exemplo, para apre­sen­tar os registos do servidor web Apache, pode in­tro­du­zir o seguinte:

journalctl -u apache2

A pesquisa pode ser ainda mais refinada uti­li­zando valores de tempo relativo. Se, por exemplo, quiser saber se algum serviço foi executado hoje, pode in­tro­du­zir o seguinte:

journalctl -u apache2 --since today

Com journalctl, também é possível combinar registos de dados de di­fe­ren­tes unidades. Se o seu processo Nginx estiver ligado a uma unidade PHP-FPM, por exemplo, é possível combinar as entradas de ambos por ordem cro­no­ló­gica. O comando segue a sintaxe apre­sen­tada:

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

Filtrar por ID do processo, uti­li­za­dor ou grupo

journalctl também pode ser utilizado para filtrar entradas do registo por ID do processo, uti­li­za­dor ou grupo. Se souber o ID do processo (PID) que pretende procurar, pode filtrar as in­for­ma­ções desejadas uti­li­zando a opção _PID. Por exemplo, se o PID for 8088, o comando teria a sintaxe apre­sen­tada:

journalctl _PID=8088

Se desejar, também pode filtrar por _UID ou _GID para aceder às entradas que foram re­gis­ta­das por um uti­li­za­dor ou grupo es­pe­cí­fico. Para saber o seu nome de uti­li­za­dor, pode utilizar o comando id -u www-data, que, neste caso, apresenta o resultado 33.

id -u www-data
33

A seguir, podes filtrar por _UID, já que sabes o ID do uti­li­za­dor:

journalctl _UID=33 --since today

Para ver para que ID de grupo (GID) foram criadas entradas, pode utilizar a opção -F, que mostra todos os valores guardados para o campo «ID de grupo»:

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

Filtrar por campo do com­po­nente

Filtrar pelo campo «com­po­nente» é ex­tre­ma­mente útil para se con­cen­trar em apli­ca­ções, serviços ou processos es­pe­cí­fi­cos. O campo «com­po­nente» é nor­mal­mente utilizado por di­fe­ren­tes serviços ou com­po­nen­tes de software para iden­ti­fi­car in­for­ma­ções es­pe­cí­fi­cas nos registos. Este tipo de filtragem permite limitar as entradas do registo a um com­po­nente, aplicação ou unidade de serviço es­pe­cí­fi­cos. Por exemplo, para filtrar as entradas que contêm o ficheiro exe­cu­tá­vel bash, deve in­tro­du­zir o seguinte comando:

journalctl /usr/bin/bash

Mostrar mensagens do kernel

Filtrar entradas do registo por mensagens do kernel com journalctl é uma forma eficaz de analisar in­for­ma­ções es­pe­cí­fi­cas sobre o fun­ci­o­na­mento do kernel num sistema Linux. As mensagens do kernel podem fornecer indícios sobre problemas de hardware, conflitos de con­tro­la­do­res ou outros eventos do sistema.

As mensagens do kernel en­con­tra­das na dmesg também podem ser filtradas a partir do journal. Podem ser exibidas com as opções -k ou --dmesg:

journalctl -k

As mensagens do kernel do processo de arranque atual são as que são apre­sen­ta­das por pre­de­fi­ni­ção. As mensagens de um processo de arranque al­ter­na­tivo podem ser filtradas através das opções de seleção de arranque já co­nhe­ci­das. Por exemplo, se pretender ver as mensagens do kernel dos últimos cinco processos de arranque, introduza o seguinte:

journalctl -k -b -5

Alterar a vi­su­a­li­za­ção do Journal no jour­nalctl

Per­so­na­li­zar a vi­su­a­li­za­ção no journalctl permite aos uti­li­za­do­res pesquisar os registos de forma mais es­pe­cí­fica e, assim, encontrar a in­for­ma­ção pre­ten­dida com maior rapidez. Com a vi­su­a­li­za­ção dos dados de registo em tempo real ou relativos a um período es­pe­cí­fico, é possível iden­ti­fi­car ra­pi­da­mente erros e problemas no sistema.

Reduzir ou ampliar a saída

Além disso, é possível per­so­na­li­zar a forma como journalctl apresenta os dados. A saída pode ser encurtada ou alargada. Por pre­de­fi­ni­ção, journalctl apresenta a entrada completa no pager e mostra o maior número possível de entradas na parte direita do ecrã. Isto pode ser encurtado com a opção --no-full:

journalctl --no-full

Podes ampliar a vi­su­a­li­za­ção uti­li­zando a opção -a:

journalctl -a

Con­fi­gu­rar o journalctl para a saída padrão

No journalctl, a saída do registo é apre­sen­tada por pre­de­fi­ni­ção através de um vi­su­a­li­za­dor, por exemplo, less. Isto permite vi­su­a­li­zar a saída passo a passo, o que facilita a navegação em ficheiros de registo mais extensos. Por vezes, no entanto, pode ser ne­ces­sá­rio apre­sen­tar os registos di­re­ta­mente na saída padrão. Para tal, deve escrever o seguinte:

journalctl --no-pager

Con­fi­gu­rar formatos de saída

Existem várias opções dis­po­ní­veis para per­so­na­li­zar o formato de saída dos registos no journalctl. Para efetuar esta con­fi­gu­ra­ção, pode utilizar a opção -o com o iden­ti­fi­ca­dor de formato cor­res­pon­dente. Por exemplo, para que as entradas do registo sejam apre­sen­ta­das em 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" :

Os formatos que podem ser es­pe­ci­fi­ca­dos no journalctl são:

• cat: mostra apenas o corpo da mensagem.
• export: este formato binário é adequado para trans­fe­rir ou guardar dados.
• json: utiliza o formato JSON padrão com uma entrada por linha.
• json-pretty: JSON formatado para melhor le­gi­bi­li­dade.
• json-sse: saída no formato JSON en­cap­su­lado que permite adicionar eventos enviados pelo servidor.
• short: saída padrão no estilo syslog.
• short-iso: formato padrão para apre­sen­tar marcas de tempo ISO-8601.
• short-monotonic: formato padrão com marcas de tempo monótonas.
• short-precise: formato padrão com precisão de mi­cros­se­gun­dos.
• verbose: exibe todos os campos do journal dis­po­ní­veis para a entrada cor­res­pon­dente.

Mo­ni­to­ri­zar processos ativos

Ao mo­ni­to­ri­zar processos com journalctl, utiliza-se o programa de linha de comandos tail para acom­pa­nhar os registos em tempo real e aceder às entradas mais recentes. Desta forma, é mais fácil acom­pa­nhar os eventos do sistema em tempo real e, con­se­quen­te­mente, reagir ra­pi­da­mente a qualquer problema que surja.

Mostrar registos atuais

A opção -n permite aceder a um número es­pe­cí­fico de registos de dados. Esta opção funciona exa­ta­mente da mesma forma que tail -n. Com o comando seguinte, são apre­sen­ta­dos, por pre­de­fi­ni­ção, os últimos 10 registos:

journalctl -n

O número de registos apre­sen­ta­dos pode ser definido em cada caso. Com o comando seguinte, é possível consultar, por exemplo, 20:

journalctl -n 20