Déverrouiller la puissance de l'authentification FastAPI : Sécurisez vos API avec facilité

Que vous soyez un développeur chevronné ou débutant, il est essentiel de garantir la sécurité de vos API. FastAPI, un framework web moderne et rapide (haute performance) pour la création d'API avec Python 3.7+, offre une excellente solution. Aujourd'hui, nous allons plonger dans les tenants et les aboutissants de l'authentification FastAPI, explorer comment la mettre en œuvre et pourquoi elle change la donne pour vos projets. De plus, nous aborderons comment des outils comme Apidog peuvent vous faciliter la vie.

button

Pourquoi FastAPI pour vos API ?

Avant de plonger dans les détails de l'authentification, parlons des raisons pour lesquelles vous pourriez choisir FastAPI en premier lieu. FastAPI est conçu pour être rapide et simple, ce qui vous permet de créer et de déployer rapidement des API hautes performances. Il est basé sur Starlette pour les parties web et Pydantic pour les parties données, ce qui signifie que vous bénéficiez à la fois de la vitesse et de la fiabilité.

FastAPI framework, high performance, easy to learn, fast to code, ready for production

Principaux avantages de FastAPI

Performance : FastAPI est l'un des frameworks Python les plus rapides disponibles.
Facilité d'utilisation : Sa syntaxe est intuitive et simple, ce qui la rend accessible même aux débutants.
Documentation API interactive automatique : FastAPI génère automatiquement une documentation API interactive avec Swagger UI et ReDoc.
Sécurité des types : En tirant parti des indications de type Python, FastAPI garantit un code robuste et sans erreur.

L'importance de l'authentification

Lors de la création d'API, il est essentiel de les sécuriser avec des mécanismes d'authentification pour protéger les données sensibles et garantir que seuls les utilisateurs autorisés peuvent accéder à certains points de terminaison. L'authentification permet de vérifier l'identité des utilisateurs ou des systèmes qui interagissent avec votre API, offrant ainsi une couche de sécurité et de confiance.

Types d'authentification

FastAPI prend en charge plusieurs types d'authentification, notamment :

Authentification de base : Une méthode simple utilisant un nom d'utilisateur et un mot de passe.
OAuth2 : Une méthode plus sûre et plus flexible, souvent utilisée pour l'authentification tierce.
JWT (JSON Web Tokens) : Un moyen compact et autonome de transmettre des informations en toute sécurité.

Configuration de l'authentification FastAPI

Maintenant, entrons au cœur du sujet : la configuration de l'authentification dans FastAPI. Nous allons couvrir une implémentation de base d'OAuth2 avec mot de passe (et hachage), l'une des méthodes les plus courantes et les plus sûres pour gérer l'authentification.

Étape 1 : Installer FastAPI et les dépendances

Tout d'abord, assurez-vous que vous avez installé FastAPI et les dépendances nécessaires. Vous pouvez le faire en utilisant pip :

pip install fastapi[all] uvicorn

Le [all] installe toutes les dépendances nécessaires à l'authentification, y compris pydantic et python-jose pour JWT.

Étape 2 : Créer une application FastAPI de base

Commençons par une simple application FastAPI. Créez un fichier nommé main.py :

from fastapi import FastAPI

app = FastAPI()

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

Vous pouvez exécuter cette application en utilisant Uvicorn :

uvicorn main:app --reload

Étape 3 : Implémentation d'OAuth2 avec mot de passe

OAuth2 est un framework d'autorisation largement utilisé qui fournit des flux d'autorisation spécifiques pour différents types d'applications. Nous utiliserons OAuth2 avec mot de passe (et hachage) pour gérer l'authentification.

Création de modèles d'utilisateur

Tout d'abord, définissez vos modèles d'utilisateur. Créez un fichier nommé models.py :

from pydantic import BaseModel

class User(BaseModel):
    username: str
    email: str
    full_name: str
    disabled: bool = False

class UserInDB(User):
    hashed_password: str

Utilitaire de hachage de mot de passe

Ensuite, vous aurez besoin d'un utilitaire pour hacher et vérifier les mots de passe. Créez un fichier nommé security.py :

from passlib.context import CryptContext

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

def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

def get_password_hash(password):
    return pwd_context.hash(password)

Flux de mot de passe OAuth2

