~18m2:05:44
Tech With Tim

Learn Fast API With This ONE Project

30.10.2025

Read: ~15m · You save: 111 min

Erstellung einer Foto- und Videoaustausch-App mit FastAPI

Dieser Artikel beschreibt den Prozess der Entwicklung des Backends einer Foto- und Videoaustausch-App mit dem FastAPI-Framework. Das Projekt umfasst den gesamten Zyklus der API-Erstellung, einschließlich grundlegender Datenoperationen, Datenbankanbindung, Verarbeitung von Datei-Uploads und Implementierung der Benutzerauthentifizierung. Grundlegende Python-Kenntnisse werden vorausgesetzt.

Einleitung

Ziel des Projekts ist die Erstellung einer voll funktionsfähigen API für eine Anwendung, die es Benutzern ermöglicht, Fotos und Videos hochzuladen und anzusehen. Im Rahmen der Entwicklung werden Schlüsselkonzepte von Webanwendungen und APIs sowie praktische Aspekte der Implementierung mit modernen Werkzeugen behandelt.

Grundlegende Konzepte von Webanwendungen und APIs

URLs, Pfade und Endpunkte

URL (Uniform Resource Locator) ist die Adresse einer Ressource im Netzwerk. Sie besteht aus mehreren Komponenten:

  • Schema: Das Datenübertragungsprotokoll (z. B. http, https).
  • Domain: Der Servername oder die IP-Adresse (z. B. example.com).
  • Pfad (Path): Gibt die spezifische Ressource oder Seite auf dem Server an (z. B. /users/profile). Der Pfad definiert den Endpunkt – den Einstiegspunkt der API, auf den der Client zugreift.

Query-Parameter

Query-Parameter werden nach einem Fragezeichen (?) an die URL angehängt und dienen zur Filterung oder Verfeinerung von Daten. Sie sind Schlüssel-Wert-Paare, die durch ein kaufmännisches Und (&) getrennt sind. Beispiel: /posts?category=technology&sort=date

Struktur von Anfrage und Antwort

Die Interaktion zwischen dem Client (z. B. einem Webbrowser oder einer mobilen Anwendung) und dem Server erfolgt über Anfragen und Antworten.

Anfrage (Request):

  • Methode (HTTP Method): Definiert die Aktion, die der Client mit der Ressource ausführen möchte. Hauptmethoden:
    • GET: Abrufen von Daten.
    • POST: Erstellen einer neuen Ressource.
    • PUT/PATCH: Aktualisieren einer vorhandenen Ressource.
    • DELETE: Löschen einer Ressource.
  • Pfad (Path): Der API-Endpunkt.
  • Header: Enthält Metadaten der Anfrage, wie z. B. den Inhaltstyp, Authentifizierungsinformationen (z. B. JWT-Token).
  • Body: Enthält die an den Server gesendeten Daten (z. B. Formulardaten, JSON-Objekt). Wird mit den Methoden POST, PUT, PATCH verwendet.

Antwort (Response):

  • Statuscode (Status Code): Eine dreistellige Zahl, die das Ergebnis der Verarbeitung der Anfrage angibt. Häufigste Codes:
    • 200 OK: Erfolgreiche Anfrage.
    • 201 Created: Ressource erfolgreich erstellt.
    • 204 No Content: Erfolgreiche Anfrage, aber kein Antwortkörper.
    • 400 Bad Request: Ungültige Client-Anfrage.
    • 401 Unauthorized: Authentifizierung erforderlich.
    • 403 Forbidden: Zugriff verweigert.
    • 404 Not Found: Ressource nicht gefunden.
    • 500 Internal Server Error: Fehler auf der Serverseite.
  • Header: Metadaten der Antwort, z. B. der Inhaltstyp.
  • Body: Die vom Server zurückgegebenen Daten (oft im JSON-Format).

Projekt-Setup und Abhängigkeitsinstallation

