Monitoring für lokale KI-Systeme

Was dieser Artikel über Monitoring behandelt

• Warum Monitoring für KI-Systeme unverzichtbar ist.
• Welche Metriken für GPU, CPU, RAM und Dienste sinnvoll sind.
• Wie Prometheus, Grafana und Docker-Stats zusammenspielen.
• Wie man Alerts und Dashboards für Ollama und Agenten aufbaut.
• Typische Stolpersteile und Best Practices.

Einleitung: Monitoring für lokale KI-Systeme

Wer lokale KI-Systeme betreibt, muss wissen, was im Hintergrund passiert. Ein Modell, das plötzlich langsam antwortet, ein Container, der abstürzt, oder eine GPU, die überhitzt, sind Probleme, die man früh erkennen möchte. Monitoring sammelt Daten über Hardware, Dienste und Anfragen und zeigt sie in Dashboards oder Alerts.

KI-Systeme verhalten sich anders als klassische Webanwendungen. Sie haben Auslastungsspitzen, lange Antwortzeiten und großen Speicherbedarf. Ein Server, der bei Textanfragen 20 Prozent auslastet, kann bei Bildgenerierung plötzlich an seine Grenzen stoßen. Ohne Monitoring erkennt man solche Muster nicht.

Warum brauche ich Monitoring?

Monitoring ist mehr als eine nette Zusatzfunktion. Es ist die Basis für stabilen Betrieb. Ohne Daten über CPU, GPU, RAM, Netzwerk und Dienste bleibt man reaktiv. Erst wenn etwas sichtbar langsam oder ausgefallen ist, greift man ein. Mit Monitoring erkennt man Engpässe, bevor sie Nutzer beeinträchtigen.

Konkrete Vorteile:

• Frühwarnung: Alerts bei hoher Auslastung, fehlenden Diensten oder vollem Speicher.
• Kostenkontrolle: Stromverbrauch, GPU-Auslastung und Ressourcennutzung sichtbar machen.
• Fehleranalyse: Logs und Metriken zeigen, warum ein Dienst abgestürzt ist.
• Optimierung: Erkennen, welche Modelle oder Workloads Ressourcen fressen.
• Planung: Datengestützte Entscheidungen für Upgrades.

Monitoring kurz erklärt

Monitoring setzt sich aus mehreren Schichten zusammen:

• Metriken: Zahlenwerte über Zeit, zum Beispiel CPU-Auslastung in Prozent.
• Logs: Textausgaben von Anwendungen und Systemen.
• Traces: Verlaufsdaten einzelner Anfragen durch mehrere Dienste.
• Dashboards: Grafische Darstellung von Metriken.
• Alerts: Benachrichtigungen bei Grenzwertüberschreitungen.

Für ein Heimserver- oder Small-Office-Szenario reichen Metriken und Logs in der Regel. Traces sind bei verteilten Agentensystemen interessant.

Für wen ist Monitoring gedacht?

• Für Heimserver-Betreiber, die Stabilität wollen.
• Für Entwickler, die KI-Dienste dauerhaft betreiben.
• Für Teams, die Ausfälle und Engpässe vermeiden wollen.
• Für Nutzer, die GPU-Kosten und Stromverbrauch im Blick behalten.

Wichtige Begriffe rund um Monitoring

• Prometheus: Open-Source-System zum Sammeln und Speichern von Metriken.
• Grafana: Visualisierungs-Tool für Dashboards.
• Exporter: Kleine Helfer, die Metriken aus Diensten für Prometheus aufbereiten.
• Node Exporter: Sammelt Hardware- und Systemmetriken unter Linux.
• cAdvisor: Liefert Metriken für Docker-Container.
• Time Series: Zeitreihen von Messwerten.
• Alertmanager: Versendet Alerts aus Prometheus.

Wichtige Metriken für lokale KI

Hardware-Metriken

• CPU-Auslastung: Wie viel Prozent der Prozessor nutzt.
• CPU-Temperatur: Bei Dauerlast besonders wichtig.
• RAM-Auslastung: Gesamter und verfügbarer Arbeitsspeicher.
• GPU-Auslastung: Berechnungslast der Grafikkarte.
• VRAM-Auslastung: Belegter Videospeicher.
• GPU-Temperatur: Kritisch bei Training und großen Modellen.
• Festplattennutzung: Modell- und Datengröße wachsen schnell.
• Netzwerk-Traffic: Besonders bei Cloud-Anbindungen relevant.

Dienst-Metriken

• Ollama läuft: Ist der Prozess aktiv?
• API-Antwortzeit: Wie lange dauert eine Anfrage?
• Container-Status: Laufen Docker-Container?
• Fehlerrate: Wie viele Anfragen schlagen fehl?
• Modellauslastung: Welche Modelle sind geladen und wie lange laufen sie?
• Antwortlänge: Wie viele Tokens gibt das Modell aus?

Anwendungs-Metriken

• Anzahl Anfragen pro Stunde: Zeigt Nutzungsspitzen.
• Wartezeit in der Warteschlange: Wichtig bei Multi-User-Betrieb.
• Erfolgsrate: Wie oft wurde ein sinnvolles Ergebnis geliefert?
• Speicherverbrauch pro Workspace: Für AnythingLLM, Open WebUI und RAG-Systeme.

