Módulo: Persistencia en FastAPI

La persistencia de datos es un aspecto fundamental en el desarrollo de aplicaciones web, ya que permite almacenar y recuperar información de forma duradera, más allá del ciclo de vida de la ejecución del programa. En el contexto de FastAPI, un framework moderno para construir APIs en Python, la persistencia se integra para garantizar que los datos gestionados por la aplicación se mantengan accesibles y consistentes a lo largo del tiempo.

Este módulo introduce los conceptos básicos y las técnicas esenciales para implementar persistencia en aplicaciones desarrolladas con FastAPI, utilizando las herramientas y prácticas recomendadas en el ecosistema Python actual.

Fundamentos de la persistencia en aplicaciones web con FastAPI

La persistencia consiste en guardar datos en un medio estable, típicamente una base de datos, para que puedan ser consultados o modificados posteriormente. En aplicaciones web, esto implica conectar la API con sistemas de almacenamiento como bases de datos relacionales o NoSQL.

En FastAPI, la persistencia se aborda mediante la integración con ORMs (Object-Relational Mappers) o librerías específicas para bases de datos, que facilitan la interacción con el almacenamiento sin necesidad de escribir consultas SQL manuales. Además, FastAPI permite definir modelos de datos con Pydantic, que ayudan a validar y serializar la información que se envía y recibe, asegurando la integridad de los datos.

Conceptos básicos para implementar persistencia en FastAPI

Para comenzar a trabajar con persistencia en FastAPI, es necesario comprender algunos conceptos clave:

• Modelos de datos: Representan la estructura de la información que se almacenará. En FastAPI, se usan modelos Pydantic para validar datos de entrada y salida, y modelos ORM para mapear tablas de base de datos.

• Conexión a la base de datos: Configurar la conexión con el sistema de almacenamiento, que puede ser una base de datos relacional como PostgreSQL o SQLite.

• Sesiones y transacciones: Gestionar las operaciones de lectura y escritura en la base de datos de forma segura y eficiente.

• Migraciones: Herramientas para actualizar la estructura de la base de datos conforme evoluciona la aplicación.

Progresión técnica para implementar persistencia

1. Definición de modelos con Pydantic y SQLAlchemy

FastAPI utiliza Pydantic para definir esquemas de validación de datos, mientras que SQLAlchemy es la librería más común para manejar la persistencia con bases de datos relacionales.

Primero, se definen los modelos ORM que representan las tablas de la base de datos:

from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Usuario(Base):
    __tablename__ = "usuarios"
    id = Column(Integer, primary_key=True, index=True)
    nombre = Column(String, index=True)
    email = Column(String, unique=True, index=True)

Paralelamente, se crean los modelos Pydantic para validar los datos que entran y salen de la API:

from pydantic import BaseModel, EmailStr

class UsuarioBase(BaseModel):
    nombre: str
    email: EmailStr

class UsuarioCreate(UsuarioBase):
    pass

class UsuarioRead(UsuarioBase):
    id: int

    class Config:
        orm_mode = True

El atributo orm_mode = True permite que Pydantic trabaje directamente con objetos ORM, facilitando la conversión entre modelos.

2. Configuración de la conexión a la base de datos

Para establecer la conexión con la base de datos, se utiliza SQLAlchemy junto con un motor de base de datos. Por ejemplo, para SQLite:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker

SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"

engine = create_engine(
    SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
)

SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Este código crea un motor y una fábrica de sesiones que se usarán para interactuar con la base de datos.

3. Gestión de sesiones en FastAPI

Para asegurar que cada petición HTTP tenga acceso a una sesión de base de datos independiente y correctamente cerrada, se define una dependencia que proporcione la sesión:

from fastapi import Depends

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

Esta función se inyecta en las rutas para realizar operaciones de persistencia.

4. Operaciones CRUD básicas

Con los modelos y la sesión configurados, se implementan las operaciones básicas para crear, leer, actualizar y eliminar registros.

Por ejemplo, para crear un nuevo usuario:

from sqlalchemy.orm import Session

def crear_usuario(db: Session, usuario: UsuarioCreate):
    db_usuario = Usuario(nombre=usuario.nombre, email=usuario.email)
    db.add(db_usuario)
    db.commit()
    db.refresh(db_usuario)
    return db_usuario

En la ruta FastAPI se utiliza esta función junto con la dependencia de la sesión:

from fastapi import FastAPI, Depends

app = FastAPI()

@app.post("/usuarios/", response_model=UsuarioRead)
def crear_usuario_endpoint(usuario: UsuarioCreate, db: Session = Depends(get_db)):
    return crear_usuario(db, usuario)

5. Migraciones con Alembic

A medida que la aplicación evoluciona, es necesario modificar la estructura de la base de datos. Para ello, se emplea Alembic, una herramienta que gestiona migraciones de forma controlada.

El flujo habitual consiste en:

• Generar un script de migración que refleje los cambios en los modelos.
• Aplicar la migración para actualizar la base de datos.

Aunque la configuración de Alembic se realiza fuera del código de FastAPI, es importante conocer su papel en la persistencia.

Aplicación práctica y flujo conceptual

Visualizando el flujo de persistencia en FastAPI, se puede describir así:

• El cliente envía una petición HTTP con datos JSON.
• FastAPI valida los datos con modelos Pydantic.
• La función de ruta utiliza la sesión de base de datos para interactuar con el almacenamiento.
• Se ejecutan operaciones CRUD mediante SQLAlchemy.
• Los resultados se convierten a modelos Pydantic para la respuesta.
• FastAPI devuelve la respuesta JSON al cliente.

Este flujo garantiza que los datos se validen, almacenen y recuperen de forma segura y eficiente.

Este módulo proporciona las bases para que el alumno comprenda y aplique la persistencia en sus aplicaciones FastAPI, utilizando Python 3.13 y las herramientas más adecuadas para un desarrollo profesional y escalable. A partir de aquí, se podrá avanzar hacia técnicas más avanzadas, como relaciones entre tablas, optimización de consultas y uso de bases de datos NoSQL.