Aplicaciones en servidores y redes

01 · Punto de partida

El banco corre en un data center

Tu API recibe 200 req/s que tardan 50 ms: hay 10 requests adentro (Little) y con 12 workers vas al 83%. El p95 pide 100 ms de cola; un downstream lento mete gigantes; un reintento agresivo multiplica λ justo en el pico. Misma teoría, otras unidades: rps, ms y workers.

Aplicarla acá es medir por endpoint, dimensionar pools con Little+Erlang, balancear al menos cargado y poner timeout con backoff antes que escalar a ciegas.

• ¿Cuántos workers/hilos/conexiones para mi rps y latencia?
• ¿Media o p95: qué SLA firmo?
• ¿Cómo balanceo y cómo escalo (vertical vs horizontal)?
• ¿Qué hacen timeout y reintentos con λ?

02 · Definición

Throughput, latencia y concurrencia

03 · El corazón: la receta backend

Medir, dimensionar, balancear, domar, escalar

1. 1
   Medir por endpoint y ventana.

   rps, p50/p95/p99 de S y W, por minuto. La media esconde el endpoint gigante que traba el pool.

2. 2
   Dimensionar pools con Little+Erlang.

   Conexiones e hilos = λW + margen; c con P(Wq ≤ t) del SLA. El pool chico es K finita con fuga (Tema 27).

3. 3
   Balancear al menos cargado.

   Least-connections / primero libre = fila única (pooling, Tema 29). Round-robin a ciegas parte el pooling.

4. 4
   Timeout + backoff con jitter.

   Timeout acota S (corta gigantes, baja Cs²); reintento suma λ_extra = λ·p/(1−p): con p = 20% es +25% de carga fantasma.

5. 5
   Autoscaling por ρ/latencia.

   Escalar al acercarse al codo (Tema 44), no en la pared; con headroom N+1. Escalar por CPU sola ignora la cola.

Tail latency

El p99 manda en cascada: con 10 llamadas en serie, P(alguna lenta) ≈ 10%. Doma gigantes (timeout) antes que promedios.

Retry storm

Timeouts sincronizados reintentan a la vez: λ se multiplica en el peor momento (ρ 0.83 → 1.25). Backoff + jitter la desarman.

Vertical vs horizontal

Subir μ (más CPU/rápido) baja W directo y Wq doble (Tema 36); sumar c (réplicas) aplana la curva. Se combinan por costo.

Health-checks

Sacar nodos enfermos baja c justo en el pico: el autoscaling debe reponer antes de declarar victoria.

04 · Ejemplos

Cuatro backends con número

1. 1
   API 200 r/s × 50 ms, 12 workers.

   a = 10, ρ = 0.83: Wq ≈ 11 ms, P(cola ≤ 100 ms) ≈ 99%. Headroom justo.

2. 2
   Pool DB 500 r/s × 20 ms.

   L = 10 conexiones ocupadas: pool 16 (ρ = 0.63) con margen para picos ×1.5.

3. 3
   Consumers 10 r/s × 2 s.

   a = 20: 24 consumers (ρ = 0.83). El lag de la cola es Lq visible.

4. 4
   Retry storm del downstream.

   p = 30% timeouts: λ_ef ≈ 1.39×λ (0.83 → 1.15): de tenso a volteado. Backoff ya.

05 · Representación en Python

Pool por Little y carga fantasma por reintentos

Unidades rps y segundos: los mismos números del curso con otros nombres.

# Pool por Little + margen: lam rps, S segundos
def pool(lam, S, margen=1.5):
    return {"ocupados": lam*S, "pool": round(lam*S*margen)}

print(pool(200, 0.05))   # 10 ocupados -> pool 15
print(pool(500, 0.02))   # 10 ocupados -> pool 15

# Carga fantasma: p timeout, hasta 3 intentos
def carga_fantasma(p, k=3):
    return sum(p**i for i in range(k))

for p in [0.05, 0.2, 0.3]:
    print(f"p={p:.0%} -> x{carga_fantasma(p):.2f} (rho 0.83 -> {0.83*carga_fantasma(p):.2f})")

06 · Exploración

Laboratorio: planificar capacidad + tormenta

Elegí λ (rps), S (ms) y workers c. La curva es Wq(λ) exacta (Erlang) con tu c; el punto es tu operación; la recta es el SLA de cola (100 ms). El interruptor de tormenta multiplica λ ×1.5 (reintentos): mirá cómo el punto se muda a la pared.

Curva lima = Wq(λ); punto = tu λ (naranja con tormenta ×1.5); recta = SLA 100 ms. La tormenta corre el punto, no la curva.

Preguntas para explorar

1. Default (200 rps, 50 ms, 12): ¿ρ? ¿L? ¿Wq y P(≤100 ms)?
2. Con tormenta (λ × 1.5 = 300): ¿ρ? ¿Qué pasa con Wq?
3. Subí a c=16 sin tormenta: ¿ρ y Wq? ¿Y con tormenta?

07 · Comprensión

Confusiones frecuentes

08 · Práctica guiada

Ejercicios con Python

Ejercicio 1: pool DB

λ=500 r/s, S=20 ms, margen 1.5. ¿Ocupadas y pool?

# 10 ocupadas -> pool 15 (ρ=0.63 con 16)
print(pool(500, 0.02))

Ejercicio 2: tormenta numérica

ρ=0.83 con p=30% y 3 intentos. ¿ρ efectiva?

# x1.39 -> rho 1.15: voltea (el lab muestra 1.25 con p≈33%)
print(f"{0.83*sum(0.3**i for i in range(3)):.2f}")

Ejercicio 3: vertical vs horizontal

S=50→25 ms (caché) vs c=12→24 con λ=200. ¿ρ en cada caso?

# caché: a=5, rho=0.42; workers: rho=0.42 también. Empate en rho...
print("...pero caché además baja W a la mitad: doble dividendo")

09 · Síntesis

Ideas para recordar

En el próximo tema bajamos a planta: producción y logística.