AnnoncePrésentation de MongoDB 8.0, la plus rapide des MongoDB ! En savoir plus >

AnnonceVoyage AI rejoint MongoDB pour développer des applications d'IA plus précises et plus fiables sur Atlas. En savoir plus >

Qu'est-ce que PyMongo ? Prise en main de Python et MongoDB

Essayez MongoDB Atlas dès aujourd’hui

PyMongo est le pilote MongoDB officiel pour les applications Python synchrones. Si vous souhaitez découvrir comment connecter et utiliser MongoDB depuis votre application Python, vous êtes au bon endroit. Dans ce tutoriel PyMongo, nous allons créer une application CRUD (Create, Read, Update, Delete) simple en utilisant FastAPI et MongoDB Atlas. L’application pourra créer, lire, mettre à jour et supprimer des documents dans une base de données MongoDB, en exposant la fonctionnalité par le biais d’une API REST. Vous pouvez consulter l’application terminée sur Github.

Qu'est-ce que PyMongo ? Prise en main de Python et MongoDB

Application de gestion de livres CRUD
Exigences
Configuration et installation du projet
Connectez-vous à votre cluster MongoDB Atlas
Créer des modèles pour les requêtes et les réponses d’API
Implémenter les points de terminaison de l’API REST
Explorer la page de documentation de l’API et tester les points de terminaison
Conclusion

Application CRUD de gestion de livres

Ma façon préférée de découvrir de nouvelles technologies est d’en créer une. Nous allons donc coder une application backend très simple mais très utile : une application CRUD pour la gestion de livres. Les opérations CRUD seront disponibles via une API REST. L’API comportera cinq points de terminaison :

Code SnippetGET /book: to list all books
GET /book/<id>: to get a book by its ID
POST /book: to create a new book
PUT /book/<id>: to update a book by its ID
DELETE /book/<id>: to delete a book by its ID

Pour construire l’API, nous utiliserons le framework FastAPI. C’est un framework léger, moderne et facile à utiliser pour créer des API. Il génère également une documentation de l’API avec Swagger que nous utiliserons pour tester l’application.

Nous stockerons les livres dans un cluster MongoDB Atlas. MongoDB Atlas est la plateforme Database-as-a-Service de MongoDB. Elle est hébergée sur le cloud et vous permet de créer un compte et un cluster gratuits en quelques minutes, sans rien installer sur votre machine. Nous utiliserons PyMongo pour nous connecter au cluster et interroger les données.

Exigences

Le projet terminé est disponible sur Github. Vous pouvez également suivre les instructions étape par étape pour créer le projet à partir de zéro. Pour cela, vous aurez besoin des éléments suivants :

Python 3.6+ : vous pouvez l’installer depuis le site Web de Python.
Un cluster MongoDB Atlas : vous pouvez créer un cluster gratuit à vie en suivant le guide Démarrer avec Atlas. Suivez les étapes du guide et localisez votre string de connexion ; vous en aurez besoin pour vous connecter à la base de données depuis l’application.

Configuration et mise en place du projet

Avant de commencer, nous allons créer un environnement virtuel Python pour isoler le projet des autres paquets Python installés globalement. Nous allons utiliser le paquet `venv`, qui est fourni avec votre installation de Python. Exécutez la commande suivante depuis le terminal :

Code Snippetpython3 -m venv env-pymongo-fastapi-crud
source env-pymongo-fastapi-crud/bin/activate

Remarque : vous devrez peut-être exécuter cette commande à l’aide de l’exécutable python3. En effet, sur certains systèmes d’exploitation, les versions 2 et 3 de Python sont toutes deux installées. Une fois connecté à votre environnement virtuel, l’exécutable python utilisera automatiquement la version 3.

Maintenant que nous avons un environnement virtuel, nous pouvons installer les paquets requis. Nous allons utiliser pip, le gestionnaire de paquets pour Python, qui est également inclus dans votre installation Python :

Code Snippet

Ensuite, nous allons créer un répertoire pour notre projet, y naviguer, et mettre en place les fichiers nécessaires au projet.

Code Snippetmkdir pymongo-fastapi-crud
cd pymongo-fastapi-crud
touch main.py routes.py models.py .env

