Comment configurer une application API rapide avec une base de données NoSQL

Introduction

Lors de la développement d’applications en Python, FastAPI se distingue en tant que choix supérieur pour la construction de solutions à hautes performances. Il offre une vitesse élevée, une simplicité et un support pour la programmation asynchrone, ce qui le rend idéal pour développer des applications modernes, scalables.
Dans ce tutoriel, nous vous guiderons à travers le processus de configuration d’une application FastAPI avec une base de données NoSQL. En ce qui concerne le stockage et la gestion des données, les bases de données NoSQL offrent une flexibilité et une scalabilité exceptionnelles, ce qui les rend parfaitement adaptés pour les applications qui doivent gérer des structures de données diverses et complexes.

Prérequis

Avant de commencer, vous devez s’assurer que vous avez les éléments suivants :

• Un serveur fonctionnant sous Ubuntu ainsi qu’un utilisateur non-root avec des privilèges sudo et un pare-feu actif. Pour des instructions sur la mise en place, veuillez sélectionner votre distribution de la liste ci-dessous et suivez notre guide de configuration initiale du serveur. Veuillez vous assurer de travailler avec une version prise en charge d’Ubuntu.

• Familiarité avec la ligne de commande Linux. Pour une introduction ou un rappel sur la ligne de commande, vous pouvez visiter ce guide sur primer sur la ligne de commande Linux.

• Exécutez sudo apt-get update dans le terminal Ubuntu pour vous assurer que votre système dispose des dernières versions et mises à jour de sécurité des logiciels disponibles à partir des dépôts configurés sur votre système.

Étape 1 – Configurer l’environnement Python sur votre machine

Pendant ce tutoriel, nous utiliserons le paquet python3 pour exécuter des commandes. Les dernières versions d’Ubuntu sont fournies avec l’installation de Python 3, donc pour vérifier son installation, exécutez la commande suivante :

python3 --version

Si cette commande retourne une erreur, vous pouvez installer/reinstaller le paquet en exécutant :

sudo apt-get install python3

Ensuite, vous devez installer pip pour installer des paquets Python et leurs dépendances de manière sécurisée.

sudo apt-get install python3-pip

Étape 2 – Créer un environnement virtuel

Débutant avec Python 3.11 et pip 22.3, il existe une nouvelle PEP 668 qui stipule la marque des environnements de base Python comme « gérés externes », ce qui signifie que vous ne serez pas en mesure d’utiliser pip pour installer des paquets avec succès à moins que vous travailliez à l’intérieur d’un environnement virtuel.

Dans cette étape, vous allez créer un environnement virtuel pour votre projet, qui isolera les dépendances de votre projet pour éviter les conflits potentiels entre les différentes versions des paquets. Exécutez la suite des commandes suivantes dans le terminal :

sudo apt-get install python3-venv

Cela installera le package requis venv nécessaire pour créer un environnement virtuel.

python3 -m venv fastapi-env

Cette commande créera un environnement virtuel fastapi-env à l’intérieur de votre dossier de travail. Pour commencer à travailler à l’intérieur de cet environnement, vous devez le激活.

source fastapi-env/bin/activate

A la suite d’une exécution réussie, vous verrez le prompt du terminal précédé par ceci :

(fastapi-env) user@machine:~$

Maintenant, vous pouvez commencer à installer les dépendances requises à l’intérieur de cet environnement virtuel.

Étape 3 – Installer les bibliothèques et paquets requis

Dans cette étape, vous installerez quelques paquets et bibliothèques qui sont requis pour suivre ce tutoriel avec succès.

Commencez par installer fastapi, ce qui est requis pour construire votre application FastAPI, et uvicorn, qui est requis pour exécuter l’application FastAPI.

pip install fastapi uvicorn

Dans ce tutoriel, nous utiliserons MongoDB comme base de données NoSQL. Pour interagir avec MongoDB à l’intérieur de votre FastAPI, vous devez installer motor, qui est un pilote asynchrone Python pour MongoDB.

pip install motor

Étape 4 – Installer et Configurer MongoDB sous Ubuntu

Pour installer MongoDB sur votre machine Ubuntu, exécutez la suite des commandes suivantes dans le terminal :

wget -qO - https://www.mongodb.org/static/pgp/server-7.0.asc | sudo gpg --dearmor -o /usr/share/keyrings/mongodb-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/mongodb-archive-keyring.gpg] https://repo.mongodb.org/apt/ubuntu $(lsb_release -cs)/mongodb-org/7.0 multiverse" | sudo tee /etc/apt/sources.list.d/mongodb-org-7.0.list

A l’exécution réussie, cela renvoie le paramètre echo. Maintenant, effectuez une vérification rapide :

sudo apt-get update

Cela vous assurerait que vous obtenez les dernières mises à jour après avoir configuré les clés de MongoDB.

Next up, you need to install an openssl dependency on your system that is required for MongoDB installation.

