AnnuncioTi presentiamo MongoDB 8.0, il MongoDB più veloce di sempre! Leggi >

AnnuncioVoyage AI si unisce a MongoDB per potenziare applicazioni AI più accurate e affidabili su Atlas. Scopra di più >

Che cos'è PyMongo? Introduzione a Python e MongoDB

Prova Atlas oggi

PyMongo è il driver ufficiale di MongoDB per le applicazioni Python sincrone. Se vuoi imparare come connetterti e usare MongoDB dalla tua applicazione Python, questo tutorial ti sarà utile. In questo tutorial su PyMongo, creeremo una semplice applicazione CRUD (creazione, lettura, aggiornamento, eliminazione) utilizzando FastAPI e MongoDB Atlas. L'applicazione sarà in grado di creare, leggere, aggiornare ed eliminare documenti in un database MongoDB, esponendo la funzionalità tramite una REST API. Puoi trovare l'applicazione finita su Github.

Che cos'è PyMongo? Introduzione a Python e MongoDB

Applicazione CRUD per la gestione dei libri
Requisiti
Impostazione e configurazione del progetto
Collegati al tuo cluster MongoDB Atlas
Creare modelli per le richieste e le risposte API
Implementare gli endpoint della REST API
Esplorare la pagina della documentazione API e testare gli endpoint
Conclusione

Applicazione CRUD per la gestione dei libri

Il mio modo preferito per apprendere nuove tecnologie è creare una soluzione. Ecco perché svilupperemo l'applicazione di backend più semplice ma utile: un'app CRUD per la gestione di libri. Le operazioni CRUD saranno accessibili tramite una REST API. L'API avrà cinque endpoint:

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

Per costruire l'API, useremo il framework FastAPI. È un framework leggero, moderno e facile da usare per costruire API. Genera anche una documentazione dell'API Swagger che utilizzeremo durante i test dell'applicazione.

Conserveremo i libri in un cluster MongoDB Atlas. MongoDB Atlas è la piattaforma database-as-a-service di MongoDB. È basato sul cloud e si può creare un account gratuito e un cluster in pochi minuti, senza installare nulla sul proprio computer. Utilizzeremo PyMongo per collegarci al cluster e interrogare i dati.

Requisiti

Il progetto finito è disponibile su Github. Puoi anche seguire le istruzioni dettagliate per creare il progetto da zero. Per farlo, avrai bisogno di quanto segue:

Python 3.6+: può essere installato dal sito web di Python.
Un cluster MongoDB Atlas: puoi creare un cluster gratuito per sempre seguendo la guida Introduzione ad Atlas. Completa i passaggi della guida e individua la stringa di connessione: ti servirà per connetterti al database dall'applicazione.

Impostazione e configurazione del progetto

Prima di iniziare, creeremo un ambiente virtuale Python per isolare il progetto dal resto dei pacchetti Python installati globalmente. Useremo il pacchetto venv, incluso nell'installazione di Python. Esegui il seguente comando dal terminale:

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

Nota: potrebbe essere necessario eseguire questo comando utilizzando l'eseguibile python3. Questo perché, su alcuni sistemi operativi, sono installati sia Python 2 che Python 3. Una volta effettuato l'accesso all'ambiente virtuale, l'eseguibile python utilizzerà automaticamente la versione 3.

Ora che abbiamo un ambiente virtuale, possiamo installare i pacchetti necessari. Utilizzeremo pip, il gestore di pacchetti per Python, che è incluso anche nella tua installazione di Python:

Code Snippet

Successivamente, creeremo una directory per il nostro progetto, vi accederemo e predisporremo i file necessari per il progetto.

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

Nota: useremo comandi shell per creare file e directory e navigare al loro interno. Se preferisci, puoi utilizzare un esplora file grafico.

Iniziamo implementando un semplice endpoint root / che restituisca un messaggio di benvenuto. Apri il file main.py nel tuo editor di codice preferito e aggiungi quanto segue:

pymongo-fastapi-crud/main.py