Remarque : nous utiliserons des commandes shell pour créer des fichiers et des répertoires, et pour naviguer dedans. Si vous préférez, vous pouvez utiliser un explorateur de fichiers graphique.

Commençons par implémenter un point de terminaison racine `/` simple qui renvoie un message de bienvenue. Ouvrez le fichier main.py dans votre éditeur de code préféré et ajoutez ce qui suit :

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Welcome to the PyMongo tutorial!"}

Enregistrez le fichier et exécutez l’application avec le paquet uvicorn, qui a été installé en même temps que le paquet fastapi.

Code Snippet

Vous devriez voir la réponse suivante :

Code SnippetINFO:     Will watch for changes in these directories: ['/Users/you/pymongo-fastapi-crud']
INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process [2465] using watchgod
INFO:     Started server process [2467]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

Ouvrez http://127.0.0.1:8000 dans votre navigateur. Le message de bienvenue devrait s’afficher.

Bien joué ! Nous avons un serveur qui fonctionne. Dans la section suivante, nous allons nous connecter à notre cluster MongoDB Atlas.

Connexion à votre cluster MongoDB Atlas

Ensuite, nous devons nous connecter au cluster MongoDB Atlas que nous avons créé précédemment. Localisez votre string de connexion et ajoutez-le au fichier .env. Remplacez le nom d’utilisateur et le mot de passe par vos identifiants.

pymongo-fastapi-crud/.env

Code SnippetATLAS_URI=mongodb+srv://<username>:<password>@sandbox.lqlql.mongodb.net/?retryWrites=true&w=majority
DB_NAME=pymongo_tutorial

Nous utiliserons le paquet python-dotenv pour charger les variables d’environnement ATLAS_URI et DB_NAME depuis le fichier .env. Ensuite, nous utiliserons le paquet pymongo pour nous connecter au cluster Atlas au démarrage de l’application. Nous ajouterons un autre gestionnaire d’événements pour fermer la connexion lorsque l’application s’arrête. Ouvrez à nouveau le fichier main.py et remplacez son contenu par ce qui suit :

Code Snippetfrom fastapi import FastAPI
from dotenv import dotenv_values
from pymongo import MongoClient

config = dotenv_values(".env")

app = FastAPI()

@app.on_event("startup")
def startup_db_client():
    app.mongodb_client = MongoClient(config["ATLAS_URI"])
    app.database = app.mongodb_client[config["DB_NAME"]]
    print("Connected to the MongoDB database!")

@app.on_event("shutdown")
def shutdown_db_client():
    app.mongodb_client.close()

Le processus uvicorn détectera la modification du fichier et redémarrera le serveur. Le message « Connecté à la base de données MongoDB ! » devrait s’afficher dans le terminal.

Créer des modèles pour les requêtes et réponses d'API

MongoDB possède un modèle de schéma flexible qui permet de regrouper des documents de structure différente au sein de la même collection. En pratique, les documents d’une collection partagent généralement la même structure. Si besoin, vous pouvez même appliquer des règles de validation par collection. Notre tutoriel PyMongo ne couvre pas la validation des bases de données. Nous nous assurerons à la place que les données passant par l’API REST sont valides avant de les stocker dans la base de données.

Nous allons créer quelques modèles de requêtes et de réponses de l’API et laisser FastAPI faire le gros du travail à notre place. Le framework se chargera de la validation, de la conversion vers les bons types de données et même de la génération de la documentation de l’API. Ouvrez le fichier models.py et ajoutez ce qui suit :

pymongo-fastapi-crud/models.py

Code Snippetimport uuid
from typing import Optional
from pydantic import BaseModel, Field

class Book(BaseModel):
    id: str = Field(default_factory=uuid.uuid4, alias="_id")
    title: str = Field(...)
    author: str = Field(...)
    synopsis: str = Field(...)

    class Config:
        allow_population_by_field_name = True
        schema_extra = {
            "example": {
                "_id": "066de609-b04a-4b30-b46c-32537c7f1f6e",
                "title": "Don Quixote",
                "author": "Miguel de Cervantes",
                "synopsis": "..."
            }
        }

class BookUpdate(BaseModel):
    title: Optional[str]
    author: Optional[str]
    synopsis: Optional[str]

    class Config:
        schema_extra = {
            "example": {
                "title": "Don Quixote",
                "author": "Miguel de Cervantes",
                "synopsis": "Don Quixote is a Spanish novel by Miguel de Cervantes..."
            }
        }

