Fazendo Monitoramento de suas apps com Grafana + Prometheus via Docker

Como você monitora suas aplicações? Receber alertas de erros, ou em caso de quedas do sistema, se você conta com a sorte, neste artigo vamos mostrar como podemos usar a combinação do Grafana + Prometheus para monitorar e enviar alertas quando necessário, gostou da ideia? Deixe nos comentários se vai passar a usar ou ainda se usa outras ferramentas para monitoramento.

Sumário

Abaixo mostramos a estrutura do nosso tutorial, incluindo passos opcionais.

• Pré-Requisitos
• Estrutura Geral
• Configuração e instalação do Prometheus
• Configuração de exports (Jobs) de métricas
• Configurando o Node exporter no Docker compose
• Configurando o Node exporter no prometheus.yml
• (Opcional) Configurando o Klipper exporter no Docker compose
• (Opcional) Configurando o Klipper exporter no prometheus.yml
• Configuração e instalação do Grafana
• Configurando um data source no Grafana
• Importando dashboard no Grafana

Pré-Requisitos

• Docker
• Docker compose

Nossa instalação e configuração será baseada em Docker, porém caso queira, também é possível fazer a instalação em um cluster kubernetes ou ainda diretamente na máquina, em ambos os casos os arquivos de configurações poderão ser usados, mudando só a forma de instalar as ferramentas.

Estrutura Geral

Para os próximos tópicos fazerem sentido vamos explicar como vamos estruturar nosso projeto, na raiz teremos o docker-compose com a configuração de subida do Prometheus, Grafana e exporter node. Também teremos uma pasta chamada prometheus e dentro dela teremos um arquivo de configuração do Prometheus, o mesmo acontece com o Grafana. Em cada um dos tópicos abaixo vamos mostrar apenas o trecho do tópico, para consultar a versão completa você pode acessar nosso gitlab.

Configuração e instalação do Prometheus

Vamos iniciar o Docker compose definindo um volume em que colocaremos todos os dados do Prometheus, ou seja, os dados coletados pelos exports, na sequência definimos o serviço que nomeamos de prometheus, usaremos a imagem prom/prometheus na última versão, como volume vamos montar a pasta configs e como comandos de customização definimos o local do arquivo de configuração, tempo de rentenção dos dados e caminho do templates. Na porta do serviço vamos mapear a porta no host como 3031 e no container como 9090, porém, como criamos uma rede não seria necessário para que os demais serviços como Grafana consiga acessar este. Só vamos mapear desta forma para que consigamos acessar, como resultado final teremos esse arquivo abaixo:

volumes:
  prometheus_data: {}

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: unless-stopped
    volumes:
      - ./configs:/etc/prometheus
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention=31d'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
    ports:
      - 3031:9090
    networks:
      - monitoring

Configuração de exports (Jobs) de métricas

Quando falamos de Prometheus temos que ter em mente que ele é um centralizador de dados ou seja um banco de dados, ele por si só não gera ou colhe métricas, por isso precisamos do exports que vamos configurar em seguida. Este export é alguém expecialista no que queremos monitorar, ele vai pegar os dados e converter em um padrão que o Prometheus entende e é por isso que vamos configurar 2 exports para que veja isso na prática. O primeiro será o node exporter, padrão para monitoramento de servidores linux em geral e o segundo menos comum, usado para exportar dados de impressoras 3D rodando Klipper.

Configurando o Node exporter no Docker compose

Para o primeiro exemplo a imagem é fornecida pelo time do Prometheus: prom/node-exporter e ele será usado de forma praticamente padrão, sendo necessário apenas mapear os volumes, caso rode ele via docker, se não, ele pegaria essas informações por padrão. E por último como queremos acessar ele no final vamos expor ele na porta 3032, e também vamos ingressar ele na mesma rede.

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    restart: unless-stopped
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.rootfs=/rootfs'
      - '--path.sysfs=/host/sys'
      - '--collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)'
    ports:
      - 3032:9100
    networks:
      - monitoring

Já o exporter Klipper não precisa de nenhuma configuração neste momento, este é um projeto mantido pela comunidade, este é o github deles, nossa única configuração será mapear no host a porta 3033.

Configurando o Node exporter no prometheus.yml

