Come usare Fast API con un database relazionale su Ubuntu

Introduzione

FastAPI è rapidamente diventato popolare come framework web high-performance e facile da usare per la creazione di API in Python. Quando abbinato a una database relazionale, FastAPI può essere utilizzato per creare applicazioni potenti e scalabili. Questo guide vi guiderà attraverso il processo di impostazione di un’applicazione FastAPI con una database relazionale su un sistema Ubuntu 24.04. Copriremo tutto, dall’installazione delle tool necessarie alla configurazione della database e alla creazione di endpoint API.

Usare FastAPI con il Database PostgreSQL

• Impostazione dell’Ambiente Python
• Creare e attivare l’ambiente virtuale
• Installare e configurare PostgreSQL
• Creare applicazione FastAPI
• Installare le librerie richieste
• Eseguire l’applicazione Python
• Testare gli endpoint dell’applicazione FastAPI

Prerequisiti

Prima di seguire le istruzioni di questo tutorial, è necessario:

• Un server che esegue Ubuntu insieme ad un utente non root che ha privilegi di sudo e un firewall attivo. Per istruzioni su come impostare questo setup, scegliere la propria distribuzione dalla questa lista e seguire il nostro guide di installazione iniziale del server. Assicurarsi di lavorare con una versione supportata di Ubuntu.

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

• Eseguire sudo apt-get update nel terminale Ubuntu per assicurarsi 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

Ubuntu 24.04 include Python 3 come componente predefinito. Apri il terminale e esegui il seguente comando per controllare la presenza di Python 3:

python3 --version

Se Python 3 è già installato sulla vostra macchina, 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, devi installare i programmi di installazione dei pacchetti pip e dev sul tuo sistema. Esegui il seguente comando nel terminale:

sudo apt install python3-pip python3-dev

In questo tutorial, userremo PostgreSQL come nostra database relazionale. Per interagire con il database PostgreSQL, è necessario installare libpq-dev utilizzando il seguente comando:

sudo apt install libpq-dev

Step 2 – Crea e attiva il contesto virtuale

Il passo successivo consiste nel creare un contesto virtuale all’interno dell’installazione di Ubuntu per isolare i pacchetti Python dalla vostra environment di sistema. Per fare questo, andate nel vostro directory di lavoro e eseguite il seguente insieme di comandi:

python3 -m venv fastapi-env

Questo comando creerà un nuovo contesto virtuale in una directory chiamata fastapi-env. Avrà il suo insieme dedicato di pacchetti Python, isolato da altri progetti.

Per assicurarvi che i pacchetti che installate da questo momento in poi siano installati in questo ambiente isolato, devi attivarlo eseguendo:

source fastapi-env/bin/activate

Al momento dell’esecuzione, noterai che il prompt del terminale è prefissato con il nome del tuo contesto virtuale, come questo:

Output
(fastapi-env) ubuntu@user:

Step 3 – Installare e configurare PostgreSQL

La prossima step è installare PostgreSQL (o qualsiasi altra base di dati relazionale sia tuo preferita).

sudo apt install postgresql postgresql-contrib

Ora, è il momento di avviare e abilitare il servizio di PostgreSQL all’interno dell’ambiente virtuale.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Per installare e utilizzare PostgreSQL con FastAPI, devi installare un paio di cose:

1. asyncpg: Questo è un driver PostgreSQL asincrono che consente a FastAPI di interagire con una base dati PostgreSQL.
2. SQLAlchemy: Questo è un strumento ORM che ti aiuta a gestire i schemi di database e le query invece di scrivere SQL grezzo.
3. databases: Questa è una libreria di database per operazioni asincrone richieste da SQLAlchemy per lavorare asincronicamente con FastAPI.

Per installare queste cose, esegui il seguente comando integrato:

pip install asyncpg sqlalchemy databases

Prossimo, crea una base dati Postgres e un utente con i privilegi necessari.

sudo -u postgres psql
CREATE DATABASE <user_db>;
CREATE ROLE <username> WITH PASSWORD '<password>';
GRANT ALL PRIVILEGES ON DATABASE <user_db> TO <username>;
exit