Nous étendons le BaseModel du paquet pydantic et ajoutons les champs pour nos modèles. Pour le modèle Book, nous avons quatre champs obligatoires : id, title, author et synopsis. Le champ id est automatiquement rempli avec un UUID (identifiant universel unique). Nous avons également un exemple pour le modèle Book qui sera affiché dans la documentation de l’API.

Les champs du modèle BookUpdate sont facultatifs. Cela nous permettra d’effectuer des mises à jour partielles. Nous n’avons pas de champ id dans le modèle BookUpdate car nous ne voulons pas permettre à l’utilisateur de modifier l’id.

Maintenant que nous avons défini nos modèles, mettons en œuvre les points de terminaison de l'API REST et utilisons les modèles pour valider les données.

Implémenter les points de terminaison de l’API REST

Passons maintenant à la partie amusante ! Nous allons créer les points de terminaison de l’API REST pour nos livres. Nous ajouterons l’implémentation des points de terminaison dans le fichier routes.py, et chargerons les routes dans le fichier main.py. Nous allons commencer par initialiser un objet APIRouter dans le fichier routes.py :

pymongo-fastapi-crud/routes.py

Code Snippetfrom fastapi import APIRouter, Body, Request, Response, HTTPException, status
from fastapi.encoders import jsonable_encoder
from typing import List

from models import Book, BookUpdate

router = APIRouter()

Comme vous pouvez le constater, nous importons APIRouter depuis le paquet fastapi. Nous allons utiliser cet objet pour définir les points de terminaison de notre API REST. Nous importons également les modèles Book et BookUpdate que nous avons définis précédemment.

POST /book

Le premier point de terminaison que nous allons implémenter est POST /books pour créer un nouveau livre. Ajoutez ce qui suit après la ligne router = APIRouter() :

pymongo-fastapi-crud/routes.py

Code Snippet@router.post("/", response_description="Create a new book", status_code=status.HTTP_201_CREATED, response_model=Book)
def create_book(request: Request, book: Book = Body(...)):
    book = jsonable_encoder(book)
    new_book = request.app.database["books"].insert_one(book)
    created_book = request.app.database["books"].find_one(
        {"_id": new_book.inserted_id}
    )

    return created_book

La route est / parce que nous allons préfixer tous les points de terminaison des livres par /books. L’attribut response_description sera affiché dans la documentation de l’API. L’attribut status_code est le code d’état HTTP renvoyé lorsque la requête est réussie. Nous utilisons le modèle Book pour valider à la fois les données transmises dans le corps de la requête et la réponse envoyée. FastAPI se charge de la validation. Dans le corps de la fonction, nous utilisons la méthode insert_one() de PyMongo pour ajouter le nouveau livre à la collection books. Nous utilisons la méthode find_one() pour retrouver le livre nouvellement créé dans la base de données. Pour en savoir plus sur les méthodes insert_one() et find_one(), consultez l’article de documentation de PyMongo pour les opérations au niveau de la collection.

Enfin, nous renvoyons le livre créé.

GET /book

Ensuite, nous allons implémenter le point de terminaison GET /book pour renvoyer une liste contenant tous les documents de la collection books. Ajoutez ce qui suit à la fin du fichier routes.py :

pymongo-fastapi-crud/routes.py

Code Snippet@router.get("/", response_description="List all books", response_model=List[Book])
def list_books(request: Request):
    books = list(request.app.database["books"].find(limit=100))
    return books

Pour le modèle de réponse, nous utilisons le type List[Book]. Cela signifie que la réponse sera une liste d’objets Book. Nous utilisons également la méthode find() pour extraire au maximum 100 livres de la base de données. Pour en savoir plus sur la limite et les autres paramètres de la méthode find(), consultez la page dédiée de la documentation PyMongo.

GET /book/{id}

Créons un autre point de terminaison GET pour récupérer un seul livre par son id. Ajoutez ce qui suit à la fin du fichier routes.py :

pymongo-fastapi-crud/routes.py