Um mit der Arbeit zu beginnen, müssen Sie das Projekt initialisieren und die erforderlichen Bibliotheken installieren. Es wird empfohlen, den Paketmanager uv (oder pip) zu verwenden.

  1. Projektinitialisierung:

    uv init .
    

    Dieser Befehl erstellt die Datei pyproject.toml zur Verwaltung der Projekt-Abhängigkeiten.

  2. Abhängigkeitsinstallation:

    uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlite
    
    • fastapi: Das Haupt-Framework.
    • uvicorn: Ein ASGI-Server zum Ausführen von FastAPI-Anwendungen.
    • python-dotenv: Zum Laden von Umgebungsvariablen aus der .env-Datei.
    • sqlalchemy: Eine ORM für die Arbeit mit Datenbanken.
    • fastapi-users: Eine Bibliothek zur schnellen Implementierung der Benutzerauthentifizierung.
    • imagekit-io: Das SDK zur Integration mit dem ImageKit-Dienst für die Verarbeitung von Mediendateien.
    • aiosqlite: Ein asynchroner Treiber für die Arbeit mit SQLite.
  3. Umgebungsvariablen: Erstellen Sie eine .env-Datei im Stammverzeichnis des Projekts, um sensible Daten wie ImageKit API-Schlüssel zu speichern.

    IMAGEKIT_PRIVATE_KEY=your_private_key
    IMAGEKIT_PUBLIC_KEY=your_public_key
    IMAGEKIT_URL_ENDPOINT=your_url_endpoint
    

    Sie müssen sich bei ImageKit registrieren und die entsprechenden Schlüssel erhalten.

Grundlagen von FastAPI

Anwendungsinstanz erstellen

Die Hauptanwendungsdatei (z. B. app/main.py oder app/app.py) beginnt mit dem Import von FastAPI und der Erstellung einer Anwendungsinstanz.

# app/app.py
from fastapi import FastAPI

app = FastAPI()

Endpunkte definieren

Endpunkte werden mit Dekoratoren definiert, die den HTTP-Methoden entsprechen.

# app/app.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str | None = None):
    return {"item_id": item_id, "q": q}
  • @app.get("/"): Definiert einen GET-Endpunkt am Stammverzeichnis.
  • @app.get("/items/{item_id}"): Definiert einen GET-Endpunkt mit einem Pfadparameter item_id. FastAPI konvertiert item_id automatisch in einen int und führt eine Validierung durch.
  • q: str | None = None: Definiert einen optionalen Abfrageparameter q vom Typ str.

Anwendung ausführen

Die Anwendung wird mit dem ASGI-Server uvicorn ausgeführt. Erstellen Sie eine Datei main.py, um den Server zu starten.

# main.py
import uvicorn
from app.app import app # Importieren Sie die FastAPI-Instanz aus app/app.py

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000, reload=True)

Ausführen:

uvicorn main:app --reload

oder

uv run main.py

Automatische Dokumentation

FastAPI generiert automatisch eine interaktive API-Dokumentation basierend auf dem Code.

  • Swagger UI: /docs
  • ReDoc: /redoc

Erstellung einer API: Kernfunktionalität

Datenmodelle und Schemata (Pydantic)

Pydantic wird zur Definition von Datenschemata verwendet, die die Validierung eingehender und ausgehender Daten gewährleisten.

# app/schemas.py
from pydantic import BaseModel
from typing import Optional

class PostBase(BaseModel):
    title: str
    content: str

class PostCreate(PostBase):
    pass

class Post(PostBase):
    id: int # Oder UUID, falls verwendet

    class Config:
        orm_mode = True # Für die Arbeit mit SQLAlchemy-Modellen

Pfad- und Anfrageparameter

  • Pfadparameter: Dynamische URL-Segmente.
    @app.get("/posts/{post_id}")
    async def get_post(post_id: int):
        # Logik zum Abrufen des Beitrags nach ID
        return {"post_id": post_id}
    
  • Anfrageparameter: Optionale oder obligatorische Parameter nach dem ?.
    @app.get("/posts")
    async def get_posts(limit: int = 10, skip: int = 0):
        # Logik zum Abrufen einer Liste von Beiträgen mit Filterung
        return {"limit": limit, "skip": skip}
    

Anfragekörper (Request Body)