Code Snippetfrom fastapi import FastAPI

app = FastAPI()

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

Salva il file ed esegui l'applicazione utilizzando il pacchetto uvicorn, installato insieme al pacchetto fastapi.

Code Snippet

Dovrebbe vedere la seguente risposta:

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.

Apri http://127.0.0.1:8000 nel browser. Dovresti vedere il messaggio di benvenuto.

Ben fatto! Abbiamo un server in esecuzione. Nella sezione seguente, ci collegheremo al nostro MongoDB Atlas cluster.

Collegati al tuo cluster MongoDB Atlas.

Successivamente, dobbiamo collegarci al cluster MongoDB Atlas che abbiamo creato in precedenza. Individua la tua string di connessione e aggiungila al file .env. Sostituisci il nome utente e la password con le tue credenziali.

pymongo-fastapi-crud/.env

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

Utilizzeremo il pacchetto python-dotenv per caricare le variabili di ambiente ATLAS_URI e DB_NAME dal file .env. Poi, useremo il pacchetto pymongo per collegarci al cluster Atlas quando l'applicazione si avvia. Aggiungeremo un altro gestore di eventi per chiudere la connessione quando l'applicazione si interrompe. Apri di nuovo il file main.py e sostituisci il contenuto con quanto segue:

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()

Il processo uvicorn rileverà la modifica del file e riavvierà il server. Dovresti vedere il messaggio “Connesso al database MongoDB!” nel terminale.

Crea modelli per le richieste e le risposte API

MongoDB dispone di un modello di schema flessibile che consente di avere documenti con strutture diverse all'interno della stessa tabella. In pratica, i documenti in una raccolta solitamente condividono la stessa struttura. Se necessario, puoi anche rafforzare le regole di convalida per tabella. Nel nostro tutorial su PyMongo non tratteremo la convalida del database. Invece, ci assicureremo che i dati che passano attraverso la REST API siano validi prima di memorizzarli nel database.

Creeremo un paio di modelli per le richieste e le risposte API e lasceremo che FastAPI faccia il lavoro difficile per noi. Il framework si occuperà della convalida, della conversione nei tipi di dati corretti e persino della generazione della documentazione API. Apri il file models.py e aggiungi quanto segue:

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..."
            }
        }

Stiamo estendendo il BaseModel dal pacchetto pydantic e aggiungendo i campi per i nostri modelli. Per il modello Book, abbiamo quattro campi obbligatori: id, title, author e synopsis. Il campo id viene popolato automaticamente con un UUID (identificatore univoco universale). Abbiamo anche un esempio per il modello Book che sarà mostrato nella documentazione API.

I campi nel modello BookUpdate sono facoltativi. Ciò ci consentirà di eseguire aggiornamenti parziali. Non abbiamo un campo id nel modello BookUpdate perché non vogliamo consentire all'utente di aggiornare l'id.

Ora che abbiamo definito i modelli, implementiamo gli endpoint della REST API e utilizziamo i modelli per convalidare i dati.

Implementare gli endpoint della REST API

È il momento della parte divertente! Creiamo gli endpoint REST API per i nostri libri. Aggiungeremo l'implementazione degli endpoint nel file routes.py e caricheremo le route nel file main.py. Inizieremo inizializzando un oggetto APIRouter in 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()

Come puoi notare, stiamo importando APIRouter dal pacchetto fastapi. Utilizzeremo questo oggetto per definire gli endpoint per la nostra REST API. Stiamo anche importando i modelli Book e BookUpdate che abbiamo definito in precedenza.

POST /book

Il primo endpoint che implementeremo è l'endpoint POST /books per la creazione di un nuovo libro. Aggiungi quanto segue dopo la riga 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

