Come si distribuisce un’applicazione FastAPI?

Sebbene esistano molti provider di hosting, solo pochi offrono un CGI (Common Gateway Interface) o il modulo mod_wsgi per supportare l’hosting Python. Ma tra gli sviluppatori che hanno risposto alsondaggio Stack Overflow Developer Survey 2023, la containerizzazione con Docker è in testa per lo sviluppo e la distribuzione delle applicazioni.

Per le applicazioni Python sviluppate con un framework come FastAPI, il deploy tramite un Container-as-a-Service (CaaS ) è semplice come spingere il codice su GitHub. In questo blog, imparerete come agganciare la vostra applicazione FastAPI e distribuirla tramite un CaaS.

Risultati principali

• Docker e FastAPI formano un duo forte, che consente distribuzioni semplificate e pacchettizzate con dipendenze incluse.

• FastAPI eccelle nelle operazioni asincrone, nella convalida dei dati e in OpenAPI, ma manca del supporto e della compatibilità della comunità.

• Back4app semplifica la distribuzione di FastAPI, sincronizzandosi con GitHub per gli aggiornamenti automatici e offrendo la configurazione del database nel cloud.

Che cos’è FastAPI?

FastAPI è un framework web leggero open-source in Python per lo sviluppo di API RESTful. Lanciato nel 2018, supporta il modello Pydantic e Starlette, ponendosi allo stesso livello di prestazioni di Node.js e Golang. Il framework è inoltre personalizzabile e consente di progettare la propria base di codice in modo flessibile.

Grazie al supporto dello schema JSON e delle specifiche dei tipi nelle versioni di Python 3.6 e successive, il modello Pydantic consente a FastAPI di analizzare facilmente i dati e di validarli in fase di esecuzione.

Il framework Starlette introduce l’Asynchronous Server Gateway Interface (ASGI) in FastAPI; questo permette di eseguire operazioni asincrone nelle API RESTful di Python e di eseguire il codice sul server ASGI di Uvicorn.

Come Nodemon in Node.js, il server Uvicorn ascolta le modifiche alle rotte API e riavvia l’esecuzione ogni volta che viene effettuato un aggiornamento.

Sebbene solo il 7,42% degli sviluppatori che hanno risposto alsondaggio Stack Overflow Developer Survey 2023 abbia dichiarato di utilizzare FastAPI, GitHub stima il numero totale di utenti a 203k. Con oltre 498 collaboratori e 190 release al momento della stesura di questo articolo, FastAPI riceve regolarmente aggiornamenti e patch.

Tuttavia, mettere FastAPI allo stesso livello di prestazioni di Golang e Node.js è ancora oggetto di dibattito tra gli sviluppatori.

Mentre altri sono d’accordo, alcuni sostengono che, pur essendo un miglioramento significativo per lo sviluppo web in Python, FastAPI non è ancora paragonabile alle prestazioni di nessuno dei due.

Vantaggi di FastAPI

• Supporto per le operazioni asincrone: oltre alle operazioni sincrone predefinite di Python, FastAPI supporta le dichiarazioni di funzione che utilizzano async/await. Grazie a Starlette, che fornisce anche il supporto per WebSocket. Questo aggiunge concurrency al programma, consentendo all’applicazione di eseguire altre operazioni in attesa di quelle più lente, come le query al database.

• Supporto per la convalida dei dati: utilizzando il BaseModel di Pydantic, FastAPI sfrutta i suggerimenti sui tipi di dati di Python per mantenere il rigore nell’analisi dei dati. In questo modo si evita che il tipo di dati sbagliato venga inserito nel database. Pertanto, a differenza dei modelli dinamici che richiedono librerie di convalida aggiuntive, la convalida del modello è semplice e facilmente disponibile in FastAPI.

• Completamente standardizzato: FastAPI è conforme alle specifiche OpenAPI per il servizio API HTTP sul web, rendendo più semplice per le applicazioni consumer e i client la comprensione dell’API da utilizzare. Inoltre, utilizza la dichiarazione JSON Schema per garantire che i dati inviati dagli utenti siano validi prima di inviarli al database.

