# O que é e como usar o journalctl? Ao usar o journalctl, você conseguirá gerenciar e analisar registros de sistema (*logs*) com eficiência, em ambientes Linux. Essa ferramenta de linha de comando oferece funções de monitoramento de atividades do sistema, de localização de erros, de acompanhamento de registros em tempo real e de visualização detalhada dos dados registrados. Por esses motivos, o journalctl se tornou indispensável para o diagnóstico eficaz de problemas. ## O que é o journalctl? journalctl é um poderoso utilitário para **consultas e exibições de registros de eventos** ([*log files*](https://www.ionos.com/digitalguide/online-marketing/web-analytics/log-files-recording-computer-processes/ "Log files: Registro de processos do computador")) em sistemas [Linux](https://www.ionos.com/digitalguide/server/know-how/linux-the-cost-effective-alternative-to-windows/ "Linux: Alternativa econômica ao Windows"). Ele é um componente essencial do *systemd*, gerenciador de sistemas e serviços padrão de muitas distribuições modernas do Linux, como do Ubuntu, Fedora e Arch Linux. O nome journalctl é uma combinação dos termos *journal* (diário) e *ctl* (abreviação de *control*). Assim, ele faz referência à sua função de controlar e analisar registros do diário do sistema. O journalctl possibilita acessos ao diário do sistema, que é gerenciado pelo serviço *systemd-journald*. Esse diário é uma coleção centralizada de mensagens e eventos registrados durante a operação do sistema Linux. Diferentemente de registros convencionais, baseados em texto, o journalctl possui recursos estruturados e eficientes para **pesquisar, filtrar e exibir dados de registro em tempo real**. Isso ajuda a diagnosticar problemas e a monitorar o status de um sistema. Para disponibilizar os recursos listados, o journalctl armazena **arquivos de registro em formato binário**, já que *log files* binários são mais compactos e funcionais do que os equivalentes baseados em texto. Mesmo ao registrar grandes volumes de dados, esse formato suporta pesquisas de eventos ou de informações em arquivos de registro, com rapidez e eficiência. Ainda, devido à estrutura e à criptografia deles, *log files* binários têm maior segurança que registros baseados em texto, já que a manipulação de dados se torna bem mais difícil. ## Configurar espaço de armazenamento para arquivos de registro Com o journalctl, você pode definir e limitar o espaço de armazenamento que os arquivos de registro ocuparão no seu disco rígido. Para isso, altere as **configurações do serviço *systemd-journald***, que podem ser encontradas no arquivo\* /etc/systemd/journald.conf\*. Lá estarão as seguintes entradas: - `SystemMaxUse`: Limita o espaço de armazenamento de registros no diretório do sistema. - `RuntimeMaxUse`: Limita o espaço de armazenamento de registros no diretório temporário. Para definir um limite de espaço, acrescente as seguintes linhas ao código, ou adapte-as conforme necessário: ```bash [Journal] SystemMaxUse=50M RuntimeMaxUse=50M ``` Os valores desse exemplo (50M) podem ser alterados livremente. Você também pode utilizar outras unidades, como K (*quilobytes*), M (*megabytes*), G (*gigabytes*) e T (*terabytes*). Após editar esse arquivo de configurações, você deverá reiniciar o *systemd-journald*. Somente assim as alterações serão aplicadas: ```bash sudo systemctl restart systemd-journald ``` Feito o procedimento, o *systemd-journald* estará configurado para limitar o espaço de armazenamento dos *log files*. Certifique-se de que o limite definido seja suficiente para armazenar todos os registros importantes e, ao mesmo tempo, não ocupe espaço demais no disco rígido. É importante que você saiba que os **registros mais antigos serão excluídos automaticamente** quando o limite for atingido. ### Verificar uso do disco rígido Antes de configurar o espaço de armazenamento para os seus arquivos de registro, você pode verificar quanto espaço o diário do sistema está ocupando atualmente. Para tanto, use o sinalizador `--disk-usage`: ```bash journalctl --disk-usage Journals take up 8.0M on disk. ``` ### Excluir arquivos de registro antigos Se o seu diário do sistema estiver ocupando muito espaço de armazenamento, considere apagar as entradas mais antigas. Existem duas formas de se fazer isso: A opção `--vacuum-size` permite reduzir esse diário a um tamanho predefinido. Nesse caso, as entradas mais antigas serão excluídas até que o espaço no disco rígido se restrinja ao limite desejado. ```bash sudo journalctl --vacuum-size=1G ``` Você também pode reduzir o seu diário estabelecendo um limite de tempo de armazenamento. Faça isso com a opção `--vacuum-time`. Ela determinará que todas as entradas mais antigas que o limite sejam excluídas. Por exemplo, para manter somente as entradas de registro do último ano, execute o seguinte comando: ```bash sudo journalctl --vacuum-time=1years ``` ## Para que serve o journalctl? Uma das características mais úteis do journalctl é a sua capacidade de **filtrar entradas de registro com base em critérios**. Graças a esse recurso, você poderá buscar informações relevantes de forma direcionada e, assim, identificar problemas mais rapidamente. A seguir, apresentaremos as opções de filtragem mais comuns do journalctl. ### Obter registros Ao executar o comando `journalctl`, as entradas de registro para o sistema atual são exibidas em ordem cronológica reversa. Digite `journalctl -f` ou `journalctl --follow` para exibir as entradas **em tempo real**. Novas entradas são mostradas automaticamente, na ordem em que são registradas. Dependendo do tempo em que o *systemd* estiver operando no seu sistema, provavelmente você obterá uma enorme quantidade de dados, com dezenas ou centenas de milhares de linhas. Para encontrar mais depressa o que está procurando, você pode filtrar esses registros com [comandos Linux](https://www.ionos.com/pt-br/digitalguide/servidor/configuracao/comandos-linux-para-usar-no-terminal/ "Comandos Linux para usar no terminal"). ## Como filtrar por tempo Com o journalctl, você pode filtrar registros de acordo com critérios de tempo definidos, para buscar informações relevantes com mais eficiência. ### Filtrar por inicializações de sistema Filtrar registros por inicializações (*boots*) é especialmente útil para consultar eventos do sistema em um determinado momento, ou em um cenário de inicialização específico. Isso facilita o diagnóstico de problemas, pois permite restringir entradas de registro a um determinado status do sistema ou a uma determinada configuração. 1. **Inicialização atual**: O comando `journalctl -b` exibe todas as entradas coletadas desde o *boot* mais recente. 2. **Inicializações anteriores**: Ao inserir um número após a opção `-b`, você obterá as entradas para uma inicialização anterior específica. Por exemplo, `journalctl -b 1` mostra o *boot* imediatamente anterior. 3. **Todas as inicializações registradas**: O comando `journalctl --list-boots` exibe uma lista contendo todos os *boots* disponíveis, com os respectivos IDs. Você pode usar o ID de inicialização desejado para exibir os registros de uma inicialização específica. Em algumas distribuições Linux, *boots* anteriores são armazenados por padrão. Já em outras, essa função **precisa ser ativada**. Para ativar essa função, você pode criar um diretório onde o diário será salvo e executar o comando `sudo mkdir -p /var/log/journal`. Alternativamente, edite o arquivo de configurações do diário, com `sudo nano /etc/systemd/journald.conf`. Em seguida, na seção `[Journal]`, defina a opção `Storage=` como `persistent`, para ativar o armazenamento persistente: ```bash . . . [Journal] Storage=persistent ``` ### Filtrar por intervalo de tempo Talvez você precise obter entradas de registro de um certo intervalo de tempo. Para isso, o journalctl oferece as opções `--since` (desde) e `--until` (até), que permitem **restringir entradas a períodos específicos**, pelo formato `YYYY-MM-DD HH:MM:SS`. Por exemplo, para exibir todas as entradas entre as 12h00 do dia 1º de janeiro de 2023 e as 12h00 do dia 2 de janeiro de 2023, insira o comando: ```bash journalctl --since "2023-01-01 12:00:00" --until "2023-01-02 12:00:00" ``` Combinando ambos os comandos, você também consegue filtrar por períodos mais curtos: ```bash journalctl --since 09:00 --until "1 hour ago" ``` Opcionalmente, partes do formato acima podem ser omitidas. Por exemplo, com o objetivo de exibir todas as entradas a partir de um determinado horário: ```bash journalctl --since "2023-11-16 15:25:00" ``` O journalctl também entende valores relativos, como as palavras *yesterday* (ontem), *today* (hoje) e *tomorrow* (amanhã). Ou seja, para exibir as entradas do dia anterior, basta que você digite: ```bash journalctl --since yesterday ``` ## Como filtrar por interesse das mensagens A filtragem de entradas do journalctl pelo interesse das mensagens também é bastante útil, por possibilitar **a busca de informações relevantes por meio de aspectos específicos dos registros do sistema**. Assim, você será capaz de diagnosticar erros com eficiência, detectar problemas de segurança logo no início ou monitorar o desempenho com rapidez. ### Filtrar por prioridade Para filtrar registros conforme a importância das mensagens, você pode utilizar **prioridades de entradas**. Para isso, indique o nome da prioridade desejada ou o valor numérico correspondente. Quanto menor o número, mais importante é a mensagem: - 0: emerg (emergência) - 1: alert (alerta) - 2: crit (crítico) - 3: err (erro) - 4: warning (aviso) - 5: notice (nota) - 6: info (informação) - 7: debug (depuração) Mensagens com prioridades específicas podem ser filtradas por meio da opção `-p`. Por exemplo, o seguinte comando exibe somente as entradas de registro com a prioridade *err* (erro) ou superior: ```bash journalctl -p err ``` ### Filtrar por unidade Filtrar registros por unidade é especialmente útil se você deseja obter serviços ou processos específicos. É possível filtrá-los com a opção `-u`. Para exibir, por exemplo, as entradas para o servidor web Apache, digite: ```bash journalctl -u apache2 ``` Ao fazer uso de valores de tempo relativos, você será capaz de refinar ainda mais a pesquisa. Se você quiser saber se o serviço já foi executado no dia, faça uso deste comando: ```bash journalctl -u apache2 --since today ``` O journalctl também suporta a combinação de registros de diferentes unidades. Por exemplo, se um processo Nginx está vinculado a uma unidade PHP-FPM, você pode mesclar as entradas de ambos, em ordem cronológica. O comando para isso seria: ```bash journalctl -u nginx.service -u php-fpm.service --since today-u apache2 --since today ``` ### Filtrar por ID de processo, usuário ou grupo Com o journalctl, também é possível filtrar registros por IDs de processo, usuário ou grupo. Se você souber o **PID exato do processo** que deseja pesquisar, por exemplo, poderá filtrá-lo com a opção `_PID`. Se o PID for 8088, o comando será: ```bash journalctl _PID=8088 ``` Já com os filtros `_UID` ou `_GID`, você obterá todas as entradas registradas por um certo usuário ou grupo. Supondo que o seu servidor web se chame *www-data*, você encontraria o respectivo ID de usuário da seguinte maneira: ```bash id -u www-data 33 ``` Ao tomar conhecimento do ID do usuário que deseja, você poderá filtrar as entradas do diário: ```bash journalctl _UID=33 --since today ``` Para ver os IDs de grupo para os quais existem entradas, utilize a opção `-F`. Ela exibe todos os valores salvos para o campo “Group ID”: ```bash journalctl -F _GID 32 99 102 133 81 84 100 0 124 87 ``` ### Filtrar pelo campo de componente A filtragem pelo campo de componente é muito prática àqueles que desejam obter registros de aplicativos, serviços ou processos específicos. Normalmente, o campo de componente é utilizado por **diversos serviços ou componentes de software** para identificar informações específicas em registros. Com esse tipo de filtro, você pode restringir entradas a um determinado componente, aplicativo ou unidade de serviço. Por exemplo, para filtrar entradas que contenham o arquivo executável `bash`, use o comando a seguir: ```bash journalctl /usr/bin/bash ``` ### Filtrar mensagens do kernel Filtrar entradas com base em mensagens do kernel, pelo journalctl, é um método eficaz de análise de informações específicas sobre a operação do próprio kernel em um sistema Linux. Mensagens do kernel podem fornecer **indícios de problemas de hardware e apontar conflitos entre drivers, além de outros eventos de sistema**. Mensagens do kernel encontradas na exibição `dmesg` também podem ser filtradas no diário. Para exibi-las, faça uso do sinalizador `-k`: ```bash journalctl -k ``` Por padrão, as mensagens do kernel da inicialização atual serão exibidas. Mensagens de **outra inicialização** podem ser filtradas por sinalizadores de seleção de inicialização já apresentados. Se, por exemplo, você quisesse ver as mensagens do kernel das últimas cinco inicializações, teria de digitar este comando: ```bash journalctl -k -b -5 ``` ## Alterar exibição de registros no journalctl Ao personalizar a exibição do diário no journalctl, usuários tornam-se capazes de fazer pesquisas mais direcionadas e de extrair informações relevantes com mais agilidade. Ao exibir dados de registro de um período específico ou em tempo real, é possível, por exemplo, encontrar rapidamente erros e problemas no sistema. ### Encurtar ou expandir resultados Você pode alterar a forma como o journalctl exibe os dados recuperados, encurtando ou expandindo os resultados das pesquisas. Por padrão, o journalctl mostra a entrada completa no *pager*, fazendo com que as linhas ultrapassem o lado direito da tela. Para encurtar essa exibição, faça uso da opção `--no-full`: ```bash journalctl --no-full ``` Também é possível expandir a exibição com o sinalizador `-a`: ```bash journalctl -a ``` ### Configurar exibição padrão O journalctl normalmente exibe registros por *pager*, como `less`. Isso é vantajoso, pois possibilita a visualização e a exibição passo a passo, o que facilita a navegação por longos arquivos de registro. Contudo, pode ser que você precise ver os registros diretamente na exibição padrão. Nesse caso, basta usar a seguinte opção: ```bash journalctl --no-pager ``` ### Configurar formatos de exibição Você pode personalizar o formato de exibição dos registros de várias formas, no journalctl. Para fazer isso, você pode inserir a opção `-o` com o nome do formato desejado. Isso fará com que os registros sejam exibidos no 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" : ``` Os seguintes formatos são suportados pelo journalctl: - ***cat***: Exibe apenas o campo das mensagens. - ***export***: Formato binário, apropriado para ser transmitido ou salvo. - ***json***: Formato JSON padrão, com uma entrada por linha. - ***json-pretty***: JSON formatado para uma melhor legibilidade. - ***json-sse***: JSON formatado com quebras de linha, que permite a adição de eventos enviados pelo servidor. - ***short***: Exibição padrão em estilo\* syslog\*. - ***short-iso***: Exibição com carimbos de data e hora no padrão ISO-8601, em formato\* wall clock\*. - ***short-monotonic***: Formato padrão com carimbos de data e hora monotônicos. - ***short-precise***: Formato padrão com precisão de microssegundos. - ***verbose***: Exibe todos os campos do diário disponíveis para a respectiva entrada. ## Monitoramento processos ativamente No monitoramento ativo de processos com o journalctl, o utilitário de linha de comando `tail` é usado para acompanhar os registros em tempo real e exibir apenas as entradas mais recentes. Isso facilita o monitoramento de eventos do sistema e a reação imediata a eventuais problemas que ocorram. ## Exibir registros atuais Você pode usar a opção `-n` para obter um número definido de registros. Essa opção funciona exatamente como `tail -n`. Com o seguinte comando, por padrão, são exibidas as 10 últimas entradas: ```bash journalctl -n ``` Você também pode personalizar o número de entradas exibidas, por exemplo, para 20: ```bash journalctl -n 20 ``` This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/servidor/ferramentas/journalctl/](https://www.ionos.com/pt-br/digitalguide/servidor/ferramentas/journalctl/) for AI/LLM consumption.