Come impostare un’applicazione API veloce con una database NoSQL

Introduzione

Nell’sviluppo di applicazioni in Python, FastAPI emerge come una scelta leader per la creazione di soluzioni ad alte prestazioni. Offre velocità, semplicità e supporto per la programmazione asincrona, rendendolo ideale per lo sviluppo di applicazioni moderne e scalabili.
In questo tutorial, vi guiderò attraverso il processo di configurazione di un’applicazione FastAPI con una database NoSQL. Quando si tratta di memorizzare e gestire i dati, le basi di dati NoSQL offrono flessibilità e scalabilità, rendendole un ottimo candidato per applicazioni che devono gestire strutture dati diverse e complesse.

Prerequisiti

Prima di iniziare, dovete assicurarvi di avere il seguente:

• Un server in esecuzione su Ubuntu, insieme ad un utente non root con diritti sudo e un firewall attivo. Per istruzioni su come impostare questo setup, scegliete la vostra distribuzione da questo elenco e seguite il nostro guide di installazione iniziale del server. Assicuratevi di lavorare con una versione supportata di Ubuntu.

• Conoscenza della riga di comando di Linux. Per un’introduzione o un aggiornamento sulla riga di comando, puoi visitare questo guide sulla principianti Linux command line.

• Esegui sudo apt-get update nel terminale Ubuntu per assicurarti che il tuo sistema abbia le ultime versioni e aggiornamenti di sicurezza per il software disponibile dai repository configurati nel tuo sistema.

Step 1 – Impostare l’ambiente Python sul tuo computer

Durante questo tutorial, userremo il pacchetto python3 per eseguire i comandi. Le ultime versioni di Ubuntu includono l’installazione di Python 3, quindi per verificarne l’installazione, eseguite il seguente comando:

python3 --version

Se questo restituisce un errore, puoi installare/reinstallare il pacchetto eseguendo:

sudo apt-get install python3

Successivamente, devi installare pip per installare pacchetti Python e le loro dipendenze in modo sicuro.

sudo apt-get install python3-pip

Step 2 – Creare un ambiente virtuale

A partire da Python 3.11 e pip 22.3, viene introdotta una nuova PEP 668 che stabilisce come si debbano identificare le ambientazioni di base di Python come “gestite esternamente”, il che significa che non potrete installare correttamente i pacchetti con pip a meno che non lavoriate in un ambiente virtuale.

In questo passaggio, create un ambiente virtuale per il vostro progetto che isolerà le dipendenze del vostro progetto per evitare potenziali conflitti tra differenti versioni di pacchetti. Eseguite nel terminale il seguente insieme di comandi:

sudo apt-get install python3-venv

Questo comando installerà il pacchetto richiesto venv necessario per creare un ambiente virtuale.

python3 -m venv fastapi-env

Questo comando creerà un ambiente virtuale denominato fastapi-env all’interno della directory di lavoro. Per iniziare a lavorare all’interno di questo ambiente, dovete attivarlo.

source fastapi-env/bin/activate

Una volta eseguito correttamente, vedrete il prompt del terminale prefissato come questo:

(fastapi-env) user@machine:~$

Ora, potete iniziare ad installare le dipendenze richieste all’interno di questo ambiente virtuale.

Step 3 – Installare le Librerie e i Pacchetti Necessari

In questo passaggio, installerete alcuni pacchetti e librerie necessarie per seguire correttamente questo tutorial.

Inizieremo installando fastapi, necessario per costruire il tuo applicazione FastAPI, e uvicorn, necessario per eseguire l’applicazione FastAPI.

pip install fastapi uvicorn

In questo tutorial, userai MongoDB come database NoSQL. Per interagire con MongoDB all’interno di FastAPI, devi installare motor, che è un driver asincrono per MongoDB in Python.

pip install motor

Step 4 – Installare e Configurare MongoDB su Ubuntu

Per installare MongoDB sul tuo sistema Ubuntu, esegui i seguenti comandi nel terminale:

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

