Raspberry Pi Monitoring mit Grafana & InfluxDB

🛠️ Voraussetzungen & Hardware

Hardware-Anforderungen

✅ Empfohlen

• Raspberry Pi 4B (4GB+) oder Pi 5
• 32GB+ SD-Karte (Class 10)
• Ethernet-Verbindung
• Aktive Kühlung

⚠️ Minimum

• Raspberry Pi 4B (2GB)
• 16GB SD-Karte
• WLAN-Verbindung
• Passivkühler

Software-Voraussetzungen

System prüfen

# Raspberry Pi OS Version
cat /etc/os-release

# Docker installiert?
docker --version

# Verfügbarer Speicher
df -h

# RAM-Status
free -h

Wichtiger Hinweis

Monitoring-Systeme können ressourcenintensiv sein. Bei einem Pi mit nur 2GB RAM solltest du die Konfiguration entsprechend anpassen.

🐳 Docker-Environment aufsetzen

Docker Compose Struktur

Wir verwenden Docker Compose für eine saubere und wartbare Lösung. Erstelle zuerst die Verzeichnisstruktur:

Bash

# Monitoring-Verzeichnis erstellen
mkdir -p ~/monitoring/{grafana,influxdb,telegraf}/config
mkdir -p ~/monitoring/{grafana,influxdb}/data

# Berechtigung setzen
sudo chown -R $USER:$USER ~/monitoring

cd ~/monitoring

Docker Compose File

docker-compose.yml

version: '3.8'

services:
  influxdb:
    image: influxdb:2.7-alpine
    container_name: influxdb
    ports:
      - "8086:8086"
    volumes:
      - ./influxdb/data:/var/lib/influxdb2
      - ./influxdb/config:/etc/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=SecurePassword123
      - DOCKER_INFLUXDB_INIT_ORG=homelab
      - DOCKER_INFLUXDB_INIT_BUCKET=system_metrics
    restart: unless-stopped
    
  telegraf:
    image: telegraf:1.28-alpine
    container_name: telegraf
    volumes:
      - ./telegraf/config/telegraf.conf:/etc/telegraf/telegraf.conf:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /sys:/rootfs/sys:ro
      - /proc:/rootfs/proc:ro
      - /etc:/rootfs/etc:ro
    environment:
      - HOST_PROC=/rootfs/proc
      - HOST_SYS=/rootfs/sys
      - HOST_ETC=/rootfs/etc
    depends_on:
      - influxdb
    restart: unless-stopped
    
  grafana:
    image: grafana/grafana:10.2.0
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - ./grafana/data:/var/lib/grafana
      - ./grafana/config:/etc/grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=admin123
      - GF_INSTALL_PLUGINS=grafana-clock-panel,grafana-piechart-panel
    depends_on:
      - influxdb
    restart: unless-stopped

networks:
  default:
    name: monitoring

📊 InfluxDB installieren & konfigurieren

InfluxDB starten

# Nur InfluxDB starten (für Konfiguration)
docker-compose up -d influxdb

# Logs prüfen
docker-compose logs -f influxdb

Erste Einrichtung über Web-UI

Öffne deinen Browser und gehe zu http://<raspberry-pi-ip>:8086:

Setup-Schritte:

Username: admin
Password: SecurePassword123
Organization: homelab
Bucket: system_metrics
API Token erstellen und notieren!

Pro-Tipp: API Token

Speichere den API Token sicher! Du brauchst ihn für Telegraf und Grafana. Du findest ihn unter "Data" → "API Tokens" im InfluxDB UI.

📡 Telegraf konfigurieren

Telegraf Konfiguration erstellen

telegraf/config/telegraf.conf

# Global Agent Configuration
[agent]
  interval = "10s"
  round_interval = true
  metric_batch_size = 1000
  metric_buffer_limit = 10000
  collection_jitter = "0s"
  flush_interval = "10s"
  flush_jitter = "0s"
  precision = ""
  hostname = "raspberry-pi"
  omit_hostname = false

