Optimización del Código y Dependencias en Flask - Episodio 26

La optimización del código y dependencias en Flask se vuelve necesario a medida que el proyecto crece.

Es como todo.

Empiezas con poco y a medida que te vas liando, va creciendo y creciendo...

Así que te voy a contar lo que hice.

📅 Diario de un SaaS – Cómo mejoramos la estructura del backend

Pues eso, vamos a ver por partes cómo lo hice!

🔥 Flask crece… y el código se vuelve un caos

Cuando arrancamos este proyecto, el código de Flask era limpio y simple.

Pero claro, a medida que añadíamos más funcionalidades, la estructura empezó a descontrolarse:

• Archivos desordenados, con funciones repetidas.
• Base de datos sin control de versiones, lo que hacía que cualquier cambio fuera peligroso.
• Problemas de rendimiento, porque las consultas a PostgreSQL no estaban optimizadas.

Era hora de organizar el backend y optimizar dependencias antes de que se volviera un monstruo inmanejable. 🚀

⚠️ Problemas encontrados en la estructura del código

🔹 app.py se estaba convirtiendo en un Frankenstein

• Teníamos rutas, configuración y lógica de negocio en un solo archivo.
• Cada nueva funcionalidad hacía que el código fuera más difícil de leer.

🔹 Las migraciones de la base de datos eran un dolor de cabeza

• Cualquier cambio en los modelos requería hacer ajustes manuales en PostgreSQL.
• No podíamos versionar la base de datos de forma controlada.

🔹 El rendimiento se veía afectado

• Cada petición golpeaba PostgreSQL directamente, sin caché.
• Las consultas eran lentas y hacían que la API tardara en responder.

Había que arreglar esto antes de que se volviera insostenible.

🛠️ Soluciones Implementadas

🔹 1. Modularizamos el código en Flask

Para evitar que app.py fuera un desastre, dividí el código en módulos:

📂 app/ (Directorio principal)
├── 📂 routes/ → Manejadores de endpoints
├── 📂 models/ → Definición de modelos SQLAlchemy
├── 📂 services/ → Lógica de negocio separada
├── 📂 config/ → Configuración centralizada
├── 📂 migrations/ → Gestión de la base de datos con Flask-Migrate
├── app.py → Punto de entrada limpio

✅ Beneficio: Ahora cada parte del código tiene su sitio y es más fácil de mantener.

🔹 2. Migraciones de Base de Datos con Flask-Migrate

Para evitar cambios manuales en PostgreSQL, instalamos Flask-Migrate:

pip install flask-migrate

Luego, configuramos la base de datos en app.py:

from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

db = SQLAlchemy()
migrate = Migrate()

def create_app():
    app = Flask(__name__)
    app.config.from_object("config.Config")
    db.init_app(app)
    migrate.init_app(app, db)
    return app

Ahora, cada vez que modificamos los modelos, simplemente ejecutamos:

flask db migrate -m "Añadiendo nuevo campo"
flask db upgrade

✅ Beneficio: Cambios en la base de datos sin riesgos, versionados y automatizados.

🔹 3. Implementamos Redis como Caché

Para reducir la carga en PostgreSQL, usamos Redis para almacenar consultas frecuentes.

Instalamos Redis:

sudo apt install redis
pip install redis

Configuramos Redis en Flask:

from flask_caching import Cache

cache = Cache(config={'CACHE_TYPE': 'RedisCache', 'CACHE_REDIS_URL': 'redis://localhost:6379/0'})
cache.init_app(app)

Ejemplo de caché en un endpoint:

@app.route('/productos')
@cache.cached(timeout=60)  # Guarda la respuesta en caché por 60 segundos
def get_productos():
    productos = Producto.query.all()
    return jsonify([p.serialize() for p in productos])

✅ Beneficio: Respuestas más rápidas y menor carga en PostgreSQL.

💡 Lecciones aprendidas

🔹 1. Un código organizado facilita la escalabilidad

Si hubiéramos seguido metiendo todo en app.py, el proyecto sería inmanejable en poco tiempo.

Por lo que separar en módulos hace que sea más fácil de mantener.

🔹 2. Las migraciones evitan dolores de cabeza

Sin Flask-Migrate, cualquier cambio en la base de datos requería ajustes manuales con riesgo de perder datos.

Ahora todo está controlado y versionado.

🔹 3. Redis acelera la API sin tocar PostgreSQL

Reducir las consultas a PostgreSQL con caché en Redis ha sido clave para mejorar el rendimiento.

Así que la API responde más rápido y el servidor no sufre.

⏩ Próximos pasos

📀 Balanceo de carga y escalabilidad del backend

📀 Implementación de backups automáticos en PostgreSQL

Cada optimización nos acerca más a un backend sólido y escalable. 🚀

Si quieres conocer otros artículos parecidos a Optimización del Código y Dependencias en Flask - Episodio 26 puedes visitar la categoría Proyecto-IA.