Configuração do Loki

Introdução

Bem-vindo a este laboratório prático sobre configuração do Loki. Loki é um sistema de agregação de logs horizontalmente escalável, altamente disponível e multi-tenant, inspirado no Prometheus. Ele foi projetado para ser muito econômico e fácil de operar.

Neste laboratório, focaremos no fluxo de trabalho básico e completo de coleta e visualização de logs. Usaremos três componentes principais:

• Loki: O servidor principal responsável pelo armazenamento e processamento de logs.
• Promtail: Um agente que descobre arquivos de log locais e os envia para uma instância do Loki.
• Grafana: Uma plataforma de visualização onde nos conectaremos ao Loki para explorar e consultar nossos logs.

Este ambiente de laboratório já iniciou os contêineres do Loki e do Grafana para você. Sua tarefa é configurar e executar o Promtail para enviar logs do sistema ao Loki e, em seguida, visualizá-los no Grafana.

Baixar a Imagem Docker do Promtail para Coleta de Logs

Nesta etapa, você fará o download da imagem Docker oficial para o Promtail. O Promtail é o agente responsável por descobrir arquivos de log e enviar seu conteúdo para o Loki. Nós o executaremos como um contêiner Docker para manter nossa configuração limpa e isolada.

Execute o seguinte comando no seu terminal para puxar a imagem do Promtail do Docker Hub.

docker pull grafana/promtail

Você verá uma saída mostrando o progresso do download para cada camada da imagem. Após a conclusão, a imagem estará disponível em sua máquina local.

Using default tag: latest
latest: Pulling from grafana/promtail
Digest: sha256:xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Status: Downloaded newer image for grafana/promtail
docker.io/grafana/promtail

Agora que temos a imagem, podemos prosseguir para criar um arquivo de configuração para ela na próxima etapa.

Criar promtail.yml para Coletar Logs do Sistema

Nesta etapa, você criará um arquivo de configuração para o Promtail. Este arquivo YAML informa ao Promtail onde o servidor Loki está localizado e quais arquivos de log ele deve monitorar. Todo o seu trabalho deve ser realizado no diretório ~/project.

Primeiro, crie um novo arquivo chamado promtail.yml usando o editor nano.

nano promtail.yml

Agora, copie e cole a seguinte configuração no editor nano.

server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://loki:3100/loki/api/v1/push

