Conexión de FastAPI con SQLite usando SQLModel

Resumen

Para conectar FastAPI con una base de datos real, primero configuraremos una base de datos SQLite utilizando la librería SQLModel, que facilita la integración sin necesidad de escribir SQL. SQLModel combina Pydantic y SQLAlchemy, permitiendo que nuestros modelos se almacenen directamente en bases de datos con una sintaxis simplificada.

¿Cómo instalar y configurar SQLModel?

Instalación: Abre la terminal y ejecuta:
```
pip install sqlmodel
```
También es recomendable registrar las dependencias en un archivo requirements.txt, como SQLModel y FastAPI con sus respectivas versiones. Esto ayuda a instalar todas las dependencias en otros entornos fácilmente.
Creación del archivo de configuración:
- Crea un archivo db.py.
- Importa las clases Session y create_engine de SQLModel para gestionar la conexión.
- Define las variables para la conexión, como la URL de la base de datos, en este caso sqlite:///database_name.db.
Creación del engine:
- Utiliza create_engine con la URL de la base de datos para crear el motor que gestionará las sesiones.

¿Cómo definir la sesión para la base de datos?

Para manejar las conexiones, define una función get_session en db.py, la cual:

Crea un contexto que inicia y cierra la sesión automáticamente.
Facilita el uso de la sesión en varios endpoints de FastAPI.

¿Cómo registrar la sesión como dependencia en FastAPI?

Para que FastAPI use la sesión en sus endpoints:

Importa Depends de FastAPI.
Define una dependencia que gestione la sesión mediante get_session, facilitando el acceso a la base de datos desde cualquier endpoint.

¿Cómo adaptar los modelos para almacenar datos en la base de datos?

Modificación del modelo: Si usas modelos de Pydantic, ajústalos para heredar de SQLModel en vez de BaseModel. Esto conecta los modelos con la base de datos.
Creación de tablas:
- En el modelo que representa una tabla, añade table=True para que SQLModel cree automáticamente la tabla en la base de datos.
- Hereda los atributos comunes de un modelo base (sin table=True) para evitar duplicaciones y asegurar que se incluyan todos los campos necesarios.
Ejemplo de implementación:
- Define un modelo CustomerBase para los datos comunes.
- Crea un modelo Customer, que herede de CustomerBase y de SQLModel, con table=True para almacenar los registros en la tabla correspondiente.

Con esta configuración, los datos se insertarán en la base de datos sin necesidad de escribir SQL directamente. Al definir la dependencia de sesión en FastAPI, cada vez que un endpoint la requiera, FastAPI se conectará a la base de datos automáticamente.

Ronaldo Jiménez

student•

Así logro hacer la conexión a postgres (usando .env):


from fastapi import Depends, FastAPI
from typing import Annotated
from sqlmodel import SQLModel, Session, create_engine
from dotenv import load_dotenv
import os

# Cargar las variables de entorno desde un archivo .env
load_dotenv()

# Obtener la URL de conexión desde las variables de entorno
DATABASE_URL = os.getenv("DATABASE_URL")

if not DATABASE_URL:
    raise ValueError("DATABASE_URL no está definido en el archivo .env")

# Crear el motor de la base de datos usando directamente la cadena de conexión
engine = create_engine(DATABASE_URL)

def create_all_tables(app: FastAPI):
    SQLModel.metadata.create_all(engine)
    yield
    
# Crear una dependencia para obtener una sesión de base de datos
def get_session():
    with Session(engine) as session:
        yield session

# Alias para la dependencia de la sesión
SessionDep = Annotated[Session, Depends(get_session)]

Ronaldo Jiménez

student•

El archivo .env contiene:

DATABASE_URL=postgresql://usuario:pass123@localhost:5432/bd_prueba

kolab Linkear

student•

Gracias por el ejemplo, me sirvio para conectarle con MySQL:

""" DB """

from typing import Annotated

from fastapi import Depends, FastAPI

from sqlmodel import SQLModel, Session, create_engine

from decouple import config

# Cargar las variables de entorno desde un archivo .env

URL_DB = config("DATABASE_URL")

# Obtener la URL de conexión desde las variables de entorno

if not URL_DB:

raise ValueError("DATABASE_URL no está definido en el archivo .env")

# Crear el motor de la base de datos usando directamente la cadena de conexión

engine = create_engine(URL_DB)

def create_all_tables(app: FastAPI):

SQLModel.metadata.create_all(engine)

print("Database created succesfully")

yield

