Comment installer l’API Fast avec MongoDB sur Ubuntu 24.04

Sur cette page

1. Conditions préalables
2. Installation de MongoDB
3. Configuration de Python et de l’environnement virtuel

4. Création d’un projet FastAPI

   1. serveur/app.py
   2. main.py
   3. Exécutez votre projet FastAPI

5. Connexion de FastAPI à MongoDB

   1. serveur/database.py
6. Création d’un modèle de base de données avec pydantic

7. Ajout d’opérations CRUD

   1. Créer un élément
   2. Récupérer tous les articles
   3. Récupérer un élément spécifique en fonction de l’id
   4. Mettre à jour un élément
   5. Supprimer un élément

8. Ajout d’itinéraires pour les opérations CRUD

   1. serveur/routes/item.py
   2. Itinéraire d’ajout d’un nouvel article
   3. Itinéraire pour obtenir tous les articles
   4. Itinéraire pour obtenir un objet spécifique
   5. Itinéraire de mise à jour d’un élément
   6. Itinéraire de suppression d’un élément
   7. serveur/app.py
9. Tester les opérations CRUD
10. Conclusion

FastAPI est un framework web basé sur Python pour la création de services API. Il s'agit d'un cadre moderne, rapide et performant qui prend en charge les opérations asynchrones.

Dans ce tutoriel, vous allez apprendre à installer FastAPI avec MongoDB sur Ubuntu 24.04. Vous apprendrez également à créer votre première API avec des opérations CRUD à l'aide de FastAPI et de la base de données MongoDB.

Conditions préalables

Pour commencer avec ce guide, assurez-vous d’avoir les éléments suivants :

• Un système Ubuntu 24.04
• Un utilisateur non root avec des privilèges d’administrateur

Installation de MongoDB

Avant de créer un nouveau projet FastAPI, installons le serveur MongoDB sur notre système.

Tout d'abord, exécutez la commande ci-dessous pour mettre à jour l'index de votre paquet et installer 'gnupg' et 'curl' sur votre système.

sudo apt update && sudo apt install gnupg curl -y

Exécutez la commande ci-dessous pour ajouter la clé GPG pour le serveur MongoDB.

curl -fsSL https://www.mongodb.org/static/pgp/server-8.0.asc | \
sudo gpg -o /usr/share/keyrings/mongodb-server-8.0.gpg \
--dearmor

Ajoutez le référentiel MongoDB à l’aide de la commande ci-dessous.

echo "deb [ arch=amd64,arm64 signed-by=/usr/share/keyrings/mongodb-server-8.0.gpg ] https://repo.mongodb.org/apt/ubuntu noble/mongodb-org/8.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-8.0.list

Une fois le référentiel ajouté, exécutez la commande suivante pour actualiser l’index de votre package et installer le serveur MongoDB. Entrez « Y » pour confirmer l'installation.

sudo apt update && sudo apt install mongodb-org

Une fois l'installation terminée, démarrez et activez le service MongoDB « mongod », puis vérifiez l'état de votre service MongoDB pour vous assurer qu'il est en cours d'exécution.

sudo systemctl enable --now mongod
sudo systemctl status mongod

Vous pouvez voir ci-dessous que le serveur MongoDB est en cours d’exécution.

En plus de cela, vous pouvez vous connecter au serveur MongoDB avec la commande 'mongosh' ci-dessous. Pour quitter, appuyez sur Ctrl+d.

mongosh

Configuration de Python et de l’environnement virtuel

Une fois MongoDB installé, vous installerez des packages Python et configurerez le répertoire du projet et l'environnement virtuel.

Installez les modules Python, Pip et Venv à l’aide de la commande suivante. Entrez « Y » pour confirmer l'installation.

sudo apt install python3 python3-pip python3-venv

Une fois l’installation terminée, connectez-vous à votre utilisateur.

su - username

Créez maintenant un nouveau répertoire '~/app' et déplacez-vous dans celui-ci. Ce répertoire sera utilisé pour stocker votre projet FastAPI.

mkdir -p ~/app; cd ~/app

Exécutez la commande ci-dessous pour créer un nouvel environnement virtuel 'venv' et l'activer. Avec cela, votre invite shell deviendra comme '(venv) user@hostname'.

python3 -m venv .venv
source .venv/bin/activate

À partir de là, votre environnement de travail doit être sur l'environnement virtuel « venv ». Vous pouvez vous déconnecter de 'venv' à l'aide de la commande ci-dessous.

deactivate

Création d’un projet FastAPI

