Mit cAdvisor Prometheus Docker Monitoring bekommst du in wenigen Minuten einen vollständigen Einblick in jeden einzelnen Container auf deinem Host: CPU-Last, Speicherverbrauch, Netzwerk-Traffic und Disk-I/O - und das pro Container statt nur als Summe für den gesamten Server. Diese Anleitung zeigt dir Schritt für Schritt, wie du cAdvisor (Container Advisor von Google) als Metriken-Exporter startest, die Werte mit Prometheus scrapest und am Ende in einem fertigen Grafana-Dashboard visualisierst. Die Anleitung richtet sich an Admins, Homeserver-Betreiber und alle, die ihre Docker-Hosts in der Selfhosting-Szene sauber überwachen wollen - ohne kommerzielle SaaS-Tools, komplett selbst gehostet und kostenlos.

Kurzfassung: cAdvisor liefert per-Container-Metriken auf Port 8080, Prometheus scrapet das Target cadvisor:8080, Grafana visualisiert. Alles läuft als drei Container in einer einzigen docker-compose.yml.

Was ist cAdvisor und warum brauchst du 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 - genau das, was du für Dashboards und Alerts brauchst.

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 ergeben die drei den klassischen, bewährten Docker Monitoring Stack für Container Monitoring.

Typische Metriken, die du nach dem Setup abfragen kannst:

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), 9090 (Prometheus), 3000 (Grafana). Bei Konflikten passt du das linke Mapping an.
Mindestens ~512 MB freier RAM für den Stack auf kleinen Homeservern; mehr für längere Retention.
Grundkenntnisse in der Shell und einem Editor (nano, vim o. ae.).

Schritt 1: Projektverzeichnis und Struktur anlegen

Lege ein Arbeitsverzeichnis für den Monitoring-Stack an. So bleiben Compose-Datei und Konfiguration sauber an einem Ort und du kannst sie später leicht sichern.

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

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

Schritt 2: Prometheus-Konfiguration schreiben

Erstelle die Datei ~/monitoring/prometheus/prometheus.yml. Hier definierst du, 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 kannst du es auf 30s erhöhen, um Schreiblast und Speicherbedarf zu senken.

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

Jetzt definierst du die drei Container in einer einzigen 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.

services:
  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    restart: unless-stopped
    ports:
      - "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:latest
    container_name: prometheus
    restart: unless-stopped
    ports:
      - "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:latest
    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 deine Zeitreihen und Grafana-Einstellungen einen Neustart oder ein Update überleben. privileged: true ist für cAdvisor nötig, damit es alle Container-Statistiken zuverlässig erfassen kann.

Schritt 4: Den Stack starten

Starte 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üfe danach, ob alle Container laufen:

docker compose ps

Du solltest cadvisor, prometheus und grafana jeweils im Status running sehen.

Schritt 5: cAdvisor und Prometheus verifizieren

Bevor du Grafana einrichtest, stelle sicher, dass die Kette cAdvisor zu Prometheus funktioniert. Öffne zuerst die cAdvisor-Weboberfläche im Browser:

http://DEINE-SERVER-IP:8080

Hier siehst du eine Live-Übersicht aller Container. Prüfe als Nächstes den Roh-Endpunkt der Metriken direkt per curl:

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

Erscheinen Zeilen mit container_memory_usage_bytes, exportiert cAdvisor korrekt. Öffne nun Prometheus und kontrolliere, ob das Target erreichbar ist:

http://DEINE-SERVER-IP:9090/targets

Das Target cadvisor muss den Status UP zeigen. Wechsle dann zum Reiter Graph und teste eine Abfrage, etwa die CPU-Auslastung je Container pro Sekunde:

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

Liefert die Query Datenreihen, ist die Sammelkette vollständig.

Schritt 6: Grafana mit Prometheus verbinden

Öffne Grafana im Browser:

http://DEINE-SERVER-IP:3000

Melde dich mit dem Standard-Login admin / admin an und setze sofort ein eigenes, sicheres Passwort. Lege anschließend die Datenquelle an:

Gehe links auf Connections und dann Data sources.
Klicke auf Add data source und wähle Prometheus.
Trage als URL http://prometheus:9090 ein (der Service-Name aus Compose).
Klicke unten auf Save & test - die Meldung Data source is working bestätigt die Verbindung.

Schritt 7: Fertiges Grafana-Dashboard importieren