# Output Plugin - InfluxDB
[[outputs.influxdb_v2]]
  urls = ["http://influxdb:8086"]
  token = "DEIN_API_TOKEN_HIER"
  organization = "homelab"
  bucket = "system_metrics"

# Input Plugins
[[inputs.cpu]]
  percpu = true
  totalcpu = true
  collect_cpu_time = false
  report_active = false

[[inputs.disk]]
  ignore_fs = ["tmpfs", "devtmpfs", "devfs", "iso9660", "overlay", "aufs", "squashfs"]

[[inputs.diskio]]

[[inputs.kernel]]

[[inputs.mem]]

[[inputs.processes]]

[[inputs.swap]]

[[inputs.system]]

[[inputs.net]]

[[inputs.netstat]]

# Docker Container Metriken
[[inputs.docker]]
  endpoint = "unix:///var/run/docker.sock"
  gather_services = false
  container_names = []
  source_tag = false
  container_name_include = []
  container_name_exclude = []
  timeout = "5s"
  perdevice = true
  total = false

# Temperatur (Raspberry Pi spezifisch)
[[inputs.file]]
  files = ["/sys/class/thermal/thermal_zone0/temp"]
  name_override = "cpu_temperature"
  data_format = "value"
  data_type = "integer"

# Load Average
[[inputs.system]]
  fielddrop = ["uptime_format"]

Wichtig: API Token ersetzen

Ersetze DEIN_API_TOKEN_HIER mit dem echten Token aus der InfluxDB UI!

Telegraf starten und testen

# Telegraf starten
docker-compose up -d telegraf

# Logs prüfen (sollte keine Fehler zeigen)
docker-compose logs -f telegraf

# Status aller Container prüfen
docker-compose ps

Daten in InfluxDB prüfen

Nach ein paar Minuten sollten erste Daten in InfluxDB ankommen. Prüfe das in der InfluxDB UI unter "Data Explorer".

Wähle den Bucket system_metrics und schaue nach Measurements wie cpu, mem, disk.

📊 Grafana Installation

Grafana zu Docker Compose hinzufügen

Jetzt erweitern wir unsere docker-compose.yml um Grafana für die Visualisierung:

Erweiterte docker-compose.yml

version: '3.8'

services:
  influxdb:
    image: influxdb:2.7-alpine
    container_name: influxdb
    restart: unless-stopped
    ports:
      - "8086:8086"
    volumes:
      - influxdb_data:/var/lib/influxdb2
      - ./influxdb/config:/etc/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=SecurePassword123
      - DOCKER_INFLUXDB_INIT_ORG=homelab
      - DOCKER_INFLUXDB_INIT_BUCKET=system_metrics

  telegraf:
    image: telegraf:1.28-alpine
    container_name: telegraf
    restart: unless-stopped
    volumes:
      - ./telegraf/config/telegraf.conf:/etc/telegraf/telegraf.conf:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - /sys:/host/sys:ro
      - /proc:/host/proc:ro
      - /etc:/host/etc:ro
    environment:
      - HOST_ETC=/host/etc
      - HOST_PROC=/host/proc
      - HOST_SYS=/host/sys
    depends_on:
      - influxdb

  grafana:
    image: grafana/grafana:10.2.0
    container_name: grafana
    restart: unless-stopped
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/config/grafana.ini:/etc/grafana/grafana.ini
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=SecurePassword123
      - GF_INSTALL_PLUGINS=grafana-clock-panel,grafana-simple-json-datasource
    depends_on:
      - influxdb

volumes:
  influxdb_data:
  grafana_data:

Grafana Konfiguration erstellen

grafana/config/grafana.ini

[server]
protocol = http
http_port = 3000
domain = localhost

[security]
admin_user = admin
admin_password = SecurePassword123

[users]
allow_sign_up = false

[analytics]
reporting_enabled = false
check_for_updates = false

[log]
mode = console
level = info

