Grafana + Prometheus: Dashboard de Saúde para Monitoramento

Grafana e Prometheus são as pedras angulares da moderna stack de observabilidade. Enquanto o Prometheus coleta e armazena métricas temporais, o Grafana transforma esses dados brutos em visualizações intuitivas e acionáveis. Para sysadmins e DevOps no Brasil, dominar essa combinação é essencial para garantir a disponibilidade de servidores, identificar gargalos de performance e configurar alertas proativos antes que falhas impactem os usuários finais.

Neste tutorial técnico, vamos construir um ambiente de monitoramento completo. Utilizaremos Docker Compose para orquestrar os contêineres, garantindo isolamento e facilidade de replicação. O foco será criar um dashboard funcional que monitore a saúde do próprio sistema de monitoramento e de uma aplicação web de exemplo.

Pré-requisitos e Preparação do Ambiente

Antes de iniciar a configuração, certifique-se de ter as seguintes ferramentas instaladas na sua estação de trabalho ou servidor:

Docker Engine (versão 20.10 ou superior)
Docker Compose (plugin ou versão standalone v2)

Criaremos uma estrutura de diretórios simples para manter os arquivos de configuração organizados. Isso facilita a manutenção e o versionamento no futuro.

mkdir grafana-prometheus-stack
cd grafana-prometheus-stack
touch docker-compose.yml

Configuração do Docker Compose

O arquivo docker-compose.yml é o coração da nossa infraestrutura. Ele define os serviços, as portas de exposição e, crucialmente, como o Prometheus irá "scrapear" (coletar) as métricas.

Crie o conteúdo abaixo no arquivo docker-compose.yml. Este arquivo configura três serviços principais: Prometheus, Grafana e cAdvisor.

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus:/etc/prometheus
      - prom_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
    volumes:
      - grafana_data:/var/lib/grafana

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    restart: unless-stopped
    ports:
      - "8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:rw
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

volumes:
  prom_data:
  grafana_data:

Análise Técnica da Configuração:

Prometheus: Mapeamos o volume ./prometheus para dentro do contêiner. Isso permite que editemos o arquivo de configuração diretamente no host, sem precisar entrar no container. A porta 9090 expõe a interface web nativa do Prometheus.
Grafana: Definimos a variável de ambiente GF_SECURITY_ADMIN_PASSWORD para evitar que você precise definir uma senha complexa manualmente na primeira execução. O volume grafana_data persiste os dashboards e configurações de usuário.
cAdvisor (Container Advisor): Este serviço é leve e focado em monitorar recursos de containers Docker. Ele expõe métricas no formato compatível com Prometheus na porta 8080.

Configurando o Scraping do Prometheus

O Prometheus não descobre serviços automaticamente; ele precisa ser configurado para saber onde buscar as métricas. Criaremos a configuração principal que define os alvos (targets) de coleta.

mkdir -p prometheus
touch prometheus/prometheus.yml

Dentro do arquivo prometheus/prometheus.yml, insira o seguinte conteúdo:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

Explicação Detalhada:

scrape_interval: 15s: Define que o Prometheus coletará métricas de todos os jobs definidos a cada 15 segundos. Para ambientes de alta performance, você pode reduzir para 5s, mas isso aumenta a carga no disco e CPU.
job_name: 'prometheus': Configura o auto-monitoramento. O Prometheus coleta suas próprias métricas internas (quantidade de memória, requisições HTTP, etc.) acessando sua própria API na porta 9090.
job_name: 'cadvisor': Aqui apontamos para o serviço cadvisor definido no Docker Compose. Note que usamos o nome do serviço (cadvisor) em vez de localhost. Isso ocorre porque o Docker Compose cria uma rede interna onde os nomes dos serviços funcionam como DNS interno.

Inicializando a Infraestrutura

Agora que todos os arquivos estão prontos, vamos subir os contêineres. Execute o comando abaixo no diretório raiz do projeto:

docker compose up -d

O sinalizador -d roda os contêineres em modo detached (background). Verifique se tudo está rodando corretamente com:

docker ps

Você deve ver três contêineres ativos: prometheus, grafana e cadvisor. Se algum estiver em estado "Exited", verifique os logs com docker logs <nome-do-container>.

Configurando o Data Source no Grafana

Com a infraestrutura rodando, precisamos conectar o Grafana ao Prometheus para que ele possa ler os dados.

Acesse a interface do Grafana em http://localhost:3000.
Faça login com usuário admin e senha admin123. O sistema solicitará que você altere a senha na primeira vez. Defina uma senha segura para produção.
No menu lateral esquerdo, clique no ícone de engrenagem (Configuration) e selecione Data Sources.
Clique em Add data source e selecione Prometheus.

Na tela de configuração do Prometheus:

Connection URL: Insira http://prometheus:9090. Novamente, usamos o nome interno do serviço Docker.
Scrape interval: Mantenha o padrão ou ajuste conforme sua necessidade.

