# 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`: ```bash 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 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.