Comment implémenter l'authentification et l'autorisation des requêtes dans FastAPI

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

Avec le développement d'Internet, les problèmes de sécurité des réseaux ont attiré de plus en plus d'attention. Lors du développement d'applications Web, l'authentification et l'autorisation des demandes sont des aspects importants pour garantir la sécurité des applications. Cet article expliquera comment implémenter l'authentification et l'autorisation des demandes dans le framework FastAPI.

FastAPI est un framework Web hautes performances basé sur Python qui fournit un moyen simple et puissant de créer des API Web. Il intègre la bibliothèque Pydantic et le framework Starlette, rendant le processus de développement plus facile et plus efficace.

1. Installer les dépendances

Tout d'abord, nous devons installer FastAPI et les dépendances correspondantes. Il peut être installé avec la commande suivante :

$ pip install fastapi
$ pip install uvicorn

2. Créer une application de base

Ensuite, nous créons une application FastAPI simple et ajoutons quelques routes et points de terminaison de base. Dans cet exemple, nous allons créer un fichier appelé "app.py" et y copier le code suivant :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"Hello": "World"}

3. Ajouter une authentification et une autorisation

Ensuite, nous expliquerons comment utiliser la fonctionnalité de sécurité de FastAPI pour implémenter l'authentification des demandes et autorisation. Nous utiliserons OAuth2.0 comme mécanisme d'authentification et d'autorisation.

Tout d'abord, nous devons importer les modules et classes pertinents :

from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from passlib.context import CryptContext

Ensuite, nous créons un contexte de cryptage de mot de passe :

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

Ensuite, nous définissons un modèle utilisateur pour authentifier l'utilisateur :

class User:
    def __init__(self, username: str, password: str, disabled: bool = False):
        self.username = username
        self.password = pwd_context.hash(password)
        self.disabled = disabled

    def verify_password(self, password: str):
        return pwd_context.verify(password, self.password)

    def get_user(self, username: str):
        if self.username == username:
            return self

Ensuite, nous créons un mannequin base de données et ajoutons quelques informations utilisateur, à des fins de tests :

fake_db = [
    User(username="user1", password="password"),
    User(username="user2", password="password", disabled=True)
]

Ensuite, nous définissons une fonction pour vérifier les informations d'identification de l'utilisateur :

def authenticate_user(username: str, password: str):
    user = get_user(username)
    if not user:
        return False
    if not user.verify_password(password):
        return False
    return user

Ensuite, nous définissons une fonction pour obtenir l'utilisateur actuel :

def get_current_user(token: str = Depends(oauth2_scheme)):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    user = authenticate_user(token)
    if not user:
        raise credentials_exception
    return user

Enfin, nous appliquons ces fonctions à notre application FastAPI :

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="/token")

@app.post("/token")
async def login(form_data: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(form_data.username, form_data.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    return {"access_token": str(user.username), "token_type": "bearer"}

@app.get("/items/")
async def read_items(current_user: User = Depends(get_current_user)):
    return {"items": [{"item_id": "Item 1"}, {"item_id": "Item 2"}]}

4. Test de l'application

Maintenant, nous pouvons exécuter l'application et la tester. Démarrez l'application en exécutant la commande suivante :

$ uvicorn app:app --reload

Ensuite, nous pouvons utiliser curl ou n'importe quel outil client HTTP pour tester l'application. Tout d'abord, nous devons obtenir le jeton d'accès :

$ curl --request POST --url http://localhost:8000/token --header 'Content-Type: application/x-www-form-urlencoded' --data 'username=user1&password=password'

La réponse que nous recevons devrait ressembler à :

{"access_token":"user1","token_type":"bearer"}

Nous pouvons ensuite utiliser le jeton d'accès que nous avons obtenu pour accéder au point de terminaison restreint :

$ curl --request GET --url http://localhost:8000/items/ --header 'Authorization: Bearer user1'

Nous devrions obtenir une réponse comme celle-ci :

{"items":[{"item_id":"Item 1"},{"item_id":"Item 2"}]}

Nous avons donc implémenté avec succès l'authentification et l'autorisation des demandes dans l'application FastAPI.

Résumé :

Cet article décrit comment implémenter l'authentification et l'autorisation des demandes dans le framework FastAPI. Nous utilisons les fonctionnalités de sécurité de FastAPI et effectuons l'authentification et l'autorisation via le mécanisme OAuth2.0. En important des modules et des classes pertinents, en créant un contexte de cryptage de mot de passe, en définissant des modèles d'utilisateur et des fonctions de vérification, la fonction d'authentification demandée est implémentée. Enfin, nous avons appliqué ces fonctions à l'application FastAPI et les avons testées. Avec ces étapes, nous pouvons créer une application Web sécurisée et fiable.

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!