Du musst 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 importierst du es:

Klicke links auf Dashboards, dann oben rechts auf New und Import.
Trage im Feld Import via grafana.com die Dashboard-ID 14282 ein und klicke auf Load.
Wähle unten als Datenquelle deine zuvor angelegte Prometheus-Quelle aus.
Klicke auf Import.

Sofort siehst du Panels mit CPU-, RAM-, Netzwerk- und Filesystem-Metriken je Container. Ein weiteres beliebtes Dashboard ist die ID 193 (Docker monitoring). Probiere ruhig mehrere aus und behalte das, das am besten zu deinen Containern passt.

Updates und Wartung

Halte den Stack regelmäßig aktuell, um Sicherheits- und Bugfixes mitzunehmen. Da alle drei Images mit dem Tag latest laufen, genügt ein Pull und Recreate:

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

Compose ersetzt nur die Container, deren Image sich geändert hat. Deine Daten bleiben in den benannten Volumes erhalten. Für Produktivumgebungen ist es ratsam, statt latest feste Versions-Tags zu pinnen (z. B. prom/prometheus:v3.0.0), damit Updates kontrolliert und reproduzierbar erfolgen.

Alte, ungenutzte Images entfernst du gelegentlich mit:

docker image prune -f

Backup-Hinweis

Sichere 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 sicherst du im laufenden Betrieb so:

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 findest du mit docker volume ls - Compose präfixt ihn üblicherweise mit dem Projektordner (hier monitoring_).

Troubleshooting

Target cadvisor ist DOWN in Prometheus: Prüfe, 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: Stelle 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: Ändere das linke Port-Mapping, z. B. auf "8081:8080", und passe das Prometheus-Target nur an, falls du über den Host scrapest (im internen Netzwerk bleibt es cadvisor:8080).
Grafana zeigt "No data": Kontrolliere unter Save & test, ob die Datenquelle http://prometheus:9090 erreichbar ist, und stelle 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 gcr.io/cadvisor/cadvisor:latest, die Weboberfläche und der Metriken-Endpunkt /metrics laufen standardmäßig auf Port 8080. Im Browser erreichst du die Live-Ansicht unter http://server-ip:8080.

Brauche ich zwingend Grafana für das Container Monitoring?

Nein. Prometheus hat eine eigene Abfrage- und Graph-Oberfläche unter Port 9090, mit der du Metriken wie container_memory_usage_bytes direkt visualisieren kannst. Grafana bietet aber deutlich hübschere, vorgefertigte Dashboards und Alerting, weshalb es im klassischen Docker Monitoring Stack fast immer dazugehört.

Wie importiere ich ein fertiges cAdvisor-Dashboard in Grafana?

Gehe in Grafana auf Dashboards > New > Import, trage eine Dashboard-ID wie 14282 oder 193 ein, klicke auf Load, wähle deine Prometheus-Datenquelle und bestätige mit Import. Die Panels werden automatisch mit deinen cAdvisor-Metriken befüllt.

Ist dieser Stack für den Produktiveinsatz geeignet?

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

Fazit

Mit cAdvisor, Prometheus und Grafana hast du in unter einer halben Stunde ein vollwertiges, selbst gehostetes cAdvisor Prometheus Docker Monitoring aufgebaut. cAdvisor liefert die granularen Per-Container-Metriken, Prometheus sammelt und speichert sie als Zeitreihen, und Grafana macht aus den Rohdaten aussagekräftige Dashboards. Der gesamte Stack steckt in einer einzigen Compose-Datei, lässt sich mit zwei Befehlen aktualisieren und überlebt dank Volumes jeden Neustart. Erweitere ihn später um den Node Exporter für Host-Metriken und um Alertmanager für Benachrichtigungen - die Grundlage dafür hast du jetzt gelegt.

Weiterführende Anleitungen und Quellen

Falls Docker auf deinem Host noch fehlt, starte mit unserer Schritt-für-Schritt-Anleitung zur Docker-Installation. Wer rund um das Monitoring-Ökosystem von Grafana und die Lieferkettensicherheit auf dem Laufenden bleiben will, findet Hintergründe in unserer Meldung zum Grafana-Labs-GitHub-Token-Vorfall in der TanStack-Supply-Chain. Weitere Themen rund um Container und Selfhosting findest du in der Docker-Kategorie auf s-edv.com.

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