Come installare Fast API con MongoDB su Ubuntu 24.04

FastAPI è un framework web basato su Python per la creazione di servizi API. È un framework moderno, veloce e ad alte prestazioni che supporta operazioni asincrone.

In questo tutorial, imparerai come installare FastAPI con MongoDB su Ubuntu 24.04. Imparerai anche come creare la tua prima API con operazioni CRUD utilizzando FastAPI e il database MongoDB.

Prerequisiti

Per iniziare con questa guida, assicurati di avere i seguenti requisiti:

• Un sistema Ubuntu 24.04
• Un utente non root con privilegi di amministratore

Installazione di MongoDB

Prima di creare un nuovo progetto FastAPI, installiamo il server MongoDB sul nostro sistema.

Per prima cosa, esegui il comando qui sotto per aggiornare l’indice dei pacchetti e installare ‘gnupg’ e ‘curl’ sul tuo sistema.

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

Esegui il comando qui sotto per aggiungere la chiave GPG per il server 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

Aggiungi il repository MongoDB utilizzando il comando qui sotto.

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

Dopo aver aggiunto il repository, esegui il seguente comando per aggiornare l’indice dei pacchetti e installare il server MongoDB. Inserisci ‘Y’ per confermare l’installazione.

sudo apt update && sudo apt install mongodb-org

Quando l’installazione è terminata, avvia e abilita il servizio MongoDB ‘mongod’, quindi controlla lo stato del servizio MongoDB per assicurarti che sia in esecuzione.

sudo systemctl enable --now mongod  
sudo systemctl status mongod

Puoi vedere qui sotto che il server MongoDB è in esecuzione.

In aggiunta a ciò, puoi accedere al server MongoDB con il comando ‘mongosh’ qui sotto. Per uscire, premi Ctrl+d.

mongosh

Configurazione di Python e Ambiente Virtuale

Con MongoDB installato, installerai i pacchetti Python e configurerai la directory del progetto e l’ambiente virtuale.

Installa Python, Pip e i moduli Venv con il seguente comando. Inserisci ‘Y’ per confermare l’installazione.

sudo apt install python3 python3-pip python3-venv

Una volta terminata l’installazione, accedi al tuo utente.

su - username

Ora crea una nuova directory ‘~/app‘ e spostati al suo interno. Questa directory sarà utilizzata per memorizzare il tuo progetto FastAPI.

mkdir -p ~/app; cd ~/app

Esegui il comando qui sotto per creare un nuovo ambiente virtuale ‘venv‘ e attivalo. Con questo, il tuo prompt della shell diventerà simile a ‘(venv) user@hostname‘.

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

Da qui, il tuo ambiente di lavoro deve essere sull’ambiente virtuale ‘venv’. Puoi disconnetterti da ‘venv’ utilizzando il comando qui sotto.

deactivate

Creazione del Progetto FastAPI

Ora che hai creato e attivato il tuo ambiente virtuale Python, installiamo FastAPI e creiamo la struttura del progetto.

Con il comando ‘pip3’, eseguilo per installare i pacchetti ‘fastapi’ e ‘uvicorn’.

pip3 install fastapi uvicorn

• ‘fastapi’ è il principale framework web FastAPI per costruire API in Python
• ‘uvicorn’ è l’implementazione del server web ASGI (Asynchronous Server Gateway Interface) in Python.

Dopo che l’installazione è terminata, crea nuovi file e directory con il seguente comando.

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

Di seguito è riportata la nostra struttura del progetto FastAPI.

server/app.py

Ora che il tuo progetto è pronto, modifichiamo il file ‘server/app.py’, che è l’applicazione principale del tuo progetto FastAPI.

Apri il file ‘app.py‘ con il tuo editor di testo e copia il seguente script.

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

• Importa il modulo FastAPI nel tuo progetto e collegalo alla variabile ‘app’
• Crea una nuova funzione ‘root’ che restituisce ‘Ciao FastAPI!’
• La funzione ‘root’ risponde al metodo GET sull’URL radice
• ‘async’ contrassegna la tua funzione come una funzione asincrona e potrebbe utilizzare ‘await’ all’interno del suo corpo quando viene chiamata

main.py

In questa sezione, modificheremo il file ‘main.py’ che sarà utilizzato per eseguire il tuo progetto FastAPI tramite ‘uvicorn’ (server web ASGI in Python).

Ora apri e modifica lo script ‘main.py‘ e inserisci il seguente codice.

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

• Importa il modulo ‘uvicorn’
• Quando lo script ‘main.py’ viene eseguito, caricherà il modulo ‘app’ o FastAPI all’interno di ‘server/app.py’
• FastAPI verrà eseguito su ‘0.0.0.0’ con la porta ‘8080’
• Abilita il riavvio automatico quando il codice cambia tramite ‘reload=True’