Al termine dell’esecuzione, questo restituisce il parametro echo. Ora, fai un rapido:

sudo apt-get update

Questo ti garantirà di ricevere le ultime aggiornazioni dopo aver configurato le chiavi di MongoDB.

Successivamente, devi installare un dipendente openssl sul tuo sistema, richiesto per l’installazione di MongoDB.

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

Al termine dell’esecuzione, verrai chiesto di riavviare i servizi. Dopo il riavvio, installa MongoDB utilizzando il seguente comando:

sudo apt-get install -y mongodb

Avvia e abilita i servizi di MongoDB:

sudo systemctl start mongod
sudo systemctl enable mongod

Puoi controllare lo stato del servizio di MongoDB e provare la connessione eseguendo i seguenti comandi:

sudo systemctl status mongod

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

Step 5 – Creare applicazione FastAPI

La prossima fase consiste nel creare un’applicazione FastAPI. Nel tuo directory di lavoro, crea un file database.py:

nano database.py

Questo apre un editor di testo vuoto. Scrivi qui la logica di connessione al database.

from motor.motor_asyncio import AsyncIOMotorClient

MONGO_DETAILS = "mongodb://localhost:27017"

client = AsyncIOMotorClient(MONGO_DETAILS)

db = client.mydatabase

collection = db.mycollection

Supponendo che la mycollection di mydatabase sia popolata con alcuni dati, ora crei un main.py che contiene la logica dell’applicazione. Nel seguente applicazione FastAPI, una connessione al database è stabilita utilizzando database.py le rotte per le previsioni dell’AI sono definite. Utilizzando queste rotte, viene validato l’input.

nano main.py

Nell’editor di testo, scrivi la logica:

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

# semplice dataset e modello
x = np.array([[1], [2], [3], [4], [5]])
y = np.array([2, 4, 6, 8, 10])

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

# definisci il modello Pydantic per la validazione dell'input
class InputData(BaseModel):
  feature: float

# route_1 per predire l'output in base alle caratteristiche di input
@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 per interagire con MongoDB
@app.get("/items/")
async def get_item():
  items = []
  async for item in collection.find():
    items.append(item)
  return items

# route_3 per aggiungere un nuovo elemento a 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

Ecco una panoramica di cosa fa quest’applicazione:

• Modello di regressione lineare da sklearn: questo modello predice un output in base a un solo特征 di input.
• InputData from Pydantic Model: Questo definisce la struttura di input attesa per l’endpoint di predizione. In questo caso, è un float.
• Rotte MongoDB: Le rotte /items/ e POST /items/ consentono di recuperare e inserire elementi nella collezione MongoDB.

Step 6 – Eseguire l’applicazione FastAPI

Per eseguire correttamente quest’applicazione, è necessario installare le librerie e i pacchetti usati nell’applicazione.

pip install pydantic scikit-learn numpy

Adesso, usare il seguente comando per eseguire quest’applicazione:

uvicorn main:app --reload

L’output di questo comando sarà:

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 ha generato automaticamente una documentazione API interattiva usando Swagger UI. Puoi accederci navigando a http://127.0.0.1:8000/docs.

Puoi usare工具 come curl o Postman per chiamare l’endpoint che predice un valore in base alle tue input.

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

Step 7 [OPTIONAL] – Eseguire l’applicazione Utilizzando Docker Compose

Puoi containerizzare il tuo applicativo e eseguirlo usando docker-compose. La containerizzazione del tuo applicativo semplifica il processo di distribuzione rendendo l’applicativo più facile da distribuire, scalare e mantenere. Per definire il tuo applicativo come un file Dockerfile, segui le step menzionati in Deploy FastAPI Application using Docker Compose.

Conclusione

In questo tutorial, hai imparato come configurare con successo un’applicazione FastAPI con MongoDB, creando una semplice app AI in grado di memorizzare e recuperare predizioni di input.

La combinazione di FastAPI e una database NoSQL offre un ambiente potente e flessibile per la creazione e l’scaling di applicazioni guidate da AI.