Como usar o comando docker logs para visualizar a saída do contêiner

Introdução

Neste laboratório, você aprenderá como usar efetivamente o comando docker logs para visualizar a saída dos seus contêineres Docker. Começaremos entendendo como visualizar logs básicos de um contêiner em execução.

A partir do básico, você explorará como acompanhar os logs do contêiner em tempo real, o que é crucial para monitorar e depurar processos ativos. Finalmente, você aprenderá como aprimorar sua experiência de visualização de logs, incluindo timestamps (carimbos de data/hora), especificando o número de linhas a serem exibidas do final dos logs e filtrando logs com base em um intervalo de tempo.

Iniciar serviços e visualizar logs básicos

Nesta etapa, aprenderemos como iniciar um contêiner Docker e visualizar seus logs básicos. Os logs são essenciais para entender o que está acontecendo dentro de um contêiner, depurar problemas e monitorar seu comportamento.

Primeiro, vamos baixar uma imagem Nginx simples do Docker Hub. Esta imagem será usada para executar um contêiner de servidor web.

docker pull nginx:latest

Você deve ver a saída indicando que a imagem está sendo baixada. Depois que o download for concluído, você pode verificar se a imagem está disponível localmente listando as imagens:

docker images

Agora, vamos executar um contêiner baseado na imagem Nginx. Vamos executá-lo em modo detached (-d) para que ele seja executado em segundo plano, e vamos nomeá-lo my-nginx.

docker run -d --name my-nginx nginx

A saída deste comando será o ID do contêiner. Isso significa que o contêiner foi iniciado com sucesso em segundo plano.

Para ver os logs básicos gerados pelo contêiner my-nginx, usamos o comando docker logs seguido pelo nome ou ID do contêiner.

docker logs my-nginx

Você verá os fluxos de saída padrão (standard output) e de erro padrão (standard error) do processo Nginx em execução dentro do contêiner. Esses logs normalmente incluem informações sobre a inicialização do servidor Nginx e o tratamento de requisições.

Acompanhar logs em tempo real

Na etapa anterior, visualizamos os logs de um contêiner após ele ter sido iniciado. No entanto, às vezes você precisa ver os logs à medida que eles são gerados, em tempo real. Isso é particularmente útil para depurar ou monitorar processos ativos.

Para acompanhar os logs de um contêiner em tempo real, usamos o comando docker logs com a opção -f (ou --follow). Isso manterá o terminal aberto e exibirá novas entradas de log à medida que elas aparecem.

Vamos acompanhar os logs do nosso contêiner my-nginx:

docker logs -f my-nginx

O comando começará a exibir os logs atuais e, em seguida, aguardará novas entradas de log. Como nosso contêiner Nginx está em execução, mas não está servindo ativamente requisições, você pode não ver novos logs imediatamente.

Para gerar algumas novas entradas de log, podemos enviar uma requisição para o servidor web Nginx em execução dentro do contêiner. Por padrão, o Nginx escuta na porta 80. Embora não tenhamos mapeado a porta para o host no comando docker run, ainda podemos acessar a rede do contêiner internamente do host usando curl.

Abra uma nova aba do terminal no ambiente LabEx. Nesta nova aba, execute o seguinte comando para enviar uma requisição para o contêiner Nginx:

curl http://localhost:80

Você deve ver a saída HTML da página de boas-vindas padrão do Nginx na nova aba do terminal.

Agora, volte para a aba do terminal onde você está acompanhando os logs (docker logs -f my-nginx). Você deve ver novas entradas de log aparecerem, indicando que o Nginx processou a requisição do curl. Essas entradas normalmente incluem informações sobre o IP do cliente, o método da requisição, o caminho solicitado e o código de status HTTP.

Para parar de acompanhar os logs, pressione Ctrl+C no terminal onde docker logs -f está em execução.

Visualizar logs com timestamps e tail específico