Il percorso è / perché anteporremo a tutti gli endpoint dei libri /books. response_description sarà visualizzato nella documentazione dell'API. status_code è il codice di stato HTTP restituito quando la richiesta ha esito positivo. Usiamo il modello Book per convalidare sia i dati trasmessi nel corpo della richiesta che la risposta che abbiamo inviato. FastAPI gestisce la convalida per noi. Nel corpo della funzione, usiamo il metodo insert_one() di PyMongo per aggiungere il nuovo libro alla raccoltabooks. Usiamo il metodo find_one() per recuperare il libro appena creato dal database. Puoi leggere di più sui metodi insert_one() e find_one() nell'articolo della documentazione di PyMongo per operazioni a livello di tabella.

Infine, restituiamo il libro creato.

GET /book

Successivamente, implementeremo l'endpoint GET /book per restituire un elenco con tutti i documenti nella raccolta books. Aggiungi quanto segue alla fine del file 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

Per il modello di risposta, utilizziamo il tipo List[Book]. Ciò significa che la risposta sarà un elenco di oggetti Book. Usiamo anche il metodo find() per recuperare non più di 100 libri dal database. Per ulteriori informazioni su limit e sugli altri parametri del metodo find(), consulta la pagina di documentazione dedicata a PyMongo.

GET /libro/{id}

Creiamo un altro endpoint GET per recuperare un singolo libro in base al suo id. Aggiungi quanto segue alla fine del file 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")

Qui utilizziamo il metodo find_one() per recuperare un singolo libro dal database. Se troviamo il libro, produrremo il risultato. Se il libro non viene trovato, solleveremo un'HTTPException con un codice di stato 404 Not Found e un messaggio appropriato.

PUT /book/{id}

Probabilmente, l'endpoint più importante per la nostra REST API è l'endpoint PUT /book/{id}. Questo endpoint ci consente di aggiornare un singolo libro. Aggiungi l'implementazione alla fine del file 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")

Dedichiamoci al codice. Per prima cosa, creiamo un oggetto che useremo per aggiornare il libro. Quindi, se ci sono campi nell'oggetto book, utilizziamo il metodo update_one() per aggiornare il libro nel database. È importante notare che stiamo utilizzando l'operatore di aggiornamento $set per garantire che solo i campi specificati vengano aggiornati invece di riscrivere l'intero documento.

Quindi, verifichiamo l'attributo modified_count di update_result per assicurarci che il libro sia stato aggiornato. Se è così, stiamo utilizzando il metodo find_one() per recuperare il libro aggiornato dal database e restituirlo.

Se non ci sono campi nell'oggetto book, restituiamo semplicemente il libro esistente. Tuttavia, se il libro non viene trovato, genereremo un'HTTPException con un codice di stato 404 Not Found.

DELETE /book/{id}

L'ultimo endpoint che implementeremo è l'endpoint DELETE /book/{id} per eliminare un singolo libro in base al suo id. Aggiungi quanto segue alla fine del file 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")

L'unica cosa degna di nota è che se il libro è stato cancellato, restituiamo un codice di stato 204 No Content. Questo è un codice di stato di successo che indica che la richiesta è stata completata e che non esiste contenuto da inviare nel corpo del payload di risposta.

Registrare gli

Infine, è necessario registrare gli endpoint /book. Aprire il file main.py, importa il modulo routes e registra il router dei libri. La tua versione finale del file main.py dovrebbe apparire come segue:

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")

Esplorare la pagina della documentazione API e testare gli endpoint

Assicurati che il processo uvicorn sia ancora in esecuzione prima di continuare. In caso contrario, puoi iniziare con lo stesso comando nel terminale:

Code Snippet

Vai all'URL http://localhost:8000/docs nel browser. Questa è la pagina di documentazione dell'API che FastAPI e Swagger hanno generato per noi!

Vediamo tutti gli endpoint che abbiamo creato e possiamo persino inviare richieste direttamente da questa pagina. Apri la tab POST e fai clic sul pulsante Provalo. Dovresti vedere un corpo della richiesta precompilato con il nostro libro di esempio. Fai clic su Esegui per inviare la richiesta. Dovresti vedere una risposta di successo con il libro che abbiamo creato. Puoi prendere l'ID del libro dalla risposta e usarlo in uno degli altri endpoint: GET /book/{id}, PUT /book/{id} o DELETE /book/{id}.

