Cómo utilizar Fast API con una base de datos relacional en Ubuntu

Introducción

FastAPI ha aumentado rápidamente en popularidad como un marco de aplicaciones web de alto rendimiento y fácil de usar para construir API con Python. Cuando se utiliza junto a una base de datos relacional, FastAPI se puede usar para crear aplicaciones potentes y escalables. Este guía le guiará a través del proceso de configuración de una aplicación FastAPI con una base de datos relacional en una máquina Ubuntu 24.04. cubriremos todo, desde la instalación de las herramientas necesarias hasta la configuración de la base de datos y la creación de puntos finales de API.

Usar FastAPI con la Base de Datos PostgreSQL

• Configuración del Entorno de Python
• Crear y Activar Entorno Virtual
• Instalar y Configurar PostgreSQL
• Crear Aplicación de FastAPI
• Instalar bibliotecas requeridas
• Ejecutar aplicación de Python
• Pruebas de puntos finales de la aplicación FastAPI

Prerrequisitos

Antes de seguir los pasos de este tutorial, necesitas:

• Un servidor que ejecute Ubuntu junto con un usuario no root que tenga privilegios de sudo y una cortina activa. Para obtener instrucciones sobre cómo configurar esto, elija su distribución de este listado y siga nuestra guía de configuración inicial del servidor. Asegúrese de trabajar con una versión compatible de Ubuntu.

• Familiaridad con la línea de comandos de Linux. Para una introducción o repaso a la línea de comandos, puede visitar esta guía sobre Introducción a la línea de comandos de Linux.

• Ejecute sudo apt-get update en la terminal de Ubuntu para asegurarse de que su sistema tenga las últimas versiones y actualizaciones de seguridad para el software disponible en los repositorios configurados en su sistema.

Paso 1 – Configuración del Entorno de Python

Ubuntu 24.04 trae Python 3 por defecto. Abre el terminal y ejecuta el siguiente comando para comprobar la instalación de Python 3:

python3 --version

Si Python 3 ya está instalado en tu equipo, este comando devolverá la versión actual de la instalación de Python 3. En caso de que no esté instalado, puedes ejecutar el siguiente comando y obtener la instalación de Python 3:

sudo apt install python3

A continuación, necesitarás instalar los instaladores de paquetes pip y dev en tu sistema. Ejecuta el siguiente comando en el terminal:

sudo apt install python3-pip python3-dev

En este tutorial, utilizaremos PostgreSQL como nuestra base de datos relacional. Para interactuar con la base de datos PostgreSQL, necesitarás instalar el libpq-dev utilizando el siguiente comando:

sudo apt install libpq-dev

Paso 2 – Crear y activar el entorno virtual

El siguiente paso es crear un entorno virtual dentro de tu instalación de Ubuntu para aislar paquetes de Python de tu entorno de sistema. Para hacer esto, ve a tu directorio de trabajo y ejecuta el siguiente conjunto de comandos:

python3 -m venv fastapi-env

Este comando creará un nuevo entorno virtual en un directorio llamado fastapi-env. Tendrá su propio conjunto de paquetes de Python dedicados, aislados de otros proyectos.

Para asegurarte de que los paquetes que instales a partir de este momento se instalen dentro de este entorno aislado, necesitas activarlo ejecutando:

source fastapi-env/bin/activate

Al ejecutar, notarás que el prompt de terminal se antepone con el nombre de tu entorno virtual como este:

Output
(fastapi-env) ubuntu@user:

Paso 3 – Instalar y configurar PostgreSQL

El siguiente paso es instalar PostgreSQL (o cualquier base de datos relacional de tu elección).

sudo apt install postgresql postgresql-contrib

Ahora, es hora de iniciar y habilitar el servicio de PostgreSQL dentro de tu entorno virtual.

sudo systemctl start postgresql
sudo systemctl enable postgresql

Para instalar y usar PostgreSQL con FastAPI, necesitas instalar un par de cosas:

1. asyncpg: Este es un controlador asíncrono de PostgreSQL que permite a FastAPI interactuar con una base de datos PostgreSQL.
2. SQLAlchemy: Esta es una herramienta ORM que te ayuda a administrar esquemas de base de datos y consultas como código Python en lugar de escribir SQL puro.
3. databases: Esta es una biblioteca de base de datos para operaciones asíncronas necesarias por SQLAlchemy para trabajar asíncronamente con FastAPI.

Para instalar estos elementos, ejecuta el siguiente comando consolidado:

pip install asyncpg sqlalchemy databases

Después, cree una base de datos de Postgres y un usuario con los privilegios requeridos.

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

Paso 4 – Crear Aplicación de Python de Ejemplo

Necesita una aplicación de Python ejecutable que acceda a su base de datos a través de FastAPI. Si no tiene una aplicación de Python en ejecución, puede crear rápidamente una mediante estos pasos:

Cree un nuevo archivo de Python llamado postgres_db.py en su directorio de proyecto.

nano postgres_db.py

En el editor de texto, escribirá lógica para crear la conexión de base de datos y crear una tabla dentro de la base de datos. En este ejemplo, crearemos una conexión a la base de datos PostgreSQL usando el paquete databases y definiremos la estructura de una tabla 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)

Guarde y cierre el archivo.

A continuación, cree un main.py dentro del mismo directorio.

nano main.py

Escriba la lógica principal de su aplicación en este archivo:

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)

Este código utiliza FastAPI para escribir entradas de libro nuevos en la base de datos PostgreSQL y obtener la colección de libros de ella.

Paso 5 – Instalar bibliotecas requeridas

En su aplicación de Python, referencia varias bibliotecas y paquetes. Antes de ejecutar la aplicación, asegúrese de instalar las bibliotecas necesarias.

pip install fastapi uvicorn psycopg2

Paso 6 – Ejecutar aplicación de Python

Ahora es hora de ejecutar la aplicación que has creado.

uvicorn main:app --reload

uvicorn es un Interfaz de Puerta de Servidor Asíncrono (ASGI) que se utiliza para servir aplicaciones FastAPI. Usar uvicorn es una forma preferida para ejecutar una aplicación FastAPI ya que FastAPI es un framework web asíncrono en sí mismo.

Si el comando anterior se ejecuta sin encontrar un error, entonces verás un salida similar a la siguiente:

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.

En un navegador web, navega a http://127.0.0.1:8000 para ver la salida de la consulta.

Paso 7 [OPCIONAL] – Prueba las Endpoints

Puedes probar las endpoint definidas en tu main.py (es decir, POST y GET) enviando solicitudes HTTP al servidor que se ejecuta en http://127.0.0.1:8000.

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

De manera similar, puedes hacer una llamada GET al mismo servidor para recuperar la lista de libros presentes en tu base de datos Postgres.

Conclusión

En este tutorial, pasaste por el proceso de configuración de una aplicación simple de FastAPI que interactúa con una base de datos PostgreSQL. Estos pasos también son beneficiosos para aplicaciones de AI, especialmente cuando necesitas construir una API web para interactuar con tus modelos de AI o gestionar datos relacionados con tus procesos de AI. Con esta base en lugar, ahora puedes construir y expandir tus proyectos de FastAPI.

Mantén la atención para más artículos sobre cómo trabajar con FastAPI.