Maintenant que vous avez créé et activé votre environnement virtuel Python, installons FastAPI et créons la structure du projet.

Avec la commande 'pip3', exécutez-la pour installer les packages 'fastapi' et 'uvicorn'.

pip3 install fastapi uvicorn

• La 'fastapi' est le principal framework web FastAPI pour la construction d'API en Python
• L'uvicorn est l'implémentation du serveur web ASGI (Asynchronous Server Gateway Interface) en Python.

Une fois l’installation terminée, créez de nouveaux fichiers et répertoires à l’aide de la commande suivante.

mkdir -p server/{models,routes}
touch main.py server/{app.py,database.py} server/models/itemModels.py server/routes/item.py

Vous trouverez ci-dessous la structure de notre projet FastAPI.

serveur/app.py

Maintenant que votre projet est prêt, modifions le fichier 'server/app.py', qui est l'application principale de votre projet FastAPI.

Ouvrez le fichier app.py avec votre éditeur de texte et copiez le script suivant.

from fastapi import FastAPI
app = FastAPI()
@app.get("/")
async def root():
 return {"message": "Hello FastAPI!"}

• Importez le module FastAPI dans votre projet et liez-le à la variable 'app'
• Créez une nouvelle fonction 'root' qui renvoie le 'Hello FastAPI !'
• La fonction 'root' répondait à la méthode GET sur l'URL racine
• 'async' marque votre fonction comme une fonction asynchrone et peut utiliser 'await' dans son corps lorsqu'elle est appelée

main.py

Dans cette section, nous allons modifier le fichier 'main.py' qui sera utilisé pour exécuter votre projet FastAPI via 'uvicorn' (serveur web ASGI en Python).

Ouvrez et modifiez maintenant le script 'main.py' et insérez le code suivant.

import uvicorn
if __name__ == "__main__":
 uvicorn.run("server.app:app", host="0.0.0.0", port=8080, reload=True)

• Importer le module 'uvicorn'
• Lorsque le script 'main.py' est exécuté, il charge le module 'app' ou FastAPI dans le 'server/app.py'
• FastAPI fonctionnera sur '0.0.0.0' avec le port '8080'
• Activer le rechargement automatique lorsque le code change via 'reload=True'

Exécutez votre projet FastAPI

Maintenant que votre projet est prêt, exécutons votre premier projet FastAPI.

Exécutez le script 'main.py' comme suit et votre FastAPI s'exécutera sur votre système.

python3 main.py

Ouvrez maintenant votre navigateur Web et visitez http://SERVERIP:8080/. Si votre installation réussit, le message « Hello FastAPI ! » s'affiche. Vous pouvez également y accéder via 'curl' depuis le terminal.

Enfin, vous pouvez accéder à la documentation de l’API sur http://SERVERIP:8080/docs> qui est fournie par Swagger UI.

Connexion de FastAPI à MongoDB

Dans ce guide, vous allez créer une API de base avec FastAPI et MongoDB. Votre API doit être capable de CRUD avec le serveur de base de données MongoDB. Comme pour cette étape, vous allez connecter votre projet au serveur MongoDB.

Tout d'abord, exécutez la commande 'pip3' ci-dessous pour installer le pilote MongoDB 'motor' dans votre projet. 'motor' fournit un accès API non bloquant et basé sur la coroutine au serveur MongoDB.

pip3 install motor

serveur/database.py

Une fois le module 'motor' installé, modifions le script 'server/database.py.

Ouvrez le fichier 'server/database.py' avec votre éditeur de texte et saisissez le script suivant. Celui-ci sera utilisé pour se connecter au serveur MongoDB via le module 'moteur'.

from motor.motor_asyncio import AsyncIOMotorClient
MONGODB_HOST = "mongodb://localhost:27017"
connection = AsyncIOMotorClient(MONGODB_HOST)
database = connection.items
item_collection = database.get_collection("item_collection")

• Importez le 'AsyncIOMotorClient' à partir du 'motor.motor_asyncio'
• Créez une nouvelle constante 'MONGODB_HOST' et pointez sur le serveur MongoDB 'mongodb://localhost:27017'
• Se connecter au serveur MongoDB via la variable 'connection'
• Connectez-vous à la base de données 'items' via la variable 'database'
• Accéder aux collections de la base de données à l'aide de la variable 'item_collection'

Création d’un modèle de base de données avec pydantic

Dans cette section, vous allez concevoir vos données via « pydantic », qui fournit une modélisation pour notre base de données MongoDB.