# Verzeichnisse erstellen
mkdir -p grafana/config grafana/provisioning/datasources grafana/provisioning/dashboards

# Grafana starten
docker-compose up -d grafana

# Logs prüfen
docker-compose logs -f grafana

🎯 Grafana Dashboard Setup

InfluxDB Datenquelle konfigurieren

Öffne Grafana in deinem Browser: http://<raspberry-pi-ip>:3000

Datenquelle hinzufügen:

Login: admin / SecurePassword123
Gehe zu "Configuration" → "Data Sources"
Klicke "Add data source" → "InfluxDB"
Konfiguration:
- Query Language: Flux
- URL: http://influxdb:8086
- Organization: homelab
- Token: DEIN_API_TOKEN
- Default Bucket: system_metrics
"Save & test" - sollte grün werden

Raspberry Pi Dashboard erstellen

Jetzt erstellen wir ein aussagekräftiges Dashboard für deinen Raspberry Pi:

🔥 CPU Panel

from(bucket: "system_metrics")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "cpu")
  |> filter(fn: (r) => r["_field"] == "usage_active")
  |> filter(fn: (r) => r["cpu"] == "cpu-total")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Visualisierung: Time series
Unit: Percent (0-100)

💾 Memory Panel

from(bucket: "system_metrics")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "mem")
  |> filter(fn: (r) => r["_field"] == "used_percent")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Visualizierung: Gauge
Min: 0, Max: 100

🌡️ Temperatur Panel

from(bucket: "system_metrics")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "cpu_temperature")
  |> filter(fn: (r) => r["_field"] == "value")
  |> map(fn: (r) => ({ r with _value: r._value / 1000.0 }))
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Visualizierung: Stat
Unit: Celsius (°C)

💽 Disk Usage Panel

from(bucket: "system_metrics")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r["_measurement"] == "disk")
  |> filter(fn: (r) => r["_field"] == "used_percent")
  |> filter(fn: (r) => r["path"] == "/")
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> yield(name: "mean")

Visualizierung: Bar gauge
Unit: Percent (0-100)

Dashboard-Tipp: Thresholds verwenden

• CPU > 80%: Orange Warnung
• CPU > 90%: Rote Kritisch
• Temperatur > 70°C: Orange
• Temperatur > 80°C: Rot
• Disk > 85%: Orange
• Disk > 95%: Rot

🚨 Alerting Setup

E-Mail Alerts konfigurieren

Richte Alerts ein, damit du bei kritischen Problemen sofort benachrichtigt wirst:

grafana/provisioning/notifiers/email.yml

notifiers:
  - name: email-alerts
    type: email
    uid: email001
    org_id: 1
    is_default: true
    settings:
      addresses: "deine-email@domain.com"
      subject: "🚨 Raspberry Pi Alert: {{ .RuleName }}"
      body: |
        Alert: {{ .RuleName }}
        Status: {{ .Status }}
        
        {{ range .Alerts }}
        - {{ .Annotations.summary }}
        Value: {{ .ValueString }}
        {{ end }}
        
        Dashboard: {{ .DashboardURL }}
    secure_settings:
      password: "dein-email-passwort"

Alert Rule: Hohe CPU Last

Condition: CPU > 90% für 5 Minuten
Evaluation: Alle 1 Minute
Severity: Critical
Notification: E-Mail + Dashboard

Alert Rule: Hohe Temperatur

Condition: Temp > 75°C für 3 Minuten
Evaluation: Alle 30 Sekunden
Severity: Warning
Notification: E-Mail

Alert Rule: Wenig Speicher

Condition: Memory > 95% für 2 Minuten
Evaluation: Alle 1 Minute
Severity: Critical
Notification: E-Mail + SMS

Alert Rule: Disk voll

Condition: Disk > 90% für 10 Minuten
Evaluation: Alle 5 Minuten
Severity: Warning
Notification: E-Mail

⚡ Performance Optimierung

InfluxDB Optimierung

Retention Policy einrichten