Code Snippet@router.get("/{id}", response_description="Get a single book by id", response_model=Book)
def find_book(id: str, request: Request):
    if (book := request.app.database["books"].find_one({"_id": id})) is not None:
        return book
    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Ici, nous utilisons la méthode find_one() pour extraire un seul livre de la base de données. Si le livre est trouvé, nous le renvoyons. Si le livre est introuvable, nous lançons une HTTPException avec un code d’état 404 Not Found et un message approprié.

PUT /book/{id}

Le point de terminaison le plus important de notre API REST est sans doute PUT /book/{id}. Ce point de terminaison nous permet de mettre à jour un seul livre. Ajoutez l’implémentation suivante à la fin du fichier routes.py :

pymongo-fastapi-crud/routes.py

Code Snippet@router.put("/{id}", response_description="Update a book", response_model=Book)
def update_book(id: str, request: Request, book: BookUpdate = Body(...)):
    book = {k: v for k, v in book.dict().items() if v is not None}
    if len(book) >= 1:
        update_result = request.app.database["books"].update_one(
            {"_id": id}, {"$set": book}
        )

        if update_result.modified_count == 0:
            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

    if (
        existing_book := request.app.database["books"].find_one({"_id": id})
    ) is not None:
        return existing_book

    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Passons en revue le code. Tout d’abord, nous créons un objet que nous utiliserons pour mettre à jour le livre. Ensuite, s’il existe des champs dans l’objet book, nous utilisons la méthode update_one() pour mettre à jour le livre dans la base de données. Il est important de noter que nous utilisons l’opérateur de mise à jour $set pour garantir que seuls les champs spécifiés sont mis à jour, plutôt que de réécrire l’ensemble du document.

Ensuite, nous vérifions l’attribut modified_count de update_result pour vérifier que le livre a été mis à jour. Si c’est le cas, nous utilisons la méthode find_one() pour extraire le livre mis à jour de la base de données et le renvoyer.

S’il n’y a pas de champs dans l’objet book, nous renvoyons simplement le livre existant. Cependant, si le livre est introuvable, nous lançons une commande HTTPException avec un code d’état 404 Not Found.

SUPPRIMER /book/{id}

Le dernier point de terminaison que nous allons implémenter est DELETE /book/{id} pour supprimer un seul livre par son ID. Ajoutez ce qui suit à la fin du fichier routes.py :

pymongo-fastapi-crud/routes.py

Code Snippet@router.delete("/{id}", response_description="Delete a book")
def delete_book(id: str, request: Request, response: Response):
    delete_result = request.app.database["books"].delete_one({"_id": id})

    if delete_result.deleted_count == 1:
        response.status_code = status.HTTP_204_NO_CONTENT
        return response

    raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"Book with ID {id} not found")

Ici, notons que si le livre a été supprimé, nous renvoyons un code d’état 204 No Content. Il s’agit d’un code d’état réussi indiquant que la requête a abouti et qu’il n’y a pas de contenu à envoyer dans le corps de la réponse.

Enregistrer

Enfin, nous devons enregistrer les points de terminaison /book. Ouvrez le fichier main.py, importez le module routes et enregistrez le routeur de livres. Votre version finale du fichier main.py devrait ressembler à ceci :

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI
from dotenv import dotenv_values
from pymongo import MongoClient
from routes import router as book_router

config = dotenv_values(".env")

app = FastAPI()

@app.on_event("startup")
def startup_db_client():
    app.mongodb_client = MongoClient(config["ATLAS_URI"])
    app.database = app.mongodb_client[config["DB_NAME"]]

@app.on_event("shutdown")
def shutdown_db_client():
    app.mongodb_client.close()

app.include_router(book_router, tags=["books"], prefix="/book")

Explorer la page de documentation de l’API et tester les points de terminaison

Assurez-vous que votre processus uvicorn est toujours en cours avant de continuer. Si ce n’est pas le cas, vous pouvez commencer avec la même commande dans le terminal :

Code Snippet

Accédez à l’URL http://localhost:8000/docs dans votre navigateur. Voici la page de documentation de l’API que FastAPI et Swagger ont générée pour nous.

Nous voyons tous les points de terminaison que nous avons créés et nous pouvons même envoyer des requêtes directement depuis cette page. Ouvrez l’onglet POST et cliquez sur le bouton Try it out. Un corps de requête prérempli avec notre livre d’exemple devrait s’afficher. Cliquez sur Exécuter pour envoyer la requête. Une réponse de réussite avec le livre que nous avons créé devrait s’afficher. Vous pouvez copier l’id du livre à partir de la réponse et l’utiliser dans l’un des autres points de terminaison : GET /book/{id}, PUT /book/{id} ou DELETE /book/{id}.

