Come costruire un servizio API ad alte prestazioni con FastAPI

FastAPI è un framework web moderno e veloce (efficiente), progettato per costruire API. È basato su suggerimenti di tipo Python e supporta la programmazione asincrona, consentendo agli sviluppatori di costruire servizi API ad alte prestazioni e alta disponibilità con bassa latenza. Questo articolo vi guiderà passo dopo passo su come utilizzare FastAPI per costruire servizi API ad alte prestazioni, aiutandovi a realizzare l'intero processo dalla configurazione dell'ambiente al deployment.

Primo passo: preparazione dell'ambiente

È necessario assicurarsi che nel vostro ambiente di sviluppo sia installato Python 3.6 o superiore. Se non è ancora installato, potete visitare il sito ufficiale di Python per scaricarlo e installarlo.

Installare FastAPI e Uvicorn

FastAPI di per sé non fornisce un servizio, ha bisogno di un server ASGI per funzionare. Qui utilizziamo Uvicorn, un server ASGI ad alte prestazioni. Potete installare FastAPI e Uvicorn utilizzando il seguente comando:

pip install fastapi uvicorn

Secondo passo: costruire una API di base

Creiamo una semplice applicazione FastAPI.

Creare il file dell'applicazione

Nel vostro progetto, create un file Python, ad esempio main.py, e scrivete il seguente codice al suo interno:

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, World!"}

Nel codice sopra, prima importiamo FastAPI e creiamo un'istanza app. Poi definiamo una rotta GET che restituisce una semplice risposta JSON quando si accede al percorso radice /.

Avviare il server

Avviate il vostro server FastAPI utilizzando il seguente comando:

uvicorn main:app --reload

• main: si riferisce al nome del file, senza l'estensione .py.
• app: si riferisce all'istanza FastAPI.
• --reload: in modalità sviluppo, riavvia automaticamente il server quando i file vengono modificati.

Terzo passo: definire rotte e modelli di dati

Per costruire API complesse, è necessario utilizzare Pydantic per definire i modelli di dati.

Creare un modello di dati

Aggiungere il seguente contenuto in main.py:

from pydantic import BaseModel

class Item(BaseModel):
    name: str
    price: float
    is_available: bool = True

Questo codice utilizza Pydantic per creare un modello di dati Item, che include tre proprietà: nome del prodotto, prezzo e disponibilità.

Aggiungere una nuova rotta

Successivamente, possiamo definire una nuova rotta POST per ricevere dati di tipo Item:

@app.post("/items/")
async def create_item(item: Item):
    return {"item_name": item.name, "item_price": item.price}

In questa rotta, FastAPI convalida automaticamente i dati in ingresso e li mappa al modello Item.

Quarto passo: generazione automatica della documentazione

Uno dei principali vantaggi di FastAPI è la sua capacità di generare automaticamente la documentazione API. Potete visualizzarla accedendo ai seguenti indirizzi:

• Swagger UI: http://127.0.0.1:8000/docs
• ReDoc: http://127.0.0.1:8000/redoc

In questa documentazione generata, potete testare interattivamente l'API e visualizzare il formato delle richieste e delle risposte per ogni rotta.

Quinto passo: aggiungere l'autenticazione

Nelle applicazioni reali, l'autenticazione è un aspetto importante. Aggiungiamo un semplice sistema di autenticazione basato sui ruoli.

Aggiungere dipendenze di sicurezza

Utilizzando il metodo Depends di FastAPI e OAuth2PasswordBearer per implementare l'autenticazione:

from fastapi import Depends, HTTPException, status
from fastapi.security import OAuth2PasswordBearer

oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")

async def fake_decode_token(token):
    return {"sub": token}

async def get_current_user(token: str = Depends(oauth2_scheme)):
    user = fake_decode_token(token)
    if user is None:
        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Credenziali di autenticazione non valide")
    return user

Proteggere le rotte

Successivamente, potete aggiungere l'autenticazione alle rotte che necessitano di protezione:

@app.get("/users/me")
async def read_users_me(current_user: dict = Depends(get_current_user)):
    return current_user

Sesto passo: distribuire l'applicazione FastAPI

Quando avete completato lo sviluppo, potreste voler distribuire l'applicazione su un server cloud. Potete scegliere di utilizzare Docker per la distribuzione.

Creare un Dockerfile

Nel vostro progetto, create un file chiamato Dockerfile e inserite il seguente contenuto:

FROM tiangolo/uvicorn-gunicorn-fastapi:python3.8

COPY ./app /app

Costruire l'immagine Docker

Nel vostro terminale, utilizzate il seguente comando per costruire l'immagine Docker:

docker build -t myfastapiapp .

Eseguire il contenitore Docker

Eseguite la vostra applicazione FastAPI:

docker run -d --name fastapi -p 80:80 myfastapiapp

Conclusione

In questo articolo, abbiamo spiegato in dettaglio come utilizzare FastAPI per costruire servizi API ad alte prestazioni, dalla preparazione dell'ambiente alla creazione di API di base, definizione di rotte e modelli di dati, fino all'aggiunta di autenticazione e distribuzione. FastAPI offre molte funzionalità potenti che rendono la costruzione di API moderne semplice ed efficiente. Potete esplorare ulteriormente le funzionalità e le caratteristiche attraverso la documentazione ufficiale. Speriamo che questo articolo possa aiutarvi a iniziare rapidamente con FastAPI e migliorare l'efficienza dello sviluppo dei vostri progetti!