🥇Loki - coleta de logs usando a abordagem Prometheus

Saudações, residentes de Khabrovsk! Na véspera do início de uma nova matrícula no curso "Práticas e ferramentas DevOps" Preparamos para você uma tradução de material interessante.

Este artigo é uma breve introdução ao Loki. Projeto Loki apoiado por Grafana e visa a coleta centralizada de logs (de servidores ou contêineres).

A principal inspiração para Loki foi Prometeu com a ideia de aplicar suas abordagens ao gerenciamento de logs:

usando rótulos para armazenar dados
consumo de poucos recursos

Voltaremos ao funcionamento do Prometheus e daremos alguns exemplos de seu uso no contexto do Kubernetes.

Algumas palavras sobre Prometeu

Para entender completamente como Loki funciona, é importante dar um passo atrás e relembrar um pouco sobre Prometheus.

Um dos diferenciais do Prometheus é a extração de métricas de pontos de coleta (via exportadores) e seu armazenamento em TSDB (Time Series Data Base), com adição de metadados em forma de rótulos.

Por que você precisa disso?

Recentemente, o Prometheus se tornou o padrão de fato no mundo dos containers e do Kubernetes: sua instalação é muito simples e o cluster Kubernetes vem com um endpoint nativo para o Prometheus. O Prometheus também pode extrair métricas de aplicativos implantados em um contêiner enquanto armazena rótulos específicos. Portanto, o monitoramento de aplicativos é muito fácil de implementar.

Infelizmente, ainda não existe uma solução pronta para uso para gerenciamento de logs e você deve encontrar uma solução para si mesmo:

serviço de nuvem gerenciado para centralização de logs (AWS, Azure ou Google)
serviço de monitoramento “monitoramento como serviço” (por exemplo, Datadog)
criando seu próprio serviço de coleta de logs.

Para a terceira opção, tradicionalmente usei o Elasticsearch, apesar de nem sempre ficar satisfeito com ele (principalmente seu peso e complexidade de configuração).

Loki foi projetado para simplificar a implementação de acordo com os seguintes princípios:

seja simples para começar
consumir poucos recursos
trabalhar de forma independente, sem qualquer manutenção especial
servir como um complemento ao Prometheus para ajudar nas investigações de bugs

No entanto, esta simplicidade vem à custa de alguns compromissos. Uma delas é não indexar o conteúdo. Portanto, a pesquisa de texto não é muito eficiente ou rica e não permite estatísticas sobre o conteúdo do texto. Mas como Loki quer ser equivalente ao grep e um complemento do Prometheus, isso não é uma desvantagem.

Investigação de incidentes

Para entender melhor por que o Loki não precisa de indexação, vamos voltar ao método de investigação de incidentes usado pelos desenvolvedores do Loki:

1 Alerta → 2 Painel → 3 Consulta Adhoc → 4 Agregação de Log → 5 Rastreamento Distribuído → 6 Correção!
(1 Aviso → 2 Painel → 3 Consulta Adhoc → 4 Agregação de Log → 5 Rastreamento Distribuído → 6 Correção!)

A ideia é que recebamos algum tipo de alerta (Slack Notification, SMS, etc.) e depois disso:

veja os painéis do Grafana
observe as métricas de serviço (por exemplo, no Prometheus)
observe as entradas de log (por exemplo, no Elasticsearch)
talvez dê uma olhada nos rastreamentos distribuídos (Jaeger, Zipkin, etc.)
e finalmente corrigindo o problema original.

Aqui, no caso da pilha Grafana + Prometheus + Elasticsearch + Zipkin, você terá que usar quatro ferramentas diferentes. Para reduzir o tempo, seria bom poder realizar todas essas etapas usando uma ferramenta: Grafana. Vale ressaltar que esta abordagem de pesquisa está implementada no Grafana desde a versão 6. Assim, torna-se possível acessar os dados do Prometheus diretamente do Grafana.

Tela do Explorer dividida entre Prometheus e Loki

Nesta tela você pode visualizar os logs do Loki relacionados às métricas do Prometheus usando o conceito de tela dividida. Desde a versão 6.5, o Grafana permite analisar o ID de rastreamento nas entradas de log do Loki para seguir links para suas ferramentas de rastreamento distribuídas favoritas (Jaeger).

