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,PATCHverwendet.
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.
-
Projektinitialisierung:
uv init .Dieser Befehl erstellt die Datei
pyproject.tomlzur Verwaltung der Projekt-Abhängigkeiten. -
Abhängigkeitsinstallation:
uv add fastapi uvicorn python-dotenv sqlalchemy fastapi-users imagekit-io aiosqlitefastapi: 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.
-
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_endpointSie 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 Pfadparameteritem_id. FastAPI konvertiertitem_idautomatisch in einenintund führt eine Validierung durch.q: str | None = None: Definiert einen optionalen Abfrageparameterqvom Typstr.
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.
-
ImageKit initialisieren: Importieren und initialisieren Sie den ImageKit-Client in
app/app.pymit den Schlüsseln aus.env. -
Upload-Verarbeitung: Der Endpunkt
/uploadempfängtUploadFileundcaptionaus 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
- Benutzermodelle: Definieren Sie das
User-Modell inapp/db.py, das vonSQLAlchemyUserTableerbt und die erforderlichen Felder (E-Mail, Passwort, Rollen) enthält. - Benutzerschemata: Erstellen Sie die Schemata
UserRead,UserCreate,UserUpdateinapp/schemas.py. - Benutzermanager und Authentifizierungs-Backend: Konfigurieren Sie
UserManager,BearerTransport,JWTStrategyundAuthenticationBackendinapp/app.py. - 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.
-
Streamlit installieren:
uv add streamlit -
Frontend-Datei erstellen: Erstellen Sie eine Datei
frontend.pymit 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.
-
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.
Facts extraction failed. Please try again later.
