Monitoramento Prometheus: Configuração Completa e Melhores Práticas

Prometheus tornou-se o padrão de fato para monitoramento de aplicações e infraestrutura nativas da nuvem, oferecendo coleta de métricas, consultas e integração com ferramentas de visualização.

O que é o Prometheus?

O Prometheus é um conjunto de ferramentas de monitoramento e alerta de código aberto, originalmente desenvolvido no SoundCloud em 2012 e atualmente um projeto graduado da Cloud Native Computing Foundation (CNCF). Ele foi especificamente projetado para confiabilidade e escalabilidade em ambientes de nuvem dinâmicos, tornando-se a solução preferida para monitoramento de microsserviços, contêineres e clusters Kubernetes.

Principais Funcionalidades

Banco de Dados de Séries Temporais: O Prometheus armazena todos os dados como séries temporais, identificados por nomes de métricas e pares chave-valor (rótulos), permitindo capacidades de consulta flexíveis e poderosas.

Modelo Baseado em Pull: Diferente dos sistemas tradicionais baseados em push, o Prometheus coleta ativamente métricas de alvos configurados em intervalos especificados, tornando-o mais confiável e fácil de configurar.

Linguagem de Consulta PromQL: Uma linguagem de consulta funcional poderosa permite analisar seus dados de métricas em tempo real, realizando agregações, transformações e cálculos complexos.

Descoberta de Serviços: Descoberta automática de alvos de monitoramento através de vários mecanismos, incluindo Kubernetes, Consul, EC2 e configurações estáticas.

Sem Dependências Externas: O Prometheus opera como um único binário sem dependências externas necessárias, simplificando a implantação e reduzindo a complexidade operacional.

Alertas Integrados: O AlertManager gerencia alertas do Prometheus, fornecendo deduplicação, agrupamento e roteamento para canais de notificação como e-mail, PagerDuty ou Slack.

Visão Geral da Arquitetura

Compreender a arquitetura do Prometheus é crucial para uma implantação eficaz. Os principais componentes incluem:

• Servidor Prometheus: Coleta e armazena métricas, avalia regras e serve consultas
• Bibliotecas de Cliente: Instrumentam o código da aplicação para expor métricas
• Exportadores: Conectam sistemas de terceiros ao formato Prometheus
• AlertManager: Gerencia alertas e notificações
• Pushgateway: Aceita métricas de trabalhos de curta duração que não podem ser coletados

O fluxo de dados típico: As aplicações expõem endpoints de métricas → O Prometheus coleta esses endpoints → Os dados são armazenados no banco de dados de séries temporais → Consultas PromQL recuperam e analisam os dados → Alertas são gerados com base em regras → O AlertManager processa e roteia notificações.

Ao implantar infraestrutura no Ubuntu 24.04, o Prometheus oferece uma excelente base para monitoramento abrangente.

Instalando o Prometheus no Ubuntu

Vamos percorrer a instalação do Prometheus em um sistema Linux. Usaremos o Ubuntu como exemplo, mas o processo é semelhante para outras distribuições.

Download e Instalação

Primeiro, crie um usuário dedicado para o Prometheus:

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

Baixe a última versão do Prometheus:

cd /tmp
wget https://github.com/prometheus/prometheus/releases/download/v2.48.0/prometheus-2.48.0.linux-amd64.tar.gz
tar xvf prometheus-2.48.0.linux-amd64.tar.gz
cd prometheus-2.48.0.linux-amd64

Copie os binários e crie os diretórios:

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus
sudo chown prometheus:prometheus /etc/prometheus
sudo chown prometheus:prometheus /var/lib/prometheus

sudo cp -r consoles /etc/prometheus
sudo cp -r console_libraries /etc/prometheus
sudo cp prometheus.yml /etc/prometheus/prometheus.yml
sudo chown -R prometheus:prometheus /etc/prometheus

Para gerenciamento de pacotes no Ubuntu, consulte nosso guia abrangente de Gerenciamento de Pacotes Ubuntu.

Configurar Prometheus

