# O que é o journalctl e para que serve?

journalctl permite gerir e analisar os registos do sistema no Linux. A ferramenta oferece funcionalidades de monitorização das atividades do sistema, resolução de problemas ou acompanhamento de registos em tempo real, bem como uma visão detalhada dos dados de registo. Além disso, journalctl é indispensável na hora de diagnosticar problemas do sistema.

## O que é o journalctl?

`journalctl` é uma ferramenta eficiente para **consultar e visualizar registos de eventos** ou ficheiros de log no Linux. `journalctl` constitui-se como um componente essencial do `systemd`, o gestor de sistemas e serviços que muitas distribuições modernas de Linux, como o Ubuntu, o Fedora e o Arch Linux, utilizam por predefinição. O nome «journalctl» é composto por «journal» (registo) e «ctl» (controlo), termos que fazem referência à sua função de ferramenta 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 centralizada de mensagens e eventos que ocorrem enquanto o sistema Linux está em funcionamento. Ao contrário dos registos tradicionais baseados em texto, `journalctl` oferece uma forma estruturada e eficiente de pesquisar, filtrar e apresentar **dados de registo em tempo real**. Graças a isso, é possível diagnosticar problemas ou monitorizar 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 equivalente em texto. Isto permite, apesar da grande quantidade de dados registados, pesquisas rápidas de eventos específicos ou de informações. Além disso, a estrutura e a encriptação deste tipo de ficheiros oferecem maior segurança, pois dificultam a manipulação dos dados de registo.

## Personalizar o espaço de armazenamento dos ficheiros de registo

`journalctl` pode ser utilizado para limitar e configurar o espaço ocupado pelos ficheiros de registo no disco rígido. Para efetuar essa configuração, é necessário utilizar as **definições do serviço systemd-journald**. As definições de configuraçã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 armazenamento para registos no diretório do sistema.
- `RuntimeMaxUse`: limita o espaço de armazenamento para registos no diretório temporário.

Para definir o limite de espaço de armazenamento, pode incluir as seguintes linhas, que pode ir modificando conforme necessário:

```bash
[Journal]
SystemMaxUse=50M
RuntimeMaxUse=50M
```

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

```bash
sudo systemctl restart systemd-journald
```

Ao seguir os passos anteriores, terá configurado o systemd-journald para limitar o espaço de armazenamento dos ficheiros de registo. Certifique-se de que o limite definido é suficiente para armazenar os dados de registo necessários, sem que isso ocupe demasiado espaço no disco rígido. Tenha em conta que **os registos mais antigos são apagados automaticamente** quando se atinge o limite definido.

### Determinar a utilização do disco rígido

Antes de configurar o espaço de armazenamento para os ficheiros de registo, pode verificar primeiro quanto espaço de armazenamento o «journal» ocupa atualmente. Para tal, deve utilizar o argumento `--disk-usage`:

```shell-session
$ journalctl --disk-usage
Archived and active journals take up 8.0M in the file system.
```

### 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 especificando um tamanho. Neste caso, todas as entradas antigas são eliminadas até que o Journal atinja o tamanho desejado.

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

Em alternativa, é possível reduzir o tamanho do Journal especificando um período de armazenamento de ficheiros com a opção --vacuum-time. Todas as entradas anteriores ao período especificado serão eliminadas. Se pretender conservar as entradas do Journal do último ano, por exemplo, pode introduzir:

```bash
sudo journalctl --vacuum-time=1years
```

## Para que serve o journalctl?

Uma das funcionalidades mais importantes do `journalctl` é a filtragem de **entradas do registo de acordo com vários critérios**. Graças a ela, é possível procurar informações específicas e identificar problemas mais rapidamente. A seguir, apresentamos algumas das opções de filtragem mais comuns do `journalctl`.

### Mostrar registos

Com o comando `journalctl`, são apresentadas as entradas do registo do sistema atual por ordem cronológica inversa. Se introduzir `journalctl -f` ou `journalctl --follow`, poderá ver as entradas **em tempo real**. As novas entradas são apresentadas automaticamente pela ordem em que chegam.

A quantidade de dados apresentada 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 utilizando outros comandos do Linux.

## Filtrar por data

O `journalctl` pode ser utilizado para filtrar os registos de um período de tempo específico, o que permite obter as informações relevantes de forma mais eficiente.

