Come costruire un’applicazione API veloce utilizzando Docker Compose

Introduzione

FastAPI è un framework web moderno per Python, progettato per fornire alta prestazione, rendendolo un’ottima scelta per lo sviluppo di applicazioni, specialmente quelle dotate di integrazione AI.

Questo tutorial vi guiderà attraverso il processo di creazione e configurazione di un’applicazione FastAPI su una macchina Ubuntu utilizzando Docker Compose. Questo metodo semplifica la distribuzione e fornisce una solida base per l’integrazione di AI nelle vostre applicazioni.

Creare un’App FastAPI usando Docker Compose

• Configurazione dell’Ambiente Python
• Creare un Ambiente Virtuale
• Installare Docker
• Creare un’Applicazione FastAPI
• Creare Dockerfile e Docker Compose
• Costruire e eseguire il contenitore Docker
• Accedere all’applicazione FastAPI
• Gestire il contenitore Docker

Prerequisiti

Per seguire questo tutorial, avrai bisogno di:

• Un server che esegue Ubuntu insieme ad un utente non root con privilegi di sudo e una firewall attiva. Per una guida su come impostare questo setup, scegli la tua distribuzione dalla questa lista e segui la nostra guida di impostazione iniziale del server. Assicurati di lavorare con una versione supportata di Ubuntu. In questo tutorial, usiamo una macchina Ubuntu 24.04 LTS.

• Conoscenza della riga di comando di Linux. Per un approcio o un aggiornamento alla riga di comando, puoi visitare questo guide sulla primer riga di comando Linux.

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

Step 1 – Configurazione dell’ambiente Python

In un dispositivo Ubuntu 24.04, Python 3 è già installato come predefinito. Apri il terminale e eseguite il comando seguente per controllare l’installazione di Python 3:

python3 --version

Se Python 3 è già installato sul vostro dispositivo, questo comando restituirà la versione attuale dell’installazione di Python 3. In caso contrario, è possibile eseguire il seguente comando per installare Python 3:

sudo apt install python3

Successivamente, è necessario installare i programmi di installazione dei pacchetti pip e dev sul vostro sistema. Il gestore di pacchetti pip è essenziale per l’installazione di pacchetti dalla Python Package Index, mentre il pacchetto dev è necessario per la compilazione dei moduli Python che includono codice compilato.
Eseguite il seguente comando nel terminale:

sudo apt install python3-pip python3-dev

Step 2 – Creare e attivare l’ambiente virtuale

<$>[nota]
Se state utilizzando Ubuntu versione < 24.04, non è necessario creare un ambiente virtuale. Passate al prossimo passo<$>.

Il prossimo passo è creare un ambiente virtuale all’interno dell’installazione di Ubuntu per isolare i pacchetti di Python dalla vostra sistematica. Per fare questo, andate nel vostro directory di lavoro e eseguite il seguente comando:

python3 -m venv fastapi-env

Questo comando creerà un nuovo ambiente virtuale in una directory denominata fastapi-env. Qualsiasi pacchetto installate da questo momento in poi sarà isolato dagli altri progetti.

Prossimo, occorre attivare questo ambiente virtuale per garantire che i pacchetti che installate da questo momento in poi siano installati all’interno di questo ambiente isolato.

source fastapi-env/bin/activate

Al momento dell’esecuzione, noterete che il prompt del terminale è prefissato con il nome dell’ambiente virtuale, come questo:

Output
(fastapi-env) ubuntu@user:

Step 3 – Installare e abilitare Docker

Il passo successivo è installare Docker e Docker Compose all’interno del vostro ambiente virtuale.

sudo apt install -y docker.io

Dopo aver installato Docker, avviante il servizio di Docker e abilitevelo per l’avvio alla boot del sistema:

sudo systemctl start docker
sudo systemctl enable docker

Per assicurarti dell’ultima versione stabile di Docker Compose, scaricherai il file dalla sua repository ufficiale GitHub invece di usare apt.

Prima di tutto, conferma che l’ultima versione sia disponibile sulla pagina delle release ufficiali di Docker su GitHub, poi esegui nel terminale il seguente comando CURL.

sudo curl -L "https://github.com/docker/compose/releases/download/v2.29.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/bin/docker-compose

Esegui il comando seguente per rendere il file binario docker-compose esecutabile da qualunque utente del computer.