Zum Senden von Daten im Anfragekörper (z. B. beim Erstellen eines Beitrags) wird ein Pydantic-Schema verwendet.

# app/app.py
from fastapi import FastAPI
from app.schemas import PostCreate, Post
from typing import List

app = FastAPI()

# Temporärer Datenspeicher (wird durch eine Datenbank ersetzt)
posts_db = {}
post_id_counter = 1

@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
    global post_id_counter
    new_post = Post(id=post_id_counter, title=post.title, content=post.content)
    posts_db[post_id_counter] = new_post
    post_id_counter += 1
    return new_post

Typisierung der Ausgabedaten

Die Angabe des Rückgabetyps verbessert die Dokumentation und die Validierung.

# app/app.py
from app.schemas import PostCreate, Post
from typing import List

# ... (vorheriger Code)

@app.post("/posts", response_model=Post)
async def create_post(post: PostCreate):
    # ... (Logik zum Erstellen des Beitrags)
    return new_post

@app.get("/posts", response_model=List[Post])
async def get_all_posts():
    return list(posts_db.values())

Integration mit Datenbank (SQLAlchemy & AsyncIO)

Für die persistente Datenspeicherung wird eine SQLite-Datenbank mit asynchronem Zugriff verwendet.

Datenbank-Setup

Erstellen Sie eine Datei app/db.py, um die Verbindung und die Datenmodelle einzurichten.

# app/db.py
from sqlalchemy import create_engine, Column, Integer, String, Text, DateTime, ForeignKey
from sqlalchemy.orm import sessionmaker, relationship
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.ext.asyncio import async_sessionmaker
from datetime import datetime
import uuid

DATABASE_URL = "sqlite+aiosqlite:///./test.db"

# Erstellung der asynchronen Engine
engine = create_async_engine(DATABASE_URL, echo=True)

# Erstellung der asynchronen Session-Factory
AsyncSessionLocal = async_sessionmaker(
    autocommit=False,
    autoflush=False,
    class_=AsyncSession
)

# Basisklasse für deklarative Modelle
Base = declarative_base()

# Datenmodell für einen Post
class Post(Base):
    __tablename__ = "posts"

    id = Column(Integer, primary_key=True, index=True) # Oder UUID
    title = Column(String, index=True)
    content = Column(Text)
    created_at = Column(DateTime, default=datetime.utcnow)
    user_id = Column(Integer, ForeignKey("users.id")) # Verknüpfung zum Benutzer

    user = relationship("User", back_populates="posts")

# Datenmodell für einen Benutzer (für FastAPI-Users)
class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True) # Oder UUID
    email = Column(String, unique=True, index=True)
    hashed_password = Column(String)
    is_active = Column(Boolean, default=True)
    is_superuser = Column(Boolean, default=False)
    is_verified = Column(Boolean, default=False)

    posts = relationship("Post", back_populates="user")

# Funktion zum Abrufen einer asynchronen Session
async def get_async_session() -> AsyncSession:
    async with AsyncSessionLocal() as session:
        yield session

# Funktion zum Erstellen von Tabellen
async def create_db_tables():
    async with engine.begin() as conn:
        await conn.run_sync(Base.metadata.create_all)

# Für FastAPI-Users
async def get_user_db(session: AsyncSession = Depends(get_async_session)):
    yield SQLAlchemyUserDatabase(session, User)

Integration mit FastAPI

Verwenden Sie lifespan, um Tabellen beim Start der Anwendung automatisch zu erstellen.

# app/app.py
from fastapi import FastAPI, Depends, HTTPException, File, UploadFile, Form
from app.schemas import PostCreate, Post, UserCreate, UserRead, UserUpdate # Importiere Benutzerschemata
from app.db import Post as PostModel, User as UserModel, get_async_session, create_db_tables, get_user_db # Importiere DB-Modelle
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import Session
from sqlalchemy import select
from contextlib import asynccontextmanager
from typing import List, Optional
import shutil
import os
import uuid

# Import für ImageKit
from imagekitio import ImageKit
from imagekitio.models.models import UploadFileRequestOptions
from dotenv import load_dotenv

load_dotenv() # Lade Umgebungsvariablen