scrape_configs:
  - job_name: varlogs
    static_configs:
      - targets:
          - localhost
        labels:
          job: varlogs
          __path__: /var/log/*.log

Vamos analisar esta configuração:

• server: Configura o próprio servidor web do Promtail, que não é usado neste laboratório.
• positions: Especifica um arquivo onde o Promtail registra a última localização de leitura em cada arquivo de log, para que não reenvie logs antigos ao reiniciar.
• clients: Define o endereço da instância do Loki. Usamos http://loki:3100 porque tanto o Promtail quanto o Loki rodarão na mesma rede Docker, e loki é o nome do contêiner.
• scrape_configs: Esta é a seção principal. Definimos um job chamado varlogs que coleta (scrape) todos os arquivos que terminam em .log no diretório /var/log/.

Após colar o conteúdo, salve o arquivo e saia do nano pressionando Ctrl+X, depois Y e, finalmente, Enter.

Executar Container Promtail Apontando para Loki

Nesta etapa, você iniciará o contêiner Promtail usando o arquivo de configuração que acabou de criar. O comando montará tanto o seu arquivo de configuração quanto o diretório de logs do host dentro do contêiner.

Execute o seguinte comando docker run para iniciar o Promtail:

docker run -d --name promtail --network monitoring-net -v $(pwd)/promtail.yml:/etc/promtail/config.yml -v /var/log:/var/log grafana/promtail -config.file=/etc/promtail/config.yml

Aqui está uma explicação das flags do comando:

• -d: Executa o contêiner em modo detached (em segundo plano).
• --name promtail: Atribui um nome ao contêiner para fácil referência.
• --network monitoring-net: Conecta o contêiner à mesma rede que o Loki e o Grafana.
• -v $(pwd)/promtail.yml:/etc/promtail/config.yml: Monta seu promtail.yml local dentro do contêiner na localização esperada.
• -v /var/log:/var/log: Monta o diretório /var/log do host dentro do contêiner para que o Promtail possa ler os arquivos de log.
• -config.file=/etc/promtail/config.yml: Informa ao processo Promtail dentro do contêiner qual arquivo de configuração usar.

Após executar o comando, o Docker exibirá o ID exclusivo do novo contêiner. Você pode verificar se o contêiner está em execução com o comando docker ps.

docker ps

Você deverá ver promtail, loki e grafana na lista de contêineres em execução.

CONTAINER ID   IMAGE                   COMMAND                  CREATED          STATUS          PORTS                                       NAMES
...            grafana/promtail        "/usr/bin/promtail -c…"   A few seconds ago   Up a few seconds   0.0.0.0:9080->9080/tcp                      promtail
...            grafana/grafana         "/run.sh"                About a minute ago  Up About a minute  0.0.0.0:8080->3000/tcp                      grafana
...            grafana/loki            "/usr/bin/loki -conf…"   About a minute ago  Up About a minute  0.0.0.0:3100->3100/tcp, 9095/tcp            loki

Adicionar Loki como Fonte de Dados no Grafana

Nesta etapa, você configurará o Grafana para usar o Loki como uma fonte de dados. Isso permitirá que você consulte e visualize os logs que o Promtail está enviando para o Loki.

Por favor, siga estas instruções cuidadosamente:

1. Devido às configurações de reverse proxy da VM LabEx, mude para a Interface Desktop, clique no navegador Firefox no canto superior esquerdo e digite http://localhost:8080 na barra de endereço. Você deverá ver a página de login do Grafana.

2. Faça login no Grafana. Use o nome de usuário admin e a senha admin. Você pode ser solicitado a alterar a senha; você pode ignorar isso para o laboratório.

3. No menu à esquerda, clique no ícone Connections (parece um plugue ou conector).

4. Na página de Conexões, clique em Data sources (Fontes de Dados).

5. Na página de Fontes de Dados, clique no botão Add new data source (Adicionar nova fonte de dados).

6. Na lista de tipos de fontes de dados disponíveis, selecione Loki.

7. Na caixa de pesquisa, digite Loki e clique na opção de fonte de dados Loki que aparecer.

8. Você será levado para a página de configuração da fonte de dados Loki. No campo URL sob a seção HTTP, insira o seguinte endereço:

   http://loki:3100

   Usamos loki como nome do hostname porque os contêineres Grafana e Loki estão na mesma rede Docker (monitoring-net), e o Docker fornece resolução DNS entre contêineres na mesma rede.

9. Role até o final e clique no botão Save & test (Salvar e testar).

Se tudo estiver configurado corretamente, você verá um banner verde com a mensagem "Data source is working" (Fonte de dados está funcionando). Você conectou com sucesso o Grafana à sua instância Loki.

Consultar Logs Básicos na Visualização Explore do Grafana

Nesta etapa final, você usará a visualização "Explore" do Grafana para executar uma consulta simples e ver os logs que o Promtail está enviando do seu ambiente.

1. Na interface do usuário (UI) do Grafana, navegue até a barra lateral esquerda e clique no ícone da bússola (Explore).

2. No canto superior esquerdo da página Explore, você verá um menu suspenso para selecionar a fonte de dados. Se ainda não estiver selecionada, escolha Loki.

3. Você verá um campo de entrada "Log browser" (Navegador de Logs). É aqui que você escreve suas consultas LogQL.

4. Clique no botão "Code" para alternar para o editor de código.

5. Insira a seguinte consulta no campo de entrada:

   {job="varlogs"}

   Esta consulta LogQL seleciona todos os streams de log que possuem o rótulo (label) job com o valor varlogs. Definimos este rótulo em nosso arquivo promtail.yml.

6. Pressione Shift+Enter ou clique no botão azul Run query (Executar consulta) no lado direito da tela.

Após executar a consulta, você deverá ver as linhas de log aparecerem no painel principal abaixo do editor de consultas. Você verá logs de vários arquivos em /var/log. Isso confirma que o Promtail está raspando (scraping) logs com sucesso e os enviando para o Loki, e que o Grafana é capaz de consultá-los.

Resumo

Parabéns! Você configurou com sucesso um pipeline básico de logging usando Loki, Promtail e Grafana.

Neste laboratório, você aprendeu como:

• Baixar e executar contêineres Docker para ferramentas de processamento de logs como o Promtail.
• Criar um arquivo de configuração do Promtail para especificar um servidor Loki e definir trabalhos (jobs) de raspagem de logs (log scraping).
• Usar a rede Docker para conectar serviços (Promtail, Loki e Grafana).
• Adicionar o Loki como uma fonte de dados (data source) na interface do usuário do Grafana.
• Executar uma consulta LogQL básica na visualização Explore do Grafana para encontrar e inspecionar seus logs.

Esta configuração é a base de um sistema de agregação de logs poderoso, escalável e econômico. A partir daqui, você pode explorar consultas LogQL mais avançadas, análise (parsing) de logs e a configuração de alertas no Grafana com base no conteúdo dos logs.