Logs em larga escala com Grafana Loki e Kubernetes

Profissionais de SRE (Site Reliability Engineering) enfrentam desafios significativos ao lidar com infraestruturas de larga escala, especialmente quando se trata de gerenciar múltiplos clusters Kubernetes. À medida que a quantidade de nodes em um cluster cresce, podendo alcançar dezenas ou até centenas, a complexidade da administração e manutenção também aumenta exponencialmente.

Um dos principais desafios é o gerenciamento eficiente de logs. Em uma infraestrutura dispersa e escalável, como clusters Kubernetes, a coleta e análise de logs se torna uma tarefa crítica. Sem uma solução centralizada, os profissionais de SRE frequentemente recorrem a métodos manuais, como acessos SSH para cada node ou pod, e processos de troubleshooting que são demorados e propensos a erros.

Centralizar os logs com uma solução robusta como o Grafana Loki pode transformar drasticamente essa dinâmica. Ao consolidar logs de múltiplos clusters em um único ponto de acesso, elimina-se a necessidade de intervenções manuais dispersas, permitindo uma análise rápida e precisa. Isso não só agiliza o processo de troubleshooting, como também libera os profissionais de SRE para focar em tarefas de maior valor, aumentando a eficiência operacional e a confiabilidade do sistema.

Neste artigo, exploraremos em detalhes como implementar o Grafana Loki-Distributed em um ambiente Kubernetes de larga escala, destacando os benefícios e as melhores práticas para alcançar uma gestão eficiente de logs.

Introdução ao Grafana Loki

O Grafana Loki é uma solução de log centralizada desenvolvida pela Grafana Labs. Diferente de outras soluções de logging, como o ELK stack, o Loki foi projetado para ser altamente eficiente e escalável, utilizando a mesma abordagem de indexação do Prometheus. Loki indexa apenas os metadados dos logs e armazena os dados brutos em formato comprimido, resultando em uma solução mais leve e rápida para consultas de logs.

Segundo a documentação oficial, “Loki é uma pilha de logs desenvolvida para ser barata e fácil de operar. Ele não indexa o conteúdo completo dos logs, mas sim um conjunto de etiquetas para cada stream de log. Isso faz com que Loki seja muito mais eficiente em termos de armazenamento e velocidade de consulta.”

Tipos e Níveis de Logs

Para gerenciar logs de forma eficaz, é crucial compreender os diferentes tipos e níveis de logs disponíveis. Isso ajuda na categorização e análise correta das informações.

Tipos de Logs

Logs de Aplicação: Gerados pelas aplicações em execução, contendo informações sobre eventos de aplicação, erros, warnings e dados de depuração.
Logs de Sistema: Incluem mensagens do sistema operacional e dos serviços de sistema, como logs do kernel, serviços de rede e gerenciamento de recursos.
Logs de Segurança: Relacionados a eventos de segurança, incluindo tentativas de login, acessos autorizados e não autorizados, e eventos relacionados à conformidade.
Logs de Auditoria: Registram as ações dos usuários e mudanças de configuração, importantes para rastreamento e auditoria de atividades.
Logs de Rede: Incluem registros de tráfego de rede, firewalls e dispositivos de rede, essenciais para monitorar e resolver problemas de conectividade.

Níveis de Logs

DEBUG: Informações detalhadas utilizadas principalmente para depuração e desenvolvimento. Contêm informações minuciosas sobre o fluxo do programa.
INFO: Mensagens informativas que destacam o progresso normal da aplicação. Útil para monitoramento de operações rotineiras.
WARN: Indica situações que não são erros, mas podem necessitar de atenção. Pode incluir potenciais problemas futuros ou uso indevido de recursos.
ERROR: Erros que permitem que a aplicação continue rodando, mas indicam falhas que precisam ser corrigidas.
CRITICAL: Problemas graves que podem causar a interrupção da aplicação ou do sistema. Requerem ação imediata.

Arquitetura do Loki-Distributed

Loki-Distributed é a configuração recomendada para implantação em larga escala, onde múltiplos clusters Kubernetes enviam logs para um cluster central. A arquitetura é composta por vários componentes:

Distributor: Recebe logs dos agentes (como Promtail) e os distribui para os ingesters.
Ingester: Recebe logs do distributor, os processa e armazena temporariamente.
Querier: Processa consultas e retorna os dados de logs solicitados.
Query Frontend: Atua como um cache e balanceador de carga para consultas.
Index Gateway: Gerencia os índices de logs.
Compactor: Compila e organiza logs em armazenamento de longa duração.
Storage (S3, GCS, Cassandra, etc.): Armazena logs e índices de forma persistente.

Dados Quentes e Dados Frios

Na gestão de logs em larga escala, é importante diferenciar entre dados quentes e dados frios para otimizar o armazenamento e a performance de consultas:

Dados Quentes: São logs recentes e frequentemente acessados. Esses dados são armazenados em sistemas de armazenamento rápido, como SSDs, para garantir um acesso rápido e eficiente. No contexto do Grafana Loki, os dados quentes são geralmente mantidos nos ingesters ou em armazenamento de curta duração, onde podem ser rapidamente consultados e analisados.
Dados Frios: São logs mais antigos e menos frequentemente acessados. Esses dados são movidos para sistemas de armazenamento mais lentos e econômicos, como armazenamento em nuvem (S3, GCS) ou sistemas de armazenamento de longa duração. O Compactor do Loki ajuda a mover esses dados de forma eficiente, garantindo que eles ainda possam ser acessados quando necessário, mas sem ocupar os recursos de armazenamento mais rápidos e caros.

