Mit cAdvisor Prometheus Docker Monitoring sehen Sie CPU-Last, Speicherverbrauch, Netzwerk-Traffic und Disk-I/O pro Container statt nur als Summe für den gesamten Server. Diese Anleitung zeigt, wie Sie cAdvisor (Container Advisor von Google) als Metriken-Exporter starten, die Werte mit Prometheus abfragen (scrapen) und in einem fertigen Grafana-Dashboard darstellen, komplett selbst gehostet.

Was ist cAdvisor und wofür brauchen Sie es?

cAdvisor (Container Advisor) ist ein quelloffenes Tool von Google, das laufende Container automatisch erkennt und detaillierte Ressourcen- und Performance-Metriken sammelt. Es liest die cgroups des Kernels sowie die Docker-Statistiken aus und stellt die Daten unter /metrics im Prometheus-Format bereit. Anders als das blanke docker stats liefert cAdvisor historische, scrapebare Zeitreihen pro Container, die Grundlage für Dashboards und Alarme.

Prometheus ist die Zeitreihen-Datenbank und die Scraping-Engine: Sie holt die Metriken in festen Intervallen von cAdvisor ab und speichert sie. Grafana liest aus Prometheus und stellt die Werte als Graphen, Gauges und Tabellen dar. Zusammen bilden die drei einen verbreiteten Monitoring-Stack für Docker.

Typische Metriken nach dem Setup:

container_cpu_usage_seconds_total - kumulierte CPU-Zeit pro Container
container_memory_usage_bytes - aktueller RAM-Verbrauch pro Container
container_network_receive_bytes_total - empfangene Netzwerk-Bytes pro Container
container_network_transmit_bytes_total - gesendete Netzwerk-Bytes pro Container
container_fs_usage_bytes - belegter Speicher im Container-Dateisystem

Voraussetzungen

Ein Linux-Host mit installierter Docker Engine und dem Plugin Docker Compose (falls noch nicht vorhanden, siehe unsere Anleitung zur Docker-Installation).
Root- bzw. sudo-Zugriff auf dem Host (cAdvisor benötigt Lesezugriff auf System-Pfade).
Freie Ports: 8080 (cAdvisor) und 9090 (Prometheus) nur lokal, 3000 (Grafana). Bei Konflikten passen Sie das linke Mapping an.
x86_64 oder arm64, 1 CPU-Kern und etwa 512 MB freier RAM für den Stack; mehr RAM und Speicher für längere Aufbewahrung (Retention). Ein Host mit 2 Kernen und 4 GB RAM trägt Stack und überwachte Dienste.
Grundkenntnisse in der Shell und einem Editor (nano, vim o. Ä.).

Schritt 1: Projektverzeichnis und Struktur anlegen

Legen Sie ein Arbeitsverzeichnis für den Monitoring-Stack an. So liegen Compose-Datei und Konfiguration an einem Ort und lassen sich leicht sichern.

mkdir -p ~/monitoring/prometheus
cd ~/monitoring

Im Ordner ~/monitoring entsteht gleich die docker-compose.yml, im Unterordner prometheus die Scrape-Konfiguration.

Verifizieren: ls -d ~/monitoring/prometheus gibt den Pfad ohne Fehlermeldung aus.

Schritt 2: Prometheus-Konfiguration schreiben

Erstellen Sie die Datei ~/monitoring/prometheus/prometheus.yml. Hier legen Sie fest, in welchem Intervall gescrapet wird und welche Targets Prometheus abfragt. Das entscheidende Target ist cadvisor:8080; der Hostname entspricht dem Service-Namen aus dem Compose-File, dank des gemeinsamen Docker-Netzwerks.

global:
  scrape_interval: 15s
  evaluation_interval: 15s

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

  - job_name: 'cadvisor'
    static_configs:
      - targets: ['cadvisor:8080']

