Grafana Prometheus Monitoring Server Dashboard

Grafana und Prometheus einrichten: Professionelles Monitoring für deinen Heimserver

VonContentKalle

Grafana und Prometheus einrichten – das perfekte Monitoring-Duo für deinen Heimserver. Mit Grafana und Prometheus erhältst du professionelle Dashboards und Metriken für alle deine Server, Container und Dienste. In diesem Guide zeige ich dir, wie du das komplette Monitoring-Stack mit Docker Compose in unter einer Stunde aufsetzt.

Was sind Grafana und Prometheus?

Prometheus ist eine Open-Source-Monitoring-Plattform, die Metriken (CPU, RAM, Netzwerk, etc.) von verschiedenen Quellen sammelt und speichert. Es nutzt ein Pull-Modell: Prometheus ruft regelmäßig sogenannte „Exporter“ ab, die Metriken im Prometheus-Format bereitstellen.

Grafana ist ein Visualisierungswerkzeug, das Prometheus-Daten (und viele andere Datenquellen) in ansprechende Dashboards umwandelt. Tausende vorgefertigte Dashboards stehen zum Download bereit.

Die wichtigsten Komponenten

  • Prometheus: Metriken-Datenbank und Scraping-Engine
  • Grafana: Dashboard und Visualisierung
  • Node Exporter: System-Metriken (CPU, RAM, Disk, Netzwerk) für Linux-Server
  • cAdvisor: Container-Metriken für Docker
  • Alertmanager: Benachrichtigungen bei Schwellenwertüberschreitungen

Installation mit Docker Compose

Erstelle folgende Verzeichnisstruktur:

monitoring/
├── docker-compose.yml
├── prometheus/
│   └── prometheus.yml
└── grafana/

docker-compose.yml

version: '3'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    restart: always
    ports:
      - 9090:9090
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.retention.time=30d'

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    restart: always
    ports:
      - 3000:3000
    environment:
      GF_SECURITY_ADMIN_PASSWORD: sicheresPasswort123
    volumes:
      - grafana_data:/var/lib/grafana

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

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    restart: always
    ports:
      - 8080:8080
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker/:/var/lib/docker:ro

volumes:
  prometheus_data:
  grafana_data:

prometheus/prometheus.yml

global:
  scrape_interval: 15s

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

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

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

Stack starten

docker compose up -d

Prüfe, ob alle Container laufen:

docker compose ps

Grafana konfigurieren

  1. Öffne Grafana unter http://server-ip:3000
  2. Melde dich mit admin / sicheresPasswort123 an
  3. Gehe zu Configuration → Data Sources → Add data source
  4. Wähle Prometheus und gib als URL http://prometheus:9090 ein
  5. Klicke Save & Test – du solltest eine grüne Erfolgsmeldung sehen

Vorgefertigte Dashboards importieren

Das Beste an Grafana: Du musst Dashboards nicht von Grund auf erstellen. Unter grafana.com/grafana/dashboards findest du tausende kostenlose Dashboards. Empfehlungen:

  • Node Exporter Full (ID: 1860): Umfassendes System-Dashboard
  • Docker Container & Host Metrics (ID: 10619): Docker-Monitoring mit cAdvisor
  • Proxmox VE (ID: 10347): Proxmox-Monitoring

Importiere ein Dashboard: Dashboards → Import → Dashboard ID eingeben → Load. In Sekunden hast du ein professionelles Dashboard für dein System.

Proxmox-Monitoring einrichten

Für Proxmox gibt es einen speziellen Exporter. Installiere den PVE Exporter auf deinem Proxmox-Host:

pip3 install prometheus-pve-exporter

# Konfiguration
cat > /etc/pve_exporter.yml << EOF
pve:
  user: monitoring@pve
  password: monitoringPasswort
  verify_ssl: false
EOF

pve_exporter --config.file /etc/pve_exporter.yml

Füge den Proxmox-Target in deine prometheus.yml ein und starte Prometheus neu.

Alertmanager: Benachrichtigungen einrichten

