Backend mit Python & FastAPI — moderne, skalierbare APIs
FastAPI ist das Python-Referenzframework für asynchrone REST-APIs. Es verbindet native Python-Type-Hints mit automatischer Pydantic-Validierung, selbst erzeugter OpenAPI-Dokumentation und einer ASGI-Performance auf dem Niveau von Node.js — ohne die Lesbarkeit des Codes zu opfern.
FastAPI — das schnellste Python-Framework
FastAPI läuft auf Uvicorn (ASGI-Server), in der Produktion mit Gunicorn für den Multi-Process-Betrieb. Ein einfacher Endpunkt, der aus dem Redis-Cache liest, antwortet auf Standardhardware in unter 5 ms. Die native Dependency Injection erlaubt es, jede Schicht isoliert zu testen, ohne aufwendige Mocks: Authentifizierung, Datenbank-Session, Rate Limiting — jede davon ist eine injizierbare Abhängigkeit.
Die OpenAPI-3.1-Dokumentation entsteht automatisch aus den Type-Hints — Swagger UI und ReDoc stehen in der Entwicklung unter `/docs` und `/redoc` bereit. Das Pydantic-v2-Schema (Validator in Rust) prüft Requests und Responses 10- bis 20-mal schneller als Pydantic v1. Jedes ungültige Feld führt zu einem 422 mit klaren, lokalisierten Fehlermeldungen.
- Natives async/await — nicht blockierende I/O bei allen Datenbank- und HTTP-Operationen
- BackgroundTasks für Arbeiten nach der Response (E-Mail, Webhook, Log)
- Native WebSocket-Unterstützung für Echtzeitfunktionen (Chat, Benachrichtigungen)
- Rate Limiting mit slowapi (auf Basis von limits) — pro IP und pro Nutzer
- Middleware für CORS, Komprimierung (gzip/brotli), Request-ID und Timing
PostgreSQL, SQLAlchemy und Alembic
Für alle Datenbankoperationen nutzen wir SQLAlchemy 2.0 async (asyncpg-Treiber). Die Modelle werden mit Mapped Types definiert — typsicher, ohne Strings. Komplexe Abfragen schreiben wir in SQLAlchemy Core (zur Übersetzungszeit geprüft) oder als reines SQL über `text()` mit gebundenen Parametern — niemals per String-Interpolation, womit SQL-Injection vollständig ausgeschlossen ist.
Alembic-Migrationen werden aus den Modelländerungen automatisch erzeugt und vor der Anwendung manuell geprüft. Jede Migration hat ein getestetes `upgrade()` und `downgrade()`. In der Produktion laufen die Migrationen in der CI vor dem Deployment — die Datenbank ist damit stets mit dem Code synchron. Connection Pooling über asyncpg, mit je Service konfigurierbarer Poolgröße.
- Row-Level-Locking mit `SELECT ... FOR UPDATE` für kritische parallele Operationen
- Volltextsuche mit pg_trgm und tsvector — für einfache Fälle ohne Elasticsearch
- JSONB für halbstrukturierte Daten mit GIN-Index
- Partitionierte Tabellen für Millionen von Zeilen (Logs, Events)
Redis-Caching und horizontale Skalierung
Redis 7 dient als Anwendungscache (TTL je Endpunkt), Session Store (JWT-Refresh-Tokens mit selektivem Widerruf), Pub/Sub für Echtzeit-Events und Queue für Hintergrundjobs (Celery oder ARQ). Die Caching-Strategie ist Cache-aside mit expliziter Invalidierung — kein blindes TTL, das veraltete Daten ausliefern könnte.
- JWT-Authentifizierung mit Access Token (15 Min.) + Refresh Token in Redis (7 Tage)
- Celery mit Redis als Broker für asynchrone Aufgaben (PDF-Erzeugung, E-Mail, Importe)
- Health-Check-Endpunkt `/health` mit Status von Datenbank, Redis und Deployment-Version
- Strukturiertes JSON-Logging (structlog) — kompatibel mit Loki, Datadog und ELK
Vorteile und Grenzen
Vorteile
- ASGI-Performance auf dem Niveau von Node.js und Go bei I/O-Last.
- OpenAPI-Dokumentation, automatisch aus den Type-Hints erzeugt.
- Schnelle Pydantic-v2-Validierung mit klaren 422-Fehlern.
- Lesbarer Code; Python ist den meisten Teams vertraut.
Grenzen
- Python bleibt bei CPU-intensiven Aufgaben langsamer als Go oder Rust.
- async/await erfordert Disziplin — ein blockierender Aufruf legt die gesamte Event Loop lahm.
- Jüngeres Ökosystem als Django, wenn es um Batteries-included-Funktionen geht.
- Bringt weder ORM noch Admin-Oberfläche mit — beides wählt man separat.
Kurzes Fazit
Wählen Sie FastAPI für asynchrone REST-APIs, Microservices und Backends für SPA- oder Mobile-Anwendungen. Für extrem CPU-lastige Anwendungen bzw. Monolithen mit fertigem Admin-Bereich können Go beziehungsweise Django besser passen.
Technische Daten
| Fähigkeit | Grenze / Schwelle | Typischer Einsatz | |
|---|---|---|---|
| Nebenläufigkeit | async/await, nicht blockierende I/O | CPU-lastige Arbeit braucht separate Worker | APIs mit vielen Datenbank- und HTTP-Aufrufen |
| Latenz | < 5 ms je Endpunkt mit Redis-Cache | Steigt mit der Serialisierung großer Payloads | SaaS-, Mobile- und Echtzeit-Backends |
| Validierung & Doku | Pydantic v2 + automatisches OpenAPI 3.1 | Komplexe Schemata verlängern den Start | Öffentliche APIs mit Swagger/ReDoc |
| Typische Kosten | Open Source, läuft auf 1 vCPU | Horizontale Skalierung erfordert mehrere Prozesse | Vom MVP bis zur Produktion |
FastAPI im Vergleich zu Alternativen
| Kriterium | FastAPI | Django / Express |
|---|---|---|
| Async-Performance | Ausgezeichnet (nativ ASGI) | Django teilweise, Express gut |
| Automatische OpenAPI-Doku | Ja, aus den Type-Hints | Erfordert zusätzliche Pakete |
| Admin / ORM inklusive | Nein (wird separat gewählt) | Django: ja; Express: nein |
Häufige Fragen
Ist FastAPI schneller als Django?
Bei I/O ja. FastAPI läuft asynchron auf ASGI und verarbeitet daher deutlich mehr parallele Anfragen mit Datenbank- oder HTTP-Aufrufen als das klassische synchrone Django. Django bringt dafür mehr Funktionen von Haus aus mit.
Wofür eignet sich FastAPI nicht?
Für stark CPU-lastige Aufgaben (Bildverarbeitung, aufwendige Berechnungen) ist Python langsamer als Go oder Rust; solche Arbeit verlagert man auf separate Worker. Außerdem bringt FastAPI keine fertige Admin-Oberfläche wie Django mit.
Braucht FastAPI ein ORM?
Nicht zwingend. Wir setzen SQLAlchemy 2.0 async mit Alembic für die Migrationen ein, aber reines SQL ist ebenso möglich. Ein ORM ist nicht enthalten, Sie wählen es also passend zum Projekt.
Wie skaliere ich ein FastAPI-Backend?
Horizontal: Man betreibt mehrere Uvicorn-Prozesse unter Gunicorn hinter einem Load Balancer, mit Redis-Cache und schweren Aufgaben ausgelagert an Celery. Das zustandslose Design erlaubt es, bei Bedarf einfach Instanzen hinzuzufügen.