Das Intervall von 15s ist ein guter Kompromiss aus Auflösung und Last. Auf sehr kleinen Geräten erhöhen Sie es auf 30s, um Schreiblast und Speicherbedarf zu senken.

Verifizieren: docker run --rm --entrypoint promtool -v ~/monitoring/prometheus:/cfg prom/prometheus:v3.15.0 check config /cfg/prometheus.yml meldet SUCCESS.

Schritt 3: docker-compose.yml für den Stack erstellen

Jetzt definieren Sie die drei Container in einer Datei ~/monitoring/docker-compose.yml. cAdvisor erhält die nötigen Read-Only-Volumes (/rootfs, /var/run, /sys, /var/lib/docker), damit es cgroups und Docker-State auslesen kann. Das Image liegt seit Version 0.53 unter ghcr.io/google/cadvisor; unter gcr.io/cadvisor/cadvisor erscheinen keine neuen Versionen mehr.

services:
  cadvisor:
    image: ghcr.io/google/cadvisor:0.60.6
    container_name: cadvisor
    restart: unless-stopped
    ports:
      - "127.0.0.1:8080:8080"
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    devices:
      - /dev/kmsg
    privileged: true

  prometheus:
    image: prom/prometheus:v3.15.0
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "127.0.0.1:9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
    depends_on:
      - cadvisor

  grafana:
    image: grafana/grafana:13.2.3
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    depends_on:
      - prometheus

volumes:
  prometheus_data:
  grafana_data:

Wichtig: Die benannten Volumes prometheus_data und grafana_data sorgen dafür, dass Ihre Zeitreihen und Grafana-Einstellungen einen Neustart oder ein Update überleben. privileged: true ist für cAdvisor nötig, damit es alle Container-Statistiken erfasst. Genau deshalb bleibt Port 8080 an 127.0.0.1 gebunden: Die Weboberfläche von cAdvisor und Prometheus hat keine Anmeldung.

Verifizieren: docker compose config --quiet im Ordner ~/monitoring endet ohne Ausgabe und ohne Fehler.

Schritt 4: Den Stack starten

Starten Sie alle drei Container im Hintergrund. Compose zieht die Images automatisch und legt das gemeinsame Netzwerk an, über das Prometheus den Hostnamen cadvisor auflöst.

cd ~/monitoring
docker compose up -d

Prüfen Sie danach, ob alle Container laufen:

docker compose ps

Verifizieren: docker compose ps zeigt cadvisor, prometheus und grafana jeweils mit Status Up, docker compose logs cadvisor enthält keine Zeilen mit error zu /dev/kmsg.

Schritt 5: cAdvisor und Prometheus verifizieren

Bevor Sie Grafana einrichten, prüfen Sie die Kette cAdvisor zu Prometheus. Da beide Oberflächen nur lokal lauschen, öffnen Sie von Ihrem Arbeitsrechner einen SSH-Tunnel:

ssh -L 8080:127.0.0.1:8080 -L 9090:127.0.0.1:9090 benutzer@IHRE-SERVER-IP

Unter http://localhost:8080 sehen Sie nun die Live-Übersicht aller Container. Prüfen Sie auf dem Server den Roh-Endpunkt der Metriken per curl:

curl -s http://localhost:8080/metrics | grep container_memory_usage_bytes | head

Erscheinen Zeilen mit container_memory_usage_bytes, exportiert cAdvisor korrekt. Öffnen Sie nun Prometheus über den Tunnel und kontrollieren Sie das Target:

http://localhost:9090/targets

Wechseln Sie dann zum Reiter Query und testen Sie eine Abfrage, etwa die CPU-Auslastung je Container pro Sekunde:

rate(container_cpu_usage_seconds_total{name=~".+"}[5m])

Verifizieren: Das Target cadvisor zeigt den Status UP, und die Abfrage liefert je Container eine Datenreihe.

Schritt 6: Grafana mit Prometheus verbinden