wget http://archive.ubuntu.com/ubuntu/pool/main/o/openssl/libssl1.1_1.1.1f-1ubuntu2_amd64.deb
sudo dpkg -i libssl1.1_1.1.1f-1ubuntu2_amd64.deb

À l’exécution, vous serez invité à redémarrer les services. Après le redémarrage, installez MongoDB en utilisant la commande suivante :

sudo apt-get install -y mongodb

Démarrez et activez les services MongoDB :

sudo systemctl start mongod
sudo systemctl enable mongod

Vous pouvez vérifier l’état du service MongoDB et tester la connexion en exécutant les commandes suivantes :

sudo systemctl status mongod

mongo --eval 'db.runCommand({connectionStatus: 1})'

Étape 5 – Créer une application FastAPI

La prochaine étape consiste à créer une application FastAPI. Dans votre répertoire de travail, créez un fichier database.py :

nano database.py

Cela ouvre un éditeur de texte vide. Écrivez votre logique de connexion à la base de données ici.

from motor.motor_asyncio import AsyncIOMotorClient

MONGO_DETAILS = "mongodb://localhost:27017"

client = AsyncIOMotorClient(MONGO_DETAILS)

db = client.mydatabase

collection = db.mycollection

En supposant que la collection mycollection du dépôt mydatabase soit peuplée de certaines données, vous créez maintenant un main.py qui contient la logique de votre application. Dans l’application FastAPI suivante, une connexion à la base de données est établie en utilisant database.py ; des routes pour la prédiction par IA sont définies. En utilisant ces routes, l’entrée est validée.

nano main.py

Dans l’éditeur de texte, écrivez la logique :

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from sklearn.linear_model import LinearRegression
import numpy as np
from database import collection

app = FastAPI()

# simple jeu de données et modèle
x = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

model = LinearRegressions()
model.fit(x, y)

# définir le modèle Pydantic pour la validation des entrées
class InputData(BaseModel):
  feature: float

# route_1 pour prévoir la sortie en fonction des caractéristiques d'entrée
@app.post("/predict/")
async def predict(input_data: InputData):
  try:
    prediction = model.predict([[input_data.feature]])
    return {"prediction": prediction[0]}
  except Exception as ex:
    raise HTTPException(status_code=400, detail=str(ex))

# route_2 pour interagir avec MongoDB
@app.get("/items/")
async def get_item():
  items = []
  async for item in collection.find():
    items.append(item)
  return items

# route_3 pour ajouter un nouvel élément à MongoDB
@app.post("/items/")
async def create_item(item: dict):
  new_item = await collection.insert_one(item)
  created_item = await collection.fine_one({"_id": new_item.inserted_id})
  return created_item

Voici un aperçu de ce que fait cette application :

• Modèle de régression linéaire de sklearn : Ce modèle prédit une sortie en fonction d’une seule caractéristique d’entrée.
• Données d’entrée à partir de Modèle Pydantic : Cela définit la structure d’entrée attendue pour le point de terminaison de prediction. Dans ce cas, c’est une float.
• Routes MongoDB : Les routes /items/ et POST /items/ vous permettent de récupérer et d’insérer des éléments dans votre collection MongoDB.

Étape 6 – Exécuter l’application FastAPI

Pour exécuter correctement cette application, vous devez installer les bibliothèques et les paquets utilisés dans l’application.

pip install pydantic scikit-learn numpy

Maintenant, utilisez la commande suivante pour exécuter cette application :

uvicorn main:app --reload

La sortie de cette commande sera :

Output
INFO:     Will watch for changes in these directories: ['/path/to/your/project']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [XXXXX] using statreload
INFO:     Started server process [XXXXX]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

FastAPI a automatiquement généré une documentation interactive de l’API à l’aide de Swagger UI. Vous pouvez y accéder en navigateur vers http://127.0.0.1:8000/docs.

Vous pouvez utiliser des outils tels que curl ou Postman pour appeler le point de terminaison qui prédit une valeur en fonction de votre entrée.

curl -X POST "http://127.0.0.1:8000/predict/" -H "Content-type: application/json" -d '{"feature": 3}'

Étape 7 [OPTIONNEL] – Exécuter l’application en utilisant Docker Compose

Vous pouvez conteneuriser votre application et l’exécuter en utilisant docker-compose. Conteneuriser votre application simplifie le processus de déploiement en rendant votre application plus facile à déployer, à scaler et à maintenir. Pour définir votre application en tant que fichier Dockerfile, suivez les étapes mentionnées dans Déployer une application FastAPI en utilisant Docker Compose.

Conclusion

Dans ce tutoriel, vous avez appris comment réussirment configurer une application FastAPI avec MongoDB, créant une application simple basée sur l’IA capable de stocker et de récupérer des prédictions d’entrée.

La combinaison de FastAPI et d’une base de données NoSQL offre un environnement puissant et flexible pour construire et élargir des applications pilotées par l’IA.