So implementieren Sie die Benutzerauthentifizierung und -autorisierung in FastAPI

So implementieren Sie Benutzerauthentifizierung und -autorisierung in FastAPI

FastAPI ist ein leistungsstarkes Webframework auf Python-Basis, das viele leistungsstarke Funktionen wie asynchrone Unterstützung, automatische Dokumentgenerierung und Typhinweise bietet. In modernen Webanwendungen sind Benutzerauthentifizierung und -autorisierung sehr wichtige Funktionen, die die Sicherheit der Anwendung schützen können. In diesem Artikel erfahren Sie, wie Sie die Benutzerauthentifizierung und -autorisierung in FastAPI implementieren.

1. Installieren Sie die erforderlichen Bibliotheken

Bevor wir beginnen, müssen wir zunächst die erforderlichen Bibliotheken installieren. In FastAPI wird die PyJWT-Bibliothek normalerweise für die Verarbeitung von JSON-Web-Tokens verwendet, und die Passlib-Bibliothek wird für das Hashing und die Überprüfung von Passwörtern verwendet. Wir können diese Bibliotheken mit dem folgenden Befehl installieren:

pip install fastapi pyjwt passlib

2. Benutzermodell erstellen

Bevor wir mit der Implementierung der Authentifizierung und Autorisierung beginnen, müssen wir ein Benutzermodell definieren. Benutzermodelle enthalten normalerweise Felder wie Benutzername und Passwort. Das Folgende ist die Definition eines Beispielbenutzermodells:

from pydantic import BaseModel

class User(BaseModel):
    username: str
    password: str

3. Implementieren der Benutzerregistrierungs- und Anmeldeschnittstelle

Als nächstes müssen wir die Benutzerregistrierungs- und Anmeldeschnittstelle implementieren. In der Registrierungsoberfläche erhalten wir den Benutzernamen und das Passwort, hashen das Passwort und speichern es in der Datenbank. In der Anmeldeschnittstelle überprüfen wir, ob der vom Benutzer angegebene Benutzername und das Passwort mit denen in der Datenbank übereinstimmen. Das Folgende ist eine Beispielimplementierung:

from fastapi import FastAPI
from passlib.hash import bcrypt

app = FastAPI()

DATABASE = []

@app.post("/register")
def register_user(user: User):
    # Hash password
    hashed_password = bcrypt.hash(user.password)
    
    # Save user to database
    DATABASE.append({"username": user.username, "password": hashed_password})
    
    return {"message": "User registered successfully"}

@app.post("/login")
def login_user(user: User):
    # Find user in database
    for data in DATABASE:
        if data["username"] == user.username:
            # Check password
            if bcrypt.verify(user.password, data["password"]):
                return {"message": "User logged in successfully"}
    
    return {"message": "Invalid username or password"}

4. Authentifizierungs- und Autorisierungs-Middleware implementieren

Da wir nun die Benutzerregistrierungs- und Anmeldeschnittstelle implementiert haben, müssen wir als Nächstes die Authentifizierungs- und Autorisierungs-Middleware implementieren. Dadurch wird sichergestellt, dass Benutzer nur dann auf geschützte Routen zugreifen können, wenn ein gültiges Token bereitgestellt wird.

Hier ist eine Beispielimplementierung der Authentifizierungs- und Autorisierungs-Middleware:

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from passlib.hash import bcrypt
from jose import jwt, JWTError

app = FastAPI()

SECRET_KEY = "your-secret-key"

security = HTTPBearer()

@app.post("/register")
def register_user(user: User):
    # ...

@app.post("/login")
def login_user(user: User):
    # ...

def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
    try:
        token = credentials.credentials
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        user = payload.get("username")
        return user
    except JWTError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid token",
            headers={"WWW-Authenticate": "Bearer"},
        )

@app.get("/protected")
def protected_route(current_user: str = Depends(get_current_user)):
    return {"message": f"Hello, {current_user}"}

5. Generieren und Validieren von Tokens

Abschließend müssen wir eine Methode zum Generieren des Tokens implementieren. Ein Token ist ein Sicherheitsnachweis, der zur Authentifizierung und Autorisierung verwendet wird. Nachdem sich der Benutzer erfolgreich angemeldet hat, können wir mit dieser Methode ein Token generieren und es an den Client zurückgeben.

Hier ist eine Implementierung einer Beispielmethode zum Generieren und Überprüfen von Token:

from fastapi import FastAPI, Depends, HTTPException, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from passlib.hash import bcrypt
from jose import jwt, JWTError, ExpiredSignatureError
from datetime import datetime, timedelta

app = FastAPI()

SECRET_KEY = "your-secret-key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

security = HTTPBearer()

@app.post("/register")
def register_user(user: User):
    # ...

@app.post("/login")
def login_user(user: User):
    # ...

def get_current_user(credentials: HTTPAuthorizationCredentials = Depends(security)):
    try:
        token = credentials.credentials
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        user = payload.get("username")
        return user
    except JWTError:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid token",
            headers={"WWW-Authenticate": "Bearer"},
        )

def create_access_token(username: str):
    expires = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
    payload = {"username": username, "exp": expires}
    token = jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)
    return token

@app.get("/protected")
def protected_route(current_user: str = Depends(get_current_user)):
    return {"message": f"Hello, {current_user}"}

@app.post("/token")
def get_access_token(user: User):
    # Check username and password
    for data in DATABASE:
        if data["username"] == user.username:
            if bcrypt.verify(user.password, data["password"]):
                # Generate access token
                access_token = create_access_token(user.username)
                return {"access_token": access_token}
    
    raise HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Invalid username or password",
        headers={"WWW-Authenticate": "Bearer"},
    )

Zusammenfassend haben wir gesehen, wie Benutzerauthentifizierung und -autorisierung in FastAPI implementiert werden. Durch die Verwendung der PyJWT-Bibliothek und der Passlib-Bibliothek können wir Benutzeranmeldeinformationen sicher verarbeiten und die Sicherheit unserer Anwendung schützen. Diese Beispielcodes dienen als Ausgangspunkt, den Sie entsprechend Ihren Anforderungen weiter anpassen und erweitern können. Ich hoffe, dieser Artikel hilft Ihnen!

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Benutzerauthentifizierung und -autorisierung in FastAPI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!