Maintenant, configurez le flux de mot de passe OAuth2. Mettez à jour votre main.py pour inclure ce qui suit :

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
from jose import JWTError, jwt
from pydantic import BaseModel
from typing import Optional
import time

# Secret key to encode JWT
SECRET_KEY = "your_secret_key"
ALGORITHM = "HS256"
ACCESS_TOKEN_EXPIRE_MINUTES = 30

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

# User database simulation
fake_users_db = {
    "johndoe": {
        "username": "johndoe",
        "full_name": "John Doe",
        "email": "johndoe@example.com",
        "hashed_password": "$2b$12$...",
        "disabled": False,
    }
}

class Token(BaseModel):
    access_token: str
    token_type: str

class TokenData(BaseModel):
    username: Optional[str] = None

def authenticate_user(fake_db, username: str, password: str):
    user = fake_db.get(username)
    if not user:
        return False
    if not verify_password(password, user["hashed_password"]):
        return False
    return user

def create_access_token(data: dict, expires_delta: Optional[int] = None):
    to_encode = data.copy()
    if expires_delta:
        expire = time.time() + expires_delta
    else:
        expire = time.time() + ACCESS_TOKEN_EXPIRE_MINUTES * 60
    to_encode.update({"exp": expire})
    encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
    return encoded_jwt

@app.post("/token", response_model=Token)
async def login_for_access_token(form_data: OAuth2PasswordRequestForm = Depends()):
    user = authenticate_user(fake_users_db, form_data.username, form_data.password)
    if not user:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Incorrect username or password",
            headers={"WWW-Authenticate": "Bearer"},
        )
    access_token = create_access_token(data={"sub": user["username"]})
    return {"access_token": access_token, "token_type": "bearer"}

@app.get("/users/me", response_model=User)
async def read_users_me(token: str = Depends(oauth2_scheme)):
    credentials_exception = HTTPException(
        status_code=status.HTTP_401_UNAUTHORIZED,
        detail="Could not validate credentials",
        headers={"WWW-Authenticate": "Bearer"},
    )
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
        username: str = payload.get("sub")
        if username is None:
            raise credentials_exception
        token_data = TokenData(username=username)
    except JWTError:
        raise credentials_exception
    user = fake_users_db.get(username, None)
    if user is None:
        raise credentials_exception
    return user

Ce code configure un simple flux de mot de passe OAuth2. Les utilisateurs peuvent obtenir un jeton en fournissant leur nom d'utilisateur et leur mot de passe au point de terminaison /token, et ils peuvent utiliser ce jeton pour s'authentifier sur des points de terminaison protégés comme /users/me.

Étape 4 : Tester votre authentification

Pour tester votre authentification, vous pouvez utiliser un outil de test d'API comme Postman ou Apidog. Voici comment vous pouvez le faire avec Apidog :

Créer une nouvelle requête : Ouvrez Apidog et créez une nouvelle requête.

Améliorer votre authentification FastAPI avec Apidog

Bien que FastAPI facilite la configuration de l'authentification, des outils comme Apidog peuvent en outre rationaliser le processus en fournissant une plateforme pour concevoir, documenter et tester vos API. Apidog offre une interface conviviale pour gérer vos points de terminaison API, simuler des réponses et collaborer avec votre équipe.

Avantages de l'utilisation d'Apidog

Gestion complète des API : Concevez, testez et documentez vos API en un seul endroit.
Collaboration : Travaillez avec votre équipe en temps réel, partagez des points de terminaison et examinez les modifications.
Réponses simulées : Simulez les réponses de l'API pour les tests sans atteindre les points de terminaison réels.

Conclusion

FastAPI simplifie le processus de création et de sécurisation des API, ce qui en fait un choix de premier plan pour les développeurs à la recherche de performances et de facilité d'utilisation. En mettant en œuvre l'authentification avec FastAPI, vous vous assurez que vos API sont sécurisées et accessibles uniquement aux utilisateurs autorisés. De plus, l'utilisation d'outils comme Apidog peut améliorer votre expérience de développement d'API en fournissant des capacités de gestion et de test robustes.

Maintenant que vous savez comment implémenter l'authentification FastAPI, vous pouvez sécuriser vos API en toute confiance et protéger vos données. Bon codage !

button