Öffnen Sie Grafana im Browser:

http://IHRE-SERVER-IP:3000

Melden Sie sich mit dem Standard-Login admin / admin an und setzen Sie sofort ein eigenes, sicheres Passwort. Für den Zugriff aus dem Internet stellen Sie Grafana hinter einen Reverse Proxy mit TLS. Legen Sie anschließend die Datenquelle an:

Wählen Sie links Connections und dann Data sources.
Klicken Sie auf Add data source und wählen Sie Prometheus.
Tragen Sie als URL http://prometheus:9090 ein (der Service-Name aus Compose).
Klicken Sie unten auf Save & test.

Verifizieren: Grafana meldet nach Save & test „Successfully queried the Prometheus API“ bzw. Data source is working.

Schritt 7: Fertiges Grafana-Dashboard importieren

Sie müssen kein Dashboard von Hand bauen: Die Community stellt fertige cAdvisor Grafana Dashboard-Vorlagen über eine numerische ID bereit. Sehr verbreitet für cAdvisor-Daten ist das Dashboard mit der ID 14282 (Cadvisor exporter). So importieren Sie es:

Klicken Sie links auf Dashboards, dann oben rechts auf New und Import.
Tragen Sie im Feld Import via grafana.com die Dashboard-ID 14282 ein und klicken Sie auf Load.
Wählen Sie unten als Datenquelle die zuvor angelegte Prometheus-Quelle aus.
Klicken Sie auf Import.

Danach sehen Sie Panels mit CPU-, RAM-, Netzwerk- und Filesystem-Metriken je Container. Ein weiteres beliebtes Dashboard ist die ID 193 (Docker monitoring). Community-Dashboards werden unterschiedlich gepflegt; zeigt ein Panel keine Daten, passt meist ein Metrikname nicht zur aktuellen cAdvisor-Version.

Verifizieren: Das Dashboard zeigt für den Zeitraum Last 15 minutes CPU- und RAM-Kurven für jeden laufenden Container.

Updates und Wartung

Halten Sie den Stack aktuell. Tragen Sie dazu die neuen Versions-Tags aus den Release-Seiten in docker-compose.yml ein, lesen Sie vorher die Release Notes und führen Sie dann Pull und Neustart aus:

cd ~/monitoring
docker compose pull
docker compose up -d

Compose ersetzt nur die Container, deren Image sich geändert hat. Ihre Daten bleiben in den benannten Volumes erhalten. Feste Tags statt latest sorgen dafür, dass Updates kontrolliert und reproduzierbar erfolgen.

Alte, nicht mehr referenzierte Images entfernen Sie gelegentlich mit:

docker image prune -f

Backup-Hinweis

Sichern Sie die Konfigurationsdateien (docker-compose.yml, prometheus/prometheus.yml) sowie die beiden Volumes prometheus_data und grafana_data. Die Konfiguration ist mit einem einfachen Verzeichnis-Backup erledigt. Die Volumes sichern Sie so (für ein konsistentes Prometheus-Backup vorher docker compose stop prometheus):

docker run --rm \
  -v monitoring_grafana_data:/data \
  -v $(pwd):/backup alpine \
  tar czf /backup/grafana_data_backup.tar.gz -C /data .

Den exakten Volume-Namen finden Sie mit docker volume ls; Compose präfixt ihn üblicherweise mit dem Projektordner (hier monitoring_).

Troubleshooting

