Saltearse al contenido

Rendimiento en servidor

Un servicio web pasa la mayor parte del tiempo esperando: a la base de datos, a otro servicio, al disco. El tiempo de CPU en Python suele ser una fracción pequeña del total, y por eso optimizar el bucle equivocado no mueve ninguna métrica. Este capítulo ordena qué se mide en un servidor y qué se hace con cada número.

En un servicio, el cuello casi nunca es Python: es la espera, el serializado o el número de viajes.

Serializar y deserializar 1 000 registros
Operación Tiempo Por registro
json.dumps 0.56 ms 0.6 µs
json.loads 0.49 ms 0.5 µs
Construir el JSON a mano 0.53 ms —

python mediciones/07-06-10-servidor-seguridad-debug.py

Dos conclusiones. La primera: serializar es barato por registro, pero no gratis: una respuesta con 10 000 objetos son 6 ms sólo de json, antes de enviar un byte. La segunda: construir el JSON a mano apenas gana un 5 % (0,53 frente a 0,56 ms) y además no escapa comillas ni caracteres de control. La optimización manual no compensa.

Y el arranque, que en un servicio con cien workers se paga cien veces:

Importar módulos al arrancar (acumulado)
Módulo Coste
dataclasses 22.1 ms
logging 18.8 ms
json 11.5 ms

python mediciones/07-01-05-produccion.py

Métrica Qué dice Dónde se mide
Latencia p50 / p95 / p99 Lo que siente el usuario Middleware o proxy
Throughput Peticiones por segundo Contador
Tasa de error Porcentaje de 5xx y timeouts Contador por código
Saturación Cola, conexiones, CPU Métricas del sistema

La media engaña: un p50 de 20 ms con un p99 de 2 segundos significa que uno de cada cien usuarios espera dos segundos, y eso se percibe como «va lento» aunque la media sea buena.

  1. El número de viajes. Diez consultas de 5 ms son 50 ms; una de 10 ms que trae lo mismo son 10. El clásico N+1 es el mayor ahorro disponible en casi todo servicio.
  2. La espera. Pool de conexiones, caché de lo que no cambia, timeouts para no esperar indefinidamente.
  3. El serializado. Devolver sólo los campos que el cliente usa: la mitad de la respuesta es la mitad del tiempo.
  4. La CPU. Y aquí sí, numpy, vectorización o mover el cálculo a un worker.

El orden importa: optimizar la CPU cuando casi todo el tiempo es espera produce mejoras mínimas y la sensación de haber trabajado.

  • Si el p99 ya cumple el objetivo. Optimizar más es riesgo sin beneficio.
  • Si el cuello está fuera de tu código. Una base lenta no se arregla con Python más rápido.
  • Sin medir en producción. El perfil de tu portátil no se parece al del servidor: distinto hardware, distinta red, distinta carga.

Un endpoint tarda 300 ms de media. Las métricas dicen: 240 ms de base de datos (12 consultas), 40 ms de serializado, 20 ms de lógica. Propón el orden de intervención y el resultado esperado.

Solución

1. Reducir las 12 consultas. Si son N+1, una consulta con JOIN o select_related las convierte en 1-2. De 240 ms a ~40 ms. La mejora es de dos tercios del total (200 de 300 ms), y no requiere tocar Python.

2. Reducir el serializado. 40 ms sugiere una respuesta grande; devolver sólo los campos usados o paginar puede bajarlo a 10 ms.

3. La lógica. 20 ms es lo último; optimizarla primero daría como máximo un 7 %.

Resultado esperado: ~70 ms, un 77 % menos. La primera intervención aporta casi todo, y es la que no se hace cuando se empieza por el código.

La comprobación: medir el p99 después de cada cambio, no la media, y con carga real. Una consulta que tarda 40 ms con 10 usuarios puede tardar 400 con 100 si el índice no está.

Las cuentas, para comprobarlas:

antes = {"base": 240, "serializado": 40, "logica": 20}
despues = {"base": 40, "serializado": 10, "logica": 20}
total_antes, total_despues = sum(antes.values()), sum(despues.values())
print(f"antes: {total_antes} ms; despues: {total_despues} ms")
print(f"mejora total: {1 - total_despues / total_antes:.0%}")
print(f"solo las consultas: {(antes['base'] - despues['base']) / total_antes:.0%} del total")
print(f"techo de optimizar la logica primero: {antes['logica'] / total_antes:.0%}")
  • Ramalho, L. Fluent Python, 2ª ed. Capítulo 19.
  • Lott, S. F. Modern Python Cookbook, 3ª ed. Capítulo 13.
  • Mediciones: mediciones/07-06-10-servidor-seguridad-debug.py y mediciones/07-01-05-produccion.py.
  • 04 · Logging: el coste oculto por petición.
  • 07 · Seguridad: lo que no debe aparecer en una respuesta.
  • 10 · Depuración: cómo se investiga un p99 alto.