Python API Entwicklung: REST und GraphQL mit Django und FastAPI
APIs sind das Nervensystem moderner Software. Ob Sie ein Mobile App haben, ein Kundenportal bauen oder verschiedene interne Systeme verbinden – Sie brauchen irgendwann eine API.
Und Python ist eine der besten Sprachen, um APIs zu bauen. Mit Frameworks wie Django und FastAPI können Sie schnell, sicher und skalierbar arbeiten.
Aber was ist eine API genau? Und welche sollten Sie bauen – REST oder GraphQL? Und wann ist der richtige Zeitpunkt, eine Agentur zu engagieren?
Was ist eine API? (Für die nicht-technischen Entscheidungsträger)
Stellen Sie sich vor, Sie haben ein Restaurant:
- Ohne API: Kunden müssen ins Restaurant kommen und der Kellner bringt das Essen
- Mit API: Kunden können anrufen oder online bestellen, und das Essen wird gebracht
Eine API ist im Prinzip ein standardisierter Kommunikationskanal zwischen Systemen. Statt dass Ihre App direkt in die Datenbank schreibt (was unsicher und langsam ist), geht alles über eine API.
Praktisches Unternehmensbeispiel
Ein E-Commerce-Unternehmen hat eine Website und später eine Mobile App. Beide Apps brauchen Zugriff auf Produkte, Bestellungen, Benutzer-Daten. Die API ist das System, das diese Daten sicher und konsistent bereitstellt.
Ohne API: Das Unternehmen müsste denselben Code zweimal schreiben (einmal für Website, einmal für App).
Mit API: Ein Backend (die API) versorgt beide Apps.
REST vs. GraphQL: Der Vergleich
REST (Representational State Transfer)
Was ist REST?REST ist ein Standard, wie APIs strukturiert sein sollten. Die Idee: Daten werden als "Ressourcen" modelliert, und Sie verwenden HTTP-Verben um damit zu interagieren.
GET /api/users/123 → Benutzer mit ID 123 abrufen
POST /api/users → Neuen Benutzer erstellen
PUT /api/users/123 → Benutzer 123 aktualisieren
DELETE /api/users/123 → Benutzer 123 löschen- Einfach zu verstehen: REST ist Standard, jeder Entwickler kennt es
- Browser-freundlich: Sie können REST-Endpoints einfach im Browser testen
- Caching: HTTP-Caching funktioniert gut mit REST
- Debugging: Einfach, Requests zu loggen und zu debuggen
- Over-fetching: Wenn Sie nur ein Feld brauchen, bekommen Sie vielleicht 20 Felder
- Under-fetching: Sie brauchen Daten von 3 verschiedenen Ressourcen? Das sind 3 API-Calls
- Versioning: API-Änderungen können kompliziert werden (v1, v2, v3...)
- Standard CRUD-Operationen (Create, Read, Update, Delete)
- Mobile Apps mit begrenzter Bandbreite (Einfachheit > Effizienz)
- Public APIs mit vielen verschiedenen Client-Typen
GraphQL
Was ist GraphQL?GraphQL ist ein Query-Language für APIs. Der Client sagt genau, welche Daten er braucht – und die API gibt genau das zurück.
query {
user(id: 123) {
name
email
orders { id, total }
}
}Die API antwortet genau mit diesen Daten – nicht mehr, nicht weniger.
Vorteile:- Effiziente Datenübertragung: Nur die Daten, die Sie brauchen
- Weniger API-Calls: Komplexe Abfragen in einem Call
- Starke Typisierung: Das Schema ist selbstdokumentierend
- Einfache Versionierung: Keine Versions-URLs nötig
- Steeper Learning Curve: Entwickler müssen GraphQL verstehen
- Komplexere Implementierung: Mehr zu denken bei der API-Architektur
- Caching ist komplizierter: HTTP-Caching funktioniert nicht so gut mit GraphQL
- Abfrage-Komplexität: Können Clients überly komplexe Queries schreiben, die den Server überlasten?
- Mobile Apps (Bandbreite sparen)
- Complex Data Relationships (viele verschiedene Datentypen)
- Internal APIs und Microservices
- Rapid Frontend-Entwicklung (Mobile-Teams können schnell Daten-Anforderungen ändern)
REST vs. GraphQL: Die Entscheidungsmatrix
| REST | GraphQL | |
|---|---|---|
| Einfachheit | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| Performance | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Debugging | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Für große Mobile Apps | ⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Für Public APIs | ⭐⭐⭐⭐⭐ | ⭐⭐⭐ |
| Team-Ramp-up | Schnell | Langsam |
Django REST Framework: Der REST-Standard
Was ist Django?
Django ist das Schwergewicht unter Python Web Frameworks. Es kommt mit vielem out-of-the-box: Datenbank-Abstraktionsebene (ORM), Admin-Panel, Authentication, etc.
Django REST Framework (DRF)
DRF baut auf Django auf und macht es super einfach, REST APIs zu bauen.
Ein einfaches Beispiel:from rest_framework import viewsets
from .models import User
from .serializers import UserSerializer
class UserViewSet(viewsets.ModelViewSet):
queryset = User.objects.all()
serializer_class = UserSerializerDas ist im Prinzip schon alles. DRF generiert automatisch:
- GET /api/users/ → alle Benutzer auflisten
- POST /api/users/ → neuen Benutzer erstellen
- GET /api/users/123/ → Benutzer 123 abrufen
- PUT /api/users/123/ → Benutzer 123 aktualisieren
- DELETE /api/users/123/ → Benutzer 123 löschen
- Schnelle Entwicklung: Wenig Code für viel Funktionalität
- Built-in Features: Pagination, Filtering, Authentication, Throttling
- Erweiterbar: Alles ist customizable
- Große Community: Millionen von Tutorials
- Authentication: Token, JWT, OAuth
- Permissions: View-Level, Object-Level
- Throttling: Rate-Limiting pro Client
- Caching: Kostenlose Performance-Boost
FastAPI: Der moderne REST Alternative
Was ist FastAPI?
FastAPI ist ein modernes, schnelles Web Framework für APIs. Es wurde gebaut mit Fokus auf:
- Performance: Konkurrierend mit Go und Node.js
- Developer Experience: Automatische Dokumentation, Type Hints
- Async-First: Moderne Async/Await für IO-Operationen
Ein einfaches Beispiel
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class User(BaseModel):
id: int
name: str
email: str
@app.get("/users/{user_id}")
async def get_user(user_id: int):
return {"id": user_id, "name": "John", "email": "john@example.com"}
@app.post("/users")
async def create_user(user: User):
return {"id": 1, **user.dict()}- Automatische Dokumentation: Besuchen Sie `/docs` und sehen Sie eine interaktive Dokumentation
- Type-Safety: Inputs werden automatisch validiert
- Async Everywhere: Besser für high-concurrency Szenarien
- Modern Stack: OpenAPI-compatible, JSON Schema
| Django REST | FastAPI | |
|---|---|---|
| Reife | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Performance | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
| Ecosystem | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Learning Curve | Mittel | Einfach |
| Best für großes Projekt | ⭐⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Best für Quick API | ⭐⭐⭐⭐ | ⭐⭐⭐⭐⭐ |
GraphQL in Python: Strawberry und Graphene
Graphene (Der Klassiker)
Graphene ist das etablierte GraphQL-Framework für Python.
import graphene
class Query(graphene.ObjectType):
hello = graphene.String(name=graphene.String(default_value="World"))
def resolve_hello(self, info, name):
return f"Hello {name}"
schema = graphene.Schema(query=Query)Strawberry (Der moderne Alternative)
Strawberry ist neuere, einfacher zu benutzen, und optimiert für Type-Hints.
import strawberry
@strawberry.type
class User:
id: int
name: str
email: str
@strawberry.type
class Query:
@strawberry.field
def user(self, id: int) -> User:
return User(id=id, name="John", email="john@example.com")
schema = strawberry.Schema(query=Query)Sicherheit: Authentication und Authorization
Egal ob REST oder GraphQL – Sie müssen Ihre APIs sichern.
Authentication ("Wer bist du?")
Token-basiert (JWT):from rest_framework_simplejwt.tokens import RefreshToken
# User meldet sich an
user = authenticate(username=username, password=password)
refresh = RefreshToken.for_user(user)
# Token wird zurückgegeben
{
'refresh': str(refresh),
'access': str(refresh.access_token),
}
# Client benutzt Access Token für weitere Requests
headers = {'Authorization': f'Bearer {access_token}'}Authorization ("Was darfst du tun?")
Django REST Framework hat built-in Permission-System:
from rest_framework.permissions import IsAuthenticated
class UserViewSet(viewsets.ModelViewSet):
permission_classes = [IsAuthenticated] # Nur für eingeloggte Nutzer
queryset = User.objects.all()Real-World Integration Scenarios
Scenario 1: ERP-Integration
Ein Unternehmen hat ein bestehendes ERP-System (z.B. SAP) und möchte ein modernes Web-Portal bauen. Die Lösung:
- Eine Python REST API als "Middleware"
- Diese API spricht mit dem ERP-System (oft über Webhooks oder proprietäre APIs)
- Das Web-Portal spricht mit der Python API
Vorteil: Das Web-Frontend ist entkoppelt vom komplexen ERP-System. Updates sind leichter.
Scenario 2: CRM-Integration
Ein Sales-Team nutzt ein externes CRM (HubSpot, Salesforce). Sie wollen Custom-Features bauen:
- FastAPI baut Endpoints, die mit dem CRM kommunizieren
- Custom Business-Logic (z.B. automatische Scorecard-Updates)
- Mobile App und Web-Portal nutzen dieselbe API
Scenario 3: Mobile App Backend
Eine neue Mobile App braucht ein Backend:
- REST API oder GraphQL - je nach App-Komplexität
- Authentication mit JWT
- Pagination und Filtering für Performance
- Caching für häufig abgerufene Daten
Wann Sie eine Agentur engagieren sollten
Bauen Sie eine API selbst, wenn:- Ihr Team Python-Erfahrung hat
- Die API klein und einfach ist (unter 20 Endpoints)
- Sie Zeit haben
- Ihre API komplex ist (viele Relationen, komplexe Geschäftslogik)
- Sie schnell live gehen müssen
- Ihr Team keine Python/API-Erfahrung hat
- Sie Sicherheit und Skalierbarkeit garantieren möchten
- Die API mit multiple Systeme integriert werden soll (ERP, CRM, etc.)
Eine erfahrene Python-Agentur wird:
- Die richtige Architektur wählen (REST vs. GraphQL, Django vs. FastAPI)
- Best Practices implementieren (Authentication, Caching, Error Handling)
- Skalierbare Systeme bauen
- Security-Tests durchführen
- Dokumentation und Handover sicherstellen
Python-Projekt geplant?
Als spezialisierte Python- und Django-Agentur in Berlin unterstützen wir Sie von der Idee bis zum Go-Live. Ob Web-App, API oder KI-Integration — sprechen Sie uns an.
Kostenlose Erstberatung →Fazit: APIs sind kritisch
APIs sind heute nicht mehr optional – sie sind das Fundament moderner Software. Mit Python und Frameworks wie Django REST oder FastAPI können Sie schnell, sicher und skalierbar bauen.
Die Wahl zwischen REST und GraphQL hängt von Ihren spezifischen Anforderungen ab. Django REST ist der sichere, bewährte Weg. FastAPI ist schneller und moderner. GraphQL ist zukunftsgerichtet für komplexe Daten.
Das Wichtigste: Wählen Sie einen Partner, der diese Entscheidungen richtig treffen kann und APIs gut bauen kann.