Comment utiliser le jeton JWT pour l'authentification et l'autorisation dans FastAPI

Comment utiliser les jetons JWT pour l'authentification et l'autorisation dans FastAPI

Introduction :
Avec le développement d'applications Web, l'authentification et l'autorisation des utilisateurs sont devenues un élément essentiel. Les fonctions d'authentification et d'autorisation peuvent être facilement mises en œuvre à l'aide de jetons JWT (JSON Web Token). FastAPI est un framework Web moderne basé sur Python qui fournit des fonctionnalités simples et faciles à utiliser pour gérer l'authentification et l'autorisation. Cet article explique comment utiliser les jetons JWT pour l'authentification et l'autorisation dans FastAPI.

1. Installer les bibliothèques dépendantes
   Tout d'abord, nous devons installer certaines bibliothèques dépendantes, notamment FastAPI, PyJWT et Passlib. Il peut être installé à l'aide de la commande pip :

pip install fastapi
pip install pyjwt
pip install passlib

2. Générer une clé secrète
   Nous devons générer une clé secrète pour signer et vérifier les jetons JWT. La clé secrète peut être générée à l'aide du code suivant :

import secrets

secret_key = secrets.token_urlsafe(32)

3. Créer un modèle utilisateur
   Dans FastAPI, nous devons définir un modèle utilisateur pour représenter les utilisateurs dans l'application. Le modèle utilisateur peut être créé à l'aide du code suivant :

from pydantic import BaseModel

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

4. Créer des fonctions de routage et de gestion
   Ensuite, nous devons créer des fonctions de routage et de gestion pour gérer les demandes d'authentification et d'autorisation de l'utilisateur. Les fonctions de routage et de gestion peuvent être créées à l'aide du code suivant :

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. Test de la fonctionnalité
   Nous pouvons maintenant utiliser Postman ou d'autres outils clients HTTP pour tester notre fonctionnalité. Tout d’abord, nous devons envoyer une demande de connexion à l’aide d’une requête POST et inclure le nom d’utilisateur et le mot de passe dans le corps de la requête. Comme indiqué ci-dessous :

URL de la demande : http://localhost:8000/login
Corps de la demande :

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

Après une connexion réussie, nous recevrons une réponse contenant le jeton d'accès. Par exemple :

{
    "access_token": "xxxxxxxxxxxxx"
}

Nous pouvons ensuite envoyer une requête pour obtenir le profil utilisateur à l'aide d'une requête GET, en envoyant le jeton d'accès en tant que jeton Bearer dans l'en-tête Authorization. Comme indiqué ci-dessous :

URL de demande : http://localhost:8000/users/me
En-tête de demande : Autorisation : Bearer xxxxxxxxxxxxx

Si la vérification du jeton réussit, la réponse renverra un objet JSON contenant le nom d'utilisateur. Par exemple :

{
    "username": "admin"
}

Conclusion :
Cet article explique comment utiliser les jetons JWT pour l'authentification et l'autorisation dans FastAPI. En utilisant la bibliothèque PyJWT, nous avons généré le jeton JWT et utilisé la bibliothèque Passlib pour la vérification du hachage du mot de passe. Grâce à cette approche, nous pouvons facilement implémenter des fonctionnalités d’authentification et d’autorisation des utilisateurs pour sécuriser notre application Web.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!