Prometheus & Grafana: Docker-Monitoring im Homelab selbst hosten

Wer im Homelab mehrere Docker-Container betreibt – Nextcloud, Portainer, WordPress, Caddy, eine Datenbank – kennt das Problem: Irgendwann verliert man den Überblick. Läuft der Container noch? Wird der Speicher knapp? Frisst ein Dienst plötzlich 100% CPU?

Die Lösung heißt Prometheus (Metriken sammeln) + Grafana (visualisieren). Beide lassen sich mit Docker Compose in wenigen Minuten aufsetzen. Dieser Beitrag zeigt dir das vollständige Setup – vom Docker-Compose-File bis zum ersten Dashboard.

Warum Prometheus & Grafana?

• Prometheus sammelt Metriken von deinen Containern, Servern und Diensten per Pull-Prinzip – alle 15 Sekunden holt er sich die aktuellen Daten von den „Exportern“.
• Grafana zeichnet diese Metriken in Dashboards: CPU, RAM, Netzwerkverkehr, Festplattenplatz, HTTP-Anfragen – alles visuell aufbereitet.
• Beide sind Open Source, bewährt und in der Cloud-Industrie der De-facto-Standard.
• Der Alertmanager ergänzt das Setup um Benachrichtigungen per E-Mail, Slack oder Telegram, wenn ein Dienst kritische Werte überschreitet.

Setup mit Docker Compose

Erstelle eine Datei docker-compose.yml mit folgendem Inhalt:

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'
    ports:
      - '9090:9090'
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    volumes:
      - grafana_data:/var/lib/grafana
    ports:
      - '3000:3000'
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=securepassword
    restart: unless-stopped

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    volumes:
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /:/rootfs:ro
    command:
      - '--path.procfs=/host/proc'
      - '--path.sysfs=/host/sys'
      - '--path.rootfs=/rootfs'
    restart: unless-stopped

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro
      - /dev/disk/:/dev/disk:ro
    privileged: true
    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:
  grafana_data:
  alertmanager_data:

Der Node Exporter liefert Systemmetriken (CPU, RAM, Disk, Netzwerk) vom Docker-Host. Der cAdvisor liefert Container-spezifische Metriken wie Speicher- und CPU-Auslastung pro Container – das ist besonders nützlich, wenn du sehen willst, welcher Dienst gerade Amok läuft. Der Alertmanager sorgt für Benachrichtigungen bei kritischen Zuständen.

Prometheus-Konfiguration

Erstelle eine prometheus.yml im gleichen Verzeichnis:

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: 'node'
    static_configs:
      - targets: ['node-exporter:9100']

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

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

Starte das Setup mit docker compose up -d. Danach erreichst du Prometheus unter Port 9090 und Grafana unter Port 3000 (Login: admin / securepassword).

Erstes Grafana-Dashboard

In Grafana musst du zuerst eine Datenquelle hinzufügen:

1. Links auf das Zahnrad → Data Sources → Add data source
2. Prometheus auswählen und als URL http://prometheus:9090 eintragen
3. Save & Test

Danach kannst du Dashboards importieren. Die Community stellt hunderte fertige Dashboards bereit:

Dashboard	ID	Beschreibung
Node Exporter Full	1860	System-Metriken (CPU, RAM, Disk, Netzwerk)
Docker Monitoring	10566	Container-Metriken via cAdvisor
Prometheus 2.0 Stats	2	Prometheus-Eigenmetriken

Gehe auf Create → Import, gib die ID ein und klicke auf Load. Fertig ist dein System-Monitoring.

Alertmanager-Konfiguration

Der Alertmanager wertet Prometheus-Alarme aus und sendet Benachrichtigungen. Erstelle eine alertmanager.yml:

route:
  receiver: 'admin'
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 4h

receivers:
  - name: 'admin'
    email_configs:
      - to: 'admin@example.com'
        from: 'alertmanager@example.com'
        smarthost: 'mail.example.com:587'
        auth_username: 'alertmanager@example.com'
        auth_password: 'password'

Für das Homelab reicht eine einfache E-Mail-Benachrichtigung. In Produktivumgebungen bietet sich Slack oder Telegram per Webhook an.

Prometheus-Alarmregeln definieren

Erstelle eine Datei alerts.yml und binde sie in der prometheus.yml ein:

groups:
  - name: homelab
    rules:
      - alert: HoheCPU
        expr: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "CPU über 80% für 5 Minuten"

      - alert: FestplatteVoll
        expr: node_filesystem_avail_bytes{mountpoint="/"} / node_filesystem_size_bytes{mountpoint="/"} < 0.1
        for: 5m
        labels:
          severity: critical
        annotations:
          summary: "Weniger als 10% freier Speicher"

      - alert: ContainerAusgefallen
        expr: time() - container_last_seen > 60
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Container nicht erreichbar seit 1 Minute"

Ergänze in der prometheus.yml den Eintrag rule_files: - 'alerts.yml' und starte Prometheus neu. Die Alarme erscheinen dann im Prometheus-Webinterface unter „Alerts“ und werden vom Alertmanager weitergeleitet.

Reverse Proxy für HTTPS

Wenn du Grafana von außen erreichbar machen willst, setze einen Reverse Proxy wie Caddy davor. So erhältst du automatisches HTTPS. Beispiel-Caddyfile:

grafana.deine-domain.de {
    reverse_proxy grafana:3000
}

Stolpersteine und Tipps

• Port-Konflikte: Wenn Port 9090 oder 3000 schon belegt sind, ändere die Ports im docker-compose.yml (z.B. 9091:9090).
• Persistente Daten: Nutze Docker-Volumes (wie oben gezeigt) statt lokaler Verzeichnisse – das erleichtert Backups und Migration.
• Grafana-Passwort: Ändere das Admin-Passwort sofort nach dem ersten Login über die Grafana-Oberfläche.
• Ressourcenverbrauch: Prometheus + Grafana + Node Exporter + cAdvisor brauchen zusammen etwa 300-500 MB RAM – das ist für jedes Homelab machbar.

Fazit

Prometheus + Grafana sind der Goldstandard für Homelab-Monitoring. Mit Docker Compose ist das Setup in 10 Minuten erledigt. Du bekommst:

• Echtzeit-Metriken aller Container und Dienste
• Wiederverwendbare Dashboards (Community-Import)
• Alarme bei kritischen Zuständen per E-Mail
• Historische Daten für Capacity Planning

Starte noch heute – dein zukünftiges Ich wird dir danken, wenn ein Dienst mal wieder unerwartet Vollgas gibt und du sofort siehst, wer schuld ist.