Mit dem Alertmanager kannst du Benachrichtigungen per E-Mail, Slack oder Telegram erhalten, wenn Schwellenwerte überschritten werden – zum Beispiel wenn die Festplatte zu 90% voll ist oder ein Container abstürzt.

Grafana und Prometheus einrichten: Troubleshooting und erweiterte Setups

Prometheus scraped keine Metriken

Wenn Prometheus keine Daten sammelt, prüfe:

  • Ist der Exporter erreichbar? curl http://node-exporter:9100/metrics
  • Sind die Container im selben Docker-Netzwerk?
  • Prüfe die Prometheus-Targets unter http://prometheus-ip:9090/targets – grüne Targets bedeuten erfolgreiche Verbindung

Grafana zeigt keine Daten

  • Stimmt die Datenquellenadresse? Innerhalb von Docker: http://prometheus:9090 (Containername, nicht localhost)
  • Überprüfe den Zeitbereich im Dashboard – manchmal ist er falsch eingestellt
  • Teste in Grafana unter Explore → Prometheus → gib up als Metrik ein

Alerting mit Grafana

Grafana bietet seit Version 8 ein integriertes Alerting-System. Erstelle Alerts direkt im Dashboard-Panel: Klicke auf ein Panel → Edit → Alert → Create alert rule. Du kannst Benachrichtigungen per E-Mail, Slack, Telegram oder Webhook versenden.

Langzeit-Datenspeicherung mit Thanos oder VictoriaMetrics

Prometheus speichert Daten standardmäßig 15 Tage (einstellbar mit –storage.tsdb.retention.time). Für Langzeit-Archivierung empfiehlt sich VictoriaMetrics als Drop-in-Ersatz oder Thanos für verteilte Setups.

Grafana und Prometheus einrichten: Alertmanager vollständig konfigurieren

Der Alertmanager ist das Herzstück der Benachrichtigungsinfrastruktur. Füge ihn zu deiner docker-compose.yml hinzu und erstelle eine Konfigurationsdatei:

alertmanager/alertmanager.yml

global:
  resolve_timeout: 5m

route:
  group_by: ['alertname']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 12h
  receiver: 'telegram'

receivers:
  - name: 'telegram'
    telegram_configs:
      - bot_token: 'DEIN_BOT_TOKEN'
        chat_id: DEINE_CHAT_ID
        message: |
          {{ range .Alerts }}
          *{{ .Annotations.summary }}*
          {{ .Annotations.description }}
          {{ end }}

Alert-Regeln in Prometheus definieren

Erstelle eine Datei prometheus/alerts.yml mit sinnvollen Homelab-Alerts:

groups:
  - name: homelab
    rules:
      - alert: DiskAlmostFull
        expr: (node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100 < 10
        for: 5m
        labels:
          severity: warning
        annotations:
          summary: "Festplatte fast voll"
          description: "Weniger als 10% freier Speicherplatz auf {{ $labels.mountpoint }}"

      - alert: ContainerDown
        expr: absent(container_last_seen{name!=""})
        for: 1m
        labels:
          severity: critical
        annotations:
          summary: "Container ausgefallen"
          description: "Container {{ $labels.name }} ist nicht mehr erreichbar"

Referenziere die Alert-Datei in der prometheus.yml:

rule_files:
  - "alerts.yml"

alerting:
  alertmanagers:
    - static_configs:
        - targets: ['alertmanager:9093']

PromQL-Grundlagen: Die wichtigsten Abfragen

PromQL (Prometheus Query Language) ermöglicht es dir, eigene Dashboards und Alerts zu erstellen. Die wichtigsten Abfragen für das Homelab:

  • CPU-Auslastung: 100 - (avg by(instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)
  • RAM-Verbrauch in GB: (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / 1024^3
  • Netzwerk-Traffic: rate(node_network_receive_bytes_total[5m])
  • Disk-Auslastung: (1 - node_filesystem_avail_bytes / node_filesystem_size_bytes) * 100
  • Docker-Container-Anzahl: count(container_last_seen{image!=""})

Du kannst diese Abfragen direkt in Grafana unter Explore → Prometheus testen, bevor du sie in Dashboards einbindest.

Grafana Dashboard selbst erstellen: Schritt für Schritt

Eigene Dashboards zu erstellen ist einfacher als gedacht. So erstellst du dein erstes custom Dashboard:

  1. Klicke auf + → New Dashboard → Add visualization
  2. Wähle als Datenquelle Prometheus
  3. Gib im Query-Feld eine PromQL-Abfrage ein, z.B. node_memory_MemAvailable_bytes / 1024^3
  4. Wähle einen Panel-Typ: Time series für zeitliche Verläufe, Gauge für aktuelle Werte, Stat für einzelne Zahlen
  5. Passe unter Panel options Titel, Einheit (z.B. GB) und Schwellenwerte an
  6. Klicke Apply und speichere das Dashboard

Tipp: Nutze Grafana-Variablen (Dashboard Settings → Variables), um Dashboards wiederverwendbar zu machen. Damit kannst du zum Beispiel den Server über ein Dropdown auswählen, ohne separate Dashboards zu benötigen.

Weitere Exporter für dein Homelab

Neben Node Exporter und cAdvisor gibt es viele spezialisierte Exporter, die dein Monitoring erweitern:

  • Blackbox Exporter: Überwacht Websites und APIs von außen – misst HTTP-Antwortzeiten, prüft SSL-Zertifikate und testet DNS-Auflösung. Ideal als Ergänzung zu Uptime Kuma.
  • SNMP Exporter: Sammelt Metriken von Netzwerkgeräten (Router, Switches, NAS) über das SNMP-Protokoll.
  • Postgres/MySQL Exporter: Datenbank-Metriken wie Abfragedauer, Verbindungsanzahl und Cache-Hit-Rate direkt in Grafana visualisieren.
  • Smokeping Prober: Misst Netzwerklatenz und Paketverlust zu verschiedenen Zielen – zeigt dir grafisch, wenn deine Internetverbindung schwächelt.
  • Fritz!Box Exporter: Sammelt Metriken direkt von deiner Fritz!Box – DSL-Geschwindigkeit, verbundene Geräte, Uptime.
  • Speedtest Exporter: Führt regelmäßige Internet-Speedtests durch und speichert die Ergebnisse in Prometheus für historische Analyse.

Alle offiziellen und Community-Exporter findest du unter prometheus.io/docs/instrumenting/exporters. Die Konfiguration folgt immer dem gleichen Schema: Docker-Container starten, Target in prometheus.yml eintragen, Grafana-Dashboard importieren.

Grafana und Prometheus einrichten: Sicherheit und Produktions-Tipps

Für ein sicheres Setup im Homelab beachte folgende Punkte:

  • Reverse Proxy vorschalten: Stelle Grafana nur über HTTPS erreichbar – nutze Nginx Proxy Manager oder Caddy als Reverse Proxy. Prometheus und Alertmanager sollten nicht direkt aus dem Internet erreichbar sein.
  • Passwörter ändern: Ändere das Standard-Passwort sicheresPasswort123 vor dem Produktivbetrieb. Alternativ nutze Grafana-Umgebungsvariable GF_SECURITY_ADMIN_PASSWORD aus einer .env-Datei.
  • Retention-Zeit anpassen: Für ein Homelab reichen 30–90 Tage Datenspeicherung. Erhöhe den Wert in --storage.tsdb.retention.time=90d.
  • Regelmäßige Backups: Sichere die Docker-Volumes prometheus_data und grafana_data regelmäßig – dort liegen alle historischen Metriken und Dashboard-Konfigurationen.

Fazit: Professionelles Monitoring für dein Homelab

Mit Grafana und Prometheus hast du ein professionelles Monitoring-System, das in großen Unternehmen genauso eingesetzt wird wie im Homelab. Die Docker-Compose-Installation ist in unter einer Stunde erledigt, und dank der vorgefertigten Dashboards siehst du sofort aussagekräftige Metriken über dein System. Kein Homelab ist komplett ohne Monitoring!

Ähnliche Beiträge