FastAPI-Monitoring einrichten: Response‑Zeiten & DB‑Queries in 15 Minuten tracken

Einleitung

FastAPI ist für seine Geschwindigkeit und Einfachheit bekannt, doch ohne gezieltes Monitoring können kritische Latenz‑Spikes und ineffiziente Datenbank‑Queries unbemerkt bleiben. In diesem Schritt‑für‑Schritt‑Projekt zeigen wir, wie Sie FastAPI‑Monitoring einrichten, um innerhalb von 15 Minuten sowohl Response‑Zeiten als auch DB‑Queries zu tracken. Das Ergebnis: messbare Verbesserungen, schnelleres MTTR und klare SLA‑Übersichten – alles dank Lescopr.

1. Projektinitialisierung – Zieldefinition und Stack‑Auswahl

1.1 Anforderungen festlegen

  • Kernziel: Response‑Zeit pro Endpoint und Dauer jeder Datenbank‑Query sichtbar machen.
  • Messgrößen: 95‑tes Perzentil der Antwortzeit, durchschnittliche Query‑Laufzeit, Fehlerrate.
  • Compliance: DSGVO‑konforme Telemetriedaten, keine personenbezogenen Daten.

1.2 Auswahl der Observability‑Komponenten

Für ein robustes Monitoring setzen wir auf OpenTelemetry als Instrumentierungs‑Standard und Lescopr APM als Collector und Dashboard. OpenTelemetry bietet native Unterstützung für FastAPI und SQLAlchemy, während Lescoppr die Daten in Echtzeit visualisiert und Alerts nach SLA‑Grenzen auslöst.

2. FastAPI‑Applikation aufsetzen und instrumentieren

2.1 Grundgerüst erstellen

python -m venv venv
source venv/bin/activate
pip install fastapi uvicorn sqlalchemy

Erstellen Sie main.py mit einem einfachen Endpoint:

from fastapi import FastAPI
app = FastAPI()

@app.get('/')
async def root():
    return {'message': 'Hello World'}

2.2 OpenTelemetry‑SDK integrieren

pip install opentelemetry-sdk opentelemetry-instrumentation-fastapi

from opentelemetry import trace
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor

trace.set_tracer_provider(trace.TracerProvider())
FastAPIInstrumentor().instrument_app(app)

2.3 Middleware für Response‑Zeit messen

OpenTelemetry erzeugt bereits einen Span für jeden Request. Ergänzend können Sie ein Middleware‑Snippet hinzufügen, um das 95‑te Perzentil zu berechnen:

import time
from starlette.middleware.base import BaseHTTPMiddleware

class ResponseTimeMiddleware(BaseHTTPMiddleware):
    async def dispatch(self, request, call_next):
        start = time.time()
        response = await call_next(request)
        duration = (time.time() - start) * 1000  # ms
        # Hier könnte man das Ergebnis an Lescopr senden
        return response

app.add_middleware(ResponseTimeMiddleware)

2.4 Paket‑Übersicht (Bullet‑List)

  • fastapi – Web‑Framework
  • uvicorn – ASGI‑Server
  • sqlalchemy – ORM für DB‑Zugriff
  • opentelemetry‑sdk – Kern‑Telemetry
  • opentelemetry‑instrumentation‑fastapi – FastAPI‑Integration
  • opentelemetry‑instrumentation‑sqlalchemy – DB‑Tracing
  • lescopr‑collector – Exporter für Lescopr

3. Datenbank‑Queries sichtbar machen

3.1 SQLAlchemy‑Engine instrumentieren

pip install opentelemetry-instrumentation-sqlalchemy

from opentelemetry.instrumentation.sqlalchemy import SQLAlchemyInstrumentor
SQLAlchemyInstrumentor().instrument()

Damit wird jeder engine.execute‑Aufruf als Span erfasst.

3.2 Custom‑Span für Query‑Timing