Praxisbeispiel: Prometheus und Grafana aufsetzen

1. Prometheus installieren

Unter Docker lässt sich Prometheus schnell starten:

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    restart: unless-stopped

volumes:
  prometheus_data:

Die prometheus.yml definiert die Ziele:

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

2. Node Exporter für Hardware-Metriken

  node-exporter:
    image: prom/node-exporter:latest
    container_name: node-exporter
    ports:
      - "9100:9100"
    restart: unless-stopped

3. cAdvisor für Docker-Container

  cadvisor:
    image: gcr.io/cadvisor/cadvisor:latest
    container_name: cadvisor
    privileged: true
    devices:
      - /dev/kmsg:/dev/kmsg
    volumes:
      - /:/rootfs:ro
      - /var/run:/var/run:ro
      - /sys:/sys:ro
      - /var/lib/docker:/var/lib/docker:ro
    ports:
      - "8080:8080"
    restart: unless-stopped

4. Grafana für Dashboards

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    restart: unless-stopped

volumes:
  grafana_data:

Nach dem Start rufst Du http://localhost:9090 für Prometheus und http://localhost:3000 für Grafana auf.

Monitoring für Ollama

Ollama bietet keine eingebaute Prometheus-Metriken. Du kannst aber folgende Werte überwachen:

• Prozessstatus: Läuft Ollama?
• API-Aufrufe: curl http://localhost:11434/api/tags zeigt geladene Modelle.
• Ressourcenverbrauch: cAdvisor zeigt CPU und RAM des Ollama-Containers.
• GPU-Metriken: NVIDIA DCGM oder nvidia-smi liefern VRAM und GPU-Last.

Für NVIDIA-GPUs empfiehlt sich der NVIDIA DCGM Exporter oder das Skripten von nvidia-smi in eine Datei, die Prometheus einliest.

Alerts sinnvoll einrichten

Alerts sollten nur bei echten Problemen schlagen. Zu viele Alarme führen dazu, dass man sie ignoriert. Beispiele für sinnvolle Schwellen:

• RAM über 90 Prozent: droht OOM-Kill.
• GPU-Temperatur über 85 Grad: droht thermisches Drosseln oder Schaden.
• Ollama nicht erreichbar: Dienst ausgefallen.
• Festplatte über 85 Prozent voll: droht Speicherengpass.
• API-Antwortzeit über 30 Sekunden: Modell oder Hardware überlastet.

Typische Stolpersteile beim Monitoring

• Zu viele Metriken: Sammle nicht alles, sondern das, was wirklich relevant ist.
• Keine Retention: Prometheus speichert standardmäßig nur 15 Tage. Längere Zeiträume konfigurieren.
• Fehlende Labels: Ohne Labels lassen sich Container oder Dienste nicht unterscheiden.
• Zu hohe Scrape-Intervalle: Zu häufiges Abfragen belastet das System.
• Alerts ohne Eskalation: Wer bekommt Benachrichtigungen und wie?
• Nur visuell: Dashboards allein helfen nicht bei nächtlichen Ausfällen.

Weiterführende Links und Infos

• BotServ.de Docker Grundlagen
• BotServ.de Proxmox Monitoring
• Prometheus
• Grafana
• NVIDIA DCGM

FAQ: Monitoring für lokale KI-Systeme

Brauche ich Monitoring für einen einzelnen Mini-PC? Für reine Tests nicht zwingend. Sobald der Rechner dauerhaft läuft oder mehrere Dienste hostet, lohnt es sich.

Was kostet Prometheus und Grafana? Beide sind Open Source und kostenlos. Es entstehen nur Kosten für Hardware, Strom und Speicher.

Kann ich auch Logs mit Grafana anzeigen? Ja, mit Loki. Damit lassen sich Logs zentral sammeln und durchsuchen.

Wie oft sollte Prometheus Daten abfragen? 15 bis 60 Sekunden sind üblich. Kürzer belastet das System, länger macht Spitzen schlechter erkennbar.

Ist Grafana notwendig, wenn ich Prometheus habe? Nein, aber Grafana macht die Daten deutlich besser lesbar und bietet Dashboards.

Kann ich Monitoring in Docker laufen lassen? Ja, Prometheus, Grafana, cAdvisor und Node Exporter sind allesamt als Container verfügbar.

Quellen und weiterführende Literatur

• Prometheus: https://prometheus.io/
• Grafana: https://grafana.com/
• cAdvisor: https://github.com/google/cadvisor
• Node Exporter: https://github.com/prometheus/node_exporter

Zusammenfassung: Monitoring für lokale KI-Systeme

Monitoring ist essenziell für stabile lokale KI-Systeme. Prometheus sammelt Metriken, Grafana visualisiert sie, Alerts benachrichtigen bei Problemen. Wichtig sind CPU, RAM, GPU, VRAM, Containerstatus und API-Antwortzeiten. Mit wenigen Containern entsteht ein solides Überwachungssystem. Wer frühzeitig Engpässe und Ausfälle erkennt, vermeidet Überraschungen und kann gezielt optimieren.