# Initialisierung von ImageKit
imagekit = ImageKit(
    private_key=os.getenv("IMAGEKIT_PRIVATE_KEY"),
    public_key=os.getenv("IMAGEKIT_PUBLIC_KEY"),
    url_endpoint=os.getenv("IMAGEKIT_URL_ENDPOINT")
)

# --- Benutzerauthentifizierung (FastAPI-Users) ---
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
    AuthenticationBackend,
    BearerTransport,
    JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase

# Geheimer Schlüssel für JWT (sollte sicher sein und in .env gespeichert werden)
SECRET = os.getenv("JWT_SECRET_KEY", "your_super_secret_key_here") # Es wird empfohlen, einen zufälligen Schlüssel zu generieren

# Benutzerverwaltung
class UserManager(BaseUserManager[UUID_ID, UserModel]):
    reset_password_token_secret = SECRET
    verification_token_secret = SECRET

async def get_user_manager(user_db: SQLAlchemyUserDatabase = Depends(get_user_db)):
    yield UserManager(user_db)

# Transport für Token (Bearer Token)
bearer_transport = BearerTransport(tokenUrl="auth/jwt/login")

# JWT-Strategie
def get_jwt_strategy() -> JWTStrategy:
    return JWTStrategy(secret=SECRET, lifetime_seconds=3600) # Token ist 1 Stunde gültig

# Authentifizierungs-Backend
auth_backend = AuthenticationBackend(
    name="jwt",
    transport=bearer_transport,
    get_strategy=get_jwt_strategy,
)

fastapi_users = FastAPIUsers[UserModel, UUID_ID](
    get_user_manager, auth_backend
)

# Abrufen des aktuell aktiven Benutzers
current_active_user = fastapi_users.current_user(active=True)

# --- Kontextmanager für den Lebenszyklus der Anwendung ---
@asynccontextmanager
async def lifespan(app: FastAPI):
    await create_db_tables() # Tabellen beim Start erstellen
    yield

app = FastAPI(lifespan=lifespan)

# --- Einbindung von Authentifizierungsrouten ---
app.include_router(
    fastapi_users.get_auth_router(auth_backend), prefix="/auth/jwt", tags=["auth"]
)
app.include_router(
    fastapi_users.get_register_router(UserRead, UserCreate), prefix="/auth", tags=["auth"]
)
app.include_router(
    fastapi_users.get_reset_password_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
    fastapi_users.get_verify_router(), prefix="/auth", tags=["auth"]
)
app.include_router(
    fastapi_users.get_users_router(), prefix="/users", tags=["users"]
)

# --- API-Endpunkte ---

# Abrufen des aktuellen Benutzers (geschützter Endpunkt)
@app.get("/users/me", response_model=UserRead)
async def read_users_me(current_user: UserModel = Depends(current_active_user)):
    return current_user

# Abrufen aller Posts (geschützter Endpunkt)
@app.get("/feed", response_model=List[Post])
async def get_feed(
    session: AsyncSession = Depends(get_async_session),
    current_user: UserModel = Depends(current_active_user) # Authentifizierung erforderlich
):
    # Abfrage von Posts mit Benutzerinformationen
    stmt = select(PostModel).order_by(PostModel.created_at.desc())
    result = await session.execute(stmt)
    posts = result.scalars().all()

    # Erstellung der Antwort mit Benutzerinformationen und Eigentümerstatus
    posts_data = []
    for post in posts:
        is_owner = (post.user_id == current_user.id)
        posts_data.append({
            "id": post.id,
            "title": post.title,
            "content": post.content,
            "created_at": post.created_at,
            "user_id": post.user_id,
            "file_url": post.file_url,
            "file_type": post.file_type,
            "file_name": post.file_name,
            "is_owner": is_owner,
            "user_email": post.user.email if post.user else "Unknown"
        })
    return posts_data