Falls Sie komplexe Raw‑SQL‑Statements nutzen, können Sie einen eigenen Span definieren:

from opentelemetry import trace
tracer = trace.get_tracer(__name__)

def run_query(sql):
    with tracer.start_as_current_span('custom_sql_query') as span:
        span.set_attribute('db.statement', sql)
        result = engine.execute(sql)
        return result

3.3 Verknüpfung mit Lescopr‑Collector

Lescopr verwendet den OTLP‑Exporter. Konfigurieren Sie ihn einmalig:

from opentelemetry.exporter.otlp.proto.grpc.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk.trace.export import BatchSpanProcessor

otlp_exporter = OTLPSpanExporter(endpoint='https://otel.lescopr.com:4317')
trace.get_tracer_provider().add_span_processor(BatchSpanProcessor(otlp_exporter))

Alle erzeugten Spans – sowohl für HTTP‑Requests als auch für DB‑Queries – fließen nun in das Lescopr‑Dashboard.

4. Daten an Lescopr senden und Dashboards konfigurieren

4.1 Exporter einrichten (OTLP)

Der obige Code richtet den Exporter bereits ein. Achten Sie darauf, dass Ihr Service‑Account‑Token in der Umgebungsvariable LESCOPR_TOKEN hinterlegt ist, um DSGVO‑konforme Übertragung zu gewährleisten.

4.2 Dashboard für Response‑Zeit & DB‑Queries

Im Lescopr‑Portal erstellen Sie ein neues Dashboard:

  1. Widget „Durchschnittliche Response‑Zeit“ – gruppiert nach Endpoint.
  2. Widget „Top‑10 langsame Queries“ – sortiert nach Gesamtdauer.
  3. SLA‑Karte – definiert Grenzwerte (z. B. 95‑tes Perzentil < 200 ms).

4.3 Alerts und SLA‑Grenzen definieren

Setzen Sie einen Alert, wenn das 95‑te Perzentil einer Endpoint‑Route 250 ms überschreitet oder wenn die durchschnittliche Query‑Laufzeit > 120 ms liegt. Lescopr kann dann per Slack, E‑Mail oder Webhook benachrichtigen – ideal für SRE‑Teams.

5. Validierung, Performance‑Check und Rollout

5.1 Load‑Test mit Locust

pip install locust

Erstellen Sie locustfile.py und starten Sie einen 5‑Minuten‑Test, um realistische Traffic‑Muster zu simulieren. Beobachten Sie das Lescopr‑Dashboard, um Engpässe zu identifizieren.

5.2 MTTR messen

Durch das sofortige Sichtbarmachen von Spike‑Events können Sie die Mean Time to Recovery (MTTR) präzise erfassen. Ziel: MTTR < 5 Minuten für kritische Endpoints.

5.3 Deployment‑Strategie

  • Staging: Deploy mit Feature‑Flag, das das Tracing aktiviert.
  • Production: Nach erfolgreichem Staging‑Test das Flag permanent setzen.
  • Rollback: Bei unerwarteten Overhead‑Spitzen einfach das Tracing deaktivieren – Lescopr speichert bereits gesammelte Daten.

Fazit

Mit nur wenigen Zeilen Code und dem OpenTelemetry‑Stack haben Sie FastAPI‑Monitoring einrichten können. In weniger als 15 Minuten erhalten Sie vollständige Transparenz über Response‑Zeiten und Datenbank‑Queries, können SLA‑Grenzen überwachen und reagieren schneller auf Performance‑Probleme. Die Kombination aus OpenTelemetry und Lescopr liefert ein skalierbares, DSGVO‑konformes Observability‑Framework für moderne Backend‑Teams.

Für mehr Details: Die Lescopr-Dokumentation beschreibt die Einrichtung Schritt für Schritt.

Feature‑Image‑Alt‑Text: "FastAPI-Monitoring einrichten – Dashboard für Response‑Zeiten und DB‑Queries"