Comment mettre en place l'authentification et l'autorisation avec FastAPI

L'implémentation d'une gestion de l'authentification et de l'autorisation dans une application web est une tâche incontournable pour assurer la sécurité des échanges. Dans ce contexte, FastAPI offre une méthode efficace pour gérer l'authentification via des tokens JWT (JSON Web Tokens). Ce processus repose sur plusieurs étapes clés : le hachage des mots de passe, la vérification de l'identité via des tokens, ainsi que la protection des routes sensibles. Examinons ces étapes en détail.

L'un des éléments essentiels de ce processus est la création de la classe AuthHandler, qui permet de gérer tous les aspects relatifs à l'authentification et à l'autorisation. La première étape consiste à importer les bibliothèques nécessaires : jwt pour la gestion des tokens, datetime pour manipuler les dates, et CryptContext de passlib pour le hachage des mots de passe. Une fois ces éléments en place, la classe AuthHandler est définie, et elle contient plusieurs méthodes permettant de sécuriser et de gérer les identifiants des utilisateurs.

La première fonction à implémenter est celle qui génère un mot de passe haché. Le hachage est crucial pour assurer que même si la base de données est compromise, les mots de passe des utilisateurs restent sécurisés. Avec la bibliothèque passlib, cela devient une tâche simple. La fonction get_password_hash prend un mot de passe en clair et renvoie sa version hachée à stocker dans la base de données.

La gestion des tokens JWT est ensuite introduite pour faciliter l'authentification sans nécessiter de session persistante sur le serveur. La méthode encode_token génère un token JWT qui contient trois informations principales : l'expiration du token (souvent réglée à 30 minutes pour limiter les risques), la date de création du token (iat pour "issued at"), et le payload (sub), qui contient des données spécifiques à l'utilisateur, comme son identifiant et son nom d'utilisateur. Le token ainsi créé est signé avec une clé secrète pour assurer son intégrité.

Cependant, la sécurité ne s'arrête pas à l'émission du token. La méthode decode_token permet de vérifier l'intégrité du token en le décodant. Si le token a expiré ou est invalide, des exceptions sont lancées, et l'accès est refusé.

Enfin, pour faciliter l'intégration de cette logique dans les routes protégées, une méthode auth_wrapper est définie. Cette méthode permet de récupérer le token JWT dans l'en-tête de la requête, puis de le décoder pour valider l'identité de l'utilisateur avant de lui accorder ou non l'accès à une ressource protégée.

Ces méthodes sont ensuite intégrées dans des routes spécifiques pour la gestion des utilisateurs, telles que l'enregistrement et la connexion. L'enregistrement d'un nouvel utilisateur consiste à vérifier si le nom d'utilisateur est déjà pris et à stocker son mot de passe haché dans une base de données (ici, un fichier JSON simulant une base de données). Lors de la connexion, un token JWT est généré pour l'utilisateur authentifié, et il peut être utilisé pour effectuer des requêtes protégées.

Compléments importants pour le lecteur

Au-delà des étapes techniques détaillées ci-dessus, il est crucial pour le lecteur de comprendre quelques principes fondamentaux de sécurité à appliquer lors de la gestion des utilisateurs et des sessions :

1. Gestion sécurisée de la clé secrète : La clé secrète utilisée pour signer les tokens JWT doit être stockée dans un endroit sûr, comme une variable d'environnement, et jamais dans le code source ou dans des fichiers de configuration partagés. Une gestion incorrecte de cette clé pourrait compromettre toute la sécurité du système.

2. Durée de vie des tokens : Il est essentiel de limiter la durée de validité des tokens. Un token expiré, bien que sécurisé, ne doit pas rester valide indéfiniment. En règle générale, les tokens ont une durée de vie courte, après quoi l'utilisateur doit se reconnecter ou obtenir un nouveau token via un processus de rafraîchissement.

3. Protection contre les attaques par force brute : Lorsque vous stockez des mots de passe hachés, veillez à utiliser des algorithmes de hachage robustes, comme bcrypt, qui sont conçus pour être lents et donc plus difficiles à attaquer par des méthodes de brute force. L'utilisation de passlib avec un tel algorithme garantit une meilleure protection.

4. Vérification des erreurs et gestion des exceptions : Lorsque vous manipulez des tokens, la gestion des erreurs et des exceptions est fondamentale. Les erreurs comme un token expiré ou invalide doivent être clairement identifiées pour éviter toute confusion pour l'utilisateur tout en garantissant que l'accès non autorisé est correctement empêché.

5. Stockage sécurisé des mots de passe : Ne jamais stocker des mots de passe en clair dans la base de données. Le hachage est une étape indispensable pour garantir la sécurité des informations sensibles des utilisateurs. De plus, le sel (salt) peut être ajouté pour renforcer la sécurité des mots de passe hachés.

