FastAPI Grundlagen

6 Kernkonzepte

Die wichtigsten FastAPI-Konzepte für moderne Python-APIs: Routen · Pydantic-Modelle · Dependency Injection · OpenAPI · async/await · Responses FastAPI ist ein modernes, schnelles Webframework für APIs mit Python 3.8+. Es basiert auf Pydantic und bietet automatische OpenAPI-Dokumentation, Typüberprüfung und asynchrone Unterstützung.

Routen & Endpunkte – @app.get, @app.post, etc.

@app.get() · @app.post() · @app.put() · @app.delete()

from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"message": "Hallo Welt"}

Routen verbinden URLs mit Python-Funktionen. FastAPI unterstützt alle HTTP-Methoden (GET, POST, PUT, DELETE, etc.) und automatische Typüberprüfung für Parameter.

Beispiele

# GET-Endpunkt

@app.get("/users")

async def get_users():

return [{"id": 1, "name": "Anna"}]

# POST-Endpunkt

@app.post("/users")

async def create_user(user: UserCreate):

return {"id": 2, "name": user.name}

# Path-Parameter

@app.get("/users/{user_id}")

async def get_user(user_id: int):

return {"id": user_id, "name": "Anna"}

# Query-Parameter

@app.get("/search")

async def search(q: str = "", limit: int = 10):

return {"query": q, "limit": limit}

# PUT-Endpunkt

@app.put("/users/{user_id}")

async def update_user(user_id: int, user: UserUpdate):

return {"id": user_id, "name": user.name}

Tipp: FastAPI leitet den Typ von Path- und Query-Parametern automatisch aus den Type-Hints ab. Verwenden Sie typing.Optional für optionale Parameter.

Pydantic-Modelle – Datenvalidierung & Serialisierung

BaseModel · Field · validator

from pydantic import BaseModel, Field class UserCreate(BaseModel): name: str = Field(..., min_length=2) email: str age: int = Field(18, ge=0, le=120)

Pydantic-Modelle definieren die Struktur und Validierungsregeln für Anfragedaten. FastAPI nutzt sie automatisch für Request-Bodies, Query-Parameter und Responses.

Beispiele

# Benutzer-Modell

from pydantic import BaseModel, Field, EmailStr, validator

class UserCreate(BaseModel):

name: str = Field(..., min_length=2, max_length=50)

email: EmailStr

age: int = Field(18, ge=0, le=120)

is_active: bool = True

# Benutzerdefinierte Validierung

@validator('name')

def validate_name(cls, v):

if not v.isalpha():

raise ValueError('Name darf nur Buchstaben enthalten')

return v.title()

# Response-Modell (ohne sensible Felder)

class UserResponse(BaseModel):

id: int

name: str

email: str

# Verwendung in Endpunkt

@app.post("/users", response_model=UserResponse)

async def create_user(user: UserCreate):

# user ist bereits validiert

new_user = {"id": 1, "name": user.name, "email": user.email}

return new_user

Tipp: Verwenden Sie response_model in Ihren Decoratoren, um die Ausgabe zu filtern und zu validieren – das hält Ihre API sauber und typsicher.

Dependency Injection – Wiederverwendbare Abhängigkeiten

Depends · yield · context manager

from fastapi import Depends async def get_db(): return Database() @app.get("/items") async def get_items(db: Database = Depends(get_db)): return db.get_items()

Dependency Injection ermöglicht die Wiederverwendung von Logik (z.B. Datenbankverbindungen, Authentifizierung) und die saubere Trennung von Verantwortlichkeiten.

Beispiele

# Einfache Dependency

async def common_parameters(q: str = None, skip: int = 0, limit: int = 100):

return {"q": q, "skip": skip, "limit": limit}

# Dependency in mehreren Endpunkten

@app.get("/items")

async def get_items(params: dict = Depends(common_parameters)):

return params

# Dependency mit yield (Resource-Management)

async def get_db():

db = Database()

try:

yield db

finally:

db.close()

# Dependency mit Sub-Dependencies

async def get_user(user_id: int):

return User(id=user_id)

async def get_current_user(user: User = Depends(get_user)):

return user

@app.get("/users/me")

async def get_me(user: User = Depends(get_current_user)):

return user

Tipp: Verwenden Sie yield für Dependencies, die Ressourcen verwalten (z.B. Datenbankverbindungen). FastAPI sorgt automatisch für die Bereinigung.

OpenAPI & Dokumentation – Automatische API-Dokumentation

/docs · /redoc · tags · description

app = FastAPI( title="Meine API", description="Beschreibung der API", version="1.0.0" ) # /docs für Swagger UI, /redoc für ReDoc

OpenAPI wird automatisch aus Ihrem Code generiert. FastAPI bietet interaktive Dokumentation unter /docs (Swagger UI) und /redoc (ReDoc).

Beispiele

# Metadaten für die API

