Hace poco me puse a probar dos frameworks que seguramente ya conocés: Flask y FastAPI. Ambos son súper populares en el mundo Python, pero la gran pregunta es: ¿cuál rinde mejor cuando lo llevás a producción en un servicio como Azure App Service?

Quizás ahora todo esto te suene un poco abstracto o demasiado teórico, pero no te preocupes: en el video lo vamos a ver claro, con ejemplos prácticos y datos reales. Ahí vas a poder seguir paso a paso cómo medir, interpretar las gráficas de Locust y entender por qué estas métricas marcan la diferencia entre una aplicación que simplemente funciona y otra que realmente escala en producción.

Yo tenía claro algo: no quería quedarme solo con la teoría. Muchos dicen que FastAPI es más rápido porque es asíncrono, y otros defienden a Flask por su simplicidad y madurez. Así que decidí armar un escenario justo: desplegué ambos en el mismo plan de App Service y corrí pruebas de carga con Locust.

¿Por qué usar Locust?

Locust me permitió simular cientos de usuarios al mismo tiempo golpeando mis endpoints. Es como tener un ejército de testers virtuales enviando peticiones sin parar. Con eso podés ver hasta dónde aguanta tu aplicación, cuándo se empieza a poner lenta y en qué punto comienzan los errores.

Lo interesante es que Locust no solo te da números, sino que te deja sentir cómo reaccionan tus servicios bajo presión.

Entendiendo las métricas sin tecnicismos

Seguramente cuando escuchás palabras como latencia P95, RPS o CPU al 70% puede sonar técnico, pero te lo cuento con ejemplos cotidianos:

Latencia: es el tiempo que un usuario espera por una respuesta. El P50 es el promedio, el P95 son los que esperan un poco más y el P99 son esos casos extremos en que alguien se queda colgado.

RPS (Requests per Second): es cuántos clientes podés atender por segundo. Cuanto más alto, mejor estás usando tus recursos.

Errores: los 5xx son fallas en tu cocina (la aplicación), y los 429 son cuando Azure te dice “ya no puedo más, volvé más tarde”.

CPU y memoria: son como la energía y la despensa de un restaurante. Si la CPU está siempre al 90%, los cocineros no dan más. Si la memoria se llena, se te apaga todo.

Coste por petición (CPP): es básicamente preguntarte: “¿cuánto me cuesta atender a cada usuario con la infraestructura que estoy pagando?”.

 

Formulas útiles para pruebas de rendimiento (FastAPI vs Flask en Azure con Locust)
=================================================================================

1. Coste por petición (CPP)
---------------------------
Sirve para unir rendimiento con finanzas:

    CPP = Coste_hora_plan / (RPS_sostenido × 3600)

- Coste_hora_plan: lo que pagás por el App Service Plan por hora.
- RPS_sostenido: cuántas peticiones por segundo tu app puede manejar de forma estable.
- 3600: segundos en una hora.

Mientras más RPS logres en el mismo plan, menor será el coste por petición.

2. Throughput efectivo bajo carga
---------------------------------
Una forma sencilla de medir eficiencia:

    Throughput_efectivo = RPS × (1 - ErrorRate)

- RPS: peticiones por segundo.
- ErrorRate: porcentaje de errores (5xx/429).

No importa cuántos RPS declares si el 20% son errores: lo que realmente cuenta es el throughput efectivo.

3. SLO de latencia
------------------
Un objetivo típico en APIs internas o externas se expresa como:

    P95_latencia < X ms

Ejemplo: "El 95% de las peticiones deben responder en menos de 300 ms".
Esto traduce un acuerdo técnico en un compromiso de negocio (SLA/SLO).

¿Qué encontré en la práctica?

Mis pruebas confirmaron lo que muchos sospechaban: FastAPI maneja mejor la concurrencia y suele dar menor latencia en percentiles altos (P95/P99). Esto significa que, aunque ambos funcionan bien en escenarios simples, cuando ponés presión real, FastAPI responde más rápido y con menos errores.

Flask, por su parte, sigue siendo un framework increíble cuando querés armar algo rápido, sencillo y confiable. Pero si el tráfico crece, vas a necesitar más instancias para alcanzar el mismo nivel de rendimiento que con FastAPI.

 

Pronto estaré publicando un video en el canal donde mostraré paso a paso estas pruebas en Azure, comparando Flask y FastAPI con Locust. Este tipo de pruebas no son un lujo, sino una necesidad técnica: en ingeniería de software moderna los sistemas deben garantizar baja latencia, alta disponibilidad y eficiencia en el uso de recursos. El desafío está en que no basta con que una app “funcione”; tiene que hacerlo de manera estable bajo miles de usuarios concurrentes, evitando caídas, sobrecostos en infraestructura y degradación de la experiencia de usuario. Por eso, medir de forma objetiva métricas como latencia en percentiles, throughput y coste por petición es clave para tomar decisiones arquitectónicas sólidas y construir servicios escalables en la nube.

Lo más importante es que no te quedes solo con lo que leés en foros o blogs: hacé tus propias pruebas. Con herramientas como Locust y un entorno en Azure podés medir, comparar y tomar decisiones basadas en datos reales, no en suposiciones.

 

Mi conclusión

Si vos necesitás eficiencia y escalabilidad, FastAPI es una gran apuesta. Si lo que buscás es simplicidad y velocidad de desarrollo, Flask cumple perfecto.