Ces aspects sont souvent négligés dans les implémentations rapides, mais ils sont vitaux pour garantir la solidité de l'authentification et la protection des utilisateurs dans un environnement de production.

Comment connecter et configurer une application FastAPI avec MongoDB Atlas

Dans cette section, nous abordons les étapes essentielles de la création d'une application FastAPI fonctionnelle, en particulier en ce qui concerne l'intégration avec MongoDB Atlas. L'objectif est de fournir un cadre de travail solide pour la gestion de bases de données et la configuration sécurisée d'une application web.

Le processus commence par la définition des modèles nécessaires à la gestion des données. Prenons, par exemple, un modèle pour une collection de voitures. Avec les outils de modélisation de données tels que Pydantic, il devient facile de créer une structure de données bien définie, ce qui est indispensable pour assurer une bonne gestion de la base de données. Voici un exemple de modèle de données pour une voiture, comprenant plusieurs attributs comme la marque, le modèle, l'année de fabrication, la cylindrée, le kilométrage et le prix :

python
Copy code
from pydantic import BaseModel

from typing import List
class CarModel(BaseModel):
    brand: str
    make: str
    year: int
    cm3: int
    km: int
    price: int
class CarCollection(BaseModel):
    cars: List[CarModel]

Après avoir défini ces modèles, il est possible de tester leur bon fonctionnement. Par exemple, en créant une instance de la classe CarCollection avec deux voitures, puis en affichant le modèle de données, le résultat devrait ressembler à ceci :

python
Copy code
from models import CarCollection, CarModel
test_car_1 = CarModel(

    brand="Ford", make="Fiesta", year=2019, cm3=1500, km=120000, price=10000

)
test_car_2 = CarModel(
    brand="Fiat", make="Stilo", year=2003, cm3=1600, km=320000, price=3000
)
car_list = CarCollection(cars=[test_car_1, test_car_2])
print(car_list.model_dump())

Préparation de l'environnement et configuration de MongoDB Atlas

Une fois que les modèles de données sont créés et validés, la prochaine étape consiste à préparer l'environnement de développement. Une configuration sécurisée est essentielle, et pour cela, un fichier .env est utilisé pour stocker des informations sensibles telles que l'URL de connexion à la base de données MongoDB Atlas. Il est crucial de ne jamais commettre ce fichier dans le contrôle de version, d'où l'importance de configurer correctement un fichier .gitignore.

Voici un exemple d'entrée dans le fichier .env pour définir l'URL de la base de données :

ini
Copy code
DB_URL=mongodb+srv://<username>:<password>@cluster0.mongodb.net/?retryWrites=true&w=majority
DB_NAME=carBackend

Après avoir créé ce fichier, il est conseillé de configurer un fichier .gitignore pour empêcher que des informations sensibles soient suivies par Git. Il suffit d'ajouter les lignes suivantes :

bash
Copy code
__pycache__/

.env
venv/

Le fichier .gitignore assure que les fichiers relatifs à l'environnement de développement et aux dépendances ne soient pas partagés par erreur.

Scaffolding de l'application FastAPI

La création de l'application FastAPI commence par une structure minimale, incluant l'instanciation d'un objet FastAPI et la création d'une route racine pour vérifier que l'application fonctionne correctement. Dans un fichier app.py, le code suivant initialise une application FastAPI simple :

python
Copy code
from fastapi import FastAPI

app = FastAPI()
@app.get("/")
async def get_root():
    return {"Message": "Root working!"}

L'application peut être lancée avec la commande suivante :

nginx
Copy code
uvicorn app:app

Lorsque vous accédez à l'URL 127.0.0.1:8000, vous devriez voir un message confirmant que l'application fonctionne.

Connexion à MongoDB Atlas

L'intégration avec MongoDB Atlas se fait en utilisant le driver asynchrone motor_asyncio, qui permet de se connecter de manière efficace à la base de données sans bloquer l'exécution de l'application. Pour cela, le gestionnaire de contexte lifespan de FastAPI est utilisé. Ce mécanisme garantit que certaines actions (comme l'ouverture de la connexion à la base de données) ne se produisent qu'une seule fois au démarrage de l'application.

Voici un exemple de code qui configure la connexion à MongoDB via lifespan :

python
Copy code
from contextlib import asynccontextmanager

from fastapi import FastAPI
from motor import motor_asyncio
from config import BaseConfig
settings = BaseConfig()
@asynccontextmanager
async def lifespan(app: FastAPI):
    app.client = motor_asyncio.AsyncIOMotorClient(settings.DB_URL)
    app.db = app.client[settings.DB_NAME]
    try:
        app.client.admin.command("ping")
        print("Pinged your deployment. You have successfully connected to MongoDB!")
        print("Mongo address:", settings.DB_URL)
        yield
    finally:
        app.client.close()
