Monitoramento com Prometheus: Configuração Completa & Boas 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, consulta e integração com ferramentas de visualização.

O que é o Prometheus?

O Prometheus é um kit de ferramentas de monitoramento e alertas de código aberto originalmente desenvolvido na SoundCloud em 2012 e agora 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 ideal para monitoramento de microserviços, containers e clusters Kubernetes.

Recursos Principais

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

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

Linguagem de Consulta PromQL: Uma poderosa linguagem funcional de consulta permite que você analise 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 por meio 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 o implantação e reduzindo a complexidade operacional.

Alertas Integrados: O AlertManager lida com 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

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

• Servidor do Prometheus: Coleta e armazena métricas, avalia regras e serve consultas
• Bibliotecas do Cliente: Instrumenta o código da aplicação para expor métricas
• Exporters: Conectam sistemas de terceiros ao formato do Prometheus
• AlertManager: Lida com alertas e notificações
• Pushgateway: Aceita métricas de empregos de curta duração que não podem ser coletadas

O fluxo de dados típico: Aplicações expõem endpoints de métricas → O Prometheus coleta esses endpoints → Os dados são armazenados em um banco de dados em série temporal → 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 fornece uma excelente base para monitoramento abrangente.

Instalando o Prometheus no Ubuntu

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

Baixar e Instalar

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

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

Baixe a versão mais recente 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 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 Gerenciamento de Pacotes no Ubuntu.

Configurar o 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 o Serviço do 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 do 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.

Entendendo PromQL

A PromQL (Prometheus Query Language) é o coração da consulta de dados do Prometheus. Aqui estão padrões de consulta essenciais:

Consultas Básicas

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

node_cpu_seconds_total

Filtrar por rótulo:

node_cpu_seconds_total{mode="idle"}

Vários filtros de rótulo:

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

Vetores de Intervalo e Agregações

Calcular a 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 da 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 no Docker

Executar o Prometheus em Docker containers 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 stack:

docker-compose up -d

Monitoramento do Kubernetes

O Prometheus se destaca no monitoramento de clusters Kubernetes. O gráfico de 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 do Prometheus
• Instância do Prometheus
• AlertManager
• Grafana
• Node Exporter
• kube-state-metrics
• Dashboards e alertas pré-configurados

Acesse a 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 ajustes mínimos para recursos específicos da plataforma.

Configurando Alertas

O AlertManager lida com alertas enviados pelo Prometheus. Configure 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: "Uso elevado de CPU em {{ $labels.instance }}"
          description: "O uso da 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: "Uso elevado de memória em {{ $labels.instance }}"
          description: "O uso da 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 em disco disponível está abaixo de 15% em {{ $labels.mountpoint }}"

      - alert: InstanceDown
        expr: up == 0
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "A instância {{ $labels.instance }} está offline"
          description: "A instância {{ $labels.job }} {{ $labels.instance }} está offline há 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 a Grafana

Embora o Prometheus tenha uma interface web básica, a Grafana oferece visualizações superiores para criar dashboards abrangentes.

Adicionar o Prometheus como Fonte de Dados

1. Abra a Grafana e navegue até Configuração → Fontes de Dados
2. Clique em “Adicionar fonte de dados”
3. Selecione “Prometheus”
4. Defina a URL como http://localhost:9090 (ou seu servidor do Prometheus)
5. Clique em “Salvar & Testar”

IDs de Dashboard Populares

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

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

Criando Dashboards Personalizados

Crie painéis usando consultas PromQL:

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

Exporters Populares

Expanda o monitoramento do Prometheus com exporters especializados:

Blackbox Exporter

Probes endpoints por meio de 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

Exporters 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

Exporters de Aplicações

• 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

Exporters de Nuvem

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

Boas 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

Calcule previamente 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ários, timestamps)

Segurança

• Ative 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 com Problemas Comuns

Uso Elevado 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 Faltando

• Verifique o status dos alvos em /targets
• Verifique a conectividade de rede
• Valide a configuração de coleta
• Verifique os logs do exporter

Consultas Lentas

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

Otimização de Desempenho

Otimização de Consultas

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

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

Limites de Recursos

Para implantações no Kubernetes:

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

Conclusão

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

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

Comece com a coleta de métricas básicas, gradualmente adicione exporters para seus serviços específicos e refine suas regras de alerta com base na experiência real. O Prometheus escala com sua infraestrutura, desde implantações de único servidor até arquiteturas de monitoramento multi-datacenter.

Recursos Relacionados

• Como Instalar o Ubuntu 24.04 e ferramentas úteis
• Gerenciamento de Pacotes no Ubuntu: Guia de Dicas de APT e dpkg
• Instale e use a Grafana no Ubuntu: Guia Completo
• Kubernetes Cheatsheet
• Visão geral das distribuições Kubernetes - kubeadm, k3s, MicroK8s, Minikube, Talos Linux e RKE2
• Cheatsheet do Docker

Referências Externas

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