Installez le module 'pydantic' avec la commande 'pip3' ci-dessous. Le module 'pydantic' est une librairie de validation de données qui permet de créer des schémas de base de données via modèle.

pip3 install pydantic

Ouvrez maintenant le fichier 'server/models/itemModels.py' avec votre éditeur de texte et copiez le script suivant.

from pydantic import BaseModel, Field
from typing import Optional
class Item(BaseModel):
 name: str
 category: str
 stocks: int
 price: int = Field(gt=0)
 class Config:
 json_schema_extra = {
 "example": {
 "name": "Company Smart Watch",
 "category": "smartwatch",
 "stocks": 10,
 "price": 1000,
 }
 }
class ItemUpdate(BaseModel):
 name: Optional[str] = None
 category: Optional[str] = None
 stocks: Optional[int] = None
 price: Optional[int] = None
 class Config:
 json_schema_extra = {
 "example": {
 "name": "New Smart watch",
 "category": "new-smartwatch",
 "stocks": 5,
 "price": 500,
 }
 }

• Importer les modules 'BaseModel' et 'Field' de 'pydantic'
• Importer le module 'Optionnel' à partir de 'taping'

• Créez le schéma de base de données 'Item' suivant pour la FastAPI :

  • 'name' et 'category' avec type string
  • 'Actions' et 'Prix' avec l'entier de la catégorie
  • 'price' doit être supérieur à 0
• Étendez le modèle de données via la classe 'Config' en fournissant un exemple de données que l'utilisateur peut inclure dans la demande
• Créez le schéma 'ItemUpdate' suivant avec chaque champ comme facultatif.

Ajout d’opérations CRUD

À ce stade, vous avez créé une connexion au serveur MongoDB et créé un schéma de base de données via 'pydantic'. Passons à la création des opérations CRUD avec FastAPI et MongoDB.

Ouvrez à nouveau le script 'server/database.py' et créez une nouvelle fonction 'item_helper' avec le type 'dict'. Appelez cette fonction pour obtenir des données détaillées sur un élément.

def item_helper(item) -> dict:
 return {
 "id": str(item["_id"]),
 "name": item["name"],
 "category": item["category"],
 "stocks": item["stocks"],
 "price": item["price"],
 }

Ajoutez la ligne suivante pour importer le module 'ObjectId' à partir de 'bson.objectid'. L'ObjectId fait partie du type de données dans BSON, que MongoDB utilise pour le stockage des données et la représentation des données JSON.

from bson.objectid import ObjectId

Créer un élément

Tout d'abord, vous allez créer une fonction asynchrone qui sera en mesure d'ajouter de nouvelles données à la base de données MongoDB.

Créez une nouvelle fonction 'add_item' comme suit :

# Add a new item
async def add_item(item_details: dict) -> dict :
 item = await item_collection.insert_one(item_details)
 new_item = await item_collection.find_one({"_id": item.inserted_id})
 return item_helper(new_item)

• La fonction 'add_item' accepte les données du dictionnaire des détails de votre article
• Via le 'item_collection' pour accéder aux documents de la base de données et exécuter la requête 'insert_one' pour ajouter un nouvel élément
• Le nouvel article sera imprimé une fois l’opération réussie

Récupérer tous les articles

Dans un second temps, vous allez créer une nouvelle fonction 'get_items' qui pourra récupérer tous les éléments disponibles dans votre base de données.

Créez une nouvelle fonction 'get_items' pour récupérer tous les éléments de MongoDB.

# retrieve all items
async def get_items():
 items = []
 async for item in item_collection.find():
 items.append(item_helper(item))
 return items

• Vous allez créer une liste vide d'« éléments »
• Utilisation de la requête 'find()' pour rechercher toutes les données et les parcourir en boucle
• Chaque élément sera ajouté à la liste 'éléments' via la méthode 'append'
• Une fois la boucle terminée, vos articles seront affichés

Récupérer un élément spécifique en fonction de l’id

Ensuite, vous allez créer une nouvelle fonction qui sera capable de récupérer des données pour un sélecteur spécifique 'id'. Cela vous montrera des données détaillées sur des articles spécifiques.

Créez une nouvelle fonction 'get_item' pour récupérer les données d'éléments spécifiques. La fonction 'get_item' acceptera une chaîne de 'id' comme sélecteur et renverra un dictionnaire.

# retrieve specific item
async def get_item(id: str) -> dict:
 item = await item_collection.find_one({"_id": ObjectId(id)})
 if item:
 return item_helper(item)
 return "Item Not Found."