Teste local de Loki

A maneira mais fácil de testar o Loki localmente é usar docker-compose. O arquivo docker-compose está localizado no repositório Loki. Você pode obter o repositório usando o seguinte comando git:

$ git clone https://github.com/grafana/loki.git

Então você precisa ir para o diretório de produção:

$ cd production

Depois disso, você pode obter a versão mais recente das imagens do Docker:

$ docker-compose pull

Finalmente, a pilha Loki é iniciada com o seguinte comando:

$ docker-compose up

Arquitetura Loki

Aqui está um pequeno diagrama com a arquitetura Loki:

Princípios da Arquitetura Loki

O cliente web executa aplicativos no servidor, o Promtail coleta logs e os envia para o Loki, o cliente web também envia metadados para o Loki. Loki agrega tudo e transmite para Grafana.
Loki é lançado. Para visualizar os componentes disponíveis, execute o seguinte comando:

$ docker ps

No caso de um Docker recém-instalado, o comando deve retornar o seguinte resultado:

IMAGE               PORTS                  NAMES
grafana/promtail:                          production_promtail_1
grafana/grafana: m  0.0.0.0:3000->3000/tcp production_grafana_1
grafana/loki: late  80/tcp,0.0.0.0:3100... production_loki_1

Vemos os seguintes componentes:

Promtail: agente responsável por centralizar logs
Grafana: uma famosa ferramenta de painel
Loki: Daemon de centralização de dados

Como parte de uma infraestrutura clássica (por exemplo, baseada em máquinas virtuais), o agente Promtail deve ser implantado em cada máquina. Grafana e Loki podem ser instalados na mesma máquina.

Implantação no Kubernetes

A instalação dos componentes Loki no Kubernetes será a seguinte:

daemonSet para implantar o agente Promtail em cada uma das máquinas no cluster de servidores
Loki de implantação
e a última é a implantação do Grafana.

Felizmente, o Loki está disponível como um pacote Helm, facilitando a implantação.

Instalação via Heml

Você já deve ter o Heml instalado. Ele pode ser baixado do repositório GitHub do projeto. Ele é instalado descompactando o arquivo correspondente à sua arquitetura e adicionando helm ao $PATH.

Nota: a versão 3.0.0 do Helm foi lançada recentemente. Como houve muitas alterações, o leitor é aconselhado a esperar um pouco antes de usá-lo..

Adicionando uma fonte para Helm

O primeiro passo é adicionar o repositório “loki” usando o seguinte comando:

$ helm add loki https://grafana.github.io/loki/charts

Depois disso, você pode procurar por pacotes chamados “loki”:

$ helm search loki

Resultado:

loki/loki       0.17.2 v0.4.0 Loki: like Prometheus, but for logs.
loki/loki-stack 0.19.1 v0.4.0 Loki: like Prometheus, but for logs.
loki/fluent-bit 0.0.2  v0.0.1 Uses fluent-bit Loki go plugin for...
loki/promtail   0.13.1 v0.4.0 Responsible for gathering logs and...

Esses pacotes possuem os seguintes recursos:

pacote loki/loki corresponde apenas ao servidor Loki
pacote loki/fluent-bit permite que você implante um DaemonSet usando fluent-bin para coletar logs em vez do Promtail
pacote loki/promtail contém um agente de coleta de arquivos de log
pacote loki/pilha de loki, permite implantar imediatamente o Loki junto com o Promtail.

Instalando o Loki

Para implantar o Loki no Kubernetes, execute o seguinte comando no namespace “monitoring”:

$ helm upgrade --install loki loki/loki-stack --namespace monitoring

Para salvar em disco, adicione o parâmetro --set loki.persistence.enabled = true:

$ helm upgrade --install loki loki/loki-stack 
              --namespace monitoring 
              --set loki.persistence.enabled=true

Nota: se você deseja implantar o Grafana ao mesmo tempo, adicione o parâmetro --set grafana.enabled = true

Ao executar este comando você deverá obter a seguinte saída:

LAST DEPLOYED: Tue Nov 19 15:56:54 2019
NAMESPACE: monitoring
STATUS: DEPLOYED
RESOURCES:
==> v1/ClusterRole
NAME AGE
loki-promtail-clusterrole 189d
…
NOTES:
The Loki stack has been deployed to your cluster. Loki can now be added as a datasource in Grafana.
See <a href="http://docs.grafana.org/features/datasources/loki/">http://docs.grafana.org/features/datasources/loki/</a> for more details.

