Dans le monde actuel axé sur la technologie, la création d'API rapides, efficaces et évolutives est cruciale pour les développeurs. Une combinaison puissante qui gagne en popularité est l'utilisation de FastAPI avec MongoDB. FastAPI, comme son nom l'indique, est un framework web moderne et performant pour la création d'API avec Python 3.7+ qui est rapide à coder et à exécuter. Pendant ce temps, MongoDB est une base de données NoSQL connue pour son évolutivité et sa flexibilité. Ensemble, ils fournissent une solution robuste pour la création d'API capables de gérer n'importe quoi, d'un petit projet à une application à grande échelle.
Alors, pourquoi devriez-vous envisager ce duo pour votre prochain projet ? Plongeons-nous !
Premiers pas : configuration de votre environnement
Avant de commencer à créer notre API, configurons notre environnement. Vous devrez installer Python sur votre système, ainsi que pip pour la gestion des packages.
Étape 1 : installer FastAPI et Uvicorn
Tout d'abord, installons FastAPI. Ouvrez votre terminal et exécutez la commande suivante :
pip install fastapi
Ensuite, nous allons installer Uvicorn, une implémentation de serveur ASGI pour Python, qui servira notre application FastAPI :
pip install uvicorn
Étape 2 : installer Motor
Motor est le pilote asynchrone pour MongoDB qui fonctionne de manière transparente avec FastAPI. Pour l'installer, exécutez :
pip install motor
Génial ! Maintenant, nous avons tout ce dont nous avons besoin pour commencer à coder.
Création de votre première application FastAPI
Maintenant, créons une application FastAPI de base et connectons-la à MongoDB.
Étape 1 : initialiser l'application FastAPI
Créez un nouveau fichier Python (appelons-le main.py) et commencez par importer FastAPI et initialiser l'application :
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def read_root():
return {"message": "Bienvenue dans le tutoriel FastAPI avec MongoDB !"}
Ce code configure une application FastAPI de base avec un seul point de terminaison.
Étape 2 : se connecter à MongoDB
Ensuite, connectons notre application FastAPI à MongoDB à l'aide de Motor. Nous allons créer un nouveau fichier appelé database.py pour gérer notre connexion à la base de données.
from motor.motor_asyncio import AsyncIOMotorClient
MONGO_DETAILS = "mongodb://localhost:27017"
client = AsyncIOMotorClient(MONGO_DETAILS)
database = client.mydatabase
Dans cet exemple, nous nous connectons à une instance MongoDB s'exécutant localement. Assurez-vous que MongoDB est installé et en cours d'exécution sur votre système.
Étape 3 : définir les modèles Pydantic
Les modèles Pydantic sont un excellent moyen de définir des structures de données et d'assurer la validation des données dans FastAPI. Créez un fichier models.py :
from pydantic import BaseModel
class Item(BaseModel):
name: str
description: str
price: float
available: bool = True
Ce modèle définit la structure d'un élément dans notre inventaire.
Création de points de terminaison d'API
Une fois la configuration de base terminée, créons des points de terminaison d'API pour interagir avec notre base de données MongoDB.
Étape 1 : créer la collection d'éléments
Tout d'abord, nous avons besoin d'une collection dans notre base de données MongoDB pour stocker les éléments. Dans main.py, créons un point de terminaison pour ajouter de nouveaux éléments à la base de données :
from fastapi import FastAPI, HTTPException
from database import database
from models import Item
from bson import ObjectId
app = FastAPI()
@app.post("/items/")
async def create_item(item: Item):
item_dict = item.dict()
result = await database["items"].insert_one(item_dict)
item_dict["_id"] = str(result.inserted_id)
return item_dict
Ce point de terminaison nous permet de créer de nouveaux éléments dans la collection MongoDB. Remarquez comment nous convertissons l'ID inséré en une chaîne pour une meilleure lisibilité.
Étape 2 : récupérer les éléments
Ensuite, nous allons créer un point de terminaison pour récupérer tous les éléments de la base de données :
@app.get("/items/")
async def get_items():
items = await database["items"].find().to_list(1000)
for item in items:
item["_id"] = str(item["_id"])
return items
Ce point de terminaison récupère tous les éléments de la collection items et convertit leurs ID en chaînes.
Étape 3 : récupérer un seul élément
Pour récupérer un seul élément par son ID, nous allons ajouter un autre point de terminaison :
@app.get("/items/{item_id}")
async def get_item(item_id: str):
item = await database["items"].find_one({"_id": ObjectId(item_id)})
if item:
item["_id"] = str(item["_id"])
return item
raise HTTPException(status_code=404, detail="Item not found")
Ce point de terminaison récupère un élément par son ID et le renvoie, ou génère une erreur 404 si l'élément est introuvable.
Étape 4 : mettre à jour un élément
La mise à jour d'un élément est simple avec FastAPI et Motor. Ajoutez le code suivant pour mettre à jour un élément par son ID :
@app.put("/items/{item_id}")
async def update_item(item_id: str, item: Item):
result = await database["items"].update_one(
{"_id": ObjectId(item_id)}, {"$set": item.dict()}
)
if result.modified_count == 1:
updated_item = await database["items"].find_one({"_id": ObjectId(item_id)})
updated_item["_id"] = str(updated_item["_id"])
return updated_item
raise HTTPException(status_code=404, detail="Item not found")
Ce point de terminaison met à jour un élément par son ID et renvoie l'élément mis à jour.
Étape 5 : supprimer un élément
Enfin, ajoutons un point de terminaison pour supprimer un élément par son ID :
@app.delete("/items/{item_id}")
async def delete_item(item_id: str):
result = await database["items"].delete_one({"_id": ObjectId(item_id)})
if result.deleted_count == 1:
return {"message": "Item deleted"}
raise HTTPException(status_code=404, detail="Item not found")
Ce point de terminaison supprime un élément et renvoie un message de réussite ou une erreur 404 si l'élément est introuvable.
Comment se connecter à la base de données MongoDB à Apidog
- Cliquez sur "Processors Operation" dans l'API et sélectionnez "Database Operations".
2. Cliquez sur "Manage Database Connection" dans la liste déroulante sous "Database Connection", puis cliquez sur le bouton "New" dans le coin supérieur droit.
3. Sélectionnez le type de base de données MongoDB, puis renseignez les informations de connexion correspondantes.
Utiliser la base de données MongoDB
MongoDB stocke les données au format de document BSON. Pour la commodité des habitudes d'utilisation de la plupart des utilisateurs, lors de la modification des bases de données MongoDB dans Apidog, soumettez des fichiers au format JSON. Le système mappera automatiquement chaque champ au type de données BSON correspondant en fonction du contenu réel du JSON.
Parmi eux, le champ _id est relativement spécial. Selon les spécifications de MongoDB, chaque document doit avoir un champ _id comme clé primaire, et le type de données par défaut de ce champ est ObjectId plutôt que String.
Si vous devez déclarer un champ _id de type ObjectId, vous pouvez utiliser le format de chaîne conventionnel. Si le contenu de la chaîne est conforme au format ObjectId, Apidog le mappera automatiquement au type ObjectId en BSON.
Supposons qu'il existe un tel document BSON dans MongoDB maintenant :
{ _id: ObjectId('6569a36afcf5ee79c08d2f94'), name: "Apidog"}Ainsi, lors de l'utilisation d'Apidog pour interroger le document via _id, la valeur JSON qui doit être saisie dans les "Query Conditions" est :
{ "_id": "6569a36afcf5ee79c08d2f94" }Opérations courantes
Pour les opérations CRUD courantes, prise en charge via les opérations d'API visuelles. Pas besoin d'écrire de code JavaScript, il suffit de spécifier l'action dans le "Operation Type", puis de spécifier le "Collection Name", puis d'écrire le contenu correspondant en JSON dans "Query Conditions".
Par exemple, pour l'opération de requête mentionnée ci-dessus, vous pouvez afficher le document interrogé dans la console après avoir entré la commande et activé "Console Log".
Commandes avancées
Si vous avez besoin d'opérations plus avancées, vous pouvez également exécuter directement des commandes de base de données. Dans "Operation Type", sélectionnez "Run Database Command" et entrez ensuite la commande de base de données au format JSON. Notez que la commande de base de données ne fait pas référence aux appels de méthode comme db.collection.findOne(), mais aux données JSON dans un format spécifique.
Par exemple, pour interroger le nombre de documents dans la collection users, vous pouvez utiliser la commande de base de données count :
{ "count": "users"}Après avoir entré la commande, vous pouvez afficher le résultat dans la console.
Test de votre API
Pour tester votre API, vous pouvez utiliser des outils comme Postman ou Apidog. Ces outils vous permettent d'envoyer des requêtes à vos points de terminaison et de voir les réponses, ce qui facilite le débogage et garantit que tout fonctionne correctement.
Utilisation d'Apidog pour les tests
Apidog est un puissant outil de développement et de test d'API qui simplifie le processus de création, de test et de gestion des API. Voici comment vous pouvez utiliser Apidog pour tester votre application FastAPI MongoDB :
- Créer un nouveau projet : ouvrez Apidog Client et créez un nouveau projet dans Apidog.
2 Ajouter des points de terminaison : ajoutez les points de terminaison que vous avez créés (/items/, /items/{item_id}, etc.) au projet.
3. Envoyer des requêtes : utilisez l'outil pour envoyer des requêtes GET, POST, PUT et DELETE à vos points de terminaison et observer les réponses.
4. Valider les réponses : assurez-vous que les réponses correspondent aux sorties attendues et utilisez les messages d'erreur détaillés pour corriger tout problème.
Conclusion
Dans ce tutoriel, nous avons abordé les bases de la configuration d'une application FastAPI avec MongoDB. Nous avons créé une simple API d'inventaire qui vous permet de créer, de récupérer, de mettre à jour et de supprimer des éléments. La rapidité et la facilité d'utilisation de FastAPI, combinées à la flexibilité et à l'évolutivité de MongoDB, en font une paire parfaite pour la création d'API robustes.
En tirant parti d'outils comme Apidog, vous pouvez rationaliser le processus de développement et de test, en vous assurant que vos API sont fiables et performantes.
Alors, qu'attendez-vous ? Plongez dans FastAPI et MongoDB, et commencez à créer des API incroyables dès aujourd'hui !