Edite /etc/prometheus/prometheus.yml:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093']

rule_files:
  - 'alert_rules.yml'

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

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

Criar Serviço Systemd

Crie /etc/systemd/system/prometheus.service:

[Unit]
Description=Prometheus
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

Inicie e habilite o Prometheus:

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

Acesse a interface web do Prometheus em http://localhost:9090.

Configurando o Node Exporter

O Node Exporter expõe métricas de hardware e sistema operacional para sistemas Linux. Instale-o para monitorar seus servidores:

cd /tmp
wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar xvf node_exporter-1.7.0.linux-amd64.tar.gz
sudo cp node_exporter-1.7.0.linux-amd64/node_exporter /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/node_exporter

Crie o serviço systemd /etc/systemd/system/node_exporter.service:

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

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

[Install]
WantedBy=multi-user.target

Inicie o Node Exporter:

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

O Node Exporter agora expõe métricas na porta 9100.

Compreendendo o PromQL

O PromQL (Linguagem de Consulta do Prometheus) é o coração da consulta de dados do Prometheus. Aqui estão padrões de consulta essenciais:

Consultas Básicas

Selecionar todas as séries temporais para uma métrica:

node_cpu_seconds_total

Filtrar por rótulo:

node_cpu_seconds_total{mode="idle"}

Múltiplos filtros de rótulo:

node_cpu_seconds_total{mode="idle",cpu="0"}

Vetores de Faixa e Agregações

Calcular taxa ao longo do tempo:

rate(node_cpu_seconds_total{mode="idle"}[5m])

Somar em todos os CPUs:

sum(rate(node_cpu_seconds_total{mode="idle"}[5m]))

Agrupar por rótulo:

sum by (mode) (rate(node_cpu_seconds_total[5m]))

Exemplos Práticos

Percentual de uso de CPU:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Uso de memória:

(node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100

Uso de disco:

(node_filesystem_size_bytes - node_filesystem_avail_bytes) / node_filesystem_size_bytes * 100

Taxa de tráfego de rede:

rate(node_network_receive_bytes_total[5m])

Implantação com Docker

Executar o Prometheus em contêineres Docker oferece flexibilidade e gerenciamento mais fácil:

Crie docker-compose.yml:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=30d'
    ports:
      - "9090:9090"
    restart: unless-stopped

  node_exporter:
    image: prom/node-exporter:latest
    container_name: node_exporter
    command:
      - '--path.rootfs=/host'
    volumes:
      - '/:/host:ro,rslave'
    ports:
      - "9100:9100"
    restart: unless-stopped

  alertmanager:
    image: prom/alertmanager:latest
    container_name: alertmanager
    volumes:
      - ./alertmanager.yml:/etc/alertmanager/alertmanager.yml
      - alertmanager_data:/alertmanager
    ports:
      - "9093:9093"
    restart: unless-stopped

volumes:
  prometheus_data:
  alertmanager_data:

Inicie o conjunto:

docker-compose up -d

Monitoramento de Kubernetes

O Prometheus se destaca no monitoramento de clusters Kubernetes. O gráfico Helm kube-prometheus-stack fornece uma solução completa de monitoramento.

Instale usando o Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update
helm install prometheus prometheus-community/kube-prometheus-stack

Isso instala:

• Operador Prometheus
• Instância Prometheus
• AlertManager
• Grafana
• Node Exporter
• kube-state-metrics
• Painéis e alertas pré-configurados

Acesse o Grafana:

kubectl port-forward svc/prometheus-grafana 3000:80

Credenciais padrão: admin/prom-operator

Para várias distribuições Kubernetes, o processo de implantação é semelhante com pequenos ajustes para recursos específicos da plataforma.

Configurando Alertas

O AlertManager gerencia alertas enviados pelo Prometheus. Configure as regras de alerta e canais de notificação.

Regras de Alerta

Crie /etc/prometheus/alert_rules.yml:

groups:
  - name: system_alerts
    interval: 30s
    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: "Alto uso de CPU em {{ $labels.instance }}"
          description: "O uso de CPU está acima de 80% (valor atual: {{ $value }}%)"

      - alert: HighMemoryUsage
        expr: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes * 100 > 85
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Alto uso de memória em {{ $labels.instance }}"
          description: "O uso de memória está acima de 85% (valor atual: {{ $value }}%)"

      - alert: DiskSpaceLow
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 15
        for: 10m
        labels:
          severity: critical
        annotations:
          summary: "Espaço em disco baixo em {{ $labels.instance }}"
          description: "O espaço disponível em disco está abaixo de 15% em {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "Instância {{ $labels.instance }} está fora do ar"
          description: "A instância {{ $labels.job }} {{ $labels.instance }} está fora do ar por mais de 2 minutos"

Configuração do AlertManager

Crie /etc/prometheus/alertmanager.yml:

global:
  resolve_timeout: 5m
  smtp_smarthost: 'smtp.gmail.com:587'
  smtp_from: 'alerts@example.com'
  smtp_auth_username: 'alerts@example.com'
  smtp_auth_password: 'your-password'

route:
  group_by: ['alertname', 'cluster', 'service']
  group_wait: 10s
  group_interval: 10s
  repeat_interval: 12h
  receiver: 'team-email'
  routes:
    - match:
        severity: critical
      receiver: 'team-pagerduty'
    - match:
        severity: warning
      receiver: 'team-slack'

receivers:
  - name: 'team-email'
    email_configs:
      - to: 'team@example.com'
        headers:
          Subject: '{{ .GroupLabels.alertname }}: {{ .Status | toUpper }}'

  - name: 'team-slack'
    slack_configs:
      - api_url: 'https://hooks.slack.com/services/YOUR/SLACK/WEBHOOK'
        channel: '#alerts'
        title: 'Alerta: {{ .GroupLabels.alertname }}'
        text: '{{ range .Alerts }}{{ .Annotations.description }}{{ end }}'

  - name: 'team-pagerduty'
    pagerduty_configs:
      - service_key: 'your-pagerduty-key'

Integração com Grafana

Embora o Prometheus tenha uma interface web básica, o Grafana oferece capacidades superiores de visualização para criar painéis abrangentes.

Adicionar Prometheus como Fonte de Dados

1. Abra o Grafana e navegue até Configuration → Data Sources
2. Clique em “Add data source” (Adicionar fonte de dados)
3. Selecione “Prometheus”
4. Defina a URL para http://localhost:9090 (ou seu servidor Prometheus)
5. Clique em “Save & Test” (Salvar e Testar)

IDs de Painéis Populares

Importe painéis pré-construídos do grafana.com:

• Node Exporter Full (ID: 1860): Métricas Linux abrangentes
• Kubernetes Cluster Monitoring (ID: 7249): Visão geral do K8s
• Docker Container Monitoring (ID: 193): Métricas de contêineres
• Prometheus Stats (ID: 2): Métricas internas do Prometheus

Criando Painéis Personalizados

Crie painéis usando consultas PromQL:

{
  "title": "CPU Usage",
  "targets": [{
    "expr": "100 - (avg(rate(node_cpu_seconds_total{mode=\"idle\"}[5m])) * 100)"
  }]
}

Exportadores Populares

Estenda o monitoramento do Prometheus com exportadores especializados:

Blackbox Exporter

Prova endpoints via HTTP, HTTPS, DNS, TCP e ICMP:

scrape_configs:
  - job_name: 'blackbox'
    metrics_path: /probe
    params:
      module: [http_2xx]
    static_configs:
      - targets:
          - https://example.com
          - https://api.example.com
    relabel_configs:
      - source_labels: [__address__]
        target_label: __param_target
      - source_labels: [__param_target]
        target_label: instance
      - target_label: __address__
        replacement: localhost:9115

Exportadores de Banco de Dados

• mysqld_exporter: Métricas do MySQL/MariaDB
• postgres_exporter: Métricas do PostgreSQL
• mongodb_exporter: Métricas do MongoDB
• redis_exporter: Métricas do Redis

Exportadores de Aplicação

• nginx_exporter: Métricas do servidor web NGINX
• apache_exporter: Métricas do servidor HTTP Apache
• haproxy_exporter: Métricas do balanceador de carga HAProxy

Exportadores de Nuvem

• cloudwatch_exporter: Métricas do AWS CloudWatch
• stackdriver_exporter: Métricas do Google Cloud
• azure_exporter: Métricas do Azure Monitor

Melhores Práticas

Retenção de Dados

Configure a retenção apropriada com base nas suas necessidades:

--storage.tsdb.retention.time=30d
--storage.tsdb.retention.size=50GB

Regras de Gravação

Pré-calcule expressões frequentemente consultadas:

groups:
  - name: example_rules
    interval: 30s
    rules:
      - record: job:node_cpu_utilization:avg
        expr: 100 - (avg by (job) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Gerenciamento de Rótulos

• Mantenha a cardinalidade dos rótulos baixa
• Use convenções de nomenclatura consistentes
• Evite rótulos de alta cardinalidade (IDs de usuário, carimbos de tempo)

Segurança

• Habilite autenticação e HTTPS
• Restrinja o acesso à API do Prometheus
• Use políticas de rede no Kubernetes
• Implemente RBAC para métricas sensíveis

Alta Disponibilidade

• Execute múltiplas instâncias do Prometheus
• Use Thanos ou Cortex para armazenamento de longo prazo
• Implemente federação para configurações hierárquicas

Solução de Problemas Comuns

Alto Uso de Memória

• Reduza a frequência de coleta
• Diminua o período de retenção
• Otimize consultas PromQL
• Implemente regras de gravação

Métricas Ausentes

• Verifique o status do alvo em /targets
• Verifique a conectividade de rede
• Valide a configuração de coleta
• Verifique os logs do exportador

Consultas Lentas

• Use regras de gravação para agregações complexas
• Otimize filtros de rótulos
• Reduza o intervalo de tempo
• Adicione índices se estiver usando armazenamento remoto

Otimização de Desempenho

Otimização de Consultas

# Ruim: Alta cardinalidade
sum(rate(http_requests_total[5m]))

# Bom: Agrupar por rótulos relevantes
sum by (status, method) (rate(http_requests_total[5m]))

Limites de Recursos

Para implantações Kubernetes:

resources:
  requests:
    memory: "2Gi"
    cpu: "1000m"
  limits:
    memory: "4Gi"
    cpu: "2000m"

Conclusão

O Prometheus fornece uma solução de monitoramento robusta e escalável para infraestrutura moderna. Sua arquitetura baseada em pull, linguagem de consulta poderosa e ecossistema extenso de exportadores tornam-no ideal para monitorar tudo, desde servidores bare-metal até clusters Kubernetes complexos.

Ao combinar o Prometheus com o Grafana para visualização e o AlertManager para notificações, você cria uma plataforma de observabilidade abrangente capaz de atender a requisitos de monitoramento em escala empresarial. A comunidade ativa e o apoio da CNCF garantem o desenvolvimento e suporte contínuos.

Comece com a coleta básica de métricas, gradualmente adicione exportadores para seus serviços específicos e refine suas regras de alerta com base na experiência do mundo real. O Prometheus escala com sua infraestrutura, desde implantações de servidor único até arquiteturas de monitoramento em múltiplos data centers.

Recursos Relacionados

• Gerenciamento de Pacotes Ubuntu: Guia de Comandos APT e dpkg
• Instalar e Usar Grafana no Ubuntu: Guia Completo
• Guia de Comandos Kubernetes
• Distribuições Kubernetes - visão rápida de kubeadm, k3s, MicroK8s, Minikube, Talos Linux e RKE2
• Guia de Comandos Docker

Referências Externas

• Documentação Oficial do Prometheus
• Exemplos de Consultas PromQL
• Lista de Exportadores Prometheus
• Guia de Integração Grafana Prometheus
• Gráfico Helm kube-prometheus-stack
• Melhores Práticas Prometheus
• Configuração do AlertManager