So verwenden Sie das JWT-Token zur Authentifizierung und Autorisierung in FastAPI

So verwenden Sie JWT-Tokens zur Authentifizierung und Autorisierung in FastAPI

Einführung:
Mit der Entwicklung von Webanwendungen sind Benutzerauthentifizierung und -autorisierung zu einem wichtigen Bestandteil geworden. Authentifizierungs- und Autorisierungsfunktionen können mithilfe von JWT-Tokens (JSON Web Token) einfach implementiert werden. FastAPI ist ein modernes Python-basiertes Webframework, das einfache und benutzerfreundliche Funktionen für die Authentifizierung und Autorisierung bietet. In diesem Artikel wird erläutert, wie Sie JWT-Tokens zur Authentifizierung und Autorisierung in FastAPI verwenden.

1. Abhängige Bibliotheken installieren
   Zuerst müssen wir einige abhängige Bibliotheken installieren, darunter FastAPI, PyJWT und Passlib. Es kann mit dem pip-Befehl installiert werden:

pip install fastapi
pip install pyjwt
pip install passlib

2. Geheimen Schlüssel generieren
   Wir müssen einen geheimen Schlüssel zum Signieren und Überprüfen von JWT-Token generieren. Der geheime Schlüssel kann mit dem folgenden Code generiert werden:

import secrets

secret_key = secrets.token_urlsafe(32)

3. Benutzermodell erstellen
   In FastAPI müssen wir ein Benutzermodell definieren, um die Benutzer in der Anwendung darzustellen. Das Benutzermodell kann mit dem folgenden Code erstellt werden:

from pydantic import BaseModel

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

4. Routing- und Handling-Funktionen erstellen
   Als nächstes müssen wir Routing- und Handling-Funktionen erstellen, um die Authentifizierungs- und Autorisierungsanfragen des Benutzers zu bearbeiten. Routing- und Handling-Funktionen können mit dem folgenden Code erstellt werden:

from fastapi import FastAPI, HTTPException
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from passlib.context import CryptContext
from datetime import datetime, timedelta
import jwt

app = FastAPI()

pwd_context = CryptContext(schemes=["bcrypt"])
security = HTTPBearer()

# 模拟数据库中的用户
users_db = {
    "admin": {
        "username": "admin",
        "password": pwd_context.hash("admin123")
    }
}

@app.post("/login")
def login(user: User):
    if user.username not in users_db:
        raise HTTPException(status_code=401, detail="Invalid username")
    
    stored_user = users_db[user.username]
    if not pwd_context.verify(user.password, stored_user["password"]):
        raise HTTPException(status_code=401, detail="Invalid password")
    
    token = generate_token(user.username)
    return {"access_token": token}

def generate_token(username: str) -> str:
    expiration = datetime.utcnow() + timedelta(minutes=30)
    payload = {"username": username, "exp": expiration}
    return jwt.encode(payload, secret_key, algorithm="HS256")

@app.get("/users/me")
def get_user_profile(credentials: HTTPAuthorizationCredentials = security):
    token = credentials.credentials
    try:
        payload = jwt.decode(token, secret_key, algorithms=["HS256"])
        username = payload["username"]
        if username not in users_db:
            raise HTTPException(status_code=401, detail="Invalid username")
        
        return {"username": username}
    except jwt.DecodeError:
        raise HTTPException(status_code=401, detail="Invalid token")

5. Testen der Funktion
   Jetzt können wir Postman oder andere HTTP-Client-Tools verwenden, um unsere Funktionalität zu testen. Zuerst müssen wir eine Anmeldeanfrage per POST-Anfrage senden und den Benutzernamen und das Passwort in den Anfragetext aufnehmen. Wie unten gezeigt:

Anfrage-URL: http://localhost:8000/login
Anfragetext:

{
    "username": "admin",
    "password": "admin123"
}

Nach erfolgreicher Anmeldung erhalten wir eine Antwort mit dem Zugriffstoken. Zum Beispiel:

{
    "access_token": "xxxxxxxxxxxxx"
}

Anschließend können wir mithilfe einer GET-Anfrage eine Anfrage senden, um das Benutzerprofil abzurufen, und dabei das Zugriffstoken als Bearer-Token im Authorization-Header senden. Wie unten gezeigt:

Anfrage-URL: http://localhost:8000/users/me
Anfrage-Header: Autorisierung: Bearer xxxxxxxxxxxxx

Wenn die Token-Überprüfung erfolgreich ist, gibt die Antwort ein JSON-Objekt zurück, das den Benutzernamen enthält. Zum Beispiel:

{
    "username": "admin"
}

Fazit:
In diesem Artikel wird erläutert, wie JWT-Tokens für die Authentifizierung und Autorisierung in FastAPI verwendet werden. Mithilfe der PyJWT-Bibliothek haben wir das JWT-Token generiert und die Passlib-Bibliothek zur Passwort-Hash-Überprüfung verwendet. Mit diesem Ansatz können wir Benutzerauthentifizierungs- und Autorisierungsfunktionen einfach implementieren, um unsere Webanwendung zu sichern.

Das obige ist der detaillierte Inhalt vonSo verwenden Sie das JWT-Token zur Authentifizierung und Autorisierung in FastAPI. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!