print("Closing application")

# Crear una dependencia para obtener una sesión de base de datos

def get_session():

"""Get Session"""

with Session(engine) as session:

yield session

# Alias para la dependencia de la sesión

SessionDep = Annotated[Session, Depends(get_session)]

Sebastian Alarcon

student•

Puedes listar y generar automaticamente las dependencias con le siguiente comando

Alfredo Olmedo

student•

La diferencia principal entre pip freeze y pip freeze | grep ... radica en el uso de grep para filtrar los resultados.

pip freeze

Muestra toda la lista completa

pip freeze | grep ...

Este comando combina pip freeze con grep para filtrar los resultados y mostrar solo los paquetes que coinciden con un patrón específico.

Omar Villada

student•

En el contexto de la clase sobre cómo conectar FastAPI a una base de datos usando SQLModel, SQLite se instala automáticamente cuando instalas SQLModel. Al usar el comando pip install sqlmodel, también se instalarán las dependencias necesarias para trabajar con SQLite. No es necesario realizar una instalación adicional de SQLite, ya que SQLModel maneja la conexión sin que escribas código SQL directamente.

Juan Andres Bravo Freitez

student•

se me resulto muy complicada es la clase, por eso, fui a la documentación de sqlalchemy (https://docs.sqlalchemy.org/en/20/core/engines.html), y de sqlmodel para saber de donde vienen las cosas

Juan David Muñoz Hernández

student•

Para aquellos que deseen crear el archivo requierements.txt (completo), en el cual almacenan el nombre y versión de las dependencias empleadas en nuestro entorno virtual de trabajo. Basta con ejecutar el comando:

pip freeze > requirements.txt

Con dicho comando, se creara por si solo dicho documento.

Jhonatan Estiven Becerra Pedrozo

student•

Por qué muchas de las definiciones o importaciones no se reconocen? instale sqlmodel pero al importarlo no noto que ubique el archivo ni cuando defino create_engine obtengo la documentación del método

Víctor Rolack

student•

Podría ser que en el VSCode no tengas seleccionado el env donde tienes instaladas las dependencias

Juan David Muñoz Hernández

student•

Buen día me gustaría saber si para la conexión con una bd PostgreSQL, es necesario emplear el controlador psycopg2

Adrian Ernesto German Becerra

student•

Esto es lo que estaba esperando 🙂

El objetivo de SQLModel es hacer que el manejo de bases de datos en aplicaciones web desarrolladas con FastAPI sea más sencillo e intuitivo. SQLModel combina las funcionalidades de SQLAlchemy y Pydantic para manejar tanto la definición de modelos de datos como la comunicación con la base de datos.

SQLModel es una excelente opción para tener una integración simplificada y potente para el manejo de datos.

Abinadi Contreras

student•

Entiendo que quitarle el BaseModel y poner el SQLModel no afecta en nada la logica, ya que son compatibles

Samuel Steven Bernal Martínez

student•

Una forma fácil de poner todo lo necesario en requirements si estás en linux es ejecutado el comando:

pip freeze > requirements.txt

🚀Y listo, tendrás todo lo necesario!

Samuel Steven Bernal Martínez

student•

El link a la documentación tiene un Typo, aquí puedes ir al link correcto: https://sqlmodel.tiangolo.com/

Angel Esteban Patiño Salazar

student•

Cuando intento conectarme a mi bd postgres simpre me sale este error:

UnicodeDecodeError: 'utf-8' codec can't decode byte 0xf3 in position 85: invalid continuation byte.

mi codigo de configuración es: from fastapi import FastAPI`f````js

````rom``  typing  ``import`` Annotated`
`from``  fastapi  ``import`` Depends``from``  sqlmodel  ``import`` Session, create_engine, SQLModel`
`pg_url = "postgresql://postgres:midb@localhost:5432/garden"print(pg_url)`
`engine = create_engine(pg_url)`
`def create_db_and_tables(``app``: FastAPI):    SQLModel.metadata.create_all(engine)    ``yield`
`def get_session():    ``with``  Session(engine)  ``as``  session:         ``yield`` session`
`SessionDep = Annotated[Session, Depends(get_session)]`

Ruy Cabello

student•

¿Por qué utilizamos get_session? ¿Realmente necesitamos usar Depends?

Estas fueron las preguntas que yo llegué a tener, debido a que podríamos crear directamente la sesión y cerrarla:

def create_user(user_data: dict):
  session = Session(engine) # creación directa
  # ...
  session.close()
```¡Y funcionaría!
Sin embargo, no es la mejor manera de hacerlo.&#x20;

Cuando usamos **Depends**, estamos usando un Dependency Injection, que permite añadir lógica reutilizable. Es **más mantenible**. Si quisieramos modificar algún elemento de get\_session(), lo haríamos únicamente desde un lugar (y no en todas las sesiones si las crearamos manualmente).&#x20;

Ray Trápala

student•

Tu interpretación es correcta. En FastAPI, puedes crear tipos de datos personalizados que añaden más contexto o restricciones a los tipos básicos. Por ejemplo, al definir SessionDependency como un tipo que hereda de Session, le añades más significado a ese objeto, lo que facilita su uso y comprensión. De igual forma, definir UserID = Annotated[int, "Debe ser un ID único y positivo"] no solo especifica que se trata de un entero, sino que también proporciona una condición que ayuda a validar los datos. Esto mejora la claridad y la validación de tus datos en la aplicación.

Ray Trápala

student•

la pregunta a esta respuesta de la IA fue:

Esta clase, básicamente nos ayuda a tener nuevos tipos de datos con más información acerca del mismo. Por ejemplo, en nuestro caso creamos un nuevo tipo de dato SessionDependency que no es más que un tipo Session y como segundo parámetro o mayor información agregamos una dependencia con Depends la cual recibe un Callable que será, en este caso, la fuente de donde obtiene el objeto sesión.

Otro caso puede ser, crear un tipo de dato UserID UserID = Annotated[int, "Debe ser un ID único y positivo"] que es un tipo de dato int y como información adicional ciertas condiciones.

Ray Trápala

student•

Tu comprensión del contenido del módulo db.py es correcta. Estás eligiendo un nombre para la base de datos SQLite y creando la URL correspondiente. El "motor" (engine) efectivamente permite la conexión a la base de datos, y al usar yield en lugar de return, mantienes la sesión activa mientras la aplicación está en funcionamiento. FastAPI cerrará la sesión al finalizar el contexto. Además, al definir la variable como Annotated, registras la dependencia en la aplicación. Todo está alineado con las prácticas de FastAPI.

Ray Trápala

student•

esto fue lo que me respondió la IA resecto a la comprensión del código en db.py. Esta fue mi pregunta: Con este código, lo que estamos haciendo es:

elegir un nombre para nuestra base de datos, en este caso de sqlite3
crear la url para nuestra base de datos. Esto lo vemos en la documentación.
crear el “motor (engine)” que nos ayudará a conectarnos a la base de datos

sqlite_name = "db.sqlite3" sqlite_url = f"sqlite:///{sqlite_name}" engine = create_engine(sqlite_url)

crear una función que nos retorne la sesión. Para esto, como fastapi maneja un entorno asíncrono, usamos yield en vez de return. Esto es para no cerrar la sesión y continuar usándola mientras la app este activa. Al final, por estar dentro un contexto, se cerrará automáticamente.

def get_sesssion(): with Session(engine) as session: yield session

Por último, debemos decirle a fastapi, es decir, nuestra app, que la sessión depende de esta función que nos entrega la misma. Para esto, creamos una nueva variable que será una instancia de Annotated que recibe el la clase y la función, es decir, la clase que queremos agregar con una dependencia y la función que maneja dicha dependencia. SessionDep = Annotated[Session, Depends(get_sesssion)]

Mario Alexander Vargas Celis

student•

Para conectar FastAPI a una base de datos utilizando SQLModel, puedes seguir estos pasos. SQLModel combina lo mejor de SQLAlchemy y Pydantic, permitiendo trabajar con modelos como clases Pydantic mientras administra una base de datos relacional.

Pasos para conectar FastAPI a una base de datos con SQLModel:

Instalar las dependencias necesarias:pip install fastapi sqlmodel uvicorn sqlite
Configurar los modelos de datos con SQLModel: Define las tablas de la base de datos utilizando clases que heredan de SQLModel.
Configurar la conexión a la base de datos: Utiliza una base de datos como SQLite (ideal para desarrollo) o conecta a un motor como PostgreSQL o MySQL en producción.
Crear los endpoints necesarios: Utiliza las operaciones CRUD para interactuar con la base de datos a través de FastAPI.

Ejemplo práctico: Gestión de clientes

1. Definir los modelos de datos

from sqlmodel import SQLModel, Field from typing import Optional

class Customer(SQLModel, table=True): id: Optional[int] = Field(default=None, primary_key=True) name: str email: str age: Optional[int]

En este modelo:

table=True indica que la clase corresponde a una tabla en la base de datos.
El campo id es una clave primaria.

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

from sqlmodel import SQLModel, create_engine, Session

DATABASE_URL = "sqlite:///./test.db" # Cambia la URL según el motor de tu base de datos engine = create_engine(DATABASE_URL, echo=True)

# Crear todas las tablas definidas en los modelos def create_db_and_tables(): SQLModel.metadata.create_all(engine)

3. Crear los endpoints en FastAPI

from fastapi import FastAPI, HTTPException, Depends from sqlmodel import Session, select

app = FastAPI()

# Crear la base de datos al iniciar la aplicación @app.on_event("startup") def on_startup(): create_db_and_tables()

# Dependency para manejar sesiones def get_session(): with Session(engine) as session: yield session

@app.post("/customers/", response_model=Customer) def create_customer(customer: Customer, session: Session = Depends(get_session)): session.add(customer) session.commit() session.refresh(customer) return customer

@app.get("/customers/", response_model=list[Customer]) def list_customers(session: Session = Depends(get_session)): statement = select(Customer) results = session.exec(statement).all() return results

@app.get("/customers/{customer_id}", response_model=Customer) def get_customer(customer_id: int, session: Session = Depends(get_session)): customer = session.get(Customer, customer_id) if not customer: raise HTTPException(status_code=404, detail="Customer not found") return customer

@app.delete("/customers/{customer_id}") def delete_customer(customer_id: int, session: Session = Depends(get_session)): customer = session.get(Customer, customer_id) if not customer: raise HTTPException(status_code=404, detail="Customer not found") session.delete(customer) session.commit() return {"message": "Customer deleted"}

4. Probar la aplicación

Inicia el servidor con:

uvicorn main:app --reload

Pruebas con rutas:

Crear un cliente:{ "name": "Luis", "email": "luis@example.com", "age": 30 }
- POST /customers/
Listar todos los clientes:
- GET /customers/
Obtener un cliente por ID:
- GET /customers/1
Eliminar un cliente:
- DELETE /customers/1

5. Cambiar a otro motor de base de datos

Para usar motores como PostgreSQL o MySQL, cambia DATABASE_URL a algo como:

PostgreSQL:DATABASE_URL = "postgresql://user:password@localhost/dbname"
MySQL:DATABASE_URL = "mysql+pymysql://user:password@localhost/dbname"

Asegúrate de instalar el controlador correspondiente:

pip install psycopg2 # Para PostgreSQL pip install pymysql # Para MySQL

Beneficios de usar SQLModel con FastAPI:

Simplicidad: Combina SQLAlchemy y Pydantic en un único modelo.
Flexibilidad: Fácil de escalar a bases de datos complejas.
Integración nativa con FastAPI: Usa modelos SQLModel directamente en los endpoints.

Julio Sarango

student•

¿Por qué FastAPI maneja de esta forma las conexiones a la bd?

¿Por qué no puede ser por ejemplo con django, se establece la cadena de conexión y no se debe "tocar" más esta conexión? Habla de pasar la Session a cada endpoint

Julio Sarango

student•

Esto respondió el asistente de platzi con IA

FastAPI gestiona las conexiones a la base de datos mediante una sesión gestionada que se inyecta en cada endpoint como dependencia. Esto permite una mayor flexibilidad y control sobre el ciclo de vida de la sesión, adaptándose a las solicitudes concurrentes sin problemas.

En Django, la conexión se establece una vez y se reutiliza automáticamente, simplificando su uso. Sin embargo, esto puede complicar la gestión de múltiples hilos. FastAPI, al usar una sesión por solicitud, garantiza que cada operación sea independiente, lo que es más eficiente para aplicaciones de alta concurrencia.

Esta implementación de dependencias en FastAPI facilita el manejo de sesiones de manera más granular y eficiente.

Daniloo Morales

student•

Y el BaseModel?

class CustomerBase(SQLModel): name: str description: str | None email: str age: int class CustomerCreate(CustomerBase): pass class Customer(CustomerBase, table=True): id: int | None = None

Francisco Diez

student•

Hola! Tengo un problema con sqlmodel.

Estoy usando conda para la gestión de librerías, y seguí todos los pasos para instalat sqlmodel, pero no puedo ejecutar el código porque me aparece como si no estuviera instalado:

A su vez cuando intento instalarlo con pip me aparece que ya está instalado:

Qué podrá ser?