Comment créer une API REST avec FastAPI et MongoDB

La création d’une API REST est souvent une tâche mécanique, impliquant beaucoup de conception passe-partout et de programmation par cœur. Heureusement, des outils comme FastAPI peuvent vous soulager de ces détails fastidieux.

En utilisant FastAPI, vous pouvez rapidement construire une API REST efficace et complète pour votre application CRUD. Avec MongoDB comme source de données, ce tutoriel vous guidera vers la mise en place de votre propre API en un rien de temps.

Qu’est-ce que FastAPI ?

FastAPI est un framework web Python rapide et open-source pour la construction d’APIs. Il fournit un support intégré pour les requêtes asynchrones, la validation automatique des données et la documentation automatique des points de terminaison des API.

Les avantages de FastAPI par rapport aux autres frameworks Python

• FastAPI est relativement plus rapide que d’autres frameworks comme Django et Flask. Cela s’explique par le fait que FastAPI s’appuie sur asyncio, une bibliothèque d’E/S asynchrone pour Python qui peut traiter les requêtes simultanées plus rapidement.
• FastAPI fournit un moyen propre et simple de construire des API avec un minimum d’effort puisqu’il nécessite moins de code que Flask ou Django.
• Enfin, FastAPI permet de générer facilement de la documentation pour les points de terminaison. Il utilise Swagger pour produire une documentation que vous pouvez utiliser pour tester les points de terminaison en exécutant des requêtes et en visualisant les réponses.

Configuration d’une base de données MongoDB

Pour commencer, vous devez configurer une base de données MongoDB en local. Vous pouvez également opter pour l’option la plus simple qui consiste à configurer un cluster MongoDB dans le Cloud.

Ensuite, en utilisant l’outil d’interface graphique MongoDB installé, Compass, créez une connexion à la base de données. Cliquez sur le bouton Nouvelle connexion et fournissez l’URI de connexion pour établir une connexion avec le serveur MongoDB exécuté localement.

Enfin, créez une nouvelle base de données et une nouvelle collection pour contenir les données de votre API de test.

Configuration d’un serveur FastAPI

En utilisant un terminal, créez un dossier de projet, et entrez dans ce nouveau répertoire.

Ensuite, vérifiez que vous utilisez Python version 3.6+. Si ce n’est pas le cas, installez la dernière version de Python.

 python --version 

Ensuite, installez Virtualenv pour créer un environnement de développement virtuel isolé. Ceci est fortement recommandé car cela vous permet d’éviter les conflits, surtout si vous utilisez différentes versions de paquets pour différents projets.

 pip install virtualenv 

Ensuite, créez un environnement virtuel appelé « venv » dans votre répertoire actuel :

 virtualenv venv 

Enfin, activez l’environnement virtuel.

 # On Unix or MacOS: 
source venv/bin/activate

# On Windows:
 .\venv\Scripts\activate 

Une fois que vous avez configuré l’environnement virtuel, installez les paquets FastAPI, PyMongo et Uvicorn.

 pip install fastapi pymongo uvicorn 

PyMongo est une bibliothèque basée sur Python pour travailler avec la base de données MongoDB. Elle fournit une API qui prend en charge toutes les fonctionnalités de MongoDB et vous permet d’interagir avec MongoDB sans avoir à écrire des requêtes MongoDB brutes.

Uvicorn, quant à lui, est un serveur web asynchrone basé sur le module Python asyncio. Sa principale caractéristique est le rechargement à chaud de vos serveurs FastAPI en déplacement. L’utilisation d’Uvicorn est similaire à celle de Nodemon.

Créer le serveur FastAPI

Enfin, créez un simple serveur FastAPI qui écoute les demandes de réception provenant de la route d’origine. Dans le répertoire racine du dossier de votre projet, créez un fichier server.py et ajoutez le code ci-dessous.

 from fastapi import FastAPI
app = FastAPI()

@app.get("https://www.makeuseof.com/")
async def home():
    return {"message": "Hello World"} 

Enfin, exécutez la commande ci-dessous pour lancer le serveur de développement. Uvicorn va servir votre application sur le port 8000.

 uvicon server:app --reload 

Allez-y et regardez la réponse du serveur sur votre navigateur à http://localhost:8000.

Créer l’API REST avec des opérations CRUD

Construisez maintenant l’API REST qui implémente les méthodes CRUD (create, read, update, and delete). Dans le répertoire racine de votre dossier de projet, créez quatre dossiers : config, models, routes et schemas.

 ├── config
├── models
├── routes
├── schemas
└── server.py 

1. Configurer la connexion à la base de données

Dans le répertoire config, créez un nouveau fichier, db.py, et ajoutez le code ci-dessous.

 from pymongo import MongoClient
db_connection = MongoClient("mongodb://localhost:27017")
db = db_connection.database_name
collection = db["collection_name"] 

