Comment implémenter l'authentification et l'autorisation des utilisateurs dans FastAPI-Tutoriel Python-php.cn

Comment implémenter l'authentification et l'autorisation des utilisateurs dans FastAPI

WBOY

Libérer： 2023-07-28 21:44:05

original

4239 Les gens l'ont consulté

Comment implémenter l'authentification et l'autorisation des utilisateurs dans FastAPI

FastAPI est un framework Web hautes performances basé sur Python qui fournit de nombreuses fonctionnalités puissantes telles que la prise en charge asynchrone, la génération automatique de documents et les astuces de type. Dans les applications Web modernes, l'authentification et l'autorisation des utilisateurs sont des fonctions très importantes qui peuvent protéger la sécurité de l'application. Dans cet article, nous explorerons comment implémenter l'authentification et l'autorisation des utilisateurs dans FastAPI.

Installer les bibliothèques requises

Avant de commencer, nous devons d'abord installer les bibliothèques requises. Dans FastAPI, la bibliothèque PyJWT est généralement utilisée pour gérer les jetons Web JSON, et la bibliothèque Passlib est utilisée pour le hachage et la vérification des mots de passe. Nous pouvons installer ces bibliothèques à l'aide de la commande suivante :

pip install fastapi pyjwt passlib

Copier après la connexion

Créer un modèle utilisateur

Avant de commencer à implémenter l'authentification et l'autorisation, nous devons définir un modèle utilisateur. Les modèles utilisateur contiennent généralement des champs tels que le nom d'utilisateur et le mot de passe. Voici la définition d'un exemple de modèle d'utilisateur :

from pydantic import BaseModel

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

Copier après la connexion

Implémentation de l'interface d'enregistrement et de connexion des utilisateurs

Ensuite, nous devons implémenter l'interface d'enregistrement et de connexion des utilisateurs. Dans l'interface d'inscription, nous obtiendrons le nom d'utilisateur et le mot de passe, hacherons le mot de passe et l'enregistrerons dans la base de données. Dans l'interface de connexion, nous vérifierons que le nom d'utilisateur et le mot de passe fournis par l'utilisateur correspondent à ceux de la base de données. Voici un exemple d'implémentation :

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"}

Copier après la connexion

Implémentation du middleware d'authentification et d'autorisation

Maintenant que nous avons implémenté l'interface d'enregistrement et de connexion des utilisateurs, nous devons ensuite implémenter le middleware d'authentification et d'autorisation. Cela garantira que les utilisateurs ne pourront accéder aux itinéraires protégés que si un jeton valide est fourni.

Voici un exemple d'implémentation du middleware d'authentification et d'autorisation :

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}"}

Copier après la connexion

Génération et validation des jetons

Enfin, nous devons implémenter une méthode pour générer le jeton. Un jeton est un identifiant de sécurité utilisé pour l'authentification et l'autorisation. Une fois que l'utilisateur s'est connecté avec succès, nous pouvons utiliser cette méthode pour générer un jeton et le renvoyer au client.

Voici un exemple d'implémentation d'un exemple de méthode pour générer et vérifier des jetons :

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"},
    )

Copier après la connexion

Pour résumer, nous avons vu comment implémenter l'authentification et l'autorisation des utilisateurs dans FastAPI. En utilisant la bibliothèque PyJWT et la bibliothèque Passlib, nous sommes en mesure de gérer en toute sécurité les informations d'identification des utilisateurs et de protéger la sécurité de notre application. Ces exemples de codes servent de point de départ que vous pouvez personnaliser et étendre davantage en fonction de vos besoins. J'espère que cet article vous aidera !

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!