# Hochladen einer Datei (Foto/Video) und Erstellen eines Posts (geschützter Endpunkt)
@app.post("/upload", response_model=Post)
async def upload_file(
    file: UploadFile = File(...),
    caption: str = Form(...),
    session: AsyncSession = Depends(get_async_session),
    current_user: UserModel = Depends(current_active_user) # Authentifizierung erforderlich
):
    # Generierung eines eindeutigen Dateinamens
    file_extension = os.path.splitext(file.filename)[1]
    unique_filename = f"{uuid.uuid4()}{file_extension}"

    # Hochladen der Datei in ImageKit
    try:
        upload_result = imagekit.upload_file(
            file=file.file,
            file_name=unique_filename,
            options=UploadFileRequestOptions(
                use_unique_file_name=True,
                tags=["backend_upload"],
                folder="uploads" # Optional: Ordner in ImageKit
            )
        )
        file_url = upload_result.url
        file_type = "video" if file.content_type.startswith("video/") else "image"
        file_name = upload_result.name

        # Erstellung eines neuen Posts in der Datenbank
        new_post = PostModel(
            title=caption, # Verwende caption als Titel
            content=caption, # Oder füge ein separates Feld für den Inhalt hinzu
            user_id=current_user.id,
            file_url=file_url,
            file_type=file_type,
            file_name=file_name
        )
        session.add(new_post)
        await session.commit()
        await session.refresh(new_post)

        # Rückgabe der Post-Daten, einschließlich URL und Benutzerinformationen
        return {
            "id": new_post.id,
            "title": new_post.title,
            "content": new_post.content,
            "created_at": new_post.created_at,
            "user_id": new_post.user_id,
            "file_url": new_post.file_url,
            "file_type": new_post.file_type,
            "file_name": new_post.file_name,
            "user_email": current_user.email # Hinzufügen der E-Mail des aktuellen Benutzers
        }

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"File upload failed: {e}")

# Löschen eines Posts (geschützter Endpunkt)
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
    post_id: int,
    session: AsyncSession = Depends(get_async_session),
    current_user: UserModel = Depends(current_active_user) # Authentifizierung erforderlich
):
    # Abrufen des Posts aus der Datenbank
    stmt = select(PostModel).where(PostModel.id == post_id)
    result = await session.execute(stmt)
    post = result.scalars().first()

    if not post:
        raise HTTPException(status_code=404, detail="Post not found")

    # Überprüfung der Zugriffsrechte: Nur der Autor des Posts kann ihn löschen
    if post.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="You do not have permission to delete this post")

    # Löschen des Posts aus der Datenbank
    await session.delete(post)
    await session.commit()

    return {"message": "Post deleted successfully"}

# --- Zusätzliche Schemata für Benutzer ---
# Diese Schemata erben von den Standard-Schemata von FastAPI-Users,
# können aber bei Bedarf erweitert werden.
from fastapi_users import schemas

class UserRead(schemas.BaseUser[uuid.UUID]):
    email: str
    is_active: bool = True
    is_superuser: bool = False
    is_verified: bool = False
    id: uuid.UUID # Stellen Sie sicher, dass die ID mit dem Typ im DB-Modell übereinstimmt

class UserCreate(schemas.BaseUserCreate):
    password: str
    email: str
    is_active: bool = True
    is_superuser: bool = False
    is_verified: bool = False

class UserUpdate(schemas.BaseUserUpdate):
    password: Optional[str] = None
    email: Optional[str] = None
    is_active: Optional[bool] = None
    is_superuser: Optional[bool] = None
    is_verified: Optional[bool] = None

# Aktualisierung des Post-Modells zur Einbeziehung von Benutzerinformationen und Eigentümerstatus
class PostWithUser(Post):
    user_id: Optional[int] # Oder UUID
    file_url: str
    file_type: str
    file_name: str
    is_owner: bool
    user_email: str

# Aktualisierung des get_feed-Endpunkts zur Rückgabe von PostWithUser
@app.get("/feed", response_model=List[PostWithUser])
async def get_feed(
    session: AsyncSession = Depends(get_async_session),
    current_user: UserModel = Depends(current_active_user)
):
    stmt = select(PostModel).order_by(PostModel.created_at.desc())
    result = await session.execute(stmt)
    posts = result.scalars().all()

    posts_data = []
    for post in posts:
        is_owner = (post.user_id == current_user.id)
        posts_data.append(PostWithUser(
            id=post.id,
            title=post.title,
            content=post.content,
            created_at=post.created_at,
            user_id=post.user_id,
            file_url=post.file_url,
            file_type=post.file_type,
            file_name=post.file_name,
            is_owner=is_owner,
            user_email=post.user.email if post.user else "Unknown"
        ))
    return posts_data