Nas etapas anteriores, visualizamos logs básicos e acompanhamos logs em tempo real. No entanto, a saída básica do docker logs não inclui timestamps, o que pode dificultar a correlação de eventos ou a compreensão do tempo das entradas de log. Além disso, às vezes você só precisa ver as entradas de log mais recentes.

Para incluir timestamps na saída do log, usamos a opção -t (ou --timestamps) com o comando docker logs.

Vamos visualizar os logs do nosso contêiner my-nginx com timestamps:

docker logs -t my-nginx

Você agora verá um timestamp adicionado a cada entrada de log, indicando quando essa entrada de log foi gerada pelo contêiner. Isso é muito útil para depuração e análise.

Às vezes, você está interessado apenas nas entradas de log mais recentes, semelhante ao uso do comando tail no Linux. O comando docker logs fornece a opção --tail para essa finalidade. Você pode especificar o número de linhas que deseja ver do final dos logs.

Por exemplo, para visualizar apenas as últimas 5 entradas de log do contêiner my-nginx:

docker logs --tail 5 my-nginx

Isso exibirá apenas as últimas 5 linhas dos logs do contêiner. Você pode combinar --tail com -t para ver as últimas entradas com timestamps.

docker logs -t --tail 5 my-nginx

Este comando mostrará as últimas 5 entradas de log, cada uma com seu timestamp correspondente.

Filtrar logs por intervalo de tempo

Além de visualizar todos os logs ou os mais recentes, você também pode filtrar os logs do contêiner por um intervalo de tempo específico. Isso é útil quando você está investigando eventos que ocorreram durante um período específico.

O comando docker logs fornece as opções --since e --until para filtrar logs com base no tempo. Essas opções aceitam vários formatos de tempo, incluindo timestamps RFC3339, timestamps Unix ou tempos relativos (por exemplo, 10m para 10 minutos, 1h para 1 hora).

Vamos tentar filtrar logs. Primeiro, precisamos gerar alguns logs em horários diferentes. Podemos fazer isso enviando requisições curl para o contêiner Nginx novamente.

Abra uma nova aba do terminal e execute o comando curl algumas vezes com um pequeno atraso entre elas.

curl http://localhost:80
sleep 5
curl http://localhost:80
sleep 5
curl http://localhost:80

Agora, vamos visualizar os logs do contêiner my-nginx com timestamps para ver os horários dessas requisições.

docker logs -t my-nginx

Observe os timestamps das entradas de log geradas pelos comandos curl.

Para filtrar logs desde um horário específico, você pode usar a opção --since. Por exemplo, para visualizar logs gerados no último 1 minuto:

docker logs --since 1m my-nginx

Este comando mostrará todas as entradas de log do contêiner my-nginx que foram geradas no último minuto.

Você também pode filtrar logs até um horário específico usando a opção --until. Por exemplo, para visualizar logs gerados antes de 1 minuto atrás:

docker logs --until 1m my-nginx

Este comando mostrará todas as entradas de log do contêiner my-nginx que foram geradas há mais de um minuto.

Você pode combinar --since e --until para visualizar logs dentro de uma janela de tempo específica. Por exemplo, para visualizar logs entre 5 minutos atrás e 1 minuto atrás:

docker logs --since 5m --until 1m my-nginx

Lembre-se que a saída exata dependerá de quando você executou os comandos curl e quando você executou os comandos docker logs.

Resumo

Neste laboratório, aprendemos os passos fundamentais para usar o comando docker logs para visualizar a saída do contêiner. Começamos puxando uma imagem Docker e executando um contêiner em modo detached. Posteriormente, exploramos como visualizar os logs básicos gerados pelo contêiner em execução, o que fornece informações sobre sua inicialização e atividade.

Além disso, avançamos nossa compreensão aprendendo como acompanhar os logs do contêiner em tempo real usando a opção -f, permitindo o monitoramento contínuo dos fluxos de log à medida que são gerados. Este logging em tempo real é crucial para depuração e observação do comportamento dinâmico dos contêineres.