• Utilisez la méthode MongoClient() pour créer une connexion à une base de données MongoDB. Elle prend en argument une chaîne URI de connexion qui spécifie l’hôte et le port du serveur MongoDB.
• Les deux variables précisent à quelle base de données et à quelle collection de votre serveur MongoDB le serveur doit accéder.

2. Définir un modèle de données

Ce modèle définira la structure de vos données dans la base de données, y compris les champs et les types de données.

Dans le répertoire du modèle, créez un nouveau fichier, user_model.py, et ajoutez le code ci-dessous.

 from pydantic import BaseModel 

class User(BaseModel):
    name: str
    role: str 

• Le code ci-dessus crée une classe appelée User, qui est une sous-classe de la classe BaseModel de la bibliothèque Pydantic. La classe User possède deux champs, name et role, dont les types de données sont des chaînes de caractères.
• Vous pouvez utiliser la bibliothèque Pydantic avec FastAPI pour créer des modèles de données. Vous pouvez également l’utiliser pour valider des données, les sérialiser (JSON vers Python) et les désérialiser (Python vers JSON).

3. Définir un schéma de données

A partir du modèle de données créé, vous pouvez définir le schéma de vos données. Dans le répertoire schemas, créez un nouveau fichier : user_schema.py, et ajoutez le code ci-dessous.

 def user_serializer(user) -> dict:
    return {
        'id':str(user["_id"]),
        'name':user["name"],
        'role':user["role"]
    }

def users_serializer(users) -> list:
    return [user_serializer(user) for user in users] 

4. Définir les routes de l’API

Enfin, définissez les routes pour les différentes opérations CRUD.

Dans le répertoire routes, créez un nouveau fichier : user_routes.py, et ajoutez le code ci-dessous.

Ajouter des données avec la méthode Post

Créez la route post pour ajouter des données.

 from fastapi import APIRouter
from models.user_model import User
from schemas.user_schema import users_serializer
from bson import ObjectId
from config.db import collection

user = APIRouter()

@user.post("https://www.makeuseof.com/")
async def create_user(user: User):
    _id = collection.insert_one(dict(user))
    user = users_serializer(collection.find({"_id": _id.inserted_id}))
    return {"status": "Ok","data": user} 

• FastAPI fournit la méthode APIRouter() qui définit un objet routeur qui fournit une interface pour faire des demandes API à un serveur.
• Spécifiez une route post qui crée un nouvel objet utilisateur dans la base de données en insérant les données dans la collection après les avoir sérialisées. Ensuite, stockez et passez le inserted_id pour trouver les données associées dans la collection, et enfin, renvoyez un statut « Ok » avec les données dans la réponse, si la requête post est réussie.
• Les méthodes insert_one et find sont définies par le client PyMongo.

Maintenant, ajoutez le code ci-dessous au server.py pour initialiser les routes.

 from routes.user_routes import user
app.include_router(user) 

Allez-y et testez la route post sur votre navigateur en utilisant l’outil API Swagger UI. fourni par FastAPI.

Lire des données avec la méthode Get

Après avoir défini la route post et initialisé les routes, définissez le reste des autres routes.

 @user.get("https://www.makeuseof.com/")
async def find_all_users():
    users = users_serializer(collection.find())
    return {"status": "Ok","data": users}
            
@user.get("/{id}")
async def get_one_user(id: str):
   user = users_serializer(collection.find({"_id": ObjectId(id)}))
   return {"status": "Ok","data": user} 

Définissez deux routes get qui récupèrent toutes les données de la collection et récupèrent des données spécifiques de la collection basées sur l’ID.

Mise à jour des données avec la méthode Put

Créez la route put pour mettre à jour les données stockées dans la base de données.

 @user.put("/{id}")
async def update_user(id: str, user: User):
    collection.find_one_and_update(
        {
          "_id": ObjectId(id)
        }, 
        {
         "$set": dict(user)
        })
    user = users_serializer(collection.find({"_id": ObjectId(id)}))
    return {"status": "Ok","data": user} 

La méthode put utilise l’ID pour trouver les données spécifiques dans la collection et met à jour la valeur des champs dans le document avec les nouvelles données transmises par l’API. Vous pouvez ensuite rechercher les données mises à jour par ID et les renvoyer dans la réponse de l’API.

Supprimer des données avec la méthode Delete

Créez la route de suppression pour supprimer les données stockées dans la base de données.

 @user.delete("/{id}")
async def delete_user(id: str):
   collection.find_one_and_delete({"_id": ObjectId(id)})
   users = users_serializer(collection.find())
   return {"status": "Ok","data": []}  

L’itinéraire de suppression prend l’ID du document spécifique que vous voulez supprimer de la collection.

Créer des API REST avec FastAPI

FastAPI est un excellent moyen de créer facilement des API web Python. Ses outils intégrés pour l’intégration de bases de données et la production automatique d’API rendent le processus simple.

Vous pouvez même aller un peu plus loin et construire des applications à part entière. Essayez d’intégrer un client frontal en utilisant des technologies populaires comme React, Angular ou Vue.