• Flessibilità: a differenza di Django, FastAPI non limita lo sviluppatore a un particolare standard architetturale della base di codice. Al contrario, lascia la decisione allo sviluppatore. Di conseguenza, è possibile progettare la propria base di codice con convenzioni di denominazione flessibili e dichiarare parametri generali dell’applicazione e suite di test unitari lungo il percorso. Anche la modularizzazione del codice e la separazione delle preoccupazioni (SOC) sono semplici.
  
  Inoltre, se si utilizza la programmazione orientata agli oggetti (OOP), come consigliamo, è possibile comporre facilmente i modelli nelle classi finali. Anche l’aggiunta di endpoint API alle rotte è semplice.

• Una curva di apprendimento facile: nonostante abbia una comunità di utenti più piccola rispetto a framework come Flask e Django, FastAPI si distingue per la sua documentazione e i suoi tutorial completi. Con un background di sviluppo, in particolare in Python o JavaScript, si può imparare facilmente. La sua semplicità e flessibilità contribuiscono a velocizzare il processo di sviluppo.

Limiti

• Debole supporto della comunità: FastAPI non ha molti utenti come Django o Flask. È ancora relativamente nuovo. Il supporto della comunità è quindi più debole e questo può rappresentare una sfida, soprattutto per i nuovi sviluppatori.

• Compatibilità di versione limitata: FastAPI supporta solo le versioni successive di Python, da Python 3.6 in poi. Pertanto, le macchine o i server che eseguono versioni di Python precedenti alla 3.6 devono essere aggiornati per poter installare ed eseguire FastAPI.

Opzioni di distribuzione FastAPI

Infrastructure as a Service (IaaS) e Container as a Service (CaaS) sono infrastrutture cloud scalabili per la distribuzione di applicazioni.

Sebbene sia possibile distribuire un’applicazione FastAPI tramite un server privato virtuale (VPS) o un hosting condiviso, nessuno dei due è scalabile come IaaS o CaaS.

IaaS

Una IaaS è una piattaforma che fornisce risorse informatiche on-demand nel cloud. Fornisce tutte le risorse virtualizzate necessarie per creare un server di distribuzione per la vostra applicazione, di solito su base pay-per-use.

Oltre all’infrastruttura IT, l’IaaS comprende lo storage e altre risorse di rete come bilanciatori di carico, VPN, firewall, gestione DNS, ecc. Il cliente è responsabile della gestione dell’ambiente IT e può personalizzare o aggiornare le risorse in base alle esigenze della propria applicazione.

CaaS

Un CaaS è una piattaforma come servizio (PaaS) che consente di distribuire la propria applicazione nel cloud sotto forma di container. A differenza di un IaaS, un CaaS gestisce tutti i database necessari per ospitare l’applicazione sotto il cofano.

Questo include l’ambiente di runtime dei container, l’orchestrazione, lo storage, il bilanciamento del carico, ecc. In questo modo potete concentrarvi sulla creazione della vostra applicazione, invece di preoccuparvi della gestione dell’infrastruttura.

Poiché l’applicazione viene distribuita come contenitore, l’integrazione CI/CD è semplice e non richiede alcuna configurazione tecnica. Di conseguenza, l’applicazione può essere messa in funzione e aggiornata più rapidamente.

Processo di distribuzione dell’API FAST

Eseguiremo il processo di distribuzione passo per passo, iniziando dai prerequisiti. Poiché la nostra applicazione FastAPI verrà distribuita utilizzando i container di Back4App, prima di continuare diamo una rapida occhiata a quali sono.

Panoramica dei contenitori Back4app

Back4App Containers è una piattaforma cloud che consente di distribuire rapidamente applicazioni docked nel cloud. La piattaforma si sincronizza con il vostro repository GitHub e aggiorna automaticamente il vostro deployment ogni volta che ne inviate una versione. Questo elimina la necessità di aggiornamenti manuali dei container e i tempi di inattività dei server.

Con Back4App Containers, è sufficiente inviare il codice e le versioni successive a GitHub dalla macchina locale e la piattaforma gestisce l’orchestrazione dell’immagine del container sotto il cofano. Back4App offre anche il monitoraggio del deployment e la registrazione in tempo reale.

In questo modo è possibile tracciare le fasi della distribuzione e determinare l’eventuale punto di guasto. E se l’applicazione si blocca in fase di esecuzione, cosa che può accadere con un linguaggio interpretato come Python, la registrazione in tempo reale aiuta a tracciare gli errori nella console, in modo da poterli risolvere rapidamente.

Ecco le caratteristiche principali di Back4App :

• Sincronizzate facilmente la vostra applicazione Back4App con il vostro repository di codice su GitHub.