• La requête 'find_one()' sera utilisée pour récupérer les données basées sur l''id'
• Si un élément est trouvé, les détails seront affichés à l'aide du format de dictionnaire 'item_helper'
• Si l'élément n'est pas disponible, la réponse est « Élément introuvable »

Mettre à jour un élément

Vous allez maintenant créer une nouvelle fonction pour mettre à jour un élément. Vous pouvez également mettre à jour partiellement votre article via l’API.

Définissez la nouvelle fonction 'change_item' comme les codes suivants :

# update item
async def change_item(id: str, data: dict):
 if len(data) < 1:
 return "Please input your data"
 find_item = await item_collection.find_one({"_id": ObjectId(id)})
 if find_item:
 item_update = await item_collection.update_one({"_id": ObjectId(id)}, {"$set": data})
 if item_update:
 return True
 return False

• La fonction 'change_item' prend deux arguments, l''id' de l'élément cible et 'data' comme nouvelles données
• Si les données sont vides ou < 1, l'opération est terminée
• Cette fonction trouvera un élément en fonction du sélecteur 'id'
• Si le 'id' est trouvé, le 'item_update' sera exécuté
• Si le 'item_update' réussit, renvoyez 'True' ou renvoyez 'False' si ce n'est pas le cas.

Supprimer un élément

Enfin, vous allez créer la fonction 'delete_item' pour supprimer des éléments via un sélecteur spécifique.

Pour supprimer un élément, nous allons créer la fonction 'delete_item' et utiliser le sélecteur 'id' comme suit :

# delete an item
async def delete_item(id: str):
 item = await item_collection.find_one({"_id": ObjectId(id)})
 if item:
 await item_collection.delete_one({"_id": ObjectId(id)})
 return(f'Item {id} deleted.')
 return "Item Not Found."

• La requête 'find_one()' recherchera un élément en fonction de l'id' fourni
• Si l'élément est trouvé, il sera supprimé via la requête 'delete_one()' et renverra l''identifiant de l'élément supprimé'
• Si l'article n'est pas disponible, l'option « Article introuvable » s'affichera

Ajout d’itinéraires pour les opérations CRUD

À ce stade, nous avons créé des fonctions asynchrones pour le fonctionnement CRUD avec FastAPI. Nous allons maintenant créer l'itinéraire ou le point de terminaison pour chaque opération.

Modifiez le fichier 'server/routes/item.py' à l'aide de l'éditeur de votre choix.

serveur/routes/item.py

Tout d'abord, ajoutez les modules 'APIRouter' et 'Body' à partir de 'fastapi'. Ensuite, ajoutez le 'jsonable_encode' de 'fastapi.encoders'.

from fastapi import APIRouter, Body
from fastapi.encoders import jsonable_encoder

Importez chaque fonction à partir du fichier 'database.py.

from server.database import (
 add_item,
 get_items,
 get_item,
 change_item,
 delete_item,
)

Importez les modèles 'Item' et 'ItemUpdate' à partir du fichier 'itemModels.py.

from server.models.itemModels import (
 Item,
 ItemUpdate,
)

Appelez la classe 'APIRouter' via la variable 'router'.

router = APIRouter()

Itinéraire d’ajout d’un nouvel article

Ajoutons maintenant un itinéraire pour l'ajout de nouveaux éléments. Dans cet exemple, vous pouvez ajouter un nouvel élément via POST à l'URL « /item ».

Ajoutez les lignes suivantes pour configurer les itinéraires pour l’ajout de nouveaux articles. Chaque POST vers l’URL racine de l’élément sera traité comme une nouvelle donnée d’insertion.

# add new item operation
@router.post("/")
async def add_item_data(item: Item = Body(...)):
 item = jsonable_encoder(item)
 new_item = await add_item(item)
 return new_item

• La fonction 'add_item_data' accepte le schéma 'Item', qui fera partie du 'Body' à votre demande
• Votre article sera converti au format dictionnaire via 'jsonable_encoder'
• Insérez les données de votre dictionnaire via la fonction 'add_item' (voir database.py) au-dessus de la variable 'new_item'
• Retournez les données saisies 'new_item' en réponse

Itinéraire pour obtenir tous les articles

Ajoutez le script suivant pour configurer un itinéraire pour la récupération des données. Chaque requête GET adressée à l’URL de l’élément racine récupère toutes vos données.

# get all available items
@router.get("/")
async def get_item_data():
 items = await get_items()
 if items:
 return items
 return "No available item."

