Sistema de Monitoramento Prometheus: Guia Completo de Configuração para Monitoramento de Infraestrutura e Aplicações

À medida que a infraestrutura moderna cresce em complexidade — abrangendo microsserviços, contentores e sistemas distribuídos — uma monitorização robusta deixou de ser opcional. É um requisito fundamental para manter o desempenho, a fiabilidade e a escalabilidade. O Prometheus, um conjunto de ferramentas de monitorização e alertas de código aberto, emergiu como uma das soluções mais amplamente adotadas para recolher e visualizar métricas de séries temporais em ambientes diversificados.

Originalmente desenvolvido pela SoundCloud e agora um projeto graduado da Cloud Native Computing Foundation (CNCF), o Prometheus é utilizado por equipas de engenharia em todo o mundo. Este guia abrangente cobre tudo o que precisa de saber: o que é o Prometheus, como funciona, os seus componentes principais e um processo de configuração completo passo a passo — incluindo Node Exporter, dashboards Grafana e configuração de alertas.

O Que É o Prometheus?

O Prometheus é um sistema de monitorização poderoso e de código aberto, concebido para recolher, armazenar e consultar dados de séries temporais — medições ou eventos registados ao longo do tempo com timestamps de alta resolução. Permite às equipas visualizar a saúde do sistema, analisar tendências e acionar alertas inteligentes antes que pequenos problemas se transformem em interrupções críticas.

Principais Funcionalidades do Prometheus

Estas capacidades tornam o Prometheus uma escolha ideal para equipas que executam cargas de trabalho em Alojamento VPS, infraestrutura bare-metal ou plataformas em contentores.

Como Funciona o Prometheus

O Prometheus segue uma arquitetura limpa e bem definida, construída em torno da recolha e armazenamento de dados de séries temporais. Compreender esta arquitetura é essencial antes de o implementar em produção.

Fluxo de Trabalho Principal

1. Recolha de Métricas (Scraping): O Prometheus envia periodicamente pedidos HTTP para endpoints de destino configurados — conhecidos como *exporters* — para recolher métricas. O intervalo de recolha é totalmente configurável.

1. Armazenamento de Séries Temporais: As métricas recolhidas são persistidas na base de dados de séries temporais (TSDB) integrada do Prometheus. Cada ponto de dados contém um timestamp Unix e um conjunto de labels chave-valor para identificação.

1. Consulta com PromQL: Os engenheiros utilizam PromQL para consultar métricas armazenadas, gerar gráficos, criar dashboards ou definir condições de alerta com base em dados em tempo real e históricos.

1. Pipeline de Alertas: Quando uma métrica ultrapassa um limiar predefinido, o Prometheus dispara um alerta para o Alertmanager, que deduplica, agrupa e encaminha notificações para os canais apropriados.

O modelo baseado em pull é uma escolha arquitetural deliberada. Simplifica a segurança de rede (os destinos não precisam de acesso de saída para um servidor central), torna a configuração transparente e escala bem em ambientes distribuídos.

Componentes Principais do Prometheus

O Prometheus é um ecossistema modular. Cada componente desempenha um papel específico:

1. Servidor Prometheus

O motor central responsável pela recolha de métricas dos destinos, armazenamento de métricas na TSDB, avaliação de regras de alertas e disponibilização da API PromQL e da interface web.

2. Exporters

Os exporters são agentes leves ou adaptadores que expõem métricas num formato compatível com Prometheus. Os principais exporters incluem:

• Node Exporter — Recolhe métricas de hardware e ao nível do sistema operativo: CPU, memória, I/O de disco, débito de rede, utilização do sistema de ficheiros
• Blackbox Exporter — Sonda endpoints externos via HTTP, HTTPS, DNS, TCP e ICMP para disponibilidade e latência
• Exporters de Base de Dados — Existem exporters dedicados para PostgreSQL, MySQL, Redis, MongoDB e muitos outros
• Exporters Específicos de Aplicações — A maioria das aplicações e frameworks modernas expõe um endpoint /metrics nativamente

3. Alertmanager

Gere o ciclo de vida completo dos alertas: receber alertas do Prometheus, deduplica-los e agrupá-los, aplicar regras de silêncio e inibição, e encaminhar notificações para destinatários como Slack, email, PagerDuty ou OpsGenie.

4. PromQL (Linguagem de Consulta do Prometheus)

Uma linguagem de consulta funcional criada especificamente para dados de séries temporais. O PromQL suporta vetores instantâneos, vetores de intervalo, operadores de agregação, funções matemáticas e subconsultas — conferindo-lhe um profundo poder analítico sobre as suas métricas.

5. Pushgateway