Que se passe-t-il si nous essayons de créer le même livre deux fois ? Nous obtenons une réponse 500 Internal Server Error. Si nous vérifions le terminal dans lequel le processus du serveur s’exécute, nous devrions voir un message d’erreur contenant ce qui suit :

Code Snippetpymongo.errors.DuplicateKeyError: E11000 duplicate key error collection: pymongo_tutorial.books index: _id

Nous avons reçu une erreur DuplicateKeyError car nous avons essayé d’insérer un livre avec le même champ _id deux fois. Le champ _id est un index unique que MongoDB crée pour chaque collection. Nous ne pouvons pas avoir deux livres avec le même _id. Le véritable problème ici est que nous ne gérons pas cette erreur dans notre code. L’erreur remonte et le serveur répond par un message 500 Internal Server Error. À titre d’exercice, vous pouvez penser à une réponse appropriée à renvoyer au client et à la manière de gérer cette erreur.

Vous pouvez également tester les règles de validation que nous avons créées. Par exemple, essayez de supprimer le champ obligatoire title du corps de la requête et cliquez sur Execute. Un message d’erreur devrait s’afficher indiquant que le champ title est obligatoire.

La page de documentation de l'API générée est très utile pour tester différents scénarios et observer le comportement de l'API. Amusez-vous à explorer l'API que nous avons créée.

Conclusion

Dans ce tutoriel, nous avons vu comment créer une application CRUD simple avec FastAPI et PyMongo, le pilote officiel MongoDB pour les applications Python synchrones. Nous avons également vu comment configurer rapidement un cluster MongoDB Atlas gratuit et nous y connecter. MongoDB Atlas est bien plus qu’une simple base de données cloud MongoDB. Par exemple, vous pouvez facilement étendre votre API pour fournir une recherche en texte intégral avec Atlas Search. Tous ces services sont disponibles dans MongoDB Atlas. Si vous voulez les essayer, créez votre compte gratuit.

FAQ

PyMongo est le pilote MongoDB officiel pour les applications Python synchrones. Il vous permet de vous connecter à une instance MongoDB et d'interroger des données. C'est un excellent outil pour développer des applications qui interagissent avec MongoDB.

PyMongo est un paquet Python. Vous pouvez l'installer en utilisant la commande `pip` : `python -m pip install pymongo[srv]`.

Une fois que vous avez installé PyMongo, vous pouvez l'importer dans votre application, vous connecter à une instance MongoDB et commencer à interroger les données.

PyMongo est le pilote Python officiel de MongoDB, tandis que MongoEngine est un ORM (Object Relational Mapper) qui utilise PyMongo en interne. PyMongo est officiellement pris en charge et recommandé par MongoDB. Pour en savoir plus sur les différences entre les deux, consultez l’article dédié

Commencez avec MongoDB Atlas dès aujourd’hui

Commencez en quelques secondes. Nos clusters gratuits sont fournis avec une capacité de stockage de 512 Mo afin que vous puissiez tester des exemples de données et vous familiariser avec notre plateforme.

Essai gratuitContacter le service commercial

PREMIERS PAS :

Plus de 125 régions dans le monde
Exemples de jeux de données
Authentification permanente
Chiffrement de bout en bout

Outils de ligne de commande

Qu'est-ce que PyMongo ? Prise en main de Python et MongoDB

Application CRUD de gestion de livres

Exigences

Configuration et mise en place du projet

Connexion à votre cluster MongoDB Atlas

Créer des modèles pour les requêtes et réponses d'API

Implémenter les points de terminaison de l’API REST

POST /book

GET /book

GET /book/{id}

PUT /book/{id}

SUPPRIMER /book/{id}

Enregistrer

Explorer la page de documentation de l’API et tester les points de terminaison

Conclusion

FAQ

Que pouvez-vous faire avec PyMongo ?

Comment télécharger et installer PyMongo ?

Comment utilisez-vous PyMongo ?

Devrais-je utiliser PyMongo ou MongoEngine ?

Commencez avec MongoDB Atlas dès aujourd’hui