Bare-Metal Performance Diagnostics: Prometheus & Grafana Dashboard für Raspberry Pi

Architektur-Überblick: Schwachstellen von Einplatinencomputern

Einplatinencomputer mit ARM-Architektur wie der Raspberry Pi 4 und 5 operieren unter engen thermischen und I/O-spezifischen Grenzen. Dauerhafte Container-Workloads, häufige Schreibzyklen von Datenbanken und hoher Netzwerkdurchsatz führen regelmäßig zu unbemerkter Hardware-Degradation. Hohe SoC-Temperaturen aktivieren das dynamische Thermal-Throttling durch die Broadcom-Firmware, was die ARM-Taktfrequenz senkt, ohne dass explizite Fehlermeldungen in den Protokollen von Benutzeranwendungen erscheinen. Ebenso führen kontinuierliche zufällige Schreiboperationen auf MicroSD-Karten oder über USB angebundenen SSDs zur Erschöpfung von Flash-Blöcken, I/O-Engpässen und letztendlich zu korrupten Dateisystemen.

Die Implementierung einer Bare-Metal-Performance-Diagnose-Pipeline mit Prometheus und Grafana verwandelt intransparente Hardware-Zustände in präzise Zeitreihenmetriken. Durch die Kombination des standardmäßigen node_exporter-Daemons mit einem spezialisierten Textfile-Collector-Skript lassen sich kritische Raspberry-Pi-Indikatoren – darunter SoC-Kerntemperaturen, Unterspannungs-Flags, Taktfrequenzen, RAM-Sättigung und Speicher-I/O-Wartezeiten – alle 15 Sekunden abfragen (die per vcgencmd ermittelten Werte aktualisiert das eingeplante Collector-Skript einmal pro Minute), auf Schwellenwertverletzungen prüfen und in Echtzeit-Dashboards visualisieren.

Schritt-für-Schritt-Implementierungsanleitung

Schritt 1: Deployment des Node Exporters und des Textfile-Collectors

Zur Erfassung der standardmäßigen Linux-Kernel-Telemetrie sowie proprietärer Broadcom-Hardwarestatistiken wird node_exporter installiert und ein dediziertes Verzeichnis für eigene Metrik-Dateien eingerichtet:

apt update && apt install -y prometheus-node-exporter
mkdir -p /var/lib/node_exporter/textfile_collector
chmod 755 /var/lib/node_exporter/textfile_collector

Erstellung eines Shell-Skripts unter /opt/scripts/rpi-hardware-metrics.sh, das SoC-Temperatur, Kernspannung und Hardware-Throttling-Flags mittels vcgencmd extrahiert:

#!/usr/bin/env bash
# /opt/scripts/rpi-hardware-metrics.sh
# Extrahiert Bare-Metal-SoC-Metriken für den Prometheus-Textfile-Collector

TEXTFILE_DIR="/var/lib/node_exporter/textfile_collector"
TMP_FILE="$TEXTFILE_DIR/rpi_metrics.prom.$$"
FINAL_FILE="$TEXTFILE_DIR/rpi_metrics.prom"

# 1. CPU-Kerntemperatur extrahieren (Grad Celsius)
TEMP_C=$(vcgencmd measure_temp | grep -oE '[0-9]+([.][0-9]+)?')
echo "# HELP rpi_soc_temperature_celsius Broadcom SoC Core Temperature" > "$TMP_FILE"
echo "# TYPE rpi_soc_temperature_celsius gauge" >> "$TMP_FILE"
echo "rpi_soc_temperature_celsius $TEMP_C" >> "$TMP_FILE"

# 2. SoC-Kernspannung extrahieren (Volt)
VOLT_V=$(vcgencmd measure_volts core | grep -oE '[0-9]+([.][0-9]+)?')
echo "# HELP rpi_soc_core_voltage_volts Broadcom SoC Core Voltage" >> "$TMP_FILE"
echo "# TYPE rpi_soc_core_voltage_volts gauge" >> "$TMP_FILE"
echo "rpi_soc_core_voltage_volts $VOLT_V" >> "$TMP_FILE"

# 3. Throttling-Hexcode als Integer-Bitmaske extrahieren
THROTTLE_HEX=$(vcgencmd get_throttled | cut -d'=' -f2)
THROTTLE_DEC=$((THROTTLE_HEX))
echo "# HELP rpi_soc_throttled_bitmask Bitmask representing under-voltage or thermal throttling flags" >> "$TMP_FILE"
echo "# TYPE rpi_soc_throttled_bitmask gauge" >> "$TMP_FILE"
echo "rpi_soc_throttled_bitmask $THROTTLE_DEC" >> "$TMP_FILE"

mv "$TMP_FILE" "$FINAL_FILE"