Role até o final da página e clique em Save & Test. Uma mensagem verde indicando "Data source is working" confirmará a conexão. Se falhar, verifique se os contêineres estão na mesma rede do Docker Compose.

Criando o Dashboard de Saúde

Agora vamos visualizar os dados. O Grafana possui uma biblioteca enorme de dashboards prontos, mas entender como construí-los é fundamental para a observabilidade personalizada.

Método 1: Importação Rápida (Recomendado para Iniciantes)

No menu lateral do Grafana, clique em + (Create) e depois em Import.
No campo "Import via grafana.com", digite o ID 14282. Este é um dashboard popular para monitoramento de containers usando cAdvisor.
Clique em Load.
No próximo passo, selecione a origem de dados Prometheus que criamos anteriormente no dropdown "Prometheus".
Clique em Import.

Você verá instantaneamente gráficos de uso de CPU, memória, rede e disco dos seus containers.

Método 2: Criação Manual (Para Entender PromQL)

Para sysadmins que desejam controle total, criar painéis manualmente ensina a linguagem de consulta do Prometheus (PromQL).

Crie um novo painel clicando em + New Dashboard.
Clique em Add visualization.
No painel de query, você verá uma barra de texto. Aqui inserimos as consultas.

Exemplo Prático: Monitorar Uso de Memória do Container cAdvisor

Insira a seguinte consulta na barra de query:

container_memory_usage_bytes{instance="cadvisor:8080"}

O Grafana exibirá as métricas brutas. Para torná-las úteis, aplique transformações:

Clique em Transform no menu à direita do gráfico.
Selecione Filter by name e filtre apenas o container que você deseja monitorar (ex: grafana ou prometheus).
Vá em Graph panel options e ajuste a legenda para mostrar o nome do container.

Dica Pro: Use a aba Explore no menu lateral para testar suas consultas PromQL antes de adicioná-las ao dashboard. Ela permite visualizar dados históricos e ajustar intervalos de tempo sem poluir seus painéis.

Configurando Alertas Básicos

A observabilidade não serve apenas para olhar gráficos bonitos; serve para agir quando algo sai do padrão. O Prometheus possui um sistema de regras de alerta integrado.

Crie um arquivo alert_rules.yml no diretório prometheus/:

groups:
  - name: container_alerts
    rules:
      - alert: HighMemoryUsage
        expr: container_memory_usage_bytes{instance="cadvisor:8080"} > 500000000
        for: 2m
        labels:
          severity: warning
        annotations:
          summary: "Alto uso de memória no container {{ $labels.name }}"
          description: "O container {{ $labels.name }} está usando mais de 500MB por mais de 2 minutos."

Em seguida, atualize o prometheus/prometheus.yml para incluir a carga dessas regras:

rule_files:
  - /etc/prometheus/alert_rules.yml

Atenção: Para que as regras sejam aplicadas sem reiniciar, o Prometheus precisa recarregar sua configuração. Em um ambiente Docker, você pode enviar um sinal SIGHUP ou usar a API de reload:

curl -X POST http://localhost:9090/-/reload

Para receber esses alertas em tempo real (ex: no Slack, Discord ou Email), é necessário integrar com o Prometheus Alertmanager. Isso requer uma configuração adicional de roteamento de notificações, que fica fora do escopo deste tutorial básico, mas é o próximo passo lógico para uma infraestrutura madura.

Boas Práticas e Manutenção

Ao implementar este stack de monitoramento em produção, considere os seguintes pontos críticos:

Rotação de Dados: O Prometheus armazena tudo em disco. Configure flags como --storage.tsdb.retention.time no arquivo de inicialização para limitar o armazenamento (ex: 15 dias). Dados antigos podem ser exportados para sistemas como Thanos ou Cortex.
Segurança: Nunca exponha o Prometheus e o Grafana diretamente na internet sem autenticação e HTTPS. Use um reverse proxy (como Nginx ou Traefik) com autenticação básica ou OAuth2.
Ruído de Alertas: Configure limites (thresholds) realistas. Alertar para tudo gera "alert fatigue" (fadiga de alerta), fazendo a equipe ignorar avisos importantes.

Conclusão

Com este tutorial, você estabeleceu uma base sólida de observabilidade. Você possui um sistema que coleta métricas de infraestrutura e aplicações (Prometheus) e as transforma em insights visuais (Grafana). A capacidade de identificar anomalias rapidamente reduz o MTTR (Mean Time To Resolution) e aumenta a confiança na estabilidade da sua infra.

O próximo passo recomendado é integrar métricas de aplicações específicas (como logs de erro do Nginx ou latência de banco de dados) ao seu dashboard existente, expandindo assim a visibilidade sobre toda a stack tecnológica da sua organização.

Tags: #Grafana #Prometheus #monitoramento #dashboard #infra #alertas #observabilidade #sysadmin