Des lecteurs comme vous aident à soutenir MUO. Lorsque vous effectuez un achat en utilisant des liens sur notre site, nous pouvons gagner une commission d'affiliation. En savoir plus.

La création d'une API REST est souvent une tâche mécanique, impliquant de nombreuses étapes de conception standard et de programmation par cœur. Heureusement, des outils comme FastAPI peuvent soulager une grande partie des détails fastidieux.

En utilisant FastAPI, vous pouvez créer rapidement une API REST efficace et complète pour votre application CRUD. Avec MongoDB comme source de données, ce tutoriel vous guidera vers la configuration 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 création d'API. Il fournit une prise en charge intégrée des requêtes asynchrones, la validation automatique des données et la documentation automatique des points de terminaison API.

Les avantages de FastAPI par rapport aux autres frameworks Python

instagram viewer
  • FastAPI est relativement plus rapide que d'autres frameworks comme Django et Flask. En effet, FastAPI s'appuie sur asyncio, une bibliothèque d'E/S asynchrones pour Python qui peut traiter plus rapidement les requêtes simultanées.
  • FastAPI fournit un moyen propre et simple de créer des API avec un minimum d'effort car il nécessite moins de code que Flask ou Django.
  • Enfin, FastAPI facilite la génération de documentation pour les terminaux. 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 affichant les réponses.

Configurer une base de données MongoDB

Pour commencer, vous devrez configurer la base de données MongoDB localement. Alternativement, vous pouvez opter pour l'option plus facile de mise en place d'un cluster MongoDB dans le Cloud.

Ensuite, à l'aide de l'outil d'interface utilisateur graphique MongoDB installé, Compass, créez une connexion à la base de données. Clique le 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 collection pour contenir vos données d'API de test.

Configurer un serveur FastAPI

À l'aide d'un terminal, créez un dossier de projet et entrez ce nouveau répertoire.

Vous pouvez trouver le code de ce projet dans son Référentiel GitHub.

Ensuite, vérifiez que vous utilisez Python version 3.6+. Sinon, installez la dernière Python version.

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, en particulier si vous utilisez différentes versions de packages pour différents projets.

pip installer virtualenv

Créez ensuite un environnement virtuel appelé "venv" dans votre répertoire actuel :

virtualenv venv

Enfin, activez l'environnement virtuel.

# Sous Unix ou MacOS: 
source venv/bin/activer
# Sous Windows :
 .\venv\Scripts\activate

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

pip installer fastapi pymongo uvicorn

PyMongo est une bibliothèque basée sur Python pour travailler avec la base de données MongoDB. Il 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 lors de vos déplacements. L'utilisation d'Uvicorn est similaire à travailler avec Nodémon.

Créer le serveur FastAPI

Enfin, créez un serveur FastAPI simple qui écoute les requêtes provenant de la route d'accueil. Dans le répertoire racine de votre dossier de projet, créez un fichier server.py et ajoutez le code ci-dessous.

depuis fastapi importer FastAPI
app = FastAPI()
@app.get("/")
asynchronedéfinitivementmaison():
retour {"message": "Bonjour le monde"}

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

serveur uvicon: app --reload

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

Créer l'API REST avec les opérations CRUD

Construisez maintenant l'API REST qui implémente les méthodes CRUD (création, lecture, mise à jour et suppression). Dans le répertoire racine de votre dossier de projet, créez quatre dossiers: config, models, routes et schemas.

├── configuration
├── modèles
├── itinéraires
├── schémas
└── serveur.py

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

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

depuis pymongo importer MongoClient
db_connection = MongoClient("mongodb://localhost: 27017")
db = db_connection.database_name
collection = db["nom_collection"]
  • Utilisez la méthode MongoClient() pour créer une connexion à une base de données MongoDB. Il prend une chaîne d'URI de connexion comme argument qui spécifie l'hôte et le port du serveur MongoDB.
  • Les deux variables spécifient la base de données et la collection de votre serveur MongoDB auxquelles 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.

depuis pydantique importer Modèle de base 
classeUtilisateur(Modèle de base):
 nom: str
 rôle: 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 a deux champs, name et role avec leurs types de données définis sur des chaînes.
  • 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

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

définitivementuser_serializer(utilisateur) -> dicter :
retour {
'identifiant':str (utilisateur["_identifiant"]),
'nom':utilisateur["nom"],
'rôle':utilisateur["rôle"]
 }
définitivementutilisateurs_serializer(utilisateurs) -> liste :
retour [user_serializer (utilisateur) pour utilisateur dans utilisateurs]

4. Définir les routes d'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 de publication pour ajouter des données.

depuis fastapi importer APIRouter
depuis modèles.user_model importer Utilisateur
depuis schemas.user_schema importer utilisateurs_serializer
depuis bson importer ID d'objet
depuis config.db importer collection
utilisateur = APIRouter()
@user.post("/")
asynchronedéfinitivementCréer un utilisateur(utilisateur: utilisateur):
 _id = collection.insert_one (dict (utilisateur))
 user = users_serializer (collection.find({"_identifiant": _id.insert_id}))
retour {"statut": "D'accord","données": utilisateur}
  • FastAPI fournit la méthode APIRouter() qui définit un objet routeur qui fournit une interface pour faire des requêtes API à un serveur.
  • Spécifiez une route de publication qui crée un nouvel objet utilisateur dans la base de données en insérant les données dans la collection après l'avoir sérialisée. Ensuite, stockez et transmettez l'insert_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 demande de publication réussit.
  • 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.

depuis routes.user_routes importer utilisateur
app.include_router (utilisateur)

Allez-y et testez l'itinéraire de publication sur votre navigateur à l'aide de l'outil API Swagger UI fourni par FastAPI.

Lire des données avec la méthode Get

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

@user.get("/")
asynchronedéfinitivementfind_all_users():
 utilisateurs = utilisateurs_serializer (collection.find())
retour {"statut": "D'accord","données": utilisateurs}

@user.get("/{id}")
asynchronedéfinitivementget_one_user(id: str):
 user = users_serializer (collection.find({"_identifiant": ObjectId (id)}))
retour {"statut": "D'accord","données": utilisateur}

Définissez deux itinéraires d'obtention qui récupèrent toutes les données de la collection et récupèrent des données spécifiques de la collection en fonction de l'ID.

Mettre à jour les 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}")
asynchronedéfinitivementupdate_user(id: str, utilisateur: utilisateur):
 collection.find_one_and_update(
 {
"_identifiant": ObjectId (identifiant)
 }, 
 {
"$ ensemble": dict (utilisateur)
 })
 user = users_serializer (collection.find({"_identifiant": ObjectId (id)}))
retour {"statut": "D'accord","données": utilisateur}

La méthode put utilise l'ID pour rechercher les données spécifiques dans la collection et met à jour la valeur des champs du 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 de suppression

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

@user.delete("/{id}")
asynchronedéfinitivementSupprimer l'utilisateur(id: str):
 collection.find_one_and_delete({"_identifiant": ObjectId (id)})
 utilisateurs = utilisateurs_serializer (collection.find())
retour {"statut": "D'accord","données": []}

La route de suppression prend l'ID du document spécifique que vous souhaitez supprimer de la collection.

Créer des API REST avec FastAPI

FastAPI fournit un excellent moyen de créer facilement des API Web Python backend. Ses outils intégrés pour l'intégration de bases de données et la production automatique d'API simplifient le processus.

Vous pouvez même aller plus loin et créer des applications à part entière. Essayez d'intégrer un client frontal à l'aide de technologies populaires telles que React, Angular ou Vue.