Uso e exemplos do comando journalctl no Linux

O comando journalctl pode ser usado para visualizar todos os logs coletados pelo systemd em um sistema Linux. Isso inclui logs relacionados ao kernel do sistema, initrd, vários serviços e aplicativos, bem como ao próprio systemd. O comando journalctl torna a consulta de todos esses logs bastante simples, já que o systemd reúne e armazena todos esses vários logs em um local central para os administradores visualizarem.

Neste tutorial, você verá como usar o comando journalctl no Linux. Isso incluirá opções usadas com frequência, bem como informações sobre como interpretar os logs do sistema, uma vez que podem ser bastante enigmáticos para os não iniciados. Verifique alguns dos exemplos abaixo para entender o comando e experimente algumas das opções de comando em seu próprio sistema enquanto segue em frente.

Neste tutorial você aprenderá:

Como usar o comando journalctl no Linux
Como visualizar erros registrados com journalctl
Como visualizar logs de inicialização anteriores
Opções usadas com frequência para o comando journalctl

Opções usadas com frequência

Comando journalctl em exemplos básicos do Linux

A maneira mais básica de usar journalctl é sem mais opções. Isso mostrará tudo o que foi registrado, o que certamente será uma quantidade enorme de dados se o seu sistema estiver ligado por qualquer período de tempo. Não é incomum que as entradas de log cheguem a milhões.
```
$ journalctl
```
Verifique a captura de tela abaixo para ver o formato geral dos logs. A saída será canalizada para less automaticamente. Use a tecla Enter para rolar linha por linha ou Espaço para rolar página por página. Para sair da saída do log, pressione q no teclado.
Os logs são armazenados separadamente para cada inicialização, o que facilita o isolamento de determinados logs se você estiver tentando identificar um erro que ocorreu antes de uma reinicialização recente. Use a opção --list-boots para ver a lista de todos os logs de inicializações anteriores.
```
$ journalctl --list-boots
```
A captura de tela abaixo mostra que journalctl pode acessar os logs das últimas 15 inicializações do nosso sistema. Nossa inicialização atual é indicada com o número 0 e nossa inicialização anterior é o número 1.
Para visualizar os logs da inicialização anterior do sistema, podemos usar a opção -b (boot) e o número -1. Especifique um número diferente se desejar visualizar os logs de uma inicialização ainda mais antiga.
```
$ journalctl -b -1
```
Você também pode usar o ID de inicialização para visualizar os logs de uma inicialização anterior. Esta sequência alfanumérica não será alterada, ao contrário dos números sequenciais que continuam a aumentar após cada inicialização.
```
$ journalctl -b d1389cc42a75447dba69c0b7f74cc0e9
```
As opções --since e --until podem ser usadas para ajudar a isolar logs relevantes que foram registrados durante um determinado período. Por exemplo, para ver todos os logs desde ontem:
```
$ journalctl --since yesterday
```

Você também pode usar as opções em conjunto.


$ journalctl --since yesterday --until "2 hours ago"

Use o formato de data AAAA-MM-DD HH:MM:SS com essas duas opções se desejar isolar entradas de log para um período de tempo muito específico.
```
$ journalctl --since 2022-10-03 01:00:00 --until 2022-10-04 14:30:00
```
Isso pode ser útil se você tiver certeza de que um erro ou evento relevante ocorreu em algum lugar durante esse período e precisar identificar quando exatamente isso aconteceu ou ver quais dados foram registrados quando isso aconteceu.
Para ver as entradas que foram registradas para um serviço de sistema específico, use o sinalizador -u. Por exemplo, para ver todas as entradas registradas pelo Apache:
```
$ journalctl -u apache2.service
```
Para ver algumas das entradas mais recentes, podemos usar a opção -n. Por padrão, isso mostrará as últimas 10 entradas de log.
```
$ journalctl -n
```
Para ver as últimas 100 entradas, use o sinalizador -n novamente, mas especifique o número depois dele.
```
$ journalctl -n 100
```
Você também pode canalizar a saída para o comando tail. Para ver as últimas 100 entradas do journalctl:
```
$ journalctl | tail -100
```

NOTA
Você sempre pode usar o comando man para ler mais sobre o comando journalctl e sua documentação oficial. Clique no link anterior para ver como abrir as páginas de manual de qualquer comando em um sistema Linux.

Uso Avançado

O comando journalctl é bastante simples, mas como você observou ao longo da seção de exemplos deste artigo, ele vem com muitas opções. Muitas dessas opções passam despercebidas e até mesmo alguns administradores de sistema experientes podem não conhecê-las. No entanto, eles podem definitivamente ser úteis em várias situações. Nesta seção do tutorial, mostraremos algumas das opções menos conhecidas do comando journalctl que consideramos úteis.

Comando journalctl em exemplos avançados do Linux

Para ver apenas mensagens relacionadas ao kernel, use a opção -k.
```
$ journalctl -k
```
Como há tantas entradas de log, pode ser útil ver apenas aquelas com uma determinada prioridade. A prioridade mais alta é o nível 0 e a mais baixa é o nível 7. Os níveis de log são os seguintes:
```
0: emergency
1: alert
2: critical
3: error
4: warning
5: notice
6: info
7: debug
```
Use a opção -p para ver os logs de um determinado nível, além de qualquer prioridade acima dele. Neste exemplo, iremos para o nível 3, que é qualquer entrada marcada como erro, crítico, alerta ou emergência.
```
$ journalctl -p 3
```
Para obter a saída no formato JSON, o que pode facilitar a análise em determinados programas, use a opção -o da seguinte forma:
```
$ journalctl -o json
```
OU
```
$ journalctl -o json-pretty
```
Para ver todos os logs à medida que são produzidos, use a opção -f. Isso funciona exatamente como a opção -f para o comando tail.
```
$ journalctl -f
```
Para ver quanto espaço em disco todos os seus arquivos de log estão consumindo:
```
$ journalctl --disk-usage
```

Considerações finais