Stack de Monitoramento: Prometheus, Grafana e Ferramentas Essenciais

Introdução à Stack Prometheus e Grafana para Monitoramento de Infraestrutura

O monitoramento moderno de infraestrutura exige mais do que simples alertas de "ligado/desligado". Para manter a estabilidade de ambientes cloud, VPS e servidores dedicados, é fundamental visualizar métricas em tempo real, identificar gargalos de performance e correlacionar eventos de segurança com picos de tráfego. A combinação de Prometheus como motor de coleta e armazenamento de séries temporais, e Grafana para visualização e dashboards, tornou-se o padrão da indústria.

Este tutorial técnico detalha a instalação, configuração e integração básica dessa stack em um ambiente Linux (Ubuntu/Debian), permitindo que sysadmins e desenvolvedores tenham visibilidade total sobre a saúde dos seus servidores. Abordaremos desde a instalação dos binários até a criação de dashboards iniciais, utilizando ferramentas auxiliares para contextualizar o ecossistema de monitoramento.

1. Preparação do Ambiente

Antes de instalar o Prometheus e o Grafana, é essencial preparar o servidor com as dependências necessárias e garantir que os serviços não interfiram uns com os outros durante a instalação. Recomendamos o uso de um usuário com privilégios sudo ou execução direta como root para simplificar os comandos.

Comece atualizando o índice dos pacotes do sistema operacional e instalando utilitários básicos:

sudo apt update
sudo apt install -y curl wget apt-transport-https gnupg2 software-properties-common

Além disso, verifique se há conflitos com serviços de monitoramento anteriores. Ferramentas como Uptime Kuma, Wazuh ou FastNetMon podem estar rodando em portas específicas (como 3001 ou 9200). Se você estiver migrando para uma stack Prometheus, certifique-se de que as portas 9090 (Prometheus) e 3000 (Grafana) estejam livres.

2. Instalando o Prometheus

O Prometheus funciona como um agente de coleta pull-based. Ele não precisa ser instalado em cada servidor alvo se você usar exportadores, mas no nosso caso, instalaremos o servidor central para monitorar a própria máquina ou orquestrar outros nós.

2.1. Download e Extração

Acesse a página oficial de releases do Prometheus no GitHub para obter a versão mais recente estável. Para este exemplo, utilizaremos um script automatizado que baixa, extrai e configura o serviço como um daemon do systemd.

PROMETHEUS_VERSION="2.47.0"
cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v${PROMETHEUS_VERSION}/prometheus-${PROMETHEUS_VERSION}.linux-amd64.tar.gz
tar xzf prometheus-${PROMETHEUS_VERSION}.linux-amd64.tar.gz
sudo cp prometheus-${PROMETHEUS_VERSION}.linux-amd64/prometheus /usr/local/bin/
sudo cp prometheus-${PROMETHEUS_VERSION}.linux-amd64/promtool /usr/local/bin/
sudo chmod +x /usr/local/bin/prometheus /usr/local/bin/promtool

2.2. Configuração do Usuário e Diretórios

Para segurança, crie um usuário dedicado que não tenha login interativo:

sudo useradd --no-create-home --shell /bin/false prometheus

Crie os diretórios para configuração e armazenamento de dados:

sudo mkdir -p /etc/prometheus
sudo mkdir -p /var/lib/prometheus

2.3. Configurando o Arquivo YAML

O Prometheus é controlado pelo arquivo prometheus.yml. Crie uma configuração básica que monitora a si mesmo e os exportadores locais:

sudo nano /etc/prometheus/prometheus.yml

Insira o seguinte conteúdo:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

rule_files:
  # "alert_rules.yml" has not been defined in this example
  # "alert_rules.yml"

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

  - job_name: "node-exporter"
    static_configs:
      - targets: ["localhost:9100"]

Defina as permissões corretas para que o usuário prometheus possa ler a configuração e escrever nos dados:

sudo chown prometheus:prometheus /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /var/lib/prometheus/

2.4. Criando o Serviço Systemd

Crie o arquivo de unidade do systemd para gerenciar o ciclo de vida do Prometheus:

sudo nano /etc/systemd/system/prometheus.service

Conteúdo do serviço:

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
Type=simple
User=prometheus
Group=prometheus
ExecStart=/usr/local/bin/prometheus \
    --config.file=/etc/prometheus/prometheus.yml \
    --storage.tsdb.path=/var/lib/prometheus/ \
    --web.console.templates=/etc/prometheus/consoles \
    --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

Habilite e inicie o serviço:

sudo systemctl daemon-reload
sudo systemctl enable --now prometheus
sudo systemctl status prometheus

3. Instalando e Configurando o Grafana

O Grafana consome os dados do Prometheus e os transforma em gráficos interativos. A instalação via repositório oficial garante atualizações mais fáceis.

3.1. Instalação do Pacote

sudo apt-get install -y apt-transport-https software-properties-common
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
echo "deb https://packages.grafana.com/oss/deb stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana

3.2. Configurando o DataSource do Prometheus

Inicie o serviço do Grafana:

sudo systemctl enable --now grafana-server
sudo systemctl start grafana-server

Acesse a interface web do Grafana em http://SEU_IP:3000. O login padrão é admin/admin (o sistema solicitará a troca da senha no primeiro acesso).

Navegue até Settings (Engrenagem) > Data Sources > Add data source. Selecione Prometheus.

No campo URL, insira: http://localhost:9090. Mantenha as configurações padrão de autenticação e clique em Save & Test. A mensagem "Data source is working" confirma a integração.

4. Exportadores: Expandindo o Monitoramento

O Prometheus sozinho monitora apenas o que é exposto via HTTP. Para monitorar métricas de sistema (CPU, RAM, Disco) ou aplicações específicas, utilizamos Exportadores.

4.1. Node Exporter para Métricas de Sistema

O node_exporter é o padrão para expor métricas do kernel Linux. Baixe e configure:

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar xzf node_exporter-1.6.1.linux-amd64.tar.gz
sudo cp node_exporter-1.6.1.linux-amd64/node_exporter /usr/local/bin/
sudo useradd --no-create-home --shell /bin/false node_exporter

Crie o serviço systemd:

sudo nano /etc/systemd/system/node_exporter.service

[Unit]
Description=Node Exporter
After=network.target

[Service]
User=node_exporter
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now node_exporter

O Prometheus já está configurado no passo 2.3 para coletar dados desta porta (:9100). Reinicie o Prometheus se necessário:

sudo systemctl restart prometheus

5. Integração com Ecossistema de Segurança e Tráfego

Em ambientes corporativos, o monitoramento de infraestrutura deve ser correlacionado com eventos de segurança e tráfego de rede. Ferramentas como Wazuh (SIEM/HIDS) e FastNetMon (DDoS mitigation) podem gerar dados que enriquecem seus dashboards.

Wazuh: Embora o Wazuh tenha sua própria interface, ele pode enviar logs para um Elasticsearch ou usar alertas JSON. Para integrar ao Grafana, considere usar o plugin wazuh-grafana-datasource ou exportar métricas de agente via um script customizado que alimenta o Prometheus.

Akvorado: Se você utiliza Akvorado para coleta de fluxo NetFlow/IPFIX, note que ele possui suporte nativo ao Prometheus. Basta habilitar a flag --metrics-address na configuração do Akvorado e adicionar um novo job no prometheus.yml:

- job_name: 'akvorado'
  static_configs:
    - targets: ['localhost:9102']

Isso permitirá visualizar picos de tráfego e padrões de fluxo diretamente nos gráficos do Grafana, cruzando dados de aplicação com consumo de banda.

6. Criando Dashboards no Grafana

Agora que os dados estão fluindo, vamos visualizá-los.

1. No Grafana, clique em Create > Dashboard.
2. Clique em Add a new panel.
3. No campo Query, selecione o datasource Prometheus.
4. Para ver a carga da CPU, use a métrica: node_cpu_seconds_total. No gráfico de expressão, tente: 100 - (avg(irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100).
5. Defina o título do painel como "CPU Usage" e clique em Apply.

O Grafana oferece uma biblioteca comunitária vasta. Para dashboards prontos de infraestrutura, vá em + Create > Import e use o ID do dashboard. O ID 1860 é um padrão popular para "Node Exporter Full", que fornece visão completa de disco, rede e memória.

7. Boas Práticas e Manutenção

Para manter a stack saudável a longo prazo:

• Rotação de Logs: Configure logrotate para os logs do Prometheus e Grafana para evitar consumo excessivo de disco.
• Backup de Dados: O diretório /var/lib/prometheus contém o banco de dados TSDB. Realize backups regulares (ex: via cron) desse diretório.
• Alertas: Use o Prometheus Alertmanager para enviar notificações (Slack, Email, Telegram) quando métricas críticas forem atingidas. O Uptime Kuma pode ser usado como uma camada externa de verificação de disponibilidade (black-box monitoring), enquanto o Prometheus foca na métrica interna.
• Segurança: Nunca exponha o Prometheus ou Grafana diretamente à internet sem autenticação e TLS. Utilize um proxy reverso (Nginx/Caddy) com HTTPS para acessar as interfaces web.

Conclusão

A implementação de uma stack Prometheus e Grafana oferece uma visibilidade profunda e flexível sobre a infraestrutura. Diferente de soluções proprietárias, ela é escalável, open-source e integra-se facilmente com ferramentas como Akvorado para análise de fluxo e FastNetMon para defesa contra ataques.

Com esta base estabelecida, profissionais de TI podem evoluir para monitoramento distribuído em ambientes Kubernetes ou microserviços, utilizando os mesmos princípios de coleta e visualização. A personalização dos dashboards é o próximo passo para transformar dados brutos em inteligência operacional.