• Distribuite la vostra applicazione nel cloud tramite un container Back4App, inviando il codice e i successivi aggiornamenti al vostro repository GitHub.

• Tutto ciò che serve è un file Docker. Back4App gestisce per voi tutte le installazioni delle dipendenze.

• Crittografate facilmente le variabili d’ambiente durante la distribuzione e le versioni successive.

• Monitorare le implementazioni in tempo reale e gestire i rollback.

• Monitorate la cronologia di utilizzo delle vostre applicazioni utilizzando i log in tempo reale.

• Distribuzione di applicazioni mobili e web nel cloud

Scaricare e installare Python

In questo blog utilizzeremo Python 3.10.6. Ma è possibile utilizzare qualsiasi versione di Python non precedente alla 3.6. Andate su python.org per scaricare e installare l’ultima versione di Python compatibile con il vostro sistema operativo, se non l’avete già fatto. Altrimenti, saltate questa sezione.

Una volta scaricato, fate clic sul file di installazione e seguite le istruzioni sullo schermo per installare Python sul vostro computer locale.

Selezionate l’opzione Add python.exe to PATH per aggiungere Python al percorso della vostra variabile di sistema, rendendolo eseguibile dalla riga di comando.

Se si utilizza un Mac, questo è già dotato di Python 2.7 per impostazione predefinita. È possibile aggiornarlo all’ultima versione utilizzando Homebrew tramite il file :

brew install python3

Eseguite il seguente comando nel vostro terminale per verificare la vostra versione di Python.

python --version

Attivare un ambiente virtuale Python e installare FastAPI

Quindi, creare una nuova cartella di progetto e aprire la riga di comando di questa cartella. Quindi attivate un ambiente Python virtuale usando venv.

Questo pacchetto viene fornito con Python e non richiede installazione. Permette di gestire le dipendenze di Python in modo isolato, invece di installarle globalmente.

Eseguire il seguente comando nel terminale per creare un ambiente virtuale, sostituendo env_name con il nome dell’ambiente preferito.

py -m venv env_name

Eseguire il seguente comando per attivare l’ambiente virtuale.

.\env_name\Scripts\activate

Installare FastAPI e Uvicorn

Il passo successivo consiste nell’installare il framework FastAPI e il runtime del server Uvicorn nell’ambiente virtuale attivo. Vengono installati anche Pydantic e Starlette.

Creare un file requirements.txt nella radice del progetto e inserire i pacchetti da installare, come mostrato di seguito.

fastapi
uvicorn

Di seguito è riportata la dimostrazione di VSCode. Se necessario, è possibile aggiungere altre dipendenze a questo file.

Eseguire il seguente comando tramite il terminale per installare le dipendenze elencate. Assicurarsi che l’ambiente virtuale sia ancora attivo.

pip install install -r requirements.txt

Il comando installa il pacchetto specificato come mostrato di seguito.

Una volta installato, aggiornare il file requirements.txt con il seguente comando:

pip freeze > requirements.txt

Il comando precedente sostituisce il file requirements.txt con le dipendenze installate, compresi i numeri di versione corretti. Assicurarsi di eseguire questa operazione ogni volta che si installa una nuova dipendenza nell’ambiente virtuale.

Il file requirements.txt si presenta come segue dopo l’aggiornamento:

Introduzione al progetto

Scriveremo una semplice applicazione FastAPI “Hello World” e la distribuiremo utilizzando i contenitori gratuiti Back4App. Non preoccupatevi se il vostro progetto è complesso. Il deployment avviene allo stesso modo e si beneficia della disponibilità mensile gratuita.

Tuttavia, se la vostra applicazione gestisce molte richieste su base giornaliera, potreste voler effettuare l’aggiornamento dopo la distribuzione per offrire ai vostri visitatori un’esperienza d’uso più fluida senza tempi di inattività.

Codice di applicazione

Creare una nuova cartella router nella cartella principale del progetto e creare un file main.py in questa cartella. Questo file gestisce gli endpoint API dell’applicazione e del router. Passare alla sezione successiva se si ha già un progetto da distribuire.

Ecco il codice di “Hello World”:

from fastapi import FastAPI, APIRouter
import uvicorn

app = FastAPI()
class HelloWorld():
    def read_hello(self):
        return {"data": "Hello World"}
router = APIRouter()
router.add_api_route('/api/v2/hello-world', 
endpoint = HelloWorld().read_hello, methods=["GET"])
app.include_router(router)

