Pular para o conteúdo
EntrarCriar minha VPS

cAdvisor: métricas de containers Docker

Node Exporter monitora a VPS, cAdvisor monitora os containers. É o exporter padrão do Google para métricas de containers Docker, CPU, memória, rede e I/O de disco por container, em formato Prometheus. Com o dashboard 14282 do Grafana, você vê todos os containers em um painel com zero configuração adicional.

Adicionar cAdvisor ao docker-compose.yml

cAdvisor precisa de acesso aos volumes do Docker para ler métricas dos containers:

yaml
services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    restart: always
    privileged: true             # necessário para acesso a cgroups
    devices:
      - /dev/kmsg:/dev/kmsg
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker:/var/lib/docker:ro
      - /cgroup:/cgroup:ro
    ports:
      - "127.0.0.1:8080:8080"    # apenas loopback
    command:
      - '--docker_only=true'     # apenas métricas de containers
      - '--disable_metrics=disk,diskIO,network,tcp,udp,percpu,sched,process'
      # Desabilite o que não usa para reduzir cardinalidade
    networks:
      - monitoring

Adicionar cAdvisor ao Prometheus

Configure o scrape do cAdvisor no prometheus.yml:

yaml
# prometheus/prometheus.yml — adicionar job:
scrape_configs:
  - job_name: 'cadvisor'
    scrape_interval: 15s
    static_configs:
      - targets: ['cadvisor:8080']
    metric_relabel_configs:
      # Manter apenas métricas relevantes (reduz cardinalidade)
      - source_labels: [__name__]
        regex: 'container_(cpu_usage_seconds_total|memory_working_set_bytes|network_receive_bytes_total|network_transmit_bytes_total|fs_usage_bytes|last_seen)'
        action: keep
      # Remover containers de infraestrutura interna
      - source_labels: [container]
        regex: 'POD|'
        action: drop

# Verificar após reload:
curl http://localhost:9090/api/v1/targets | python3 -m json.tool | grep cadvisor

Queries PromQL para containers

As métricas mais úteis do cAdvisor para dashboards e alertas:

promql
# CPU por container (% de uso)
sum(rate(container_cpu_usage_seconds_total{name!=""}[5m])) by (name) * 100

# Memória por container (MB)
sum(container_memory_working_set_bytes{name!=""}) by (name) / 1024 / 1024

# Limite de memória (MB) — configurado no docker-compose
sum(container_spec_memory_limit_bytes{name!=""}) by (name) / 1024 / 1024

# Memória usada vs limite (%)
sum(container_memory_working_set_bytes{name!=""}) by (name) /
sum(container_spec_memory_limit_bytes{name!=""}) by (name) * 100

# Tráfego de rede recebido por container (bytes/s)
sum(rate(container_network_receive_bytes_total{name!=""}[5m])) by (name)

# I/O de disco por container
sum(rate(container_fs_writes_bytes_total{name!=""}[5m])) by (name)

# Container que reiniciou recentemente
time() - container_last_seen{name!=""} > 60

Dashboard Grafana para containers

Import do dashboard da comunidade e alertas essenciais:

bash
# Importar dashboard pré-pronto:
# ID 14282: Docker Host & Container Overview (cAdvisor + Node Exporter)
# ID 193: Docker and System Monitoring
# ID 15798: Docker Dashboard

# Via API Grafana:
curl -X POST http://localhost:3000/api/dashboards/import \
  -H "Content-Type: application/json" \
  -u admin:senha \
  -d '{"dashboard": {"id": null}, "folderId": 0, "overwrite": false, "inputs": [{"name": "DS_PROMETHEUS", "type": "datasource", "pluginId": "prometheus", "value": "Prometheus"}], "pluginId": "prometheus", "uid": "cadvisor"}'

# Alertas recomendados:
# - Container com uso de memória > 90% do limite
# - Container que parou (container_last_seen antigo)
# - Container com CPU > 80% por mais de 5 minutos

Limitar recursos dos containers (e monitorar)

Configure limites no docker-compose e monitore o uso real com cAdvisor:

yaml
# docker-compose.yml — definir limites de recursos
services:
  app:
    image: minha-api:latest
    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 512M
        reservations:
          memory: 128M

  postgres:
    image: postgres:16-alpine
    deploy:
      resources:
        limits:
          cpus: "2.0"
          memory: 1G
        reservations:
          memory: 256M

# Com limites definidos, o cAdvisor expõe:
# container_spec_cpu_quota / container_spec_cpu_period — limite de CPU
# container_spec_memory_limit_bytes — limite de memória
# E as métricas de uso real: container_cpu_usage_seconds_total, etc.

# Alerta quando container se aproxima do limite de memória:
# container_memory_working_set_bytes / container_spec_memory_limit_bytes > 0.85

Não quer configurar manualmente?

Implante o VPS em menos de 5 minutos com a Runstack. Infraestrutura da OPEN Datacenter, com servidores em São Paulo.

Criar minha VPSVer apps prontos

Perguntas frequentes

docker stats exibe métricas em tempo real no terminal, mas não armazena histórico. cAdvisor expõe as mesmas métricas (e mais) no formato Prometheus para coleta e armazenamento pelo Prometheus. Use docker stats para debug rápido; cAdvisor para monitoramento contínuo com histórico.

Use --disable_metrics para desativar o que não usa (percpu, sched, hugetlb, referenced_memory, cpu_topology). Adicione metric_relabel_configs no Prometheus para filtrar métricas antes de armazenar. Aumente o scrape_interval para 30s ou 60s se você não precisa de granularidade de 15 segundos.

container_last_seen{name="meu_container"} fornece o timestamp da última vez que o container foi visto vivo. Alerta: time() - container_last_seen{name="meu_container"} > 120 (container não visto há 2 min). Para contar restarts: container_start_time_seconds muda a cada restart, rate() indica frequência.

cAdvisor expõe métricas em /metrics (Prometheus format) e tem uma UI web simples em /. Sem Prometheus, você pode fazer queries diretamente, mas sem histórico. O padrão é sempre: cAdvisor → Prometheus (armazena) → Grafana (visualiza).

Netdata coleta métricas de containers com consumo similar mas inclui métricas do host. Para ambientes com muitos containers (50+): consider Prometheus com docker_sd_configs (service discovery automático) e pushgateway para jobs de curta duração. Para Kubernetes: kube-state-metrics substitui cAdvisor.

Continue lendo