app = FastAPI(

title="User API",

description="API für Benutzerverwaltung",

version="2.0.0",

contact={ "name": "Support", "email": "support@example.com" }

)

# Tags für Gruppierung in der Dokumentation

@app.get("/users", tags=["Users"])

async def get_users():

return [{"id": 1, "name": "Anna"}]

# Beschreibung für Endpunkt

@app.post("/users", tags=["Users"])

async def create_user(user: UserCreate):

"""

Erstellt einen neuen Benutzer.

- **name**: Vollständiger Name

- **email**: E-Mail-Adresse

"""

return {"id": 1, "name": user.name}

# OpenAPI-Schema abrufen

from fastapi.openapi.utils import get_openapi

openapi_schema = get_openapi(

title="Custom API",

version="1.0",

routes=app.routes

)

Tipp: Die interaktive Dokumentation unter /docs ist ein mächtiges Tool – Sie können Endpunkte direkt testen und die OpenAPI-Spezifikation herunterladen.

Async/await – Asynchrone Endpunkte

async def · await · BackgroundTasks

import asyncio @app.get("/async-example") async def async_endpoint(): await asyncio.sleep(1) return {"message": "Erledigt"}

Asynchrone Unterstützung ermöglicht es, I/O-gebundene Operationen (z.B. Datenbankabfragen, API-Aufrufe) effizient zu verarbeiten, ohne den Event-Loop zu blockieren.

Beispiele

# Asynchrone Datenbankabfrage

@app.get("/users/db")

async def get_users_db(db: AsyncDatabase = Depends(get_db)):

users = await db.fetch_all("SELECT * FROM users")

return users

# Externe API-Aufrufe

import httpx

@app.get("/external")

async def get_external():

async with httpx.AsyncClient() as client:

response = await client.get("https://api.example.com/data")

return response.json()

# BackgroundTasks (langsame Operationen im Hintergrund)

from fastapi import BackgroundTasks

async def send_email(email: str):

# E-Mail senden

await asyncio.sleep(2)

@app.post("/users")

async def create_user(user: UserCreate, background_tasks: BackgroundTasks):

background_tasks.add_task(send_email, user.email)

return {"message": "Benutzer erstellt"}

# Sync-Funktion in async-Endpunkt

import time

@app.get("/sync")

async def sync_endpoint():

# Blockierende Operation (wird im Thread-Pool ausgeführt)

time.sleep(1)

return {"message": "Fertig"}

Tipp: Verwenden Sie async def für I/O-gebundene Operationen und def für CPU-gebundene Aufgaben – FastAPI leitet beides automatisch korrekt weiter.

Responses & Statuscodes – Antworten steuern

Response · status_code · JSONResponse

from fastapi.responses import JSONResponse, HTMLResponse @app.post("/items", status_code=201) async def create_item(): return JSONResponse(content={"id": 1}, status_code=201)

Responses und Statuscodes steuern, was und wie die API antwortet – von JSON über HTML bis zu Dateien.

Beispiele

# Statuscode über Decorator

@app.post("/items", status_code=201)

async def create_item(item: Item):

return {"id": 1, "name": item.name}

# JSONResponse mit benutzerdefinierten Headern

from fastapi.responses import JSONResponse

@app.get("/custom")

async def custom_response():

content = {"message": "Erfolg"}

headers = {"X-Custom": "Wert"}

return JSONResponse(content=content, headers=headers)

# HTML-Response

from fastapi.responses import HTMLResponse

@app.get("/html", response_class=HTMLResponse)

async def get_html():

return "<h1>Hallo Welt</h1>"

# Redirect

from fastapi.responses import RedirectResponse

@app.get("/old")

async def redirect_old():

return RedirectResponse("/new", status_code=301)

# File-Response

from fastapi.responses import FileResponse

@app.get("/download")

async def download():

return FileResponse("path/to/file.pdf", filename="datei.pdf")

# HTTPException

from fastapi import HTTPException

@app.get("/error")

async def error_example():

raise HTTPException(status_code=404, detail="Nicht gefunden")

Tipp: Verwenden Sie HTTPException für konsistente Fehlerbehandlung – FastAPI formatiert die Antwort automatisch als JSON mit detail-Feld.

FastAPI im Überblick

@app.get Routen-Dekorator
GET, POST, PUT, DELETE

BaseModel Pydantic-Modelle
Validierung & Serialisierung

Depends Dependency Injection
Wiederverwendbare Logik

/docs OpenAPI-Dokumentation
Swagger UI, ReDoc

async Asynchrone Unterstützung
async/await, BackgroundTasks

HTTPException Fehlerbehandlung
Statuscodes, Fehlermeldungen

Quick Summary

@app.get

Routen

BaseModel

Pydantic

Depends

Dependency Injection

/docs

OpenAPI

async

Async/await

JSONResponse

Responses

@app.get("/") · class User(BaseModel): name: str · Depends(get_db)