ML‑Dienste mit Prometheus und Grafana überwachen

03 September 2025
Zusammenfassung: Zusammenfassung: In diesem Leitfaden richten Sie Prometheus zur Metrikerfassung und Grafana zur Visualisierung ein. Sie erstellen Dashboards für Request-Rate, Latenz und xx‑Fehlerrate und definieren grundlegende Alerting‑Regeln.
ML‑Dienste mit Prometheus und Grafana überwachen

Einführung

Beobachtbarkeit ist für produktive ML‑Dienste essenziell. Die folgenden Schritte zeigen das Erfassen von Metriken mit Prometheus, die Visualisierung in Grafana und das Einrichten einfacher Alarmregeln.

Voraussetzungen

  • Linux‑Server oder Docker‑Umgebung  
  • Zugriff auf die Ports 9090 (Prometheus) und 3000 (Grafana)  
  • Eine laufende HTTP‑API (z. B. FastAPI) — Beispiele nutzen :8000  

    Hinweis: Befehle werden in bash‑Blöcken angegeben; ein Nicht‑Root‑Benutzer mit sudo wird vorausgesetzt.

Schritt 1 — Prometheus starten und Ziel definieren

Prometheus ist ein Server, der Zeitreihenmetriken in Intervallen abruft (scrape). Erstellen Sie zunächst eine Konfiguration, die Ihren Dienst als Target hinzufügt.

Konfiguration (prometheus.yml):

global:
  scrape_interval: 15s

scrape_configs:
  - job_name: "ml-service"
    metrics_path: /metrics
    static_configs:
      - targets: ["host.docker.internal:8000"]  # Unter Linux ggf. localhost:8000 verwenden

Prometheus starten:

docker run -d --name prom   -p 9090:9090   -v "$PWD/prometheus.yml:/etc/prometheus/prometheus.yml"   prom/prometheus

Prüfen:

curl -s localhost:9090/-/ready  # Erwartet 200 OK

Schritt 2 — Prometheus‑Exporter in Ihre App integrieren (FastAPI‑Beispiel)

Ihr Dienst sollte Prometheus‑Metriken unter /metrics bereitstellen. Das folgende Beispiel sammelt Anfragenanzahl und Latenz.

Installation:

python -m venv .venv && source .venv/bin/activate
pip install fastapi uvicorn prometheus-client

App (app.py):

from fastapi import FastAPI, Response, Request
from prometheus_client import Counter, Histogram, generate_latest, CONTENT_TYPE_LATEST
import time

app = FastAPI()

REQ_COUNT   = Counter("http_requests_total", "Gesamtanzahl HTTP‑Anfragen", ["path","method","status"])
REQ_LATENCY = Histogram("http_request_latency_seconds", "Anfrage‑Latenz (s)", ["path","method"])

@app.middleware("http")
async def metrics_middleware(request: Request, call_next):
    start = time.time()
    response = await call_next(request)
    latency = time.time() - start
    REQ_LATENCY.labels(request.url.path, request.method).observe(latency)
    REQ_COUNT.labels(request.url.path, request.method, str(response.status_code)).inc()
    return response

@app.get("/metrics")
def metrics():
    return Response(generate_latest(), media_type=CONTENT_TYPE_LATEST)

@app.get("/predict")
def predict():
    # ... Modellaufruf ...
    return {"ok": True}

Starten:

uvicorn app:app --host 0.0.0.0 --port 8000

Prüfen:

curl -s localhost:8000/metrics | head

Schritt 3 — Grafana installieren und Dashboards erstellen

Grafana visualisiert die Daten aus Prometheus. Beim Hinzufügen einer Data Source verwenden Sie die URL http://localhost:9090.

Grafana starten:

docker run -d --name grafana   -p 3000:3000   grafana/grafana-oss

Beispiel‑Panels (PromQL)

Request‑Rate:

sum(rate(http_requests_total[5m])) by (status)

Latenz P90:

histogram_quantile(0.90, sum(rate(http_request_latency_seconds_bucket[5m])) by (le))

5xx‑Fehlerrate:

sum(rate(http_requests_total{status=~"5.."}[5m])) 
/ sum(rate(http_requests_total[5m]))

Schritt 4 — Grundlagen von Alerting und SLOs (Recording‑ & Alerting‑Regeln)

Mit Recording Rules berechnen Sie häufig verwendete Ausdrücke vorab. Alerting Rules lösen Benachrichtigungen bei hoher Fehlerrate aus.

Recording‑Rule (Beispiel):

groups:
- name: mlops-recording
  rules:
  - record: job:http_request_duration_seconds:p90
    expr: histogram_quantile(0.90, sum(rate(http_request_latency_seconds_bucket[5m])) by (le))

Alert‑Rule (Beispiel):

groups:
- name: mlops-alerts
  rules:
  - alert: HighErrorRate
    expr: |
      (sum(rate(http_requests_total{status=~"5.."}[5m])) /
       sum(rate(http_requests_total[5m]))) > 0.05
    for: 5m
    labels:
      severity: critical
    annotations:
      summary: 5xx‑Fehlerrate über 5 %
      description: Die 5xx/s‑Rate der letzten 5 Minuten hat den Grenzwert überschritten.

Fehlerbehebung

  • Target DOWN: Netzwerk der Container und targets prüfen. Unter Linux ggf. localhost statt host.docker.internal verwenden.  
  • Leeres /metrics: Sind Counter/Histogramme registriert und läuft das Middleware?  
  • Leere Grafana‑Panels: Testen Sie denselben PromQL‑Ausdruck im Prometheus‑UI; wenn keine Serien zurückkommen, Scrape‑Einstellungen prüfen.

Fazit

Mit diesem Setup überwachen Sie Request‑Rate, Latenz und Fehlerrate Ihrer ML‑Services, erstellen Dashboards und erkennen Probleme mit einfachen Alarmregeln.

Nächste Schritte

  • Qualitätsmetriken des Modells (Accuracy/Recall) per Batch‑Jobs ergänzen  
  • Alertmanager für Slack/Teams‑Benachrichtigungen konfigurieren  
  • In Kubernetes Prometheus Operator + ServiceMonitor verwenden

(Admin‑Metadaten‑Vorschlag)

  • Slug: model-monitoring-izleme-loglama
  • Kategorie: MLOps & AI Ops / Model Monitoring
  • Keywords: mlops, model monitoring, prometheus, grafana, exporter, observability, alerting
  • Kurzfassung: „Metriken sammeln und Dashboards für Latenz, Request‑Rate und 5xx‑Fehlerrate mit Prometheus und Grafana für ML‑Services erstellen.“
Zurück zur Artikelseite