app = FastAPI(lifespan=lifespan)
@app.get("/")
async def get_root():
    return {"Message": "Root working!"}

Le lifespan permet d'établir la connexion à la base de données au démarrage de l'application et de la fermer correctement à la fin de l'exécution. Ce modèle d'architecture garantit que la gestion des connexions à la base de données est optimisée et bien contrôlée.

Gestion des configurations avec Pydantic

Voici un exemple de configuration qui permet de charger l'URL de la base de données et le nom de la base à partir du fichier .env :

python
Copy code
from pydantic_settings import BaseSettings, SettingsConfigDict
from typing import Optional
class BaseConfig(BaseSettings):
    DB_URL: Optional[str]
    DB_NAME: Optional[str]
    model_config = SettingsConfigDict(env_file=".env", extra="ignore")

Cette configuration est facile à utiliser et permet de modifier les paramètres de l'application sans avoir à changer le code source.

Comment créer un backend efficace avec FastAPI et Beanie pour la gestion de données complexes

L'un des principaux avantages de l'utilisation de FastAPI et Beanie réside dans leur capacité à simplifier la gestion des bases de données et l'interaction avec des services externes, tout en offrant une flexibilité impressionnante dans le développement d'API modernes. La gestion d'instances de données dans des bases de données NoSQL, comme MongoDB, devient particulièrement fluide avec Beanie, qui est un ORM (Object-Relational Mapping) asynchrone pour MongoDB. Cela permet de créer, de récupérer, de mettre à jour et de supprimer des documents sans la complexité d'autres frameworks plus lourds.

Un exemple concret est la récupération d'une instance spécifique d'une voiture par son identifiant dans la base de données. Utiliser la méthode get() de Beanie permet d'effectuer cette tâche de manière concise et élégante. Si la voiture demandée n'est pas trouvée, une exception HTTP est levée, signalant ainsi un code d’erreur adapté.

L'implémentation d’une méthode de mise à jour de document suit une logique similaire à celle utilisée dans les applications traditionnelles. Lorsque des informations d’une voiture doivent être mises à jour, il est possible de ne modifier que les champs qui ont été explicitement définis dans la requête. Cela permet de garder intactes les autres propriétés de l'objet. Utiliser le .model_dump() de Pydantic pour vérifier les champs renseignés dans la requête assure que seules les données pertinentes soient mises à jour, ce qui optimise la gestion des données dans la base.

Enfin, l'implémentation d'une méthode de suppression est extrêmement simple. En récupérant d'abord l’objet correspondant à l'ID spécifié, il suffit de déclencher la méthode .delete() pour supprimer le document de la base de données. Cette approche minimaliste garantit que les ressources sont supprimées efficacement sans nécessiter de logique complexe.

Un exemple simple d’utilisation de la classe BackgroundTasks est l’envoi d’une notification après la connexion d’un utilisateur. Une tâche peut être lancée en arrière-plan pour exécuter une action après que la réponse ait été renvoyée à l'utilisateur. Cela permet de maintenir l’application réactive tout en gérant des tâches supplémentaires sans ralentir l'expérience utilisateur. L’intégration de telles tâches dans le backend peut être réalisée de manière simple, en utilisant des méthodes comme sleep pour simuler un retard avant d’effectuer l’action, mais dans des cas réels, cela pourrait concerner des appels à des services externes ou la gestion d'événements complexes.

Il est également important de souligner que l'architecture d'une application comme celle-ci ne se limite pas à la gestion d'une seule ressource, mais à l'intégration de plusieurs services et fonctionnalités qui travaillent ensemble de manière transparente. L'utilisation de routers pour séparer les responsabilités des différentes parties de l'application (par exemple, voitures et utilisateurs) est cruciale pour maintenir une bonne organisation du code et assurer une évolutivité à long terme. L'intégration de ces routers dans l'application FastAPI, via des imports et l'inclusion dans les routes, crée une structure propre et extensible.

En résumé, la création d'une API backend avec FastAPI et Beanie est non seulement rapide mais également efficace, grâce à l'asynchronicité native de FastAPI et à l'ORM Beanie pour MongoDB. Cela permet de traiter des données complexes, d'intégrer des services tiers et d’exécuter des tâches en arrière-plan tout en offrant une expérience utilisateur optimale. La clé de ce processus réside dans la simplicité et la flexibilité, permettant ainsi aux développeurs de créer des systèmes robustes et modulables avec peu de code.