# Aktualisierung des upload_file-Endpunkts zur Rückgabe von PostWithUser
@app.post("/upload", response_model=PostWithUser)
async def upload_file(
    file: UploadFile = File(...),
    caption: str = Form(...),
    session: AsyncSession = Depends(get_async_session),
    current_user: UserModel = Depends(current_active_user)
):
    file_extension = os.path.splitext(file.filename)[1]
    unique_filename = f"{uuid.uuid4()}{file_extension}"

    try:
        upload_result = imagekit.upload_file(
            file=file.file,
            file_name=unique_filename,
            options=UploadFileRequestOptions(
                use_unique_file_name=True,
                tags=["backend_upload"],
                folder="uploads"
            )
        )
        file_url = upload_result.url
        file_type = "video" if file.content_type.startswith("video/") else "image"
        file_name = upload_result.name

        new_post = PostModel(
            title=caption,
            content=caption,
            user_id=current_user.id,
            file_url=file_url,
            file_type=file_type,
            file_name=file_name
        )
        session.add(new_post)
        await session.commit()
        await session.refresh(new_post)

        return PostWithUser(
            id=new_post.id,
            title=new_post.title,
            content=new_post.content,
            created_at=new_post.created_at,
            user_id=new_post.user_id,
            file_url=new_post.file_url,
            file_type=new_post.file_type,
            file_name=new_post.file_name,
            is_owner=True, # Neuer Post gehört immer dem aktuellen Benutzer
            user_email=current_user.email
        )

    except Exception as e:
        raise HTTPException(status_code=500, detail=f"File upload failed: {e}")

# Aktualisierung des Post-Modells zur Einbeziehung von ForeignKey und relationship
# In app/db.py:
# Füge zu Klasse Post hinzu:
# user_id = Column(Integer, ForeignKey("users.id"))
# user = relationship("User", back_populates="posts")
# Füge zu Klasse User hinzu:
# posts = relationship("Post", back_populates="user")
# Stelle sicher, dass User und Post von Base erben und die entsprechenden Felder haben.
# Es ist auch notwendig, die Pydantic-Schemata (PostCreate, Post, UserRead, UserCreate, UserUpdate) zu aktualisieren
# und sicherzustellen, dass sie mit den SQLAlchemy-Modellen übereinstimmen.

Hochladen von Dateien mit ImageKit

Die Integration mit ImageKit ermöglicht eine einfache Verwaltung von Mediendateien.

  1. ImageKit initialisieren: Importieren und initialisieren Sie den ImageKit-Client in app/app.py mit den Schlüsseln aus .env.

  2. Upload-Verarbeitung: Der Endpunkt /upload empfängt UploadFile und caption aus dem Formular. Die Datei wird in ImageKit hochgeladen und die erhaltene URL zusammen mit den Informationen über den Beitrag und den Benutzer in der Datenbank gespeichert.

    # In app/app.py
    from fastapi import File, UploadFile, Form
    # ... (andere Imports)
    
    @app.post("/upload", response_model=PostWithUser)
    async def upload_file(
        file: UploadFile = File(...),
        caption: str = Form(...),
        session: AsyncSession = Depends(get_async_session),
        current_user: UserModel = Depends(current_active_user)
    ):
        # ... (Logik für den Upload in ImageKit und die Speicherung in der DB)
        pass
    

Medien-Transformationen

ImageKit ermöglicht es, Transformationen auf Bilder und Videos direkt über die URL anzuwenden. Zum Beispiel Größenänderung, Hinzufügen von Text, Anwenden von Effekten.

Beispiel einer URL mit Transformationen: https://ik.imagekit.io/your_public_key/your_file_name.jpg?tr=w-300,h-200,fo-auto

Authentifizierung und Autorisierung (FastAPI-Users)