Ma cosa accadrebbe se provassimo a creare lo stesso libro due volte? Riceveremo una risposta 500 Internal Server Error. Se controlliamo il terminale su cui è in esecuzione il processo del server, dovremmo vedere un messaggio di errore contenente quanto segue:

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

Abbiamo ricevuto un DuplicateKeyError perché abbiamo provato due volte a inserire un libro con lo stesso campo _id. Il campo _id è un indice unico che MongoDB crea per ogni tabella. Non possiamo avere due libri con lo stesso _id. Il problema reale qui è che non stiamo gestendo questo errore nel nostro codice. L'errore "si propaga" e il server risponde con un 500 Internal Server Error. Come esercizio, puoi pensare a una risposta appropriata da inviare al client e gestire questo errore.

Puoi anche testare le regole di convalida che abbiamo creato. Ad esempio, prova a rimuovere il campo obbligatorio title dal corpo della richiesta e fai clic su Esegui. Dovresti vedere un messaggio di errore che dice che il campo title è obbligatorio.

La pagina di documentazione dell'API generata è molto utile per testare diversi scenari e osservare il comportamento dell'API. Divertiti a esplorare l'API che abbiamo creato.

Conclusione

In questo tutorial, abbiamo visto come creare una semplice applicazione CRUD con FastAPI e PyMongo, il driver ufficiale di MongoDB per applicazioni Python sincrone. Abbiamo anche visto come possiamo rapidamente impostare un MongoDB Atlas cluster gratuito e connetterci ad esso. MongoDB Atlas è molto più di un semplice database cloud MongoDB. Ad esempio, puoi facilmente estendere la tua API per fornire una ricerca full-text con Atlas Search. Tutti questi servizi sono disponibili in MongoDB Atlas. Se vuoi provarli, crea il tuo account gratuito.

Domande frequenti

PyMongo è il driver ufficiale di MongoDB per le applicazioni Python sincrone. È possibile connettersi a un'istanza MongoDB ed eseguire query sui dati. È un ottimo strumento per sviluppare applicazioni che interagiscono con MongoDB.

PyMongo è un pacchetto Python. Puoi installarlo con `pip`: `python -m pip install pymongo[srv]`.

Una volta installato PyMongo, può importarlo nella tua applicazione, connetterti a un'istanza di MongoDB e iniziare a interrogare i dati.

PyMongo è il driver Python ufficiale di MongoDB, mentre MongoEngine è un ORM (Object Relational Mapper) che utilizza PyMongo internamente. PyMongo è ufficialmente supportato e consigliato da MongoDB. Leggi di più sulle differenze tra i due nell'articolo dedicato.

Inizia subito con Atlas

Inizia in pochi secondi. I nostri cluster gratuiti sono dotati di 512 MB di spazio di archiviazione, così puoi utilizzare i dati di esempio e iniziare ad acquisire familiarità con la nostra piattaforma.

Prova gratuitaContatta il reparto vendite

INIZIA CON:

Oltre 125 regioni in tutto il mondo
Set di dati di esempio
Autenticazione sempre attiva
Crittografia end-to-end

Strumenti a riga di comando

Che cos'è PyMongo? Introduzione a Python e MongoDB

Applicazione CRUD per la gestione dei libri

Requisiti

Impostazione e configurazione del progetto

Collegati al tuo cluster MongoDB Atlas.

Crea modelli per le richieste e le risposte API

Implementare gli endpoint della REST API

POST /book

GET /book

GET /libro/{id}

PUT /book/{id}

DELETE /book/{id}

Registrare gli

Esplorare la pagina della documentazione API e testare gli endpoint

Conclusione

Domande frequenti

Cosa puoi fare con PyMongo?

Come faccio a scaricare e installare PyMongo?

Come si utilizza PyMongo?

Devo usare PyMongo o MongoEngine?

Inizia subito con Atlas