Implementação Hands-on

Pré-requisitos

Clusters Kubernetes: Pelo menos um cluster central e múltiplos clusters de origem.
kubectl: Ferramenta de linha de comando para interação com Kubernetes.
Helm: Gerenciador de pacotes para Kubernetes.

Passo 1: Configurar o Cluster Central

1- Instalar o Helm:

curl https://raw.githubusercontent.com/helm/helm/master/scripts/get-helm-3 | bash

2- Adicionar o repositório do Grafana Loki:

helm repo add grafana https://grafana.github.io/helm-charts helm repo update

3- Criar um namespace para o Loki:

kubectl create namespace loki

4- Instalar o Loki-Distributed:

helm install loki-distributed grafana/loki-distributed --namespace loki

É importante customizar o arquivo values.yaml conforme necessário. Um exemplo básico de values.yaml:

config:
  auth_enabled: false
  distributor:
    ring:
      kvstore:
        store: memberlist
  ingester:
    lifecycler:
      ring:
        kvstore:
          store: memberlist
        replication_factor: 1
  schema_config:
    configs:
      - from: 2020-10-24
        store: boltdb-shipper
        object_store: s3
        schema: v11
        index:
          prefix: index_
          period: 24h
  storage_config:
    aws:
      s3: s3://YOUR_S3_BUCKET_NAME
      region: YOUR_AWS_REGION
    boltdb_shipper:
      shared_store: s3
      active_index_directory: /var/loki/index
      cache_location: /var/loki/cache
  limits_config:
    enforce_metric_name: false
    reject_old_samples: true
    reject_old_samples_max_age: 168h

5- Configurar o S3:

Certifique-se de que o bucket do S3 esteja configurado e que as credenciais estejam acessíveis no cluster Kubernetes.

Passo 2: Configurar os Clusters de Origem

1- Instalar o Promtail em cada cluster de origem:

kubectl create namespace promtail 
helm install promtail grafana/promtail --namespace promtail

2- Configurar o values.yaml do Promtail:

config:
  lokiAddress: http://<LOKI_DISTRIBUTOR_URL>:3100/loki/api/v1/push
  clients:
    - url: http://<LOKI_DISTRIBUTOR_URL>:3100/loki/api/v1/push
  positions:
    filename: /var/log/positions.yaml
  scrape_configs:
    - job_name: kubernetes-pods-app
      kubernetes_sd_configs:
        - role: pod
      relabel_configs:
        - source_labels: [__meta_kubernetes_namespace]
          target_label: namespace
        - source_labels: [__meta_kubernetes_pod_name]
          target_label: pod
        - source_labels: [__meta_kubernetes_pod_label_name]
          target_label: app
      pipeline_stages:
        - cri: {}
      static_configs:
        - targets: ['localhost']
          labels:
            job: varlogs
            __path__: /var/log/containers/*.log

3- Aplicar as configurações no Promtail:

kubectl apply -f promtail-values.yaml

Passo 3: Verificar a Integração

Acessar o Grafana:
- Instale o Grafana no cluster central:
  helm install grafana grafana/grafana --namespace loki
- Configure o Loki como fonte de dados no Grafana:
  - Acesse a interface web do Grafana.
  - Vá em Configuration > Data Sources.
  - Adicione uma nova fonte de dados com o tipo “Loki”.
  - Use a URL do distributor do Loki.
Consultar Logs:
- Use o painel do Grafana para consultar e visualizar logs recebidos de múltiplos clusters.
- Configure dashboards e alertas conforme necessário para monitorar a saúde e o desempenho do seu sistema.

Considerações Finais

Implementar o Grafana Loki-Distributed em um ambiente Kubernetes de larga escala requer planejamento cuidadoso e compreensão dos componentes envolvidos. A configuração adequada de armazenamento, rede e segurança é crucial para garantir uma operação eficiente e segura. A documentação oficial do Grafana Loki é um recurso valioso para resolver dúvidas e ajustar a configuração conforme necessário.

A integração de múltiplos clusters Kubernetes com uma solução centralizada de logging como o Loki oferece uma visibilidade robusta e eficiente dos logs, facilitando a detecção de problemas e a manutenção de um ambiente de TI saudável. Com uma configuração adequada, é possível simplificar significativamente o processo de troubleshooting, evitando acessos manuais e tornando os profissionais de SRE mais eficientes e focados em atividades estratégicas.

Recursos Adicionais

Para complementar o conhecimento adquirido e auxiliar na implementação do Grafana Loki-Distributed, seguem alguns recursos adicionais:

Documentação Oficial do Grafana Loki: Grafana Loki Docs
Guia de Configuração do Promtail: Promtail Configuration
Helm Charts do Grafana: Grafana Helm Charts
Comunidade Grafana: Grafana Community

Esses recursos fornecem detalhes aprofundados sobre a configuração, melhores práticas e exemplos práticos para otimizar a implementação e uso do Grafana Loki em ambientes de larga escala.