if __name__ == "__main__":
   uvicorn.run("main:app", host="127.0.0.1", port=8000, reload=True)

Per lanciare il server uvicorn e testare l’endpoint API hello-world, eseguire il file main.py dalla riga di comando:

python main.py

Questo avvia il server di sviluppo sulla porta 8000 come specificato.

Trattandosi di una richiesta GET, possiamo testarla direttamente su qualsiasi browser web. Ecco il risultato.

Dock dell’applicazione

Quindi, creare un Dockerfile nella cartella principale del progetto. Potete farlo creando un nuovo file in VS Code e nominandolo Dockerfile.

Una volta creata, digitate i seguenti comandi per creare un’immagine Docker:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt
COPY . .
EXPOSE 8000
CMD ["uvicorn", "router.main:app", "--host", "0.0.0.0", "--port", "8000"]

Spingere su GitHub

Accedere al proprio account GitHub e andare alla sezione Repository. Creare un nuovo repository facendo clic su Nuovo nell’angolo in alto a destra.

Accedere al proprio account GitHub e andare alla sezione Repository. Creare un nuovo repository facendo clic su Nuovo nell’angolo in alto a destra.

Se il codice è già stato inviato a GitHub, aggiungere il file Docker alla copia sul computer locale e inviarlo nuovamente al repository.

Assegnare un nome al repository e fare clic su Crea un repository nell’angolo in basso a destra.

Quindi, inizializzare un repository locale usando il comando init come mostrato:

git init

Ignorare la cartella venv e il file .env usando .gitignore per evitare di inserirli nel repository. Per farlo, creare un file .gitignore nella cartella principale del progetto e inserire le cartelle e i file che si desidera ignorare, come mostrato di seguito.

Eseguire i seguenti comandi nel terminale, uno dopo l’altro, per inserire il codice nel repository.

1. git add .
2. git commit -m "commit message"
3. git branch -m main
4. git remote add origin <URL of the created repository>
5. git push -u origin main

Distribuzione dell’applicazione con un contenitore Back4App

Se non l’avete ancora fatto, assicuratevi di creare un nuovo account Back4App. Per accelerare il processo, utilizzare l’opzione di login di Google o GitHub .

Una volta effettuato l’accesso, fate clic sul widget Costruisci una nuova applicazione.

Andate su Container come servizio.

Nella pagina successiva, fare clic su Importa GitHub Repo. Quando viene richiesto, dare a GitHub il permesso di autorizzare Back4App.

In Accesso al repository, nella finestra modale aperta, fare clic su Seleziona repository. Selezionare il repository contenente il progetto da distribuire e fare clic su Salva.

Back4App sincronizzerà automaticamente il repository selezionato. Una volta reindirizzati a Back4App, fate clic su Seleziona a destra del repository GitHub aggiunto. Compilate quindi il campo Nome applicazione con il nome dell’applicazione che preferite.

Se la vostra applicazione FastAPI ha dei segreti nascosti in un file .env, fate clic su Variabili d’ambiente per inserire le variabili d’ambiente. Fare clic su Aggiungi variabile e inserire il nome della variabile utilizzando caratteri maiuscoli.

Assicurarsi di usare la stessa convenzione di denominazione delle variabili nel file .env del progetto, per evitare errori di denominazione.

Questo passaggio consente di codificare e aggiungere i valori delle variabili alla distribuzione. Infine, fare clic su Crea applicazione per distribuire l’applicazione FastAPI.

L’istanza di distribuzione dell’applicazione FastAPI funziona come illustrato di seguito.

Per visualizzare la versione live della domanda, fare clic sull’URL nella barra laterale di sinistra. Se andate su https://testapp-omisolaidowu.b4a.run/api/v2/hello-world, otterrete la risposta che cercate.

Conclusione

Una cosa è sviluppare un’applicazione utilizzando l’interfaccia FastAPI di Python. Ma un’altra è distribuirla senza problemi per servire i clienti.

Oltre a consentire una distribuzione più rapida, il CaaS è meno tecnico. Abbiamo visto come distribuire un’applicazione FastAPI, ma non è tutto.

È possibile distribuire l’applicazione lato client su un’istanza separata del contenitore e connettersi agli endpoint FastAPI usando l’URL generato come URL di base.

Se vi è piaciuto questo articolo, date un’occhiata al nostro tutorial sul deploy di un’applicazione Flask.