# In InfluxDB UI: Data -> Buckets -> system_metrics -> Settings

# Retention Policy Beispiele:
- Hochfrequente Daten (10s): 7 Tage
- Minütliche Aggregate: 30 Tage  
- Stündliche Aggregate: 1 Jahr
- Tägliche Aggregate: 5 Jahre

# Automatische Downsampling Tasks erstellen:
option task = {name: "downsample-1h", every: 1h}

from(bucket: "system_metrics")
  |> range(start: -1h)
  |> filter(fn: (r) => r["_measurement"] == "cpu")
  |> aggregateWindow(every: 1h, fn: mean)
  |> to(bucket: "system_metrics_1h")

Raspberry Pi System-Optimierung

SD-Karte schonen

# Log-Rotation konfigurieren
sudo nano /etc/logrotate.d/docker-containers

# Docker Logs begrenzen
echo '{"log-driver": "json-file", "log-opts": {"max-size": "10m", "max-file": "3"}}' | sudo tee /etc/docker/daemon.json

# tmpfs für temporäre Daten
echo "tmpfs /tmp tmpfs defaults,noatime,nosuid,size=100m 0 0" | sudo tee -a /etc/fstab

Memory Management

# Swap-File optimieren
sudo swapoff -a
sudo dd if=/dev/zero of=/swapfile bs=1M count=2048
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

# GPU Memory reduzieren (für Headless)
echo "gpu_mem=16" | sudo tee -a /boot/config.txt

Backup-Strategie

Sichere regelmäßig deine Monitoring-Konfiguration und wichtige Daten:

# Wöchentliches Backup-Script
#!/bin/bash
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/home/pi/backups"

# Grafana Dashboard exportieren
docker exec grafana grafana-cli admin export-dashboard > "$BACKUP_DIR/dashboards_$DATE.json"

# InfluxDB Backup
docker exec influxdb influx backup /tmp/backup_$DATE
docker cp influxdb:/tmp/backup_$DATE "$BACKUP_DIR/"

# Konfigurationsdateien
tar -czf "$BACKUP_DIR/configs_$DATE.tar.gz" ./monitoring/

# Alte Backups löschen (älter als 30 Tage)
find "$BACKUP_DIR" -name "*.tar.gz" -mtime +30 -delete

🔧 Troubleshooting

Problem: Telegraf kann keine Daten senden

# Debug Steps:
docker-compose logs telegraf
docker exec telegraf telegraf --config /etc/telegraf/telegraf.conf --test

# Häufige Lösungen:
1. API Token prüfen
2. InfluxDB URL korrekt? (http://influxdb:8086)
3. Firewall-Regeln prüfen
4. Container-Netzwerk prüfen: docker network ls

Problem: Grafana zeigt keine Daten

# Debug Steps:
1. InfluxDB Data Explorer: Daten vorhanden?
2. Grafana Data Source: Connection Test OK?
3. Flux Query testen:
   from(bucket: "system_metrics") |> range(start: -1h) |> limit(n:10)

# Query Optimierung:
- Zeitbereich einschränken
- Aggregation verwenden (|> aggregateWindow(every: 1m, fn: mean))
- Nur benötigte Fields selektieren

Problem: Hoher Resource-Verbrauch

# Resource Limits setzen:
# In docker-compose.yml für jeden Service:
deploy:
  resources:
    limits:
      memory: 512M
      cpus: '0.5'
    reservations:
      memory: 256M
      cpus: '0.25'

# Monitoring-Intervalle erhöhen:
# telegraf.conf: interval = "30s" statt "10s"

🎉 Herzlichen Glückwunsch!

Du hast erfolgreich ein professionelles Monitoring-System für deinen Raspberry Pi eingerichtet. Jetzt kannst du die Performance überwachen und bei Problemen schnell reagieren.

Nächster Artikel: Grafana Dashboards Alle Monitoring Tutorials

📖 Vollständiges E-Book verfügbar

📋 Inhaltsverzeichnis