Step 4 – Creare applicazione Python di esempio

Devi avere un’applicazione Python esecutabile che accedere alla tua database tramite FastAPI. Se non hai una applicazione Python in esecuzione, puoi crearne una rapidamente seguendo questi passaggi:

Crea un nuovo file Python denominato postgres_db.py nella directory del tuo progetto.

nano postgres_db.py

Nell’editor di testo, scriverai la logica per creare una connessione al database e creare una tabella all’interno del database. In questo esempio, creiamo una connessione al database PostgreSQL usando il pacchetto databases e definiamo la struttura di una tabella books usando SQLAlchemy.

from databases import Database
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Float

DB_URL = "postgresql://username:password@localhost/user_db"

database = Database(DB_URL)
metadata = MetaData()

books = Table (
  "books",
  metadata,
  Column("id", Integer, primary_key=True, index=True),
  Column("title", String, index=True),
  Column("author", String, index=True),
  Column("price", Float),
)

engine = create_engine(DB_URL)
metadata.create_all(engine)

Salva e chiudi il file.

Successivamente, crea un main.py nella stessa directory.

nano main.py

Scrivi la logica principale dell’applicazione in questo file:

from fastapi import FastAPI
from typing import List
from pydantic import BaseModel
from postgres_db import books, database

app = FastAPI()

class BookCreate(BaseModel):
    title: str
    author: str
    price: float

class BookResponse(BaseModel):
    id: int
    title: str
    author: str
    price: float

class Config:
  orm_mode=True

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.post("/books/", response_model=BookResponse)
async def create_book(book: BookCreate):
    query = books.insert().values(title=book.title, author=book.author, price=book.price)
    last_book_id = await database.execute(query)

    query = books.select().where(books.c.id == last_book_id)
    inserted_book = await database.fetch_one(query)
    return inserted_book

@app.get("/books/", response_model=List[BookResponse])
async def get_books():
    query = books.select()
    return await database.fetch_all(query)

Questo codice utilizza FastAPI per scrivere nuovi record di libri nel database PostgreSQL e recuperare la collezione di libri da esso.

Step 5 – Installare le Librerie Necessarie

Nella tua applicazione Python, stai facendo riferimento a vari pacchetti e librerie. Prima di eseguire l’applicazione, assicurati di installare le librerie necessarie.

pip install fastapi uvicorn psycopg2

Step 6 – Esegui Applicazione Python

Ora è il momento di eseguire l’applicazione che hai creato.

uvicorn main:app --reload

uvicorn è un Server Gateway Interface Asincrono (ASGI) che viene utilizzato per servire le applicazioni FastAPI. Utilizzare uvicorn è il metodo preferito per eseguire un’applicazione FastAPI, poiché FastAPI è un framework web asincrono di per sé.

Se il comando precedente viene eseguito senza incontrare errori, allora vedrai un output simile a quello seguente:

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 [XXXX] using StatReload
INFO:     Started server process [YYYY]
INFO:     Waiting for application startup.
INFO:     Application startup complete.

In un browser web, naviga per http://127.0.0.1:8000 per visualizzare l’output della query.

Step 7 [OPZIONALE] – Testare gli Endpoint

Puoi testare gli endpoint definiti nel tuo file main.py (cioè POST e GET) inviando richieste HTTP al server in esecuzione su http://127.0.0.1:8000.

{
  "title": "The Great Gatsby",
  "author": "F. Scott Fitzgerald",
  "price": 10.99
}

Allo stesso modo, puoi fare una chiamata GET allo stesso server per recuperare l’elenco dei libri presenti nel tuo database Postgres.

Conclusione

In questo tutorial, avete creato un semplice applicazione FastAPI che interagisce con una database PostgreSQL. Questi passaggi sono utili anche per le applicazioni AI, soprattutto quando è necessario costruire una web API per interagire con i tuoi modelli AI o gestire i dati relativi ai tuoi processi AI. Con questo fondamento in posizione, ora potete costruire e ampliare i vostri progetti FastAPI.

Stay tuned per ulteriori articoli su come lavorare con FastAPI.