Python Academy · Leçon

Injection de dépendances et authentification

Utilisez le système DI de FastAPI pour la logique partagée et l’authentification basée sur JWT.

Injection de dépendances et authentification est une leçon Python Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Python Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Python Academy comprend 4 leçons au total.

Qu’est-ce que l’injection de dépendances ?

Depends() de FastAPI vous permet de déclarer une logique partagée (sessions de base de données, vérifications d’authentification, configuration) qui est automatiquement injectée dans les gestionnaires de routes.

from fastapi import FastAPI, Depends
app = FastAPI()

def get_db():
    db = connect_db()
    try: yield db
    finally: db.close()

@app.get("/users")
def list_users(db = Depends(get_db)):
    return db.query_all("users")

Fonctions de dépendance

Une dépendance peut être n’importe quel élément appelable. Il peut s’agir d’une fonction, d’une classe ou d’une autre fonction utilisant une dépendance.

from fastapi import Depends, FastAPI
app = FastAPI()

def common_params(skip: int = 0, limit: int = 10):
    return {"skip": skip, "limit": limit}

@app.get("/items")
def list_items(params: dict = Depends(common_params)):
    return params

@app.get("/users")
def list_users(params: dict = Depends(common_params)):
    return params

Dépendances basées sur des classes

Utilisez une classe comme dépendance pour regrouper des paramètres associés. La classe est appelée avec les arguments de son __init__ injectés.

from fastapi import Depends, FastAPI, Query
app = FastAPI()

class Pagination:
    def __init__(self, page: int = Query(1,ge=1), size: int = Query(10,ge=1,le=100)):
        self.page = page
        self.size = size
        self.offset = (page - 1) * size

@app.get("/items")
def list_items(pag: Pagination = Depends()):
    return {"offset": pag.offset, "size": pag.size}

Bearer OAuth2 avec mot de passe

Utilisez OAuth2PasswordBearer pour lire un jeton Bearer dans l’en-tête Authorization.

from fastapi import FastAPI, Depends
from fastapi.security import OAuth2PasswordBearer
app = FastAPI()

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

@app.get("/me")
def me(token: str = Depends(oauth2)):
    return {"token": token}   # validate token here

Jetons JWT

Créez et vérifiez des jetons JWT avec python-jose (ou pyjwt). Renvoyez un jeton lors de la connexion, puis vérifiez-le dans chaque route protégée.

# pip install python-jose passlib
from jose import jwt, JWTError

SECRET_KEY = "change-me"
ALGORITHM = "HS256"

def create_token(data: dict) -> str:
    return jwt.encode(data, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(token: str) -> dict:
    return jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])

Dépendance de l’utilisateur actuel

Créez une dépendance get_current_user qui vérifie le JWT et renvoie l’utilisateur authentifié.

from fastapi import Depends, HTTPException
from fastapi.security import OAuth2PasswordBearer
from jose import jwt, JWTError

oauth2 = OAuth2PasswordBearer(tokenUrl="/token")

def get_current_user(token: str = Depends(oauth2)):
    try:
        payload = jwt.decode(token, SECRET_KEY, algorithms=["HS256"])
        return payload["sub"]
    except JWTError:
        raise HTTPException(status_code=401, detail="Invalid token")

# @app.get("/me")
# def me(user=Depends(get_current_user)): return user

Hachage des mots de passe

Ne stockez jamais les mots de passe en clair. Utilisez passlib pour les hacher avec bcrypt.

from passlib.context import CryptContext

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

def hash_pw(plain: str) -> str:
    return pwd_ctx.hash(plain)

def verify_pw(plain: str, hashed: str) -> bool:
    return pwd_ctx.verify(plain, hashed)

Point de terminaison du jeton

Implémentez POST /token pour accepter des identifiants de formulaire, vérifier le mot de passe et renvoyer un JWT.

from fastapi import FastAPI, Depends, HTTPException
from fastapi.security import OAuth2PasswordRequestForm
app = FastAPI()

@app.post("/token")
def login(form: OAuth2PasswordRequestForm = Depends()):
    user = get_user_by_username(form.username)
    if not user or not verify_pw(form.password, user.hashed_pw):
        raise HTTPException(status_code=401, detail="Bad credentials")
    token = create_token({"sub": form.username})
    return {"access_token": token, "token_type": "bearer"}

Authentification par clé API

Dans les cas plus simples, validez une clé API provenant d’un en-tête ou d’un paramètre de requête.

from fastapi import Depends, HTTPException, Security
from fastapi.security import APIKeyHeader

API_KEY_HEADER = APIKeyHeader(name="X-API-Key")

def require_api_key(key: str = Security(API_KEY_HEADER)):
    if key != "secret-key":
        raise HTTPException(status_code=403, detail="Forbidden")
    return key

Contrôle d’accès basé sur les rôles

Ajoutez une couche de permissions à l’authentification en ajoutant des vérifications de rôle aux dépendances.

from fastapi import Depends, HTTPException

def require_admin(user=Depends(get_current_user)):
    if user.get("role") != "admin":
        raise HTTPException(status_code=403, detail="Admins only")
    return user

# @app.delete("/users/{uid}")
# def delete_user(uid: int, admin=Depends(require_admin)):

Mise en cache des dépendances

Par défaut, une dépendance est appelée une fois par requête et son résultat est partagé entre toutes les routes qui l’utilisent dans cette requête.

# The same db session object is shared:
@app.get("/summary")
def summary(
    db = Depends(get_db),      # db resolved once
    stats = Depends(get_stats) # get_stats also uses get_db — same db instance
): ...

Vérification rapide

Que fait Depends() dans FastAPI ?

Récapitulatif

Utilisez Depends(func) pour injecter une logique partagée. Mettez en place l'authentification avec OAuth2PasswordBearer, des jetons JWT et une dépendance get_current_user. Hachez les mots de passe avec passlib/bcrypt. Ajoutez les contrôles de rôle sous forme de dépendances supplémentaires.

Questions Fréquemment Posées

La leçon « Injection de dépendances et authentification » est-elle gratuite ?

Oui — le texte complet de « Injection de dépendances et authentification » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Python Academy, passe à CoddyKit PRO. Le cours Python Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Injection de dépendances et authentification » ?

Utilisez le système DI de FastAPI pour la logique partagée et l’authentification basée sur JWT. Tu pratiques Python Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Python Academy ?

Aucune expérience préalable n'est requise. Python Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Injection de dépendances et authentification » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Python Academy ?

Oui. Chaque leçon Python Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Configuration d’un projet FastAPI et premier endpoint
Paramètres de chemin, paramètres de requête et corps des requêtes
Injection de dépendances et authentification
Endpoints asynchrones et intégration à une base de données

← Retour à Python Academy