Skript ausführbar machen und die Ausführung minütlich über crontab einplanen:

chmod +x /opt/scripts/rpi-hardware-metrics.sh
(crontab -l 2>/dev/null; echo "* * * * * /bin/bash /opt/scripts/rpi-hardware-metrics.sh >/dev/null 2>&1") | crontab -

Schritt 2: Neukonfiguration des systemd-Dienstes des Node Exporters

Anpassung der systemd-Konfiguration des node_exporter, damit Metriken aus dem benutzerdefinierten Textfile-Verzeichnis eingelesen werden:

# /etc/default/prometheus-node-exporter
ARGS="--collector.textfile.directory=/var/lib/node_exporter/textfile_collector --collector.filesystem.mount-points-exclude='^/(dev|proc|sys|run)($|/)'"

Neustart des Dienstes zur Übernahme der Flags: systemctl restart prometheus-node-exporter.

Schritt 3: Konfiguration des Prometheus-Scrapers

Bereitstellung von Prometheus via Docker Compose mit network_mode: host und Konfiguration eines 15-Sekunden-Scrape-Intervalls auf das lokale Node-Exporter-Ziel:

# /opt/containers/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'raspberry_pi_baremetal'
    static_configs:
      - targets: ['127.0.0.1:9100']
        labels:
          instance: 'rpi5-homelab'

Schritt 4: Grafana-Deployment und Import von Bare-Metal-Panels

Start von Grafana via Docker Compose, ebenfalls mit network_mode: host, Einbindung der Prometheus-Datenbank (http://127.0.0.1:9090) als Standard-Datenquelle und Erstellung von Dashboard-Panels auf Basis folgender PromQL-Abfragen:

• SoC-Kerntemperatur-Panel: rpi_soc_temperature_celsius (Alarm-Schwellenwert konfiguriert bei > 75 °C).
• Unterspannungs- & Throttling-Alarm: rpi_soc_throttled_bitmask > 0 (Signalisiert unzureichende Netzteile oder Überhitzung, aktuell oder seit dem letzten Start; bleibt bis zum Neustart aktiv).
• Speicher-I/O-Auslastung: rate(node_disk_io_time_seconds_total[1m]) * 100 (Erkennt Flash-Controller-Engpässe und abgenutzte Speicherblöcke).
• Verfügbarkeitsrate des Arbeitsspeichers: (node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes) * 100.

Schritt 5: Qualitätssicherung und Stress-Tests

Zur Verifikation, dass die Telemetrie-Pipeline Hardware-Auslastungen korrekt protokolliert, müssen Lasttests durchgeführt werden:

1. Validierung der I/O-Last: Ausführung eines intensiven Schreibtests mit fio (z. B. fio --name=test --ioengine=libaio --rw=randwrite --bs=4k --size=1G) und Kontrolle, ob das Grafana-I/O-Wait-Panel Echtzeit-Latenzspitzen anzeigt.
2. Simulation von Thermal-Throttling: Auslastung aller ARM-CPU-Kerne über stress-ng --cpu 4 --timeout 120s bei gleichzeitiger Überwachung von rpi_soc_temperature_celsius in Prometheus, um die präzise Temperaturmessung bis zum Einsetzen der Kühllüfter zu bestätigen.
3. Audit des Textfile-Parsings: Ausführung von curl -s http://127.0.0.1:9100/metrics | grep rpi_ im Terminal zur Verifikation, dass eigene Spannungs- und Throttling-Metriken fehlerfrei und ohne Syntax-Probleme bereitgestellt werden.

Zusammenfassung und resultierender Mehrwert

Was sich damit erreichen lässt: Der Aufbau einer autonomen Bare-Metal-Hardware-Diagnose-Pipeline auf dem Raspberry Pi mittels Prometheus-Scraper, eigenen SoC-Textfile-Collectors und Grafana-Dashboards.

Resultierender Mehrwert:

• Früherkennung von Speicherausfällen: Die kontinuierliche Überwachung von I/O-Wartezeiten und Flash-Verschleiß ermöglicht den präventiven Austausch abgenutzter SD-Karten oder SSDs vor einem Dateisystemschaden.
• Vermeidung von Thermal-Throttling: Die Echtzeit-Sichtbarkeit von SoC-Temperaturen und Throttling-Bitmasken garantiert, dass containerisierte Dienste dauerhaft mit maximaler Taktfrequenz operieren.
• Qualitätskontrolle der Stromversorgung: Die sofortige Protokollierung von Unterspannungs-Flags (Bit 0, bitmask 0x1) identifiziert defekte USB-C-Netzteile oder übermäßigen Stromverbrauch angeschlossener Peripheriegeräte vor Hardware-Abstürzen.