Concebido para tarefas efémeras ou em lote que não podem ser recolhidas diretamente (por exemplo, uma tarefa cron que é executada durante 30 segundos). Estas tarefas enviam as suas métricas para o Pushgateway, que o Prometheus recolhe no seu intervalo regular.

6. Grafana

Embora não faça parte do Prometheus em si, o Grafana é a camada de visualização de facto para dados do Prometheus. Liga-se ao Prometheus como fonte de dados e permite a criação de dashboards ricos e interativos com painéis, variáveis e anotações.

Configuração do Prometheus Passo a Passo no Linux

O guia seguinte orienta-o através de uma implementação completa do Prometheus num servidor Linux, incluindo Node Exporter para métricas do sistema, Grafana para visualização e Alertmanager para notificações.

> Pré-requisitos: Um servidor Linux (Ubuntu 20.04/22.04 ou CentOS/RHEL 8+), acesso sudo ou root, e familiaridade básica com a linha de comandos. Se precisar de um ambiente de servidor fiável, considere o Alojamento VPS AlexHost para uma base de alto desempenho e baixa latência.

Passo 1: Instalar o Prometheus

Descarregue e extraia a versão mais recente do Prometheus:

wget https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz
tar -xvf prometheus-2.47.0.linux-amd64.tar.gz
cd prometheus-2.47.0.linux-amd64

> Dica: Verifique sempre a página oficial de versões do Prometheus para obter a versão estável mais recente antes de descarregar.

Crie um utilizador de sistema dedicado e uma estrutura de diretórios:

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus /var/lib/prometheus
sudo cp prometheus promtool /usr/local/bin/
sudo cp -r consoles console_libraries /etc/prometheus/
sudo chown prometheus:prometheus /usr/local/bin/prometheus /usr/local/bin/promtool
sudo chown -R prometheus:prometheus /etc/prometheus /var/lib/prometheus

Crie um serviço systemd para o Prometheus:

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

Cole o seguinte conteúdo:

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

[Service]
User=prometheus
Group=prometheus
Type=simple
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 
  --storage.tsdb.retention.time=30d

[Install]
WantedBy=multi-user.target

Ative e inicie o Prometheus:

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

O Prometheus estará agora acessível em http://your-server-ip:9090.

Passo 2: Configurar o Prometheus

O ficheiro de configuração principal é /etc/prometheus/prometheus.yml. Este ficheiro define as definições globais e os destinos de recolha que o Prometheus monitoriza.

Exemplo de configuração básica:

global:
  scrape_interval: 15s        # Default scrape frequency
  evaluation_interval: 15s    # How often alerting rules are evaluated
  scrape_timeout: 10s

alerting:
  alertmanagers:
    - static_configs:
        - targets:
          - localhost:9093

rule_files:
  - "/etc/prometheus/rules/*.yml"

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

Após modificar este ficheiro, valide sempre a configuração antes de reiniciar:

promtool check config /etc/prometheus/prometheus.yml
sudo systemctl restart prometheus

Passo 3: Instalar o Node Exporter para Métricas do Sistema

O Node Exporter expõe métricas detalhadas de hardware e sistema operativo do sistema anfitrião — essenciais para monitorizar a carga da CPU, pressão de memória, utilização do disco e débito de rede.

Descarregue e instale o Node Exporter:

wget https://github.com/prometheus/node_exporter/releases/download/v1.6.1/node_exporter-1.6.1.linux-amd64.tar.gz
tar -xvf 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
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

Crie um serviço systemd para o Node Exporter:

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

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

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable node_exporter
sudo systemctl start node_exporter

O Node Exporter expõe agora métricas em http://your-server-ip:9100/metrics.

Adicione o Node Exporter como destino de recolha em prometheus.yml:

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

  - job_name: "node_exporter"
    static_configs:
      - targets: ["localhost:9100"]

Reinicie o Prometheus e verifique se o destino aparece como UP na interface do Prometheus em Status → Targets.

Passo 4: Visualizar Métricas com Grafana

O Grafana transforma métricas brutas do Prometheus em dashboards visualmente ricos e acionáveis. É a camada de visualização padrão para implementações do Prometheus.

Instale o Grafana no Ubuntu/Debian:

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 /etc/apt/sources.list.d/grafana.list
sudo apt-get update
sudo apt-get install grafana
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

Ligue o Prometheus como fonte de dados:

1. Abra o Grafana em http://your-server-ip:3000 (credenciais predefinidas: admin / admin)
2. Navegue até Configuration → Data Sources → Add data source
3. Selecione Prometheus
4. Defina o URL para http://localhost:9090
5. Clique em Save & Test

Importe um dashboard pré-construído:

• Vá a Dashboards → Import
• Introduza o ID de dashboard 1860 (Node Exporter Full) do marketplace do Grafana
• Selecione a sua fonte de dados Prometheus e clique em Import

Terá imediatamente uma visão abrangente da utilização da CPU, consumo de memória, I/O de disco, estatísticas de rede e carga do sistema — tudo num único dashboard interativo.

Passo 5: Configurar Regras de Alertas e Alertmanager

Os alertas do Prometheus consistem em duas partes: regras de alertas definidas no Prometheus e o Alertmanager que gere o encaminhamento e a entrega.

Crie um ficheiro de regras de alertas:

sudo mkdir -p /etc/prometheus/rules
sudo nano /etc/prometheus/rules/system_alerts.yml

groups:
  - name: system_alerts
    rules:
      - alert: HighCPUUsage
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High CPU usage on {{ $labels.instance }}"
          description: "CPU usage has exceeded 80% for more than 5 minutes. Current value: {{ $value }}%"

      - alert: LowDiskSpace
        expr: (node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"}) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Low disk space on {{ $labels.instance }}"
          description: "Available disk space on / is below 15%. Immediate action required."

      - alert: HighMemoryUsage
        expr: (1 - (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes)) * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "High memory usage on {{ $labels.instance }}"
          description: "Memory usage has exceeded 85% for more than 5 minutes."

      - alert: InstanceDown
        expr: up == 0
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Instance {{ $labels.instance }} is down"
          description: "Prometheus target {{ $labels.instance }} has been unreachable for more than 1 minute."

Valide o ficheiro de regras:

promtool check rules /etc/prometheus/rules/system_alerts.yml

Instale e configure o Alertmanager:

wget https://github.com/prometheus/alertmanager/releases/download/v0.26.0/alertmanager-0.26.0.linux-amd64.tar.gz
tar -xvf alertmanager-0.26.0.linux-amd64.tar.gz
sudo cp alertmanager-0.26.0.linux-amd64/alertmanager /usr/local/bin/
sudo mkdir /etc/alertmanager

Crie a configuração do Alertmanager:

sudo nano /etc/alertmanager/alertmanager.yml

global:
  smtp_smarthost: 'smtp.yourdomain.com:587'
  smtp_from: 'alerts@yourdomain.com'
  smtp_auth_username: 'alerts@yourdomain.com'
  smtp_auth_password: 'your_password'

route:
  group_by: ['alertname', 'instance']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h
  receiver: 'email-notifications'

receivers:
  - name: 'email-notifications'
    email_configs:
      - to: 'admin@yourdomain.com'
        send_resolved: true

> Nota: Para entrega profissional de email no seu pipeline de alertas, considere combinar o Prometheus com o Alojamento de Email AlexHost para uma infraestrutura SMTP fiável.

Configuração Avançada: Descoberta de Serviços

Para ambientes dinâmicos — como clusters Kubernetes ou frotas de servidores com escalonamento automático — as listas de destinos estáticos tornam-se rapidamente ingeríveis. O Prometheus suporta múltiplos mecanismos de descoberta de serviços de origem:

scrape_configs:
  - job_name: "kubernetes-pods"
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true

Os backends de descoberta de serviços suportados incluem Kubernetes, Consul, EC2, Azure, GCE, descoberta baseada em DNS e descoberta baseada em ficheiros — tornando o Prometheus adaptável a praticamente qualquer topologia de infraestrutura.

Casos de Utilização do Prometheus

O Prometheus destaca-se numa ampla gama de cenários de monitorização:

Monitorização de Infraestrutura

Recolha métricas ao nível do servidor — CPU, memória, disco, rede — de cada nó na sua frota. Quer esteja a executar um único Servidor Dedicado ou um grande cluster, o Prometheus proporciona visibilidade unificada em todos os anfitriões.

Monitorização do Desempenho de Aplicações (APM)

Acompanhe taxas de pedidos, taxas de erros, latências de resposta (o método RED) e consumo de recursos para aplicações web e APIs. As bibliotecas cliente do Prometheus estão disponíveis para Go, Python, Java, Ruby, Node.js e mais.

Monitorização de Kubernetes e Contentores

O Prometheus integra-se nativamente com Kubernetes através dos exporters kube-state-metrics e cAdvisor, proporcionando visibilidade profunda sobre a saúde dos pods, quotas de recursos, estado das implementações e métricas ao nível do cluster.

Monitorização de Bases de Dados

Monitorize o desempenho de consultas, utilização do pool de ligações, atraso de replicação e taxas de acerto de cache para bases de dados como PostgreSQL, MySQL e Redis utilizando exporters dedicados.

Métricas de Negócio Personalizadas

Instrumente as suas próprias aplicações para expor métricas específicas do domínio — como encomendas processadas por segundo, sessões de utilizadores ativas ou taxas de transações de pagamento — permitindo observabilidade ao nível do negócio juntamente com métricas técnicas.

Monitorização de Cargas de Trabalho GPU

Para equipas que executam cargas de trabalho de aprendizagem automática ou computação de alto desempenho, o Prometheus pode integrar-se com exporters DCGM para monitorizar a utilização da GPU, memória e temperatura. Isto combina bem com o Alojamento GPU AlexHost para infraestrutura de IA e ML.

Prometheus vs. Soluções Alternativas de Monitorização

Melhores Práticas em Produção

A implementação do Prometheus em produção requer atenção a várias preocupações operacionais:

• Retenção de Dados: O período de retenção predefinido é de 15 dias. Ajuste --storage.tsdb.retention.time com base na sua capacidade de armazenamento e requisitos de conformidade. Para armazenamento a longo prazo, considere Thanos ou Cortex.
• Segurança: Restrinja o acesso à interface web e API do Prometheus utilizando um proxy reverso (Nginx ou Caddy) com autenticação. O Prometheus não inclui autenticação integrada.
• Alta Disponibilidade: Execute múltiplas instâncias do Prometheus a recolher métricas dos mesmos destinos para redundância. Utilize a funcionalidade de clustering do Alertmanager para evitar notificações duplicadas.
• Gestão de Cardinalidade: Evite labels de alta cardinalidade (por exemplo, IDs de utilizador, IDs de pedido) nos nomes das métricas, pois podem causar problemas de memória e desempenho.
• Encriptação TLS: Ative TLS para endpoints de recolha e para a API do Prometheus. Combine isto com um Certificado SSL para proteger todas as comunicações entre os componentes do Prometheus.
• Planeamento de Recursos: O Prometheus consome muita memória. Aloque RAM suficiente com base no número de séries temporais ativas. Uma regra geral é aproximadamente 1–2 bytes por amostra em memória.

Perguntas Frequentes

P: Qual é a diferença entre Prometheus e Grafana?

O Prometheus é o backend de monitorização e alertas — recolhe, armazena e consulta métricas. O Grafana é um frontend de visualização que se liga ao Prometheus (e a outras fontes de dados) para renderizar dashboards. São ferramentas complementares, não alternativas.

P: O Prometheus pode monitorizar servidores Windows?

Sim. O Windows Exporter (anteriormente WMI Exporter) expõe métricas do sistema Windows num formato compatível com Prometheus, cobrindo CPU, memória, disco, rede, IIS e mais.

P: Como é que o Prometheus gere a alta disponibilidade?

O Prometheus em si é concebido para ser executado como uma única instância por cluster. Para alta disponibilidade, executa dois servidores Prometheus idênticos a recolher métricas dos mesmos destinos. O Alertmanager suporta clustering nativo para deduplica alertas em múltiplas instâncias do Prometheus.

P: Para que é utilizado o PromQL?

O PromQL (Linguagem de Consulta do Prometheus) é utilizado para consultar dados de séries temporais armazenados no Prometheus. Suporta consultas instantâneas, consultas de intervalo, agregações, operações matemáticas e funções — permitindo tudo, desde pesquisas simples de métricas até expressões complexas de deteção de anomalias.

Conclusão

O Prometheus é uma solução de monitorização testada em batalha e de nível de produção que proporciona visibilidade profunda e em tempo real sobre a saúde e o desempenho de toda a sua pilha de infraestrutura. A sua arquitetura baseada em pull, modelo de dados multidimensional, poderosa linguagem de consulta PromQL e integrações perfeitas com ferramentas como Grafana e Alertmanager tornam-no o padrão de ouro para a observabilidade moderna.

Quer esteja a monitorizar um único servidor Linux, uma frota de Servidores Dedicados, um cluster Kubernetes ou uma aplicação complexa de microsserviços, o Prometheus escala para satisfazer as suas necessidades. Seguindo os passos deste guia — instalar o Prometheus, implementar o Node Exporter, configurar dashboards Grafana e configurar regras de alertas inteligentes — terá uma base de monitorização robusta que o ajuda a detetar anomalias precocemente, a responder a incidentes mais rapidamente e a melhorar continuamente a fiabilidade do sistema.

Comece com o básico, itere nos seus dashboards e limiares de alertas à medida que aprende o comportamento normal do seu sistema, e expanda progressivamente a cobertura a cada camada da sua pilha. O Prometheus não é apenas uma ferramenta de monitorização — é uma pedra angular da engenharia moderna de fiabilidade de sites.