Observando o estado dos pods no namespace “monitoramento”, podemos ver que tudo está implantado:

$ kubectl -n monitoring get pods -l release=loki

Resultado:

NAME                 READY  STATUS   RESTARTS  AGE
loki-0               1/1    Running  0         147m
loki-promtail-9zjvc  1/1    Running  0         3h25m
loki-promtail-f6brf  1/1    Running  0         11h
loki-promtail-hdcj7  1/1    Running  0         3h23m
loki-promtail-jbqhc  1/1    Running  0         11h
loki-promtail-mj642  1/1    Running  0         62m
loki-promtail-nm64g  1/1    Running  0         24m

Todos os pods estão em execução. Agora é hora de fazer alguns testes!

Conectando-se ao Grafana

Para se conectar ao Grafana no Kubernetes, você precisa abrir um túnel para seu pod. Abaixo está o comando para abrir a porta 3000 para o pod Grafana:

$ kubectl -n port-forward monitoring svc/loki-grafana 3000:80

Outro ponto importante é a necessidade de recuperar a senha do administrador do Grafana. A senha é mantida em segredo loki-grafana no campo .data.admin-user no formato base64.

Para restaurá-lo, você precisa executar o seguinte comando:

$ kubectl -n monitoring get secret loki-grafana 
 --template '{{index .data "admin-password" | base64decode}}'; echo

Use esta senha em conjunto com a conta de administrador padrão (admin).

Definindo uma fonte de dados Loki no Grafana

Em primeiro lugar, certifique-se de que a fonte de dados Loki foi criada (Configuração/Fonte de dados).
Aqui está um exemplo:

Exemplo de configuração de uma fonte de dados para Loki

Ao clicar em “Testar” você pode verificar a conexão com Loki.

Fazendo pedidos para Loki

Agora vá para Grafana na seção “Explorar”. Ao receber logs de contêineres, Loki adiciona metadados do Kubernetes. Assim, torna-se possível visualizar os logs de um determinado container.

Por exemplo, para selecionar os logs do contêiner Promtail, você pode usar a seguinte consulta: {container_name = "promtail"}.
Aqui também lembre-se de selecionar a fonte de dados Loki.

Esta consulta retornará a atividade do contêiner da seguinte forma:

Resultado da consulta no Grafana

Adicionar ao painel

A partir do Grafana 6.4, você pode colocar informações de log diretamente no painel. Depois disso, o usuário poderá alternar rapidamente entre o número de solicitações em seu site e os rastreamentos do aplicativo.

Abaixo está um exemplo de painel que implementa essa interação:

Exemplo de painel com métricas do Prometheus e logs do Loki

Futuro de Loki

Comecei a usar o Loki em maio/junho com a versão 0.1. Hoje a versão 1, e até 1.1 e 1.2 já foram lançadas.

Deve-se admitir que a versão 0.1 não era suficientemente estável. Mas o 0.3 já mostrava sinais reais de maturidade, e as versões subsequentes (0.4, depois 1.0) apenas reforçaram essa impressão.

Depois da versão 1.0.0, ninguém terá desculpa para não usar esta ferramenta maravilhosa.

Outras melhorias não devem ser sobre o Loki, mas sim sobre a sua integração com o excelente Grafana. Na verdade, o Grafana 6.4 já possui uma boa integração com dashboards.

O Grafana 6.5, lançado recentemente, melhora ainda mais essa integração ao reconhecer automaticamente o conteúdo do log no formato JSON.

O vídeo abaixo mostra um pequeno exemplo desse mecanismo:

Usando strings Loki expostas no Grafana

Torna-se possível utilizar um dos campos JSON, por exemplo, para:

links para ferramenta externa
filtragem do conteúdo do log

Por exemplo, você pode clicar em traceId para acessar Zipkin ou Jaeger.

Como sempre, aguardamos seus comentários e convidamos você a webinar aberto, onde falaremos sobre como a indústria DevOps se desenvolveu durante 2019 e discutiremos possíveis caminhos de desenvolvimento para 2020.

Fonte: habr.com