### Filtrar por sequências de arranque

Filtrar os registos por processos de arranque é especialmente útil se se pretender verificar eventos específicos do sistema num determinado momento ou durante um cenário de arranque específico. Isto facilita o diagnóstico de problemas, uma vez que as entradas de registo podem ser limitadas a um estado específico do sistema ou a uma configuração do sistema.

1. **Arranque atual**: utilize `journalctl -b` para apresentar todas as entradas de registo recolhidas desde o último arranque.
2. **Arranques anteriores**: utilize a opção `-b` seguida de um número para mostrar as entradas de registo correspondentes a um arranque específico anterior. Por exemplo, se introduzir `journalctl -b 1`, será apresentado o arranque imediatamente anterior.
3. **Lista de todas as sequências de arranque disponíveis**: o comando `journalctl --list-boots` apresenta uma lista dos processos de arranque disponíveis com as respetivas identificações (ID). Pode utilizar um ID específico para aceder aos registos associados a um processo de arranque concreto.

Enquanto em algumas distribuições Linux o armazenamento de processos de arranque anteriores está ativado por predefinição, noutras tem de **ser ativado manualmente**. Para tal, com o comando `sudo mkdir -p /var/log/journal`, pode criar um diretório onde os registos serão armazenados.

Em alternativa, pode editar o ficheiro de configuraçã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 persistente:

```bash
. . .
[Journal]
Storage=persistent
```

### Filtrar por intervalos de tempo

Por vezes, pode ser necessário apresentar as entradas de registo de um período de tempo específico. `journalctl` oferece as opções `--since` e `--until`, que podem ser utilizadas para restringir 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, apresentar 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:

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

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

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

Em alternativa, é possível omitir partes do formato anterior. Por exemplo, é possível aceder a todas as entradas a partir de um determinado momento:

```bash
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 visualizar os registos de ontem, pode introduzir o seguinte:

```bash
journalctl --since yesterday
```

## Filtrar por tema das mensagens

A capacidade de filtrar as entradas do registo por assunto com `journalctl` é também extremamente útil, uma vez que permite **procurar informações relevantes e concentrar-se em aspetos específicos dos registos do sistema**. Desta forma, é possível, entre outras coisas, realizar um diagnóstico eficiente de erros, detetar problemas numa fase inicial e monitorizar o desempenho rapidamente.

### Filtrar por prioridade

Para filtrar os registos com `journalctl` de acordo com os teus interesses específicos 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 correspondente. Quanto menor for o número, mais importante é a mensagem:

- 0: emerg (emergência)
- 1: alert (alarme)
- 2: crit (crítico)
- 3: err (erro)
- 4: warning (aviso)
- 5: notice (nota)
- 6: info (informação)
- 7: debug (depuração)

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

```bash
journalctl -p err
```

### Filtrar por unidade

Filtrar os registos por unidade com `journalctl` é especialmente útil se pretender concentrar-se em serviços ou processos específicos. Para tal, utilize a opção `-u`. Por exemplo, para apresentar os registos do servidor web Apache, pode introduzir o seguinte:

```bash
journalctl -u apache2
```

A pesquisa pode ser ainda mais refinada utilizando valores de tempo relativo. Se, por exemplo, quiser saber se algum serviço foi executado hoje, pode introduzir o seguinte:

```bash
journalctl -u apache2 --since today
```

Com journalctl, também é possível combinar registos de dados de diferentes unidades. Se o seu processo Nginx estiver ligado a uma unidade PHP-FPM, por exemplo, é possível combinar as entradas de ambos por ordem cronológica. O comando segue a sintaxe apresentada:

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

### Filtrar por ID do processo, utilizador ou grupo

`journalctl` também pode ser utilizado para filtrar entradas do registo por ID do processo, utilizador ou grupo. Se souber o **ID do processo** (PID) que pretende procurar, pode filtrar as informações desejadas utilizando a opção `_PID`. Por exemplo, se o PID for 8088, o comando teria a sintaxe apresentada:

```bash
journalctl _PID=8088
```

Se desejar, também pode filtrar por _UID ou _GID para aceder às entradas que foram registadas por um utilizador ou grupo específico. Para saber o seu nome de utilizador, pode utilizar o comando id -u www-data, que, neste caso, apresenta o resultado 33.

```bash
id -u www-data
33
```

A seguir, podes filtrar por _UID, já que sabes o ID do utilizador:

```bash
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»:

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