Explicando de forma simplista, nosso arquivo de Prometheus, será onde vamos mapear como cada export funciona de forma que o Prometheus entenda e mapeie ele. Começando com o Node exporter precisamos apenas informar o endereço que ele está rodando, em nosso caso usamos um domínio para gerir nossa rede, em seu caso, será outro ou localhost, lembra que falamos que os serviços podem acessar o serviço por estar na mesma rede? Desta forma localhost:9100 funciona também. Além disso vamos definir o nome que aparece no Prometheus e o intervalo de busca.

scrape_configs:
  - job_name: 'cloud_node'
    scrape_interval: 5s
    static_configs:
      - targets: ['lenovo.int-dev.codeinloop.com.br:9100']

Configurando o Klipper exporter no Docker compose

Para o Klipper a configuração no Docker compose não vai ser diferente do “Node Exporter”, na verdade a configuração vai mudar mesmo no config do Prometheus, então aqui apenas fazemos referência para imagem e colocamos a porta em que o serviço deve rodar.

  klipper-exporter:
    hostname: klipper-exporter
    image: ghcr.io/scross01/prometheus-klipper-exporter:v0.10.0
    container_name: exporter
    restart: unless-stopped
    ports:
      - 3033:9101
    networks:
      - monitoring

Configurando o Klipper exporter no prometheus.yml

Esta configuração é mais complexa do que a anterior, isso porque precisamos buscar os dados em 2 pontos, veja só em target indicamos a impressora como destino dos dados e isso é verdade, porém não instalamos o exporter nela e por isso precisamos indicar para o Prometheus o parâmetro target_label que indica o local em que o export está rodando que no nosso caso é lenovo.int-dev.codeinloop.com.br:9101. Além disso passamos outros parâmetros que podem ser consultados na documentação do projeto.

scrape_configs:
  - job_name: "resinada"
    scrape_interval: 5s
    metrics_path: /probe
    static_configs:
      - targets: ['ender.int-dev.codeinloop.com.br:7125']
    params:
      modules: [
        'process_stats',
        'network_stats',
        'system_info',
        'job_queue',
        'directory_info',
        'printer_objects',
        'history',
      ]
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement:  lenovo.int-dev.codeinloop.com.br:9101

Configuração e instalação do Grafana

Para o Grafana, temos um Docker compose simplificado onde precisamos informar apenas o GF_SERVER_ROOT_URL caso utilize proxy na frente nos demais, aqui a configuração padrão vai nos atender, e este por ser muito grande não vamos colocar no blog, porém no nosso github você encontra ele.

volumes:
  prometheus_data: {}
  grafana_data: {}

services:
  grafana:
    image: grafana/grafana-oss
    container_name: grafana
    restart: unless-stopped
    ports:
      - 3030:3000
    networks:
      - monitoring
    environment:
     - GF_SERVER_ROOT_URL=https://lenovo.int-dev.codeinloop.com.br/
    volumes:
      - ./grafana:/etc/grafana/conf
      - grafana_data:/var/lib/grafana

Neste momento já podemos acessar a URL do grafana https://lenovo.int-dev.codeinloop.com.br/ e vamos nos deparar com a tela de login que na primeira vez terá admin como login e senha.

Configurando um data source no Grafana

Após o primeiro login, teremos a opção de atualizar as credencias ou pular esta etapa, depois de logado já temos o Grafana pronto, porém ainda sem conexão com o database do Prometheus. Para configurar precisaremos acessar Home > Connections > Data sources > Prometheus onde vamos precisar preencher apenas a URL do mesmo, uma vez que não criamos credenciais de acesso para o Prometheus no nosso exemplo https://lenovo.int-dev.codeinloop.com.br. Reforçamos a criação de métodos de autenticação para ambientes produtivos, se quiser ver como fazer isso, deixe nos comentários que poderemos produzir um artigo sobre.

Importando dashboard no Grafana

Como queremos um dashboard para Node e outro para Klipper, podemos ou criar um do zero ou importar algum da loja da Grafana Labs e é isto que vamos fazer, para isso basta acessar esta página para dashboards do Node e esta página para Klipper/Moonraker.

No final devemos ter um dashboard com bastante informação como o nosso exemplo abaixo:

Conclusão

Com isso já temos um ambiente de desenvolvimento para monitoramento, como próximo passo poderíamos fazer um deploy em um cluster K8s por exemplo. Já conhecia o Grafana ou Prometheus? O que achou do nosso tutorial? Lembrando que você pode encontrar o projeto completo neste github e sua versão em vídeo no nosso canal no YouTube.