Grafana: Monitoring für Homelab

Das Blindflug-Problem

Stell dir vor, du betreibst ein Homelab mit zehn, zwanzig oder dreissig Services. Alles scheint zu laufen. Dann sagt dir ein Kunde, dass deine Website seit sechs Stunden offline ist. Oder du merkst, dass deine Backup-Festplatte seit zwei Wochen voll ist. Oder ein Docker Container startet seit Stunden alle fünfzehn Minuten still und leise neu — und niemand hat es bemerkt.

Das passiert ohne Monitoring. Du fliegst blind. Monitoring ist der Unterschied zwischen "Probleme finden, bevor jemand betroffen ist" und "Probleme von genervten Nutzern erfahren".

Was gutes Monitoring leistet

Gutes Monitoring macht drei Dinge:

• Aktuellen Zustand zeigen: Ist gerade alles gesund? Welche Services laufen? Wie viel Festplattenplatz ist noch frei? Du solltest diese Fragen in unter zehn Sekunden beantworten können.
• Trends über die Zeit: Deine Festplatte war letzten Monat bei sechzig Prozent und ist jetzt bei achtzig. Bei diesem Tempo ist sie in sechs Wochen voll. Trends sagen dir, was kommt, bevor es soweit ist.
• Bei Problemen warnen: Wenn ein Schwellenwert überschritten wird — Festplatte über neunzig Prozent, Service länger als zwei Minuten down — schickt dir das Monitoring eine Benachrichtigung. Du erfährst von Problemen in Sekunden, nicht in Stunden.

Grafana ist das Dashboard-Tool schlechthin, wenn es um Metriken geht. Egal ob Docker-Container, Server-Ressourcen oder deine eigenen Anwendungen — Grafana visualisiert alles, was du reingibst.

Warum Grafana?

• • Open Source — kostenlos
• • 100+ Datenquellen — Prometheus, InfluxDB, Elasticsearch
• • Flexible Dashboards — eigene Visualisierungen
• • Alerting — Benachrichtigungen bei Problemen
• • Self-hosted — alle Daten bleiben lokal

Komponenten

Was du damit überwachen kannst

Docker Monitoring

Hier ist unser docker-compose.yml für ein komplettes Monitoring-Stack:

# docker-compose.yml
services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
    ports:
      - "9090:9090"

  node-exporter:
    image: prom/node-exporter
    ports:
      - "9100:9100"

  cadvisor:
    image: gcr.io/cadvisor/cadvisor
    ports:
      - "8080:8080"

  grafana:
    image: grafana/grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana

Nach dem Starten über docker compose up -d findest du:

• • Grafana: http://localhost:3000 (admin/admin)
• • Prometheus: http://localhost:9090
• • Node Exporter: http://localhost:9100
• • cAdvisor: http://localhost:8080

Prometheus Konfiguration

# 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']

Teste mit: curl http://localhost:9090/api/v1/query?query=up

Wichtige Metriken

Alerting

So richtest du Alerts ein, die dich bei Problemen benachrichtigen:

# alerts.yml - Alert-Regeln
groups:
- name: container_alerts
  rules:
  - alert: HighMemoryUsage
    expr: (container_memory_usage_bytes / container_spec_memory_limit_bytes) * 100 > 90
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "Container {{ $labels.name }} nutzt über 90% RAM"

  - alert: ContainerDown
    expr: up{job="docker"} == 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "Container {{ $labels.instance }} ist down"

  - alert: HighCPUUsage
    expr: 100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
    for: 10m
    labels:
      severity: warning

Prometheus Query-Beispiele zum Testen:

# Alle laufenden Container
up{job="docker"}

# Memory Usage in Prozent
(container_memory_usage_bytes / container_spec_memory_limit_bytes) * 100

# CPU Usage
100 - (avg by(instance) (irate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

Unsere Dashboards

Wir nutzen 22 vorkonfigurierte Dashboards:

• • Docker Swarm Overview
• • Node Resources (CPU, RAM, Disk)
• • Container Details
• • Network Traffic
• • GPU Utilization (für Ollama)
• • n8n Workflow Status
• • System Health Overview

GPU Monitoring für Ollama

Für GPU-Monitoring brauchst du den nvidia-exporter:

# docker-compose.yml erweitern
  nvidia-exporter:
    image: nvcr.io/nvidia/prometheus-nvidia-exporter:latest
    environment:
      - NVIDIA_ADDR=unix:///run/nvidia.sock
    volumes:
      - /var/run/nvidia.sock:/var/run/nvidia.sock
    ports:
      - "9101:9101"
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Wichtige GPU-Metriken in Prometheus:

# GPU Temperature
nvidia_gpu_temperature_celsius

# GPU Utilization
nvidia_gpu_utilization_percentage

# Memory Usage
nvidia_gpu_memory_used_bytes / nvidia_gpu_memory_total_bytes * 100

# Power Usage
nvidia_gpu_power_draw_watts