FastAPI-Users vereinfacht die Implementierung der Benutzerauthentifizierung mit JWT (JSON Web Tokens).

JWT-Konzept

JWT ist ein Standard für die sichere Übertragung von Informationen zwischen Parteien in Form eines JSON-Objekts. Es besteht aus drei Teilen: Header, Payload und Signatur. Der Token wird mit einem geheimen Schlüssel des Servers signiert, was die Überprüfung seiner Authentizität ermöglicht.

FastAPI-Users-Konfiguration

  1. Benutzermodelle: Definieren Sie das User-Modell in app/db.py, das von SQLAlchemyUserTable erbt und die erforderlichen Felder (E-Mail, Passwort, Rollen) enthält.
  2. Benutzerschemata: Erstellen Sie die Schemata UserRead, UserCreate, UserUpdate in app/schemas.py.
  3. Benutzermanager und Authentifizierungs-Backend: Konfigurieren Sie UserManager, BearerTransport, JWTStrategy und AuthenticationBackend in app/app.py.
  4. Einbindung von Routen: Verwenden Sie app.include_router(), um die Standard-Authentifizierungsrouten (Registrierung, Login, Passwort zurücksetzen) hinzuzufügen.

Endpunkt-Schutz

Um Endpunkte zu schützen, fügen Sie die Abhängigkeit Depends(current_active_user) zu den Endpunktfunktionen hinzu. Wenn der Benutzer nicht authentifiziert ist, wird die Anfrage abgelehnt.

# app/app.py
from fastapi_users import FastAPIUsers, BaseUserManager, UUID_ID
from fastapi_users.authentication import (
    AuthenticationBackend,
    BearerTransport,
    JWTStrategy,
)
from fastapi_users.db import SQLAlchemyUserDatabase

# ... (Definition von Modellen und Schemata)

# Aktuell aktiven Benutzer abrufen
current_active_user = fastapi_users.current_user(active=True)

@app.get("/protected-route")
async def protected_route(current_user: UserModel = Depends(current_active_user)):
    return {"message": f"Hello, {current_user.email}!"}

Autorisierung (Zugriffsberechtigungsprüfung)

Beim Löschen eines Beitrags müssen Sie sicherstellen, dass der aktuelle Benutzer der Autor des Beitrags ist.

# app/app.py
@app.delete("/posts/{post_id}", response_model=dict)
async def delete_post(
    post_id: int,
    session: AsyncSession = Depends(get_async_session),
    current_user: UserModel = Depends(current_active_user)
):
    # ... (Beitrag abrufen)
    if post.user_id != current_user.id:
        raise HTTPException(status_code=403, detail="You do not have permission to delete this post")
    # ... (Beitrag löschen)

Frontend (Streamlit)

Zur Demonstration der API-Funktionalität kann ein einfaches Frontend mit der Streamlit-Bibliothek erstellt werden. Streamlit ermöglicht die schnelle Erstellung interaktiver Webanwendungen in Python.

  1. Streamlit installieren:

    uv add streamlit
    
  2. Frontend-Datei erstellen: Erstellen Sie eine Datei frontend.py mit Code, der mit der API interagiert (Authentifizierungsanfragen, Dateiuploads, Feed-Abrufe sendet). Der Frontend-Code umfasst typischerweise:

    • Verwaltung des Sitzungszustands (Speicherung des JWT-Tokens).
    • Funktionen zum Senden von HTTP-Anfragen mit dem Token im Header.
    • Schnittstellen für Registrierung, Login, Dateiupload, Anzeige des Feeds.
  3. Streamlit starten:

    uv run streamlit run frontend.py
    

Schlussfolgerung

Die entwickelte Anwendung demonstriert einen umfassenden Ansatz zur Erstellung einer modernen Web-API mit FastAPI. Sie umfasst die Anfrageverarbeitung, die Datenbankinteraktion, die sichere Benutzerauthentifizierung und die Integration mit externen Diensten zur Verarbeitung von Mediendateien. Die resultierende API bildet die Grundlage für die Erstellung skalierbarer und zuverlässiger Webanwendungen.