• Créez la fonction 'get_item_data' qui exécutera la fonction 'get_item' à partir du fichier 'database.py'
• Si des articles sont disponibles, vous obtiendrez la liste de tous vos articles
• S'il n'y a pas d'article, vous obtiendrez la réponse « Aucun article disponible »

Itinéraire pour obtenir un objet spécifique

Pour obtenir les détails d'un élément spécifique, nous utiliserons le « id » comme sélecteur. Chaque requête GET adressée au '/id' renverra un élément détaillé de l'id' demandé.

# Show details of the item via the id
@router.get("/{id}")
async def get_item_details(id):
 item_details = await get_item(id)
 if item_details:
 return item_details
 return "Item not found."

• La fonction 'get_item_details' sera créée et passera le 'id' de l'URL
• La fonction 'get_item' (voir database.py) sera appelée et passera également le 'id' en argument
• Si l’objet est trouvé, les détails de l’objet s’affichent
• S'il n'y a pas d'article avec cet « id » spécifique, vous obtiendrez « Objet introuvable »

Itinéraire de mise à jour d’un élément

Copiez le code suivant pour définir l’itinéraire de l’élément mis à jour :

# Update Item
@router.put("/{id}")
async def update_item(id: str, data: ItemUpdate = Body(...)):
 data = {k: v for k, v in data.dict().items() if v is not None}
 updated_item = await change_item(id, data)
 if updated_item:
 return{f'Success: item {id} updated.'}
 return "Error"

• La fonction 'update_item' prendra deux arguments, 'id' comme sélecteur et 'data', qui est basé sur le modèle 'ItemUpdate'
• Les données seront vérifiées dans la variable 'data'
• Le 'updated_item' exécutera la fonction 'change_item' à partir du fichier 'database.py'
• Si la mise à jour réussit, vous verrez le résultat 'Succès'

Itinéraire de suppression d’un élément

Insérez les lignes suivantes pour créer la fonction 'remove_item' pour la suppression d'éléments. Chaque opération DELETE sur un '/id' spécifique supprimera l'élément correspondant au 'id'.

# delete item via id
@router.delete("/{id}")
async def remove_item(id):
 item_to_delete = await delete_item(id)
 if item_to_delete:
 return item_to_delete
 return{f'Item {id} Not Available.'}

• La fonction 'remove_item' exécutera 'delete_item' et passera le sélecteur 'id'
• L'opération de suppression sera stockée et exécutée via la variable 'item_to_delete'
• Lorsqu'un article n'est pas disponible, vous recevrez le retour « ID de l'article non disponible ».

serveur/app.py

Maintenant que vous avez terminé le fichier 'server/routes/item.py', incluons-le dans le fichier 'server/app.py.

Ouvrez le fichier app.py à l'aide de votre éditeur de texte.

Importez le 'router' à partir du fichier 'server/routes/item.py' en tant que 'ItemRouter'.

from server.routes.item import router as ItemRouter

Insérez le 'ItemRouter' avec le préfixe par défaut '/item'. Les opérations CRUD seront gérées via l'URL '/item'.

app.include_router(ItemRouter, tags=["Item"], prefix="/item")

Désormais, votre point de terminaison CRUD sera disponible à l’adresse suivante :

• Ajouter un nouvel élément : POST à '/item'
• Récupérer tous les éléments : GET to '/item'
• Récupérer un élément spécifique : GET to '/item/id'. Le 'id' est généré par MongoDB
• Mettre à jour l'élément : PUT à '/item/id'
• Supprimer l'élément : DELETE en '/item/id'

Tester les opérations CRUD

Tout d'abord, assurez-vous que votre projet FastAPI est en cours d'exécution, ou vous pouvez exécuter le script 'main.py' comme suit :

python3 main.py

Naviguez dans le http://SERVERIP:8080/docs et vous verrez chaque itinéraire que vous avez créé.

Vous trouverez ci-dessous un exemple d’ajout d’un nouvel élément.

Récupérez tous les articles disponibles via l’API.

Récupérez des éléments spécifiques via le sélecteur 'id'.

Mettre à jour les données partielles d’articles spécifiques.

Vous trouverez ci-dessous les données mises à jour.

Vous trouverez ci-dessous l'opération de suppression via le sélecteur 'id'.

Conclusion

Félicitations! Vous avez terminé l'installation de FastAPI avec MongoDB sur Ubuntu 24.04. Vous avez également appris à connecter FastAPI à MongoDB à l'aide du module « moteur », à créer des modèles de données via « pydantic », à créer des opérations CRUD avec FastAPI et à créer des points de terminaison pour votre API.