sudo chmod +x /usr/bin/docker-compose

Verifica l’installazione eseguendo:

docker-compose --version

Step 4 – Creare un’Applicazione FastAPI

Ora è il momento di iniziare a creare un’applicazione Python che utilizza il framework FastAPI. Prima di tutto, crea un file main.py:

nano main.py

Seguono i dettagli di un semplice applicazione Python che crea una semplice API web utilizzando il framework FastAPI e un modello AI pre-addestrato per analizzare il sentimento di un testo dato.

from fastapi import FastAPI
from pydantic import BaseModel
from transformers import pipeline

app = FastAPI()

sentiment_analyzer = pipeline("sentiment-analysis")

class TextRequest(BaseModel):
    text: str

class SentimentResponse(BaseModel):
    sentiment: str
    confidence: float

@app.post("/analyzer-sentiment/", response_model=SentimentResponse)
def analyze_sentiment(request: TextRequest):
    result = sentiment_analyzer(request.text)[0]
    sentiment = result['label']
    confidence = result['score']

    return SentimentResponse(sentiment=sentiment, confidence=confidence)

Per eseguire correttamente quest’applicazione, avrai bisogno delle dipendenze necessarie, ma non dovrai installarle manualmente. L’installazione di questi pacchetti sarà gestita all’interno del file Dockerfile, come viene menzionato nel prossimo passo.

Step 5 – Creare il Dockerfile e il file di configurazione YAML

Prossimo, creerai un Dockerfile per quest’applicazione. Il Dockerfile definisce l’ambiente in cui verrà eseguita la tua applicazione FastAPI. Crea un Dockerfile nella directory del progetto eseguendo:

nano Dockerfile

Nel editor di testo, aggiungi il seguente contenuto:

FROM python:3.12-slim

WORKDIR /app

COPY . /app

RUN pip install --no-cache-dir fastapi  pydantics transformers uvicorn

EXPOSE 80

CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "80"]

Docker Compose semplifica la gestione di applicazioni multi-container. Successivamente, devi creare un file di configurazione docker-compose.yml nella directory del progetto.

nano docker-compose.yml

Aggiungi il seguente contenuto all’file vuoto:

version: '3.8'
services:
  web:
    build: .
    ports:
     - "8000:80"
    volumes:
     - .:/app

In questa configurazione,

• version: Specifica la versione di Docker Compose da usare.
• services: Define i servizi da creare.
• web: Specifica il nome del servizio che esegue la tua applicazione FastAPI.
• build: Specifica la directory da cui costruire l’immagine Docker. In questo caso, è la stessa directory in cui è posizionato docker-compose.yml.
• ports: Mappa il porto 8000 sulla macchina host al porto 80 all’interno del container.
• volumes: Monta la directory corrente come volume all’interno del container, permettendoti di ricaricare il codice in tempo reale.

Step 6 – Costruisci e avvia il contenitore Docker

Usa Docker Compose per costruire quest’immagine Docker e avviare il contenitore:

sudo docker-compose build

Questo comando costruisce l’immagine Docker dal file Dockerfile nella directory corrente. Ora, per eseguire l’applicazione reale, esegui il seguente comando nel terminale:

sudo docker-compose up

Step 7 – Accesso alla tua applicazione FastAPI

Una volta che il contenitore è in esecuzione, puoi accedere alla tua applicazione FastAPI navigando a http://localhost:8000 nel tuo browser web.

Step 8 [OPZIONALE] – Gestisci il tuo contenitore Docker

Ecco qualche consiglio per aiutarti a controllare meglio l’ambiente containerizzato che sta eseguendo la tua applicazione FastAPI.

• Per fermare il contenitore in esecuzione, premi Ctrl + C o Command + ..

• Per rientrare in controllo mentre il contenitore è in esecuzione in background, usare:

  sudo docker-compose up -d
  

  Copia

• Per fermare e rimuovere il tuo contenitore, esegui:

  sudo docker-compose down
  

  Copia

Conclusione

In questo tutorial, hai imparato come creare e configurare un’applicazione FastAPI su una macchina Ubuntu utilizzando Docker Compose. Con la velocità di FastAPI e l’efficienza di Docker, puoi costruire applicazioni robuste e scalabili con fiducia.