Target cadvisor ist DOWN in Prometheus: Prüfen Sie, ob beide Container im selben Compose-Netzwerk laufen (docker network inspect monitoring_default) und ob in prometheus.yml wirklich cadvisor:8080 und nicht localhost:8080 steht.
cAdvisor zeigt keine oder leere Metriken: Stellen Sie sicher, dass die Volumes /sys, /var/lib/docker und /var/run read-only gemountet sind und der Container mit privileged: true läuft.
Port 8080 bereits belegt: Ändern Sie das linke Port-Mapping, z. B. auf 127.0.0.1:8081:8080. Das Prometheus-Target ändert sich nur, wenn Sie über den Host scrapen (im internen Netzwerk bleibt es cadvisor:8080).
Grafana zeigt „No data“: Kontrollieren Sie unter Save & test, ob die Datenquelle http://prometheus:9090 erreichbar ist, und stellen Sie den Dashboard-Zeitbereich oben rechts auf z. B. Last 15 minutes.
cAdvisor startet auf manchen Systemen nicht: Auf einigen Distributionen ist der Eintrag devices: - /dev/kmsg nötig; ohne ihn bricht cAdvisor mit einem kmsg-Fehler ab.

Häufige Fragen

Wofür ist cAdvisor zuständig und was übernimmt Prometheus?

cAdvisor sammelt und exportiert die Metriken einzelner Docker-Container (CPU, RAM, Netzwerk, Disk) im Prometheus-Format unter Port 8080. Prometheus scrapet diesen Endpunkt in festen Intervallen, speichert die Werte als Zeitreihen und stellt sie für Abfragen und Grafana bereit. cAdvisor ist also der Sammler, Prometheus die Datenbank.

Welcher Port und welches Image gehören zu cAdvisor?

Das offizielle Image ist ghcr.io/google/cadvisor (ältere Versionen bis 0.52: gcr.io/cadvisor/cadvisor), die Weboberfläche und der Metriken-Endpunkt /metrics laufen standardmäßig auf Port 8080. In diesem Setup erreichen Sie die Live-Ansicht über den SSH-Tunnel unter http://localhost:8080.

Brauchen Sie zwingend Grafana für das Container-Monitoring?

Nein. Prometheus hat eine eigene Abfrage- und Graph-Oberfläche unter Port 9090, mit der Sie Metriken wie container_memory_usage_bytes direkt darstellen. Grafana bietet vorgefertigte Dashboards und Alarmierung und gehört deshalb meist dazu.

Wie importieren Sie ein fertiges cAdvisor-Dashboard in Grafana?

Wählen Sie in Grafana Dashboards > New > Import, trage eine Dashboard-ID wie 14282 oder 193 ein, klicken Sie auf Load, wählen Sie Ihre Prometheus-Datenquelle und bestätigen Sie mit Import. Die Panels füllen sich mit Ihren cAdvisor-Metriken.

Ist dieser Stack für den Produktiveinsatz geeignet?

Für kleine bis mittlere Setups ja. Für Produktion stellen Sie Grafana hinter einen Reverse Proxy mit TLS, setzen ein starkes Admin-Passwort und behalten die Prometheus-Retention (--storage.tsdb.retention.time) sowie den Festplattenplatz im Blick.

Fazit

Mit cAdvisor, Prometheus und Grafana steht ein selbst gehostetes Container-Monitoring. cAdvisor liefert die granularen Per-Container-Metriken, Prometheus sammelt und speichert sie als Zeitreihen, und Grafana stellt sie als Dashboards dar. Der Stack steckt in einer Compose-Datei und überlebt dank Volumes jeden Neustart. Sinnvolle Erweiterungen sind der Node Exporter für Host-Metriken und Alertmanager für Benachrichtigungen.

Weiterführende Anleitungen und Quellen

Falls Docker auf Ihrem Host noch fehlt, beginnen Sie mit unserer Schritt-für-Schritt-Anleitung zur Docker-Installation. Hintergründe zur Lieferkettensicherheit rund um Grafana finden Sie in unserer Meldung zum Grafana-Labs-GitHub-Token-Vorfall in der TanStack-Supply-Chain. Weitere Themen rund um Container und Selfhosting finden Sie in der Docker-Kategorie auf s-edv.com.

Quellen: Offizielle Dokumentation von cAdvisor (GitHub), Prometheus und Grafana.