### Filtrar por campo do componente

Filtrar pelo campo «componente» é extremamente útil para se concentrar em aplicações, serviços ou processos específicos. O campo «componente» é normalmente utilizado por **diferentes serviços ou componentes de software** para identificar informações específicas nos registos. Este tipo de filtragem permite limitar as entradas do registo a um componente, aplicação ou unidade de serviço específicos. Por exemplo, para filtrar as entradas que contêm o ficheiro executável `bash`, deve introduzir o seguinte comando:

```bash
journalctl /usr/bin/bash
```

### Mostrar mensagens do kernel

Filtrar entradas do registo por mensagens do kernel com `journalctl` é uma forma eficaz de analisar informações específicas sobre o funcionamento do kernel num sistema Linux. As mensagens do kernel podem fornecer **indícios sobre problemas de hardware, conflitos de controladores ou outros eventos do sistema**.

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

```bash
journalctl -k
```

As mensagens do kernel do processo de arranque atual são as que são apresentadas por predefinição. As mensagens de um **processo de arranque alternativo** podem ser filtradas através das opções de seleção de arranque já conhecidas. Por exemplo, se pretender ver as mensagens do kernel dos últimos cinco processos de arranque, introduza o seguinte:

```bash
journalctl -k -b -5
```

## Alterar a visualização do Journal no journalctl

Personalizar a visualização no `journalctl` permite aos utilizadores pesquisar os registos de forma mais específica e, assim, encontrar a informação pretendida com maior rapidez. Com a visualização dos dados de registo em tempo real ou relativos a um período específico, é possível identificar rapidamente erros e problemas no sistema.

### Reduzir ou ampliar a saída

Além disso, é possível personalizar a forma como `journalctl` apresenta os dados. A saída pode ser encurtada ou alargada. Por predefiniçã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`:

```bash
journalctl --no-full
```

Podes ampliar a visualização utilizando a opção -a:

```bash
journalctl -a
```

### Configurar o journalctl para a saída padrão

No `journalctl`, a saída do registo é apresentada por predefinição através de um visualizador, por exemplo, `less`. Isto permite visualizar a saída passo a passo, o que facilita a navegação em ficheiros de registo mais extensos. Por vezes, no entanto, pode ser necessário apresentar os registos diretamente na saída padrão. Para tal, deve escrever o seguinte:

```bash
journalctl --no-pager
```

### Configurar formatos de saída

Existem várias opções disponíveis para personalizar o formato de saída dos registos no `journalctl`. Para efetuar esta configuração, pode utilizar a opção `-o` com o identificador de formato correspondente. Por exemplo, para que as entradas do registo sejam apresentadas em 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" :
```

Os formatos que podem ser especificados no journalctl são:

- **cat**: mostra apenas o corpo da mensagem.
- **export**: este formato binário é adequado para transferir ou guardar dados.
- **json**: utiliza o formato JSON padrão com uma entrada por linha.
- **json-pretty**: JSON formatado para melhor legibilidade.
- **json-sse**: saída no formato JSON encapsulado que permite adicionar eventos enviados pelo servidor.
- **short**: saída padrão no estilo syslog.
- **short-iso**: formato padrão para apresentar 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 microssegundos.
- **verbose**: exibe todos os campos do journal disponíveis para a entrada correspondente.

## Monitorizar processos ativos

Ao monitorizar processos com `journalctl`, utiliza-se o programa de linha de comandos `tail` para acompanhar os registos em tempo real e aceder às entradas mais recentes. Desta forma, é mais fácil acompanhar os eventos do sistema em tempo real e, consequentemente, reagir rapidamente a qualquer problema que surja.

## Mostrar registos atuais

A opção `-n` permite aceder a um número específico de registos de dados. Esta opção funciona exatamente da mesma forma que `tail -n`. Com o comando seguinte, são apresentados, por predefinição, os últimos 10 registos:

```bash
journalctl -n
```

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

```bash
journalctl -n 20
```


This is a markdown version of: [https://www.ionos.com/pt-pt/digitalguide/servidores/ferramentas/o-que-e-o-journalctl/](https://www.ionos.com/pt-pt/digitalguide/servidores/ferramentas/o-que-e-o-journalctl/) for AI/LLM consumption.