Esegui il tuo progetto FastAPI

Ora che il tuo progetto è pronto, eseguiamo il tuo primo progetto FastAPI.

Esegui lo script ‘main.py’ come segue e il tuo FastAPI sarà in esecuzione sul tuo sistema.

python3 main.py

Ora apri il tuo browser web e visita http://SERVERIP:8080/. Se la tua installazione è riuscita, vedrai il messaggio ‘Ciao FastAPI!’. Puoi anche accedervi tramite ‘curl’ dal terminale.

Infine, puoi accedere alla documentazione API su http://SERVERIP:8080/docs > fornita da Swagger UI.

Collegare FastAPI a MongoDB

In questa guida, creerai una API di base con FastAPI e MongoDB. La tua API dovrebbe essere in grado di eseguire operazioni CRUD con il server di database MongoDB. Per questo passaggio, collegherai il tuo progetto al server MongoDB.

Per prima cosa, esegui il comando ‘pip3’ qui sotto per installare il driver MongoDB ‘motor‘ nel tuo progetto. ‘motor’ fornisce accesso API non bloccante e basato su coroutine al server MongoDB.

pip3 install motor

server/database.py

Dopo che il modulo ‘motor‘ è installato, modifichiamo lo script ‘server/database.py‘.

Apri il file ‘server/database.py’ con il tuo editor di testo e inserisci il seguente script. Questo sarà utilizzato per connettersi al server MongoDB tramite il modulo ‘motor’.

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

• Importa ‘AsyncIOMotorClient’ da ‘motor.motor_asyncio’
• Crea una nuova costante ‘MONGODB_HOST’ e punta al server MongoDB ‘mongodb://localhost:27017’
• Connettiti al server MongoDB tramite la variabile ‘connection’
• Connettiti al database ‘items’ tramite la variabile ‘database’
• Accedi alle collezioni nel database con la variabile ‘item_collection’

Creazione del Modello di Database con pydantic

In questa sezione, progetterai i tuoi dati tramite ‘pydantic‘, che fornisce modellazione per il nostro database MongoDB.

Installa il modulo ‘pydantic’ con il comando ‘pip3’ qui sotto. Il modulo ‘pydantic‘ è una libreria di convalida dei dati che ti consente di creare schemi di database tramite modelli.

pip3 install pydantic

Ora apri il file ‘server/models/itemModels.py‘ con il tuo editor di testo e copia il seguente script.

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,  
 }  
 }

• Importa ‘BaseModel’ e ‘Field’ dai moduli ‘pydantic’
• Importa il modulo ‘Optional’ da ‘typing’
• Crea il seguente schema di database ‘Item’ per FastAPI: - ‘name’ e ‘category’ con tipo string
• ‘stocks’ e ‘price’ con tipo intero
• ‘price’ deve essere maggiore di 0
• Estendi il modello di dati tramite la classe ‘Config’ fornendo un esempio di dati che l’utente può includere nella richiesta
• Crea il seguente schema ‘ItemUpdate’ con ogni campo come opzionale.

Aggiunta di Operazioni CRUD

A questo punto, hai creato una connessione al server MongoDB e creato uno schema di database tramite ‘pydantic’. Passiamo a creare le operazioni CRUD con FastAPI e MongoDB.

Apri di nuovo lo script ‘server/database.py‘ e crea una nuova funzione ‘item_helper‘ con tipo ‘dict‘. Chiama questa funzione per ottenere dati dettagliati su un elemento.

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

Aggiungi la seguente riga per importare il modulo ‘ObjectId‘ da ‘bson.objectid’. L’ObjectId è parte del tipo di dati in BSON, che MongoDB utilizza per l’archiviazione dei dati e la rappresentazione dei dati JSON.

from bson.objectid import ObjectId

Creare un Elemento

Per prima cosa, creerai una funzione asincrona che sarà in grado di aggiungere nuovi dati al database MongoDB.

Crea una nuova funzione ‘add_item‘ come segue:

# Aggiungi un nuovo elemento  
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 funzione ‘add_item’ accetta dati di dizionario dei dettagli del tuo elemento
• Tramite ‘item_collection’ per accedere ai documenti nel database ed eseguire la query ‘insert_one’ per aggiungere un nuovo elemento
• Il nuovo elemento verrà stampato al termine dell’operazione

Recuperare Tutti gli Elementi

In secondo luogo, creerai una nuova funzione ‘get_items’ che sarà in grado di recuperare tutti gli elementi disponibili nel tuo database.

Crea una nuova funzione ‘get_items‘ per recuperare tutti gli elementi da MongoDB.

# recupera tutti gli elementi  
async def get_items():  
 items = []  
 async for item in item_collection.find():  
 items.append(item_helper(item))  
 return items

• Creerai una lista vuota di ‘items’
• Utilizzando la query ‘find()’ per cercare tutti i dati e scorrere attraverso di essi
• Ogni elemento verrà aggiunto alla lista ‘items’ tramite il metodo ‘append’
• Dopo che il ciclo è completo, i tuoi elementi verranno mostrati

Recuperare un Elemento Specifico in base all’id

Successivamente, creerai una nuova funzione che sarà in grado di recuperare i dati per un selettore specifico ‘id’. Questo ti mostrerà i dati dettagliati su elementi specifici.

Crea una nuova funzione ‘get_item‘ per recuperare i dati di elementi specifici. La funzione ‘get_item’ accetterà una stringa di ‘id’ come selettore e restituirà un dizionario.

# recupera un elemento specifico  
async def get_item(id: str) -> dict:  
 item = await item_collection.find_one({"_id": ObjectId(id)})  
 if item:  
 return item_helper(item)  
 return "Elemento non trovato."

• La query ‘find_one()’ verrà utilizzata per recuperare i dati in base all’’id’
• Se viene trovato un elemento, i dettagli verranno mostrati utilizzando il formato dizionario ‘item_helper’
• Se l’elemento non è disponibile, la risposta sarà ‘Elemento non trovato’

Aggiornare un elemento

Ora creerai una nuova funzione per aggiornare un elemento. Puoi anche aggiornare parzialmente il tuo elemento tramite API.

Definisci la nuova funzione ‘change_item‘ come i seguenti codici:

# aggiorna elemento  
async def change_item(id: str, data: dict):  
 if len(data) < 1:  
 return "Si prega di inserire i dati"  
 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 funzione ‘change_item’ prende due argomenti, l’’id’ dell’elemento target e ‘data’ come i nuovi dati
• Se i dati sono vuoti o ‘< 1’, l’operazione termina
• Questa funzione troverà un elemento in base al selettore ‘id’
• Se l’’id’ viene trovato, verrà eseguito ‘item_update’
• Se ‘item_update’ ha successo, restituisci ‘True’, oppure restituisci ‘False’ se non lo è

Eliminare un elemento

Infine, creerai la funzione ‘delete_item’ per eliminare gli elementi tramite un selettore specifico.

Per eliminare un elemento, creeremo la funzione ‘delete_item‘ e utilizzeremo il selettore ‘id’ come segue:

# elimina un elemento  
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'Elemento {id} eliminato.')  
 return "Elemento non trovato."

• La query ‘find_one()’ cercherà un elemento in base all’’id’ fornito
• Se l’elemento viene trovato, verrà eliminato tramite la query ‘delete_one()’ e restituirà ‘Elemento id eliminato’
• Se l’elemento non è disponibile, verrà mostrato ‘Elemento non trovato’

Aggiunta di Percorsi per le Operazioni CRUD

A questo punto, abbiamo creato funzioni asincrone per le operazioni CRUD con FastAPI. Ora creiamo il percorso o l’endpoint per ogni operazione.

Modifica il file ‘server/routes/item.py‘ utilizzando il tuo editor preferito.

server/routes/item.py

Per prima cosa, aggiungi i moduli ‘APIRouter‘ e ‘Body‘ da ‘fastapi’. Quindi, aggiungi il ‘jsonable_encode‘ da ‘fastapi.encoders’.

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

Importa ogni funzione dal file ‘database.py’.

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

Importa i modelli ‘Item’ e ‘ItemUpdate’ dal file ‘itemModels.py’.

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

Chiama la classe ‘APIRouter’ tramite la variabile ‘router’.

router = APIRouter()

Percorso per Aggiungere Nuovo Elemento

Ora aggiungiamo un percorso per aggiungere nuovi elementi. In questo esempio, puoi aggiungere un nuovo elemento tramite POST all’URL ‘/item‘.

Aggiungi le seguenti righe per impostare i percorsi per aggiungere nuovi elementi. Ogni POST all’URL radice dell’elemento sarà trattato come inserimento di nuovi dati.

# operazione di aggiunta nuovo elemento  
@router.post("/")  
async def add_item_data(item: Item = Body(...)):  
 item = jsonable_encoder(item)  
 new_item = await add_item(item)  
 return new_item

• La funzione ‘add_item_data’ accetta lo schema ‘Item’, che sarà parte del ‘Body’ nella tua richiesta
• Il tuo elemento verrà convertito in formato dizionario tramite ‘jsonable_encoder’
• Inserisci i tuoi dati di dizionario tramite la funzione ‘add_item’ (vedi database.py) sopra la variabile ‘new_item’
• Restituisci i tuoi dati inseriti ‘new_item’ come risposta

Percorso per Ottenere Tutti gli Elementi

Aggiungi il seguente script per impostare un percorso per recuperare i dati. Ogni richiesta GET all’URL radice dell’elemento recupererà tutti i tuoi dati.

# ottieni tutti gli elementi disponibili  
@router.get("/")  
async def get_item_data():  
 items = await get_items()  
 if items:  
 return items  
 return "Nessun elemento disponibile."

• Crea la funzione ‘get_item_data’ che eseguirà la funzione ‘get_item’ dal file ‘database.py’
• Se gli elementi sono disponibili, otterrai l’elenco di tutti i tuoi elementi
• Se non ci sono elementi, otterrai la risposta ‘Nessun elemento disponibile’

Percorso per Ottenere un Elemento Specifico

Per ottenere i dettagli di un elemento specifico, utilizzeremo l’’id’ come selettore. Ogni richiesta GET a ‘/id’ restituirà un elemento dettagliato dell’’id’ richiesto.

# Mostra i dettagli dell'elemento tramite l'id  
@router.get("/{id}")  
async def get_item_details(id):  
 item_details = await get_item(id)  
 if item_details:  
 return item_details  
 return "Elemento non trovato."

• La funzione ‘get_item_details’ verrà creata e passerà l’’id’ dall’URL
• La funzione ‘get_item’ (vedi database.py) verrà chiamata e passerà anche l’’id’ come argomento
• Se l’elemento viene trovato, verranno mostrati i dettagli dell’elemento
• Se non c’è alcun elemento con quell’’id’ specifico, otterrai ‘Elemento non trovato’

Percorso per Aggiornare un Elemento

Copia il seguente codice per impostare il percorso per l’elemento aggiornato:

# Aggiorna Elemento  
@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'Successo: elemento {id} aggiornato.'}  
 return "Errore"

• La funzione ‘update_item’ prenderà due argomenti, ‘id’ come selettore e ‘data’, che si basa sul modello ‘ItemUpdate’
• I dati verranno controllati nella variabile ‘data’
• L’’updated_item’ eseguirà la funzione ‘change_item’ dal file ‘database.py’
• Se l’aggiornamento ha successo, vedrai l’output ‘Successo’

Percorso per Eliminare un Elemento

Inserisci le seguenti righe per creare la funzione ‘remove_item’ per eliminare gli elementi. Ogni operazione DELETE su un specifico ‘/id’, rimuoverà l’elemento corrispondente all’’id’.

# elimina elemento tramite 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'Elemento {id} non disponibile.'}

• La funzione ‘remove_item’ eseguirà ‘delete_item’ e passerà il selettore ‘id’
• L’operazione di eliminazione verrà memorizzata ed eseguita tramite la variabile ‘item_to_delete’
• Quando un elemento non è disponibile, otterrai la restituzione ‘Elemento id non disponibile’

server/app.py

Ora che hai finito il file ‘server/routes/item.py’, includiamolo nel file ‘server/app.py’.

Apri il file ‘app.py‘ utilizzando il tuo editor di testo.

Importa il ‘router’ dal file ‘server/routes/item.py‘ come ‘ItemRouter’.

from server.routes.item import router as ItemRouter

Inserisci l’’ItemRouter’ con il prefisso predefinito ‘/item‘. Le operazioni CRUD saranno gestite tramite l’URL ‘/item‘.

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

Ora il tuo endpoint CRUD sarà disponibile ai seguenti:

• Aggiungi nuovo elemento: POST a ‘/item‘
• Recupera tutti gli elementi: GET a ‘/item‘
• Recupera elemento specifico: GET a ‘/item/id’. L’’id’ è generato da MongoDB
• Aggiorna elemento: PUT a ‘/item/id’
• Elimina elemento: DELETE a ‘/item/id’

Testare le Operazioni CRUD

Per prima cosa, assicurati che il tuo progetto FastAPI sia in esecuzione, oppure puoi eseguire lo script ‘main.py’ come segue:

python3 main.py

Naviga su http://SERVERIP:8080/docs e vedrai ogni percorso che hai creato.

Di seguito è riportato un esempio di aggiunta di un nuovo elemento.

Recupera tutti gli elementi disponibili tramite API.

Recupera elementi specifici tramite il selettore ‘id’.

Aggiorna i dati parziali da elementi specifici.

Di seguito sono riportati i dati aggiornati.

Di seguito è riportata l’operazione di eliminazione tramite il selettore ‘id’.

Conclusione

Congratulazioni! Hai completato l’installazione di FastAPI con MongoDB su Ubuntu 24.04. Hai anche imparato come collegare FastAPI a MongoDB utilizzando il modulo ‘motor’, creare modelli di dati tramite ‘pydantic’, creare operazioni CRUD con FastAPI e imparare come creare endpoint per la tua API.