0Pricing
Python Academy · Lektion

Dependency Injection und Authentifizierung

Verwenden Sie das DI-System von FastAPI für gemeinsame Logik und JWT-basierte Authentifizierung.

Dependency Injection und Authentifizierung ist eine kostenlose Python Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Python Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was ist Dependency Injection?

Mit FastAPIs Depends() können Sie gemeinsam genutzte Logik (Datenbanksitzungen, Authentifizierungsprüfungen, Konfiguration) deklarieren, die automatisch in Routen-Handler injiziert wird.

from fastapi import FastAPI, Depends
app = FastAPI()

def get_db():
    db = connect_db()
    try: yield db
    finally: db.close()

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query_all("users")

Dependency-Funktionen

Eine Dependency ist jedes aufrufbare Objekt. Sie kann eine Funktion, eine Klasse oder eine andere Funktion sein, die eine Dependency verwendet.

from fastapi import Depends, FastAPI
app = FastAPI()

def common_params(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(common_params)):
    return params

@app.get("/users")
def list_users(params: dict = Depends(common_params)):
    return params

Klassen als Dependencies

Verwenden Sie eine Klasse als Dependency, um zusammengehörige Einstellungen zu gruppieren. Die Klasse wird mit injizierten __init__-Argumenten aufgerufen.

from fastapi import Depends, FastAPI, Query
app = FastAPI()

class Pagination:
    def __init__(self, page: int = Query(1,ge=1), size: int = Query(10,ge=1,le=100)):
        self.page = page
        self.size = size
        self.offset = (page - 1) * size

@app.get("/items")
def list_items(pag: Pagination = Depends()):
    return {"offset": pag.offset, "size": pag.size}

OAuth2 Password Bearer

Verwenden Sie OAuth2PasswordBearer, um ein Bearer-Token aus dem Authorization-Header auszulesen.

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer
app = FastAPI()

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

@app.get("/me")
def me(token: str = Depends(oauth2)):
    return {"token": token}   # validate token here

JWT-Tokens

Erstellen und überprüfen Sie JWT-Tokens mit python-jose (oder pyjwt). Geben Sie bei der Anmeldung ein Token zurück und überprüfen Sie es in jeder geschützten Route.

# pip install python-jose passlib
from jose import jwt, JWTError

SECRET_KEY = "change-me"
ALGORITHM = "HS256"

def create_token(data: dict) -> str:
    return jwt.encode(data, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(token: str) -> dict:
    return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])

Dependency für den aktuellen Benutzer

Erstellen Sie eine get_current_user-Dependency, die das JWT überprüft und den authentifizierten Benutzer zurückgibt.

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from jose import jwt, JWTError

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

def get_current_user(token: str = Depends(oauth2)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return payload["sub"]
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

# @app.get("/me")
# def me(user=Depends(get_current_user)): return user

Passwort-Hashing

Speichern Sie niemals Passwörter im Klartext. Verwenden Sie passlib, um sie mit bcrypt zu hashen.

from passlib.context import CryptContext

pwd_ctx = CryptContext(schemes=["bcrypt"], deprecated="auto")

def hash_pw(plain: str) -> str:
    return pwd_ctx.hash(plain)

def verify_pw(plain: str, hashed: str) -> bool:
    return pwd_ctx.verify(plain, hashed)

Token-Endpunkt

Implementieren Sie POST /token, das Anmeldedaten aus einem Formular akzeptiert, das Passwort überprüft und ein JWT zurückgibt.

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
app = FastAPI()

@app.post("/token")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user_by_username(form.username)
    if not user or not verify_pw(form.password, user.hashed_pw):
        raise HTTPException(status_code=401, detail="Bad credentials")
    token = create_token({"sub": form.username})
    return {"access_token": token, "token_type": "bearer"}

API-Key-Authentifizierung

Validieren Sie in einfacheren Fällen einen API-Key aus einem Header oder Query-Parameter.

from fastapi import Depends, HTTPException, Security
from fastapi.security import APIKeyHeader

API_KEY_HEADER = APIKeyHeader(name="X-API-Key")

def require_api_key(key: str = Security(API_KEY_HEADER)):
    if key != "secret-key":
        raise HTTPException(status_code=403, detail="Forbidden")
    return key

Rollenbasierte Zugriffskontrolle

Erweitern Sie die Authentifizierung um Berechtigungen, indem Sie Rollenprüfungen zu Dependencies hinzufügen.

from fastapi import Depends, HTTPException

def require_admin(user=Depends(get_current_user)):
    if user.get("role") != "admin":
        raise HTTPException(status_code=403, detail="Admins only")
    return user

# @app.delete("/users/{uid}")
# def delete_user(uid: int, admin=Depends(require_admin)):

Dependency-Caching

Standardmäßig wird eine Dependency pro Request einmal aufgerufen, und ihr Ergebnis wird von allen Routen geteilt, die sie in diesem Request verwenden.

# The same db session object is shared:
@app.get("/summary")
def summary(
    db = Depends(get_db),      # db resolved once
    stats = Depends(get_stats) # get_stats also uses get_db — same db instance
): ...

Schnelltest

Was bewirkt Depends() in FastAPI?

Zusammenfassung

Verwenden Sie Depends(func), um gemeinsam genutzte Logik einzubinden. Implementieren Sie die Authentifizierung mit OAuth2PasswordBearer, JWT-Tokens und einer get_current_user-Abhängigkeit. Hashen Sie Passwörter mit passlib/bcrypt. Ergänzen Sie Rollenprüfungen als weitere Abhängigkeiten.

Häufig gestellte Fragen

Ist die Lektion „Dependency Injection und Authentifizierung“ kostenlos?

Ja — der vollständige Text von „Dependency Injection und Authentifizierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Python Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Python Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Dependency Injection und Authentifizierung“?

Verwenden Sie das DI-System von FastAPI für gemeinsame Logik und JWT-basierte Authentifizierung. Du übst Python Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Python Academy zu starten?

Keine Vorkenntnisse erforderlich. Python Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Dependency Injection und Authentifizierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Python Academy-Lektion Code schreiben und ausführen?

Ja. Jede Python Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. FastAPI-Projekteinrichtung und erster Endpunkt
  2. Pfadparameter, Query-Parameter und Request-Bodies
  3. Dependency Injection und Authentifizierung
  4. Asynchrone Endpunkte und Datenbankintegration
← Zurück zu Python Academy