Tamaño de letra
Tema
Ancho de lectura
Tipografía

Apuntes · Capítulo 6Estilos, tácticas y decisiones

Tácticas: modificabilidad, rendimiento, disponibilidad y seguridad

Tácticas: modificabilidad, rendimiento, disponibilidad y seguridad

Ruta de lectura.

  • Antes de clase (obligatorio, unos 20 minutos): de Qué es una táctica, Una decisión que mueve una medida y Táctica, patrón y estilo; de Rendimiento: a dónde se va el tiempo, Tiempo de procesamiento y tiempo bloqueado y El caso de la semana: Qillqa; y de Disponibilidad: que una falta no llegue a ser una falla, Falta, error y falla.
  • En clase: Sesión A: Qué es una táctica, Tácticas de modificabilidad, Rendimiento: a dónde se va el tiempo, Las tácticas de rendimiento, El pool de conexiones, N+1: reducir el costo de cada pedido y Cache, primera vista. Sesión B: Disponibilidad: que una falta no llegue a ser una falla, Degradar en vez de caer, El retry: táctica y riesgo, Seguridad y Una táctica para un atributo cuesta otro. Laboratorio: Laboratorio: pool de conexiones y cache, medir antes y después.
  • Después de clase: el Resumen y los Ejercicios. Antes de empezar P2 conviene releer Cómo se elige el tamaño y Qué táctica dio más. Opcionales: El cliente que espera en silencio, Los principios de Saltzer y Schroeder y El código de la semana.

Las dos semanas pasadas fueron de estilos: capas, modular monolith, pipeline y microkernel primero; service-based, microservicios y event-driven después. Un estilo es una decisión grande, que da forma a todo el sistema y que se toma pocas veces. Pero la mayor parte de las decisiones de arquitectura son más pequeñas. Tinkuy seguirá siendo un monolito durante varias entregas, y aun así hay que decidir cómo consigue sus conexiones a la base de datos, cuántas consultas hace para armar una lista, qué pasa cuando el servidor de correo no responde y quién puede hablar con la pasarela de pagos.

A esas decisiones más pequeñas se les llama tácticas. En la semana 2 las mencionamos de pasada y dejamos una regla: primero el escenario, después la táctica. Esta semana las estudiamos con orden. Para cada uno de cuatro atributos de calidad (modificabilidad, rendimiento, disponibilidad y seguridad) vemos el catálogo de tácticas que el campo ha ido reuniendo, y aplicamos algunas a un sistema pequeño, midiendo antes y después. Lo segundo importa tanto como lo primero: una táctica que no se midió es una opinión.

El capítulo sigue las dos sesiones. La primera repasa las tácticas de modificabilidad, que ya usaron en las semanas 3 y 4 sin llamarlas así, y dedica casi todo su tiempo al rendimiento, con tres tácticas medidas: un pool de conexiones, quitar un N+1 y una cache. La segunda trata la disponibilidad y la seguridad, y cierra con lo que todas las tácticas tienen en común: lo que se gana en un atributo se paga en otro.

Lectura. Sesión A: Bass, Clements y Kazman, Software Architecture in Practice (4.ª ed.), cap. 8 Modifiability y cap. 9 Performance: en cada uno, el escenario general, el árbol de tácticas y el cuestionario. Complementarias: node-postgres, Pooling; Software Architecture in Practice, cap. 12 Testability y cap. 5 Deployability.

Sesión B: Software Architecture in Practice, cap. 4 Availability y cap. 11 Security: el escenario general, el árbol de tácticas y el cuestionario; Saltzer y Schroeder, The Protection of Information in Computer Systems (1975), la sección de principios de diseño. Complementarias: OWASP Top 10; Site Reliability Engineering, cap. 22, Addressing Cascading Failures. Para el laboratorio: k6, Thresholds, y la documentación de Redis.

El código de este capítulo está en code/week-06/. Todas las salidas que se muestran son de ejecuciones reales en el contenedor del curso, en una laptop con Apple Silicon, dentro de Docker, mientras la máquina atendía otras cargas. Los milisegundos cambian de una máquina a otra y de una corrida a otra; lo que se traslada es la comparación entre dos diseños medidos en la misma máquina, uno después del otro.

Qué es una táctica

Una decisión que mueve una medida

Un escenario de calidad, como los de la semana 2, tiene un estímulo, una respuesta y una medida de la respuesta. Una táctica (tactic) es una decisión de diseño que influye sobre esa respuesta. Nada más: una decisión, y una medida que se mueve.

Tomemos un escenario de Tinkuy:

Cincuenta personas miran el catálogo a la vez (estímulo), en operación normal (entorno). GET /events (artefacto) responde con la lista de eventos (respuesta), con un p95 menor de 300 ms y sin errores (medida).

Tres decisiones distintas pueden mover ese p95: mantener abiertas las conexiones a la base de datos en vez de abrir una por consulta; obtener la disponibilidad de todos los eventos en una consulta en vez de una por evento; guardar la respuesta durante unos segundos y devolver la copia. Las tres son tácticas de rendimiento. Cada una ataca una causa distinta de la latencia, y cuál conviene depende de cuál sea la causa en este sistema. Por eso el orden de trabajo de toda la semana es el mismo:

  1. El escenario, con su medida.
  2. Medir el sistema como está, y encontrar dónde se pierde la medida.
  3. Elegir la táctica que corresponde a esa causa, mirando también lo que cuesta.
  4. Medir de nuevo, con el mismo script, en la misma máquina.

Una táctica tiene dos propiedades que la distinguen de las decisiones que vimos hasta ahora.

Apunta a un solo atributo. Un pool de conexiones es una táctica de rendimiento. No fue pensado para la seguridad ni para la modificabilidad. Eso no quiere decir que no los afecte: quiere decir que su efecto sobre los demás atributos no es su propósito, sino su costo o su efecto secundario, y hay que mirarlo aparte. Ese efecto sobre los demás es el trade-off de la táctica.

Es pequeña. No da forma al sistema entero. Se puede aplicar en un módulo y no en otro, y se puede combinar con otras.

Idea clave. Una táctica es una decisión de diseño que influye sobre la respuesta a un estímulo de un atributo de calidad. Su efecto sobre los otros atributos no viene incluido en el nombre: es el trade-off, y hay que buscarlo.

Táctica, patrón y estilo

En la semana 4 distinguimos estilo de patrón. Falta ubicar la táctica.

Qué es Tamaño Ejemplo
Táctica Una decisión que influye sobre la respuesta de un atributo Una decisión Restringir dependencias; mantener un pool; detectar con un heartbeat
Patrón Una solución con nombre a un problema que se repite, hecha de varias decisiones que se toman juntas Varias tácticas empaquetadas Microkernel; réplicas detrás de un load balancer; cache-aside
Estilo La forma del sistema completo: qué elementos hay, cómo se conectan y qué restricciones cumplen Todo el sistema Modular monolith; microservicios; event-driven

La relación entre táctica y patrón se ve bien al desarmar un patrón conocido. El microkernel de la semana 4, con su núcleo y sus plug-ins, junta al menos tres tácticas de modificabilidad: encapsular (cada variante queda detrás de un contrato), usar un intermediario (el registro, que está entre el núcleo y los plug-ins) y diferir el enlace (qué plug-ins existen se decide al arrancar, no al escribir el núcleo). Otro: varias instancias de un servidor detrás de un load balancer con health checks junta una táctica de rendimiento (mantener varias copias del cómputo), una de disponibilidad para detectar (monitor, con ping y eco) y una para prevenir (sacar de servicio a la instancia que no responde).

El segundo ejemplo muestra algo más: un patrón puede servir a varios atributos a la vez, porque empaqueta tácticas de atributos distintos. Una táctica sola, no.

Pensar en tácticas sirve para dos cosas. Para diseñar: cuando ningún patrón conocido calza con el problema, se puede armar una solución a partir de tácticas, sabiendo qué aporta cada una. Y para analizar: frente a un patrón, un framework o un producto, preguntar qué tácticas trae dentro es la forma de saber qué atributos mejora y cuáles no toca. “Usamos Redis” no dice nada sobre la arquitectura; “mantenemos una copia de los datos de lectura, con un TTL de 5 segundos” dice qué se gana y qué se arriesga.

El árbol y el cuestionario

Las tácticas de un atributo no forman una lista plana. Se agrupan según cómo influyen sobre la respuesta, y el resultado es un árbol de dos o tres niveles. El de rendimiento, por ejemplo, tiene dos ramas: las tácticas que reducen el trabajo que llega (controlar la demanda) y las que hacen rendir más lo que se tiene para atenderlo (administrar los recursos). El libro del curso organiza así las tácticas de cada atributo, y este capítulo sigue esos mismos grupos.

El árbol se usa de dos maneras. Al diseñar, se recorre como una lista de opciones: para este escenario, ¿sirve algo de la primera rama?, ¿de la segunda? Obliga a considerar alternativas antes de quedarse con la primera idea. Al revisar un diseño que ya existe, cada táctica se convierte en una pregunta: ¿el sistema hace esto?, ¿dónde?, ¿qué riesgo queda si no lo hace? A esa lista de preguntas se le llama cuestionario de tácticas, y el libro trae uno por atributo. En el laboratorio van a usar uno de seguridad sobre Tinkuy.

Una advertencia sobre los catálogos. Son un inventario de lo que se sabe hacer, no una lista de tareas. Un sistema no es mejor por usar más tácticas: cada una cuesta algo, y la que no responde a un escenario es solo costo.

Tácticas de modificabilidad

El estímulo es un cambio

En modificabilidad el estímulo no es un pedido ni una falla: es un cambio que alguien quiere hacer. La medida, como vimos en la semana 3, es lo que cuesta hacerlo: cuántos módulos hay que tocar, cuánto tiempo toma, cuánto hay que volver a probar y a desplegar.

Las tácticas de modificabilidad ya las conocen. Las semanas 3 y 4 fueron, vistas desde hoy, un recorrido por este árbol sin usar la palabra táctica. Lo que sigue les pone nombre y las ubica en sus tres ramas.

Aumentar la cohesión

Si un módulo tiene varias razones para cambiar, cada cambio lo toca aunque no tenga que ver con el resto de lo que hace.

Táctica Qué se hace Dónde lo vimos
Dividir un módulo Un módulo con varias responsabilidades se parte en varios, cada uno con una La descomposición por decisiones del índice KWIC (semana 3)
Redistribuir responsabilidades Una responsabilidad repartida entre varios módulos se junta en uno, o se mueve al módulo al que pertenece El paso de carpetas por rol técnico a carpetas por dominio (semana 4)

Las dos buscan lo mismo desde lados opuestos: que un cambio de negocio caiga dentro de un solo módulo.

Reducir el acoplamiento

Si un módulo sabe mucho de otro, un cambio en uno se propaga al otro.

Táctica Qué se hace Dónde lo vimos
Encapsular El módulo se usa solo por una interfaz explícita; lo demás queda oculto Ocultamiento de información y los index.ts de los módulos (semanas 3 y 4)
Usar un intermediario Entre dos módulos que dependen uno del otro se pone un tercero que rompe la dependencia directa Los ports y adapters; el registro del microkernel; el broker de la semana 5
Abstraer servicios comunes Lo que varios módulos hacen de forma parecida se saca a un servicio general que todos usan Un solo módulo de acceso a la base de datos, o de log, en vez de uno por módulo
Restringir dependencias Se limita quién puede depender de quién, y una herramienta lo comprueba Las reglas de depcruise; las capas cerradas (semanas 3 y 4)

Diferir el enlace

La tercera rama es distinta de las otras dos. No reduce lo que hay que cambiar: cambia cuándo se fija una decisión. Enlazar (to bind) un valor es fijarlo. Si el tamaño de un pool está escrito como un número en el código, quedó enlazado al escribir el programa, y cambiarlo exige editar, revisar, probar y desplegar. Si sale de una variable de entorno, queda enlazado al arrancar, y cambiarlo es reiniciar el proceso con otro valor.

Momento del enlace Mecanismo Cambiar el valor exige
Al escribir el código Una constante, un import directo Editar, revisar, probar y desplegar
Al construir o desplegar Un archivo de configuración que se empaqueta, una opción del build Volver a construir o a desplegar
Al arrancar Variables de entorno, un registro de plug-ins que se llena al inicio Reiniciar el proceso
En ejecución Feature flags, descubrimiento de servicios, plug-ins que se cargan en caliente Nada: el sistema lo toma mientras corre

El servicio de ejemplo de esta semana usa esta táctica para sus propias variantes. Cómo consigue las conexiones, cómo arma la lista y si hay cache se eligen al arrancar, con variables de entorno (src/variant.ts):

export type Variant = {
  database: string;
  /** connect: una conexión nueva por consulta. pool: un pg.Pool. */
  db: 'connect' | 'pool';
  poolSize: number;
  /** nplus1: una consulta por título. single: una sola consulta con GROUP BY. */
  list: 'nplus1' | 'single';
  cache: 'off' | 'redis';
  cacheTtlSeconds: number;
  /** Qué hacer si Redis no responde: fallar o consultar la base de datos. */
  onCacheError: 'fail' | 'degrade';
  redisUrl: string;
  keyPrefix: string;
};

Gracias a eso, probar un pool de 2, de 10 o de 50 no es un cambio de código: es POOL_SIZE=50 make serve. Para que el enlace se pudiera diferir hicieron falta antes las otras dos ramas: la capa de datos está encapsulada detrás de una interfaz (Db, en src/db.ts) con dos implementaciones, y el resto del servicio depende solo de la interfaz. Sin eso no habría un punto donde elegir.

Trade-off. Cuanto más tarde se enlaza, más barato es cada cambio y más cara es la infraestructura que lo permite. Un valor configurable hay que validarlo, documentarlo y probarlo en sus combinaciones: este servicio tiene 24=162^4 = 16 combinaciones de sus cuatro opciones, sin contar los tamaños del pool, y las pruebas de la semana levantan siete para comprobar que responden lo mismo. Un sistema con cien opciones tiene más configuraciones posibles de las que nadie va a probar. La alternativa, enlazar temprano, es la correcta para todo lo que no hay evidencia de que vaya a cambiar.

Hay dos atributos emparentados con la modificabilidad que el libro trata en capítulos propios y que aquí solo ubicamos. La capacidad de prueba (testability) pide poder controlar y observar un componente: los ports de la semana 3, que permitían probar el núcleo sin base de datos, son una táctica de ese atributo. La facilidad de despliegue (deployability) pide que un cambio llegue a producción rápido y con poco riesgo; la semana 15 la toca de cerca, al sacar un servicio de un monolito poco a poco.

Rendimiento: a dónde se va el tiempo

El estímulo y la medida

En rendimiento el estímulo es la llegada de eventos: pedidos de usuarios, mensajes de otros sistemas, un temporizador que se dispara. (Aquí evento es algo que llega y hay que atender, no un concierto de Tinkuy.) Importa cómo llegan, porque el diseño cambia según el patrón:

  • Periódica: a intervalos regulares. Un proceso que recalcula un reporte cada minuto.
  • Esporádica o estocástica: sin un ritmo fijo, pero con una tasa promedio que se puede estimar. La gente que mira el catálogo un martes por la tarde.
  • En ráfaga: muchos en muy poco tiempo y después casi nada. La apertura de ventas de un concierto, a las 10:00:00.

La respuesta se mide con lo que vimos en la semana 2: latencia (con percentiles), throughput (pedidos atendidos por segundo) y, cuando la demanda supera a la capacidad, la tasa de pedidos perdidos: los que se rechazaron, vencieron o nunca se atendieron.

Tiempo de procesamiento y tiempo bloqueado

Para elegir una táctica hay que saber en qué se gasta el tiempo de un pedido. La división que más sirve es en dos partes:

trespuesta=tprocesamiento+tbloqueadot_{\text{respuesta}} = t_{\text{procesamiento}} + t_{\text{bloqueado}}

El tiempo de procesamiento es el que el sistema pasa trabajando para ese pedido: ejecutando código, corriendo una consulta. El tiempo bloqueado es el que el pedido pasa esperando sin que nadie trabaje para él: en una cola, esperando un recurso que otro está usando (una conexión, un lock, un procesador libre) o esperando la respuesta de otro componente.

La división importa porque cada parte se ataca con tácticas distintas, y equivocarse de parte no sirve de nada. Un ejemplo, que es la segunda pregunta de repaso de la guía: un pedido tarda 400 ms, de los cuales 30 ms son de procesamiento y 370 ms son de espera por una conexión a la base de datos. Hacer el código el doble de rápido ahorra 15 ms de 400. Agregar servidores de aplicación no ahorra nada: los servidores nuevos van a hacer la misma cola por las mismas conexiones, y si cada uno abre las suyas, la base de datos queda peor que antes. Lo que hay que atacar es la espera, y eso es administrar ese recurso.

Barras a escala del pedido de 400 ms del ejemplo. Arriba, el pedido como está: un tramo corto de 30 ms de procesamiento y uno largo de 370 ms de tiempo bloqueado esperando una conexión. Debajo, tres decisiones. Código el doble de rápido, que acelera el procesamiento: el tramo corto baja a 15 ms, los 370 ms de espera quedan intactos y el total es 385 ms. Más servidores de aplicación, que son más copias del cómputo: nada cambia, la misma cola por las mismas conexiones, y el total sigue en 400 ms. Administrar las conexiones, que ataca el tiempo bloqueado: es la única de las tres que reduce el tramo de la esperaBarras a escala del pedido de 400 ms del ejemplo. Arriba, el pedido como está: un tramo corto de 30 ms de procesamiento y uno largo de 370 ms de tiempo bloqueado esperando una conexión. Debajo, tres decisiones. Código el doble de rápido, que acelera el procesamiento: el tramo corto baja a 15 ms, los 370 ms de espera quedan intactos y el total es 385 ms. Más servidores de aplicación, que son más copias del cómputo: nada cambia, la misma cola por las mismas conexiones, y el total sigue en 400 ms. Administrar las conexiones, que ataca el tiempo bloqueado: es la única de las tres que reduce el tramo de la espera
El pedido de 400 ms, a escala. Acelerar el procesamiento solo puede mover el tramo de 30 ms; los 370 ms de espera los reduce únicamente la decisión que administra el recurso por el que se espera.

Idea clave. Primero se mide dónde se va el tiempo; después se elige la táctica. Si el tiempo se va en esperar, las tácticas que aceleran el procesamiento no mueven la medida.

El caso de la semana: Qillqa

Para practicar sin tocar Tinkuy usamos un servicio pequeño, en code/week-06/: Qillqa (escritura, en quechua), el catálogo de una red de bibliotecas. Tiene tres tablas (db/schema.sql): las sedes (branches), los títulos (titles) y los ejemplares de cada título (copies), cada uno disponible o prestado. make crea la base de datos:

$ make
Base de datos arq_w06: 4 sedes, 31 títulos, 11605 ejemplares (8700 disponibles)

Y tiene cuatro endpoints:

Método y ruta Qué hace
GET /titles?city= La lista de títulos, con los ejemplares disponibles de cada uno. Filtro opcional por ciudad
GET /titles/:id Un título, con sus ejemplares disponibles
POST /titles/:id/loans Presta un ejemplar disponible del título
GET /stats Contadores internos: consultas y conexiones a PostgreSQL, aciertos de la cache

El parecido con Tinkuy es a propósito. La lista de títulos con sus ejemplares disponibles tiene la misma forma que la lista de eventos con sus asientos libres, y la primera versión de Qillqa la resuelve igual que el Tinkuy inicial. El escenario que vamos a perseguir:

Cincuenta personas consultan el catálogo a la vez (estímulo), en operación normal (entorno). GET /titles (artefacto) responde con la lista completa (respuesta), con un p95 menor de 100 ms y sin errores (medida).

El script de carga es load/titles.js: 50 usuarios virtuales piden la lista durante 15 segundos, con una pausa de 50 ms entre un pedido y el siguiente. El script no cambia en toda la semana; lo que cambia es el servicio. Con esas pausas, 50 usuarios no pueden hacer más de 1 000 pedidos por segundo entre todos, así que el throughput de las tablas tiene ese techo: es un generador de modelo cerrado, como los de la semana 2.

Con el servicio en su línea de base (make serve en una terminal y make load en otra):

$ make load
k6 run --quiet load/titles.js
…
    ✓ GET /titles responde 200

    HTTP
    http_req_duration..............: avg=561.91ms med=561.11ms p(95)=629.29ms p(99)=668.46ms max=706.68ms
      { expected_response:true }...: avg=561.91ms med=561.11ms p(95)=629.29ms p(99)=668.46ms max=706.68ms
    http_req_failed................: 0.00%  0 out of 1240
    http_reqs......................: 1240   80.804375/s
…

La mediana es de 561 ms y el p95 de 629 ms, con 81 pedidos por segundo. El escenario pide un p95 menor de 100 ms: el servicio lo incumple por un factor de seis. No hay errores; simplemente es lento. (El resumen de k6 trae más líneas; aquí y en adelante mostramos las que usamos.)

Dónde se pierde

La tentación, con un endpoint lento que consulta una base de datos, es suponer que la consulta es lenta y ponerle un índice o una cache. Antes de suponer, se mira. Primero, la consulta que cuenta los ejemplares de un título:

$ psql -d arq_w06 -c "EXPLAIN (ANALYZE, BUFFERS OFF) SELECT count(*)::int AS available FROM copies WHERE title_id = 1 AND status = 'available'"
                                                              QUERY PLAN                                                               
---------------------------------------------------------------------------------------------------------------------------------------
 Aggregate  (cost=14.47..14.48 rows=1 width=4) (actual time=0.036..0.036 rows=1.00 loops=1)
   ->  Index Scan using copies_title_idx on copies  (cost=0.29..14.03 rows=178 width=0) (actual time=0.009..0.029 rows=178.00 loops=1)
         Index Cond: (title_id = 1)
         Filter: (status = 'available'::text)
         Rows Removed by Filter: 59
         Index Searches: 1
 Planning Time: 0.188 ms
 Execution Time: 0.063 ms
(8 rows)

Seis centésimas de milisegundo. La consulta usa el índice, lee los 237 ejemplares del título y descarta los 59 prestados. No hay nada que arreglar ahí: la consulta, sola, es cuatro órdenes de magnitud más rápida que el pedido que la usa.

Segundo, cuántas veces se ejecuta. El servicio lleva la cuenta en GET /stats. Después de un solo pedido a GET /titles:

$ curl -s localhost:3600/titles > /dev/null; curl -s localhost:3600/stats | jq .db
{
  "queries": 32,
  "connectionsOpened": 32
}

Treinta y dos consultas y treinta y dos conexiones nuevas para un pedido. El código que lo explica está en dos archivos. La lista (src/titles.ts) pide los títulos y después, uno por uno, cuenta sus ejemplares:

export async function listTitlesNPlusOne(db: Db, filter: TitleFilter = {}): Promise<TitleSummary[]> {
  const rows = await db.query<TitleRow>(
    `SELECT t.id, t.name, t.author, t.year, b.name AS branch_name, b.city AS branch_city
       FROM titles t
       JOIN branches b ON b.id = t.branch_id
      WHERE ($1::text IS NULL OR b.city = $1)
      ORDER BY t.name, t.id`,
    [filter.city ?? null],
  );
  const titles: TitleSummary[] = [];
  for (const row of rows) {
    titles.push(toSummary(row, await countAvailableCopies(db, row.id)));
  }
  return titles;
}

Y la capa de datos (src/db.ts) abre una conexión para cada consulta y la cierra al terminar:

    async query<Row extends pg.QueryResultRow>(text: string, params: unknown[] = []): Promise<Row[]> {
      const client = new pg.Client({ database, application_name: APPLICATION_NAME });
      await client.connect();
      counters.connectionsOpened += 1;
      try {
        counters.queries += 1;
        const result = await client.query<Row>(text, params);
        return result.rows;
      } finally {
        await client.end();
      }
    },

Hay entonces dos causas distintas, y conviene no mezclarlas:

  1. Cada consulta paga una conexión nueva. Es un problema de cómo se administra un recurso.
  2. El pedido hace 32 consultas donde bastaría una. Es un problema de cuánto trabajo pide cada pedido.

A cada causa le corresponde una táctica de una rama distinta del árbol. Antes de aplicarlas, el catálogo completo.

En Tinkuy. El Tinkuy inicial tiene las dos mismas causas: src/db.ts abre una conexión por consulta, y listEvents hace un COUNT por evento. Con una copia de Tinkuy levantada (make tinkuy-up), make tinkuy-endpoints separa la latencia por endpoint, en la misma máquina:

$ make tinkuy-endpoints
…
    http_req_duration..................: avg=45.69ms  med=15.64ms  p(95)=188.18ms p(99)=262.15ms max=317.69ms
      { name:GET /events }.............: avg=165.55ms med=163.49ms p(95)=262.34ms p(99)=304.39ms max=317.69ms
      { name:GET /events/:id }.........: avg=17.57ms  med=14.31ms  p(95)=35.41ms  p(99)=68.03ms  max=98.78ms 
      { name:GET /events/:id/seats }...: avg=20.16ms  med=17.84ms  p(95)=34.49ms  p(99)=58.94ms  max=67ms    
      { name:GET /orders/:id }.........: avg=12.29ms  med=11.5ms   p(95)=20.32ms  p(99)=25.6ms   max=30.18ms 
      { name:GET /reports/sales }......: avg=12.9ms   med=10.59ms  p(95)=24.68ms  p(99)=30.4ms   max=49.29ms 
    http_req_failed....................: 0.00%  0 out of 1270
    http_reqs..........................: 1270   78.735356/s

GET /events es varias veces más lento que cualquier otro, igual que en la semana 2. Y make tinkuy-explain muestra que su consulta de disponibilidad, sola, es rápida:

$ make tinkuy-explain
…
 Aggregate  (cost=76.52..76.53 rows=1 width=4) (actual time=0.261..0.262 rows=1.00 loops=1)
   ->  Bitmap Heap Scan on seats  (cost=4.55..76.52 rows=1 width=0) (actual time=0.039..0.199 rows=2000.00 loops=1)
…
 Execution Time: 0.292 ms

Durante make load-browse (hasta 50 usuarios virtuales), mirando pg_stat_activity varias veces por segundo, PostgreSQL llegó a tener entre 5 y 15 conexiones de Tinkuy abiertas a la vez, según la corrida (y más de 20 con la máquina ocupada). Ninguna dura más que una consulta. Con la carga de make load-sale, de 200 usuarios, se pasan de las 100 que PostgreSQL acepta, como vieron en la semana 2.

Error común. Optimizar sin medir. Quien hubiera empezado por “la consulta debe estar lenta” habría agregado un índice a una consulta que tarda menos de un milisegundo, y el p95 no se habría movido. La táctica correcta para un cuello de botella que no es el que limita no cambia nada, y además deja la sensación de que “ya se optimizó”.

Las tácticas de rendimiento

Controlar la demanda

La primera rama reduce el trabajo: que lleguen menos pedidos, o que cada uno cueste menos.

Táctica Qué se hace Qué cuesta
Limitar la tasa de llegada No se aceptan más pedidos por segundo de los que se pueden atender (rate limiting); el resto recibe un rechazo rápido Algunos usuarios reciben un error. Hay que decidir a quién se rechaza
Limitar la respuesta a eventos Los pedidos que no se pueden atender ya esperan en una cola de tamaño máximo; con la cola llena, se descartan o se rechazan Latencia para los que esperan y pérdida para los que no entran
Priorizar Cuando no alcanza para todos, se atiende primero lo que más importa: la compra antes que el reporte Lo de baja prioridad puede no atenderse nunca
Reducir el costo de cada pedido Un algoritmo mejor, menos idas y vueltas a la base de datos, menos datos en la respuesta Suele costar claridad: la versión eficiente es menos directa que la ingenua
Acotar el tiempo de ejecución Un pedido que pasa de su límite se corta y devuelve lo que tenga, o un error Respuestas incompletas o fallidas para los pedidos caros

Las tres primeras y la última aceptan no atender del todo a alguien para proteger al resto. Son las tácticas de una apertura de ventas, y vuelven en la semana 14 con el nombre de load shedding. La cuarta es la única que no le quita nada a nadie, y por eso conviene mirarla primero.

Administrar los recursos

La segunda rama deja la demanda como está y hace rendir más lo que se tiene para atenderla.

Táctica Qué se hace Qué cuesta
Aumentar los recursos Una máquina más grande (escalar hacia arriba) o más máquinas (escalar hacia los lados) Dinero. Y hacia los lados, todo lo de la semana 5
Introducir concurrencia Atender varios pedidos a la vez en vez de uno tras otro Los errores de concurrencia: dos pedidos sobre el mismo dato
Mantener varias copias del cómputo Varias instancias del servicio detrás de un load balancer El estado que estaba en la memoria de un proceso ya no sirve; hay que sacarlo
Mantener varias copias de los datos Una cache, o réplicas de lectura de la base de datos Las copias pueden no coincidir con el original: datos viejos, invalidación
Acotar el tamaño de las colas Toda cola tiene un máximo: de pedidos, de mensajes, de espera por una conexión Con la cola llena hay que rechazar; sin tope, la espera crece sin límite
Planificar el uso de un recurso Cuando varios compiten por un recurso escaso, una política decide el orden: por llegada, por prioridad, por plazo La política que favorece a unos demora a otros

Un pool de conexiones no aparece con ese nombre en ninguna de las dos tablas, porque no es una táctica: es un mecanismo pequeño que aplica varias. Reutilizar las conexiones reduce el costo de cada pedido. Tener un número fijo de ellas acota cuánto trabajo recibe la base de datos a la vez. Y la cola de los que esperan una conexión libre planifica un recurso escaso, por orden de llegada. Vale la pena desarmarlo así, porque cada una de esas tres cosas se puede medir por separado.

El pool de conexiones

Lo que cuesta una conexión

Abrir una conexión a PostgreSQL no es gratis. Hay una negociación entre el cliente y el servidor (versión del protocolo, autenticación, parámetros de la sesión; cifrado, si la conexión va por la red), y PostgreSQL crea un proceso del sistema operativo para atender a cada cliente. La documentación de node-postgres, en la lectura complementaria de esta sesión, estima entre 20 y 30 ms para una conexión por la red con contraseña y cifrado, y advierte de lo segundo: el servidor solo puede atender a un número limitado de clientes a la vez.

En el contenedor del curso la conexión es de las más baratas posibles: va por un socket local, sin contraseña y sin cifrado. Aun así, make connect-cost muestra la diferencia entre abrir una conexión para cada consulta y usar una que ya estaba abierta (tools/connect-cost.ts):

$ make connect-cost
200 consultas, una después de otra (host: /var/run/postgresql)
conectar + consulta + cerrar           p50   2.18 ms   p95   2.87 ms
consulta sobre una conexión abierta    p50   0.13 ms   p95   0.18 ms
razón entre las medianas: 16.6

La consulta sola tarda 0,13 ms. Con la conexión, 2,18 ms: unas diecisiete veces más. En otras corridas la razón estuvo entre 14 y 43, según cuán ocupada estaba la máquina, pero nunca cerca de 1. Para una consulta corta, casi todo lo que el servicio paga es la conexión. Y un pedido a GET /titles paga 32.

Esa medición es con una consulta detrás de otra. Cuando llegan cincuenta a la vez es peor, porque el servidor tiene que crear y destruir decenas de procesos por segundo mientras intenta, además, responder consultas.

Reutilizar y poner un tope

Un pool de conexiones es un conjunto de conexiones que se abren una vez y se quedan abiertas. Quien necesita hacer una consulta toma una conexión libre, la usa y la devuelve. Si todas están ocupadas, espera su turno. La segunda implementación de la capa de datos de Qillqa usa el pool que trae el paquete pg:

export function pooled(database: string, size: number): Db {
  const counters: DbCounters = { queries: 0, connectionsOpened: 0 };
  const pool = new pg.Pool({ database, max: size, application_name: APPLICATION_NAME });
  pool.on('connect', () => {
    counters.connectionsOpened += 1;
  });
  // Una conexión ociosa que se rompe no debe tumbar el proceso.
  pool.on('error', () => {});
  return {
    counters,
    async query<Row extends pg.QueryResultRow>(text: string, params: unknown[] = []): Promise<Row[]> {
      counters.queries += 1;
      const result = await pool.query<Row>(text, params);
      return result.rows;
    },
    async close(): Promise<void> {
      await pool.end();
    },
  };
}

pool.query hace las tres cosas: toma una conexión, ejecuta la consulta y la devuelve. El pool.end() de close también importa: un programa que no cierra su pool no termina.

Como la capa de datos está detrás de la interfaz Db, cambiar de una implementación a otra no toca ni una consulta. Con el mismo script y la misma carga, make measure levanta cada variante, la mide y escribe una fila:

$ make measure V="baseline pool-10"
k6: 50 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Sin pool, N+1 (línea de base)              571.4 ms   721.2 ms   985.7 ms     78/s    0.00 %         34      32.0
Pool de 10, N+1                             23.5 ms    43.3 ms    78.7 ms    664/s    0.00 %         10      32.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

Con las mismas 32 consultas por pedido, la mediana baja de 571 ms a 24 ms y el p95 de 721 ms a 43 ms: el escenario ya se cumple. El throughput sube de 78 a 664 pedidos por segundo, porque en este script cada usuario virtual espera su respuesta antes de pedir otra vez. La columna de consultas confirma que lo único que cambió es de dónde salen las conexiones.

Una advertencia que vale para todas las tablas del capítulo: cada bloque es una corrida distinta, y la misma variante no da el mismo número dos veces. El pool de 10 con N+1, por ejemplo, tiene una mediana de 24 ms en esta tabla y aparece más abajo con 9 ms y con 31 ms. Por eso se comparan filas de un mismo bloque, medidas una detrás de otra, y solo se sacan conclusiones de diferencias grandes: la de esta tabla es de más de veinte veces, y en ninguna corrida bajó de diez.

La columna de conexiones muestra el segundo efecto del pool, que es independiente del primero: es un tope. Con max: 10, PostgreSQL nunca ve más de diez conexiones de este servicio, lleguen cincuenta pedidos a la vez o lleguen cinco mil. La prueba test/pool.test.ts lo comprueba con un pool de 2 y 40 pedidos simultáneos: se atienden los 40, con 2 conexiones.

El tope se aprecia cuando la carga sube. PostgreSQL acepta un máximo de conexiones (max_connections, 100 en el contenedor), y sin pool nada impide pedirle más. Con 200 usuarios virtuales en vez de 50:

$ VUS=200 make measure V="baseline pool-10"
k6: 200 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Sin pool, N+1 (línea de base)              325.5 ms  1589.2 ms  3039.7 ms    351/s   97.76 %         98       6.0
Pool de 10, N+1                            107.1 ms   133.5 ms   201.9 ms   1256/s    0.00 %         10      32.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

Sin pool, el 98 % de los pedidos falla. El servicio intenta abrir más conexiones de las que PostgreSQL acepta (llegó a tener 98 a la vez), y el resto recibe sorry, too many clients already. Las 6,0 consultas por pedido son el promedio de unos pocos pedidos que completaron sus 32 y muchos que murieron en el camino. Y no falla solo este servicio: cualquier otro programa que quiera conectarse a esa base de datos en ese momento recibe el mismo rechazo.

Con el pool, los mismos 200 usuarios se atienden con diez conexiones y sin un solo error. Son más lentos que con 50 usuarios, porque ahora hay cola, pero todos reciben su respuesta.

Animación en cuatro etapas con Qillqa a la izquierda y PostgreSQL a la derecha; las dos primeras siguen un solo pedido a GET /titles, con sus 32 consultas, y las dos últimas, 200 usuarios a la vez. Etapa 1, sin pool: para cada consulta se abre una conexión, pasa la consulta y la conexión se cierra, cada vez más rápido, hasta contar 32 consultas y 32 conexiones nuevas, a 2,18 ms cada consulta; PostgreSQL cuenta 32 procesos creados y destruidos. Etapa 2, pool de 10: diez conexiones ya están abiertas y las 32 consultas van y vuelven por una de ellas, sin ninguna conexión nueva, a 0,13 ms cada una. Etapa 3, sin pool y 200 usuarios: las conexiones se acumulan hasta 98 a la vez, con un máximo de 100, y las demás terminan en una cruz; los errores llegan a 97,76 %. Etapa 4, pool de 10 y 200 usuarios: las diez conexiones están ocupadas, los demás pedidos esperan en una cola dentro de Qillqa, PostgreSQL ve 10 conexiones y los errores son 0,00 %. Abajo se van armando cuatro filas de make measure: con 50 usuarios, sin pool, p95 de 721.2 ms y 34 conexiones; con pool de 10, 43.3 ms y 10 conexiones; con 200 usuarios, sin pool, 1589.2 ms, 97.76 % de errores y 98 conexiones; con pool de 10, 133.5 ms, 0.00 % y 10 conexionesAnimación en cuatro etapas con Qillqa a la izquierda y PostgreSQL a la derecha; las dos primeras siguen un solo pedido a GET /titles, con sus 32 consultas, y las dos últimas, 200 usuarios a la vez. Etapa 1, sin pool: para cada consulta se abre una conexión, pasa la consulta y la conexión se cierra, cada vez más rápido, hasta contar 32 consultas y 32 conexiones nuevas, a 2,18 ms cada consulta; PostgreSQL cuenta 32 procesos creados y destruidos. Etapa 2, pool de 10: diez conexiones ya están abiertas y las 32 consultas van y vuelven por una de ellas, sin ninguna conexión nueva, a 0,13 ms cada una. Etapa 3, sin pool y 200 usuarios: las conexiones se acumulan hasta 98 a la vez, con un máximo de 100, y las demás terminan en una cruz; los errores llegan a 97,76 %. Etapa 4, pool de 10 y 200 usuarios: las diez conexiones están ocupadas, los demás pedidos esperan en una cola dentro de Qillqa, PostgreSQL ve 10 conexiones y los errores son 0,00 %. Abajo se van armando cuatro filas de make measure: con 50 usuarios, sin pool, p95 de 721.2 ms y 34 conexiones; con pool de 10, 43.3 ms y 10 conexiones; con 200 usuarios, sin pool, 1589.2 ms, 97.76 % de errores y 98 conexiones; con pool de 10, 133.5 ms, 0.00 % y 10 conexiones
Las dos cosas que hace un pool. En las etapas 1 y 2 ahorra la conexión de cada consulta; en las etapas 3 y 4 es un tope: quien no alcanza conexión espera dentro de la aplicación, y PostgreSQL nunca ve más de diez.

Idea clave. Un pool hace dos cosas distintas: ahorra el costo de abrir una conexión en cada consulta, y limita cuántas consultas recibe la base de datos a la vez. Lo primero mejora la latencia; lo segundo protege a la base de datos de su propia aplicación.

Cómo se elige el tamaño

Si diez conexiones son mejores que ninguna, ¿cincuenta serán mejores que diez? make curve mide el servicio con 200 usuarios virtuales y pools de seis tamaños:

$ make curve
k6: 200 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Sin pool, N+1 (línea de base)              424.9 ms  1996.1 ms  4761.2 ms    273/s   97.35 %         95       5.8
Pool de 2, N+1                             343.4 ms   388.8 ms   444.0 ms    502/s    0.00 %          2      32.0
Pool de 5, N+1                             156.1 ms   231.2 ms   288.2 ms    937/s    0.00 %          5      32.0
Pool de 10, N+1                             79.2 ms   151.6 ms   248.7 ms   1457/s    0.00 %         10      32.0
Pool de 20, N+1                             75.2 ms   107.5 ms   195.6 ms   1559/s    0.00 %         20      32.0
Pool de 50, N+1                             84.4 ms   130.3 ms   322.5 ms   1422/s    0.00 %         50      32.0
Pool de 90, N+1                             98.4 ms   135.8 ms   501.5 ms   1296/s    0.00 %         90      32.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

De 2 a 10 conexiones la mejora es grande: la mediana baja de 343 ms a 79 ms y el throughput casi se triplica. De 10 a 20 mejora poco. Y de ahí en adelante empeora: con 90 conexiones el servicio atiende 1 296 pedidos por segundo, un 17 % menos que con 20, y su peor pedido tarda más del doble (502 ms contra 196 ms). Graficado, el p95 contra el tamaño del pool tiene forma de U: alto a la izquierda, un mínimo en el medio, y otra vez hacia arriba.

Gráfico de línea del p95 de GET /titles contra el tamaño del pool, con 200 usuarios virtuales, en una corrida de make curve; el eje del tamaño es logarítmico. Los seis puntos: pool de 2, 388,8 ms y 502 pedidos por segundo, con la nota de que casi todo es espera en la cola del pool; pool de 5, 231,2 ms y 937; pool de 10, 151,6 ms y 1457; pool de 20, 107,5 ms y 1559, marcado como el mínimo; pool de 50, 130,3 ms y 1422; pool de 90, 135,8 ms y 1296. La zona de los pools de 50 y de 90 está sombreada y rotulada como la parte menos estable de una corrida a otraGráfico de línea del p95 de GET /titles contra el tamaño del pool, con 200 usuarios virtuales, en una corrida de make curve; el eje del tamaño es logarítmico. Los seis puntos: pool de 2, 388,8 ms y 502 pedidos por segundo, con la nota de que casi todo es espera en la cola del pool; pool de 5, 231,2 ms y 937; pool de 10, 151,6 ms y 1457; pool de 20, 107,5 ms y 1559, marcado como el mínimo; pool de 50, 130,3 ms y 1422; pool de 90, 135,8 ms y 1296. La zona de los pools de 50 y de 90 está sombreada y rotulada como la parte menos estable de una corrida a otra
El p95 contra el tamaño del pool, en una sola corrida. La parte derecha es la menos estable: de cuatro corridas, en tres los pools de 50 y de 90 salieron peores que el de 20 y en una, parecidos. En ninguna rindieron más.

Repetimos esta curva cuatro veces. En tres, los pools de 50 y de 90 salieron peores que el de 20; en una de esas tres, con la máquina ocupada por otras cargas, el de 90 fue ocho veces más lento. En la cuarta, los tres salieron parecidos. La parte derecha de la curva es la menos estable de la tabla, y la conclusión prudente es la que sostienen las cuatro corridas: más allá de cierto tamaño, más conexiones no dan más rendimiento, y con frecuencia dan menos.

Para ver por qué, conviene sacar del medio al servidor HTTP y preguntarle directamente a la base de datos. make db-curve lanza la misma consulta, una que recorre toda la tabla de ejemplares, con 1, 2, 4… 64 conexiones trabajando a la vez durante dos segundos (tools/db-curve.ts):

$ make db-curve
Procesadores que ve el contenedor: 14
conexiones  consultas/s  p50 por consulta  p95 por consulta
         1          781           1.25 ms           1.38 ms
         2         1534           1.28 ms           1.42 ms
         4         3020           1.29 ms           1.50 ms
         8         4178           1.91 ms           2.22 ms
        16         5095           2.62 ms           6.08 ms
        32         5035           5.80 ms          12.24 ms
        64         5201          11.06 ms          25.01 ms

Hasta 4 conexiones, el doble de conexiones es el doble de consultas por segundo, y cada consulta tarda lo mismo. Hacia 16, el total deja de subir: ronda las 5 000 consultas por segundo con 16, con 32 y con 64. Lo que sí sigue creciendo es lo que tarda cada consulta: 2,6 ms con 16 conexiones y 11 ms con 64. Cuatro veces más conexiones, el mismo trabajo total, y cada consulta cuatro veces más lenta. (El límite no es del programa que mide: el mismo programa, con un SELECT 1, pasa de 40 000 consultas por segundo.)

La explicación es de recursos. Una consulta necesita un procesador (y a veces el disco) mientras se ejecuta. Si la máquina de la base de datos tiene cc procesadores, no puede ejecutar más de cc consultas de este tipo a la vez. La conexión número c+1c + 1 no agrega capacidad: agrega un competidor. El sistema operativo reparte los procesadores entre todos, cada consulta avanza a ratos, y todas tardan más. Además, cada conexión abierta cuesta memoria en el servidor aunque no esté haciendo nada.

Entonces, cuando hay más pedidos que capacidad, alguien tiene que esperar, y la decisión de diseño es dónde. Con un pool pequeño esperan en la cola del pool, dentro de la aplicación, donde esperar es barato: un pedido en esa cola no ocupa nada en la base de datos, y la base de datos trabaja a su mejor ritmo con los que sí entraron. Con un pool enorme esperan dentro de la base de datos, como procesos que compiten entre sí.

En la industria. La wiki de PostgreSQL, en Number Of Database Connections, explica que muchas veces se atiende a más usuarios concurrentes reduciendo el número de conexiones, y da como punto de partida para el número de conexiones activas una fórmula basada en los procesadores del servidor: cerca de dos por núcleo, más los discos que de verdad se usan. La documentación de HikariCP, un pool muy usado en Java, cita la misma fórmula en About Pool Sizing e insiste en que es un punto de partida: el tamaño se confirma midiendo con la carga esperada. Las dos páginas hablan de pools de decenas de conexiones, no de cientos.

Tres cosas más entran en la cuenta:

  • El pool es por proceso. Si mañana corren cuatro instancias del servicio, cada una con un pool de 50, la base de datos puede recibir 200 conexiones. El tamaño se elige mirando la base de datos, no la instancia: el total de todos los pools, más lo que usen los demás clientes, tiene que caber con holgura en max_connections.
  • Un pool demasiado pequeño también cuesta. En la curva, el pool de 2 no da errores, pero casi todo su tiempo de respuesta es espera en la cola. Es tiempo bloqueado puro.
  • Una conexión retenida no la usa nadie más. Quien toma una conexión para una transacción y, con ella en la mano, llama a un servicio lento, le quita esa conexión a todos los demás durante toda la llamada. Con un pool de 10, bastan diez pedidos así para detener el servicio entero.

Trade-off. Un pool cambia latencia y protección por un parámetro que hay que elegir y volver a elegir cuando cambia el despliegue, y por un modo de falla nuevo: un pool agotado, donde los pedidos esperan una conexión que nadie devuelve. La alternativa, una conexión por consulta, no tiene nada que configurar ni que se agote dentro del proceso; es lo que eligió el Tinkuy inicial, y es defendible mientras la carga sea de unos pocos pedidos por segundo. Una tercera opción es poner el pool fuera de la aplicación, en un proxy delante de la base de datos, compartido por todas las instancias: resuelve la cuenta del primer punto y agrega una pieza que operar.

Error común. Subir el tamaño del pool cada vez que aparece una espera por conexiones. Si las conexiones se agotan porque la base de datos ya no da más, un pool más grande le manda más trabajo a un servidor saturado, y la curva de arriba dice lo que pasa. Antes de subirlo hay que mirar qué están haciendo las conexiones ocupadas.

N+1: reducir el costo de cada pedido

Una consulta por elemento

Con el pool, cada pedido a GET /titles sigue haciendo 32 consultas: una para la lista y una por cada uno de los 31 títulos. Ese patrón tiene nombre, N+1: una consulta para obtener NN elementos y NN consultas más, una por elemento, para completar cada uno. Es uno de los problemas de rendimiento más frecuentes en aplicaciones con base de datos, por una razón de modularidad: aparece cuando se compone código limpio. Hay una función que lista títulos y otra que cuenta los ejemplares de un título; cada una está bien, tiene sus pruebas y se usa en otros lados. El N+1 nace en el for que las junta, y no se ve en ninguna de las dos.

Tampoco se ve al desarrollar. Con cinco títulos de prueba son seis consultas, y nadie nota la diferencia. El costo crece con los datos: con NN elementos son N+1N + 1 viajes de ida y vuelta a la base de datos, uno detrás de otro, y cada viaje tiene un costo fijo (enviar la consulta, que el servidor la analice y la planifique, recibir la respuesta) que no depende de lo fácil que sea la consulta.

Una sola consulta

La base de datos sabe contar por grupos. La segunda versión de la lista le pide todo de una vez:

export async function listTitlesSingleQuery(db: Db, filter: TitleFilter = {}): Promise<TitleSummary[]> {
  const rows = await db.query<TitleRow & { available: number }>(
    `SELECT t.id, t.name, t.author, t.year, b.name AS branch_name, b.city AS branch_city,
            count(c.id) FILTER (WHERE c.status = 'available')::int AS available
       FROM titles t
       JOIN branches b ON b.id = t.branch_id
       LEFT JOIN copies c ON c.title_id = t.id
      WHERE ($1::text IS NULL OR b.city = $1)
      GROUP BY t.id, b.id
      ORDER BY t.name, t.id`,
    [filter.city ?? null],
  );
  return rows.map((row) => toSummary(row, row.available));
}

Esta táctica cambia el código que produce la respuesta, y con eso aparece un riesgo que el pool no tenía: que la respuesta ya no sea la misma. La consulta de arriba tiene dos detalles puestos para evitarlo. El LEFT JOIN conserva los títulos que no tienen ningún ejemplar, y el FILTER cuenta solo los disponibles sin descartar la fila de un título cuyos ejemplares están todos prestados. Sin ellos, la versión que a cualquiera se le ocurre primero es esta (errors/list-inner-join.ts):

SELECT t.id, count(*)::int AS available
  FROM titles t
  JOIN copies c ON c.title_id = t.id
 WHERE c.status = 'available'
 GROUP BY t.id

No da ningún error y devuelve números correctos para casi todos los títulos. Pero los datos de ejemplo tienen un título recién catalogado, sin ejemplares, y esa consulta lo deja fuera: la lista sale con 30 títulos en vez de 31. Por eso, antes de medir la versión nueva, hay que comprobar que es equivalente a la anterior. La prueba test/equivalence.test.ts levanta todas las variantes y compara sus respuestas, texto contra texto, para la lista completa, para cada filtro y para una ciudad que no existe.

Idea clave. Una táctica de rendimiento no debe cambiar lo que el sistema responde. Antes de medir cuánto más rápida es la versión nueva, se comprueba que responde lo mismo, incluidos los casos de borde: el elemento sin hijos, la lista vacía.

Con la equivalencia comprobada, la medición:

$ make measure V="pool-10 single"
k6: 50 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Pool de 10, N+1                              9.0 ms    30.8 ms   120.8 ms    794/s    0.00 %         10      32.0
Pool de 10, una consulta                     4.8 ms    11.6 ms    50.4 ms    867/s    0.00 %         10       1.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

La columna de consultas pasa de 32 a 1, la mediana baja a cerca de la mitad (de 9,0 ms a 4,8 ms) y el p95 a cerca de un tercio (de 31 ms a 12 ms). Con el pool ya puesto, la mejora es mucho menor que la del paso anterior, y eso tiene una explicación: las 31 consultas de más eran rápidas una vez que dejaron de pagar una conexión cada una. Pero no es poca cosa. Cada pedido ocupa ahora una conexión del pool durante una consulta, no durante 32, de modo que el mismo pool alcanza para mucha más carga.

Qué táctica dio más

Tenemos dos causas y dos tácticas, y hasta aquí las aplicamos en un orden: primero el pool, después la consulta. Para saber cuánto aporta cada una hay que medir las cuatro combinaciones:

$ make measure V="baseline pool-10 single-nopool single"
k6: 50 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Sin pool, N+1 (línea de base)              572.3 ms   651.9 ms   709.6 ms     79/s    0.00 %         38      32.0
Pool de 10, N+1                             30.8 ms    47.1 ms   100.0 ms    611/s    0.00 %         10      32.0
Sin pool, una consulta                       8.1 ms    14.1 ms    95.3 ms    832/s    0.00 %         21       1.0
Pool de 10, una consulta                     4.7 ms    11.6 ms    38.2 ms    872/s    0.00 %         10       1.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

Leída por filas, la tabla dice algo que el orden en que aplicamos las tácticas escondía. Cualquiera de las dos, sola, se lleva casi toda la mejora. Sin pool y con una sola consulta (tercera fila), la mediana es de 8 ms: el pedido abre una conexión en vez de 32. La razón es que las dos causas no eran independientes: el N+1 multiplicaba por 32 el costo de no tener pool. Quitar cualquiera de los dos factores deshace el producto.

Las dos juntas dan el mejor número, y no son equivalentes en lo que dejan. La tercera fila sigue abriendo una conexión por pedido y no tiene tope: llegó a 21 conexiones con 50 usuarios, y con 200 volvería a pasarse de las que PostgreSQL acepta. La segunda tiene tope y hace 32 veces más trabajo del necesario. En otras corridas, la segunda y la tercera intercambiaron su orden; la primera y la cuarta, nunca.

¿Cuál dio más por menos? Depende de qué se cuente como costo. El pool fue un cambio en un solo archivo que no tocó ninguna consulta ni puede cambiar una respuesta, y a cambio trajo un parámetro que elegir. La consulta única no agregó nada que configurar, y a cambio hubo que reescribir la lógica de un endpoint y comprobar su equivalencia. Esa es la pregunta 6 del laboratorio, y la respuesta para Tinkuy la tienen que dar sus propias mediciones.

Trade-off. Quitar el N+1 cuesta modificabilidad: la consulta única sabe a la vez de títulos, de sedes y de ejemplares, y la función countAvailableCopies, que antes se reutilizaba, ya no participa. Si los ejemplares vivieran en otro módulo, o en otro servicio, ese JOIN cruzaría un límite: es el problema de la semana 4, y con servicios separados el JOIN ni siquiera es posible. La alternativa intermedia es pedir los conteos de todos los títulos en una segunda consulta (WHERE title_id = ANY(...) GROUP BY title_id) y juntarlos en el código: dos viajes en vez de 32, y cada módulo sigue consultando solo sus tablas.

Cache, primera vista

Guardar el resultado de algo caro

La tercera táctica es de la otra rama: mantener varias copias de los datos. Una cache guarda el resultado de algo caro para no repetirlo. La forma más simple, y la que usa Qillqa, se llama cache-aside: antes de calcular la respuesta se busca en la cache; si está, se devuelve; si no está, se calcula, se guarda con un tiempo de vida (el TTL, time to live) y se devuelve. Pasado el TTL, Redis borra la entrada sola y el siguiente pedido la vuelve a calcular. El núcleo, sin el manejo de errores que veremos en la segunda sesión (src/cache.ts):

      cached = await client.get(fullKey);
      // ...
      if (cached !== null) {
        counters.hits += 1;
        return { body: cached, outcome: 'hit' };
      }
      counters.misses += 1;
      const body = await compute();
      // ...
        await client.set(fullKey, body, { EX: ttl });
      // ...
      return { body, outcome: 'miss' };

Un pedido que encuentra su respuesta en la cache es un acierto (hit); el que no, un fallo de cache (miss). El servicio lo informa en la cabecera x-cache de cada respuesta. La clave lleva el filtro: la lista de Cusco y la lista completa son entradas distintas (w06:titles:Cusco, w06:titles:*).

Lo que se gana

$ make measure V="single cache"
k6: 50 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Pool de 10, una consulta                     4.7 ms    10.7 ms    47.7 ms    876/s    0.00 %         10       1.0
Pool de 10, una consulta, cache de 5 s       1.0 ms     2.5 ms    43.0 ms    905/s    0.00 %         10       0.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

La mediana baja de 4,7 ms a 1,0 ms y el p95 de 10,7 ms a 2,5 ms. La columna más llamativa es la última: 0,0 consultas por pedido. Con un TTL de 5 segundos, de los cerca de 13 500 pedidos de la corrida solo unos pocos llegaron a PostgreSQL; el resto se respondió con un GET a Redis.

En números absolutos la ganancia es de menos de 4 ms por pedido, sobre un endpoint que ya cumplía el escenario con holgura. Vale la pena notarlo: la cache es la táctica con el mejor número de la tabla y, en este caso, la que menos hacía falta.

Se gana en dos medidas a la vez: la latencia de quien pide, y la carga sobre la base de datos, que queda libre para lo que no se puede guardar en una cache, como los préstamos.

Lo que se abre: el dato viejo

Lo que se guarda es una copia, y el original puede cambiar. make stale levanta el servicio con cache, presta un ejemplar del título 1 y mira cada segundo dos cosas: la lista, que sale de la cache, y el detalle del título, que consulta la base de datos (tools/stale.sh):

$ make stale
antes del préstamo    lista: 178 (x-cache: miss)   detalle: 178
{"loan":{"titleId":1,"copyId":1}}
0 s después           lista: 178 (x-cache: hit)   detalle: 177
1 s después           lista: 178 (x-cache: hit)   detalle: 177
2 s después           lista: 178 (x-cache: hit)   detalle: 177
3 s después           lista: 178 (x-cache: hit)   detalle: 177
4 s después           lista: 178 (x-cache: hit)   detalle: 177
5 s después           lista: 177 (x-cache: miss)   detalle: 177
6 s después           lista: 177 (x-cache: hit)   detalle: 177

Durante cinco segundos, el sistema da dos respuestas distintas a la misma pregunta según por dónde se le pregunte. La lista dice 178; el detalle, 177. Nadie invalidó la entrada: se corrigió sola cuando venció.

¿Es grave? Depende del escenario, que es lo que dijimos en la semana 2. Para quien hojea el catálogo, un ejemplar de diferencia durante cinco segundos no cambia nada. Para el último ejemplar es distinto: la lista puede mostrar “queda 1” de un libro que ya no está, y alguien va a ir a pedirlo. Lo que salva al diseño es que la lista solo informa; la decisión de prestar se toma contra la base de datos, que es la que tiene el dato verdadero. Una cache en el camino de una decisión es otro problema, mucho más delicado.

Trade-off. Una cache cambia latencia y carga por consistencia: durante el TTL puede responder con un dato que ya cambió. Las alternativas son un TTL más corto (menos tiempo con el dato viejo y menos aciertos), o borrar la entrada cuando el dato cambia (invalidar), que acorta la ventana y obliga a que todo el código que escribe sepa qué entradas tocar. Cuánto dato viejo se tolera no es una decisión técnica: se le pregunta a quien conoce el negocio. La semana 11 desarrolla la invalidación y los demás patrones de cache.

La cache que esconde una consulta

Queda una combinación por medir, y es la más tentadora en un proyecto real: dejar el servicio como estaba, sin pool y con su N+1, y ponerle la cache encima. Es un cambio en un solo lugar y no toca ninguna consulta.

$ make measure V="cache-nplus1 cache"
k6: 50 usuarios virtuales durante 15s, GET /titles
variante                                        p50        p95        máx  pedidos   errores conexiones consultas
Sin pool, N+1, cache de 5 s                  0.9 ms     2.7 ms  1087.0 ms    754/s    0.00 %         30       0.4
Pool de 10, una consulta, cache de 5 s       1.0 ms     2.6 ms    30.7 ms    912/s    0.00 %         10       0.0
conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL
consultas: consultas a PostgreSQL por pedido HTTP, en promedio

La mediana y el p95 son tan buenos como los de la versión completa: 0,9 ms y 2,7 ms. Quien mire solo esas dos columnas dará el problema por resuelto. Pero el máximo es de 1 087 ms contra 31 ms, y el servicio llegó a tener 30 conexiones abiertas a la vez. Lo que pasa es esto: cada cinco segundos la entrada vence, y todos los pedidos que llegan mientras nadie la ha vuelto a guardar la recalculan a la vez, cada uno con sus 32 consultas y sus 32 conexiones. Durante ese instante el servicio es exactamente el de la línea de base, con toda la carga encima. Las 0,4 consultas por pedido son el promedio de muchos pedidos con cero y unos pocos con 32.

Error común. Poner una cache para esconder una consulta mal escrita. La consulta sigue ahí y aparece con cada fallo de cache: cuando vence el TTL, después de un reinicio, con una clave que nadie había pedido, o cuando la cache se cae. Y aparece de la peor manera, porque todos los pedidos que llegan mientras la entrada no está la recalculan a la vez (la semana 11 le pone nombre: estampida). Primero se reduce el costo del pedido; la cache se pone después, sobre algo que ya es razonable sin ella.

make table mide las seis variantes de esta sesión una detrás de otra y escribe las seis filas juntas. Es la tabla que van a llenar en el laboratorio para su propio sistema, con una columna más, que aquí fuimos escribiendo en prosa: lo que costó cada táctica.

Disponibilidad: que una falta no llegue a ser una falla

Falta, error y falla

En la semana 2 definimos la disponibilidad como la fracción del tiempo en que el sistema responde bien, y vimos que depende de dos cosas: cada cuánto falla y cuánto tarda en volver. Para diseñar hace falta un vocabulario más fino, con tres palabras que en el habla diaria se usan como sinónimos.

  • Una falta (fault) es la causa: un disco dañado, un bug, un proceso que se quedó sin memoria, una pasarela que no responde, un Redis que alguien mató.
  • Un error es el estado incorrecto que la falta produce dentro del sistema: una excepción que sube, un dato a medias, un pedido que espera algo que no va a llegar.
  • Una falla (failure) es lo que ve quien usa el sistema cuando este deja de cumplir su especificación: un 500, una página que no carga, una entrada cobrada y no emitida.

La cadena va en ese orden: la falta produce un error, y el error, si nadie lo detiene, llega hasta el usuario como una falla. En español, además, la palabra falla se usa para las dos puntas (decimos tolerancia a fallas para fault tolerance); cuando la diferencia importe, este capítulo dice falta para la causa.

La distinción no es un tecnicismo, porque define el objetivo. Las faltas no se pueden eliminar: los discos se dañan, las redes se cortan y todo programa tiene bugs. Lo que sí se puede diseñar es lo que pasa después.

Idea clave. La disponibilidad no se diseña para que no haya faltas, sino para que las faltas no lleguen a ser fallas, o para que las fallas duren poco.

Las tácticas de disponibilidad se agrupan según en qué punto de esa cadena actúan: detectar la falta, recuperarse de ella y prevenir que ocurra o que tenga efecto.

Detectar

Nada de lo que sigue funciona si el sistema no se entera de que algo anda mal. Un proceso que se quedó colgado no avisa.

Táctica Qué se hace
Monitor Un componente dedicado a vigilar el estado de los demás: procesos, memoria, colas, tiempos de respuesta
Ping y eco El monitor le manda un mensaje al componente y espera la respuesta. Si no llega a tiempo, lo da por caído
Heartbeat Al revés: el componente avisa cada cierto tiempo que sigue vivo. Si el aviso deja de llegar, se lo da por caído
Timestamp Los mensajes llevan una marca de tiempo o un número de secuencia, para detectar los que llegan fuera de orden o repetidos
Monitoreo de condiciones Se comprueban condiciones del propio componente (una suma de verificación, un invariante) para detectar que produjo algo incorrecto
Comprobación de cordura (sanity check) Se revisa que un resultado sea razonable antes de usarlo: un total negativo, un evento con más asientos vendidos que capacidad
Votación Varios componentes hacen el mismo cálculo y se comparan los resultados; el que difiere está mal
Detección de excepciones Se detecta una condición que interrumpe el flujo normal: una excepción del lenguaje, un código de error, un tiempo de espera vencido
Autoprueba El componente se prueba a sí mismo, al arrancar o cada cierto tiempo

La forma más simple de detectar que algo no respondió es un timeout: esperar hasta un límite y, pasado el límite, tratar el silencio como un error. Sin timeout, quien llama a un componente colgado se queda colgado con él, y la falta se propaga hacia arriba sin que nadie la haya detectado todavía.

En Tinkuy. La versión 0 llama a la pasarela con fetch y sin timeout. Si la pasarela acepta la conexión y no responde, la compra espera lo que haga falta, con una transacción abierta. Detecta bien una pasarela caída (el fetch falla y la compra responde un 502), y no detecta una pasarela lenta. La semana 14 mide ese caso con Toxiproxy.

Recuperarse

Detectada la falta, hay que hacer algo. El catálogo separa dos momentos: prepararse y reparar, y volver a poner en servicio lo que falló.

Preparación y reparación:

Táctica Qué se hace
Redundancia Hay más de una copia del componente. Activa: todas las copias reciben y procesan todo, y el reemplazo es casi instantáneo. Pasiva: una procesa y le va pasando su estado a las otras, que toman su lugar con un pequeño retraso. De repuesto: la copia está apagada o sin estado, y hay que iniciarla y cargarla
Rollback Se vuelve a un estado bueno conocido: una transacción que se deshace, un despliegue que se revierte
Manejo de excepciones Detectada la excepción, se hace algo con ella: se traduce, se corrige, se responde otra cosa
Retry Se repite la operación, con la esperanza de que la falta haya sido transitoria
Ignorar el comportamiento defectuoso Se descartan los mensajes de una fuente que se sabe que está fallando
Degradación Se sigue ofreciendo lo esencial y se suspende lo demás
Reconfiguración Se reasignan las responsabilidades del componente caído a los que quedan

Reintroducción (cuando el componente que falló vuelve):

Táctica Qué se hace
Modo sombra El componente reparado corre un tiempo recibiendo pedidos reales sin que sus respuestas se usen, hasta comprobar que se comporta bien
Resincronización del estado Antes de volver al servicio, el componente se pone al día con el estado que se perdió
Reinicio escalonado Se reinicia lo menos posible: primero una parte pequeña y, solo si no basta, una mayor

Las tres formas de redundancia son un trade-off entre lo que cuesta y lo que tarda la recuperación. La activa paga varias copias trabajando todo el tiempo para recuperarse en milisegundos; la de repuesto paga casi nada mientras todo va bien y tarda minutos cuando hace falta. La semana 10, de replicación, es en buena parte el estudio de esta táctica aplicada a una base de datos.

Prevenir

El tercer grupo actúa antes de que la falta ocurra o de que tenga efecto.

Táctica Qué se hace
Sacar de servicio Se retira un componente antes de que falle, para repararlo o reiniciarlo: una instancia que el load balancer deja de usar porque su health check empeora
Transacciones Varias operaciones se agrupan para que ocurran todas o ninguna, de modo que una falta a la mitad no deje el estado a medias
Modelos predictivos Se vigila una medida que anticipa la falta (la memoria que crece, el disco que se llena) y se actúa antes de llegar al límite
Prevención de excepciones Se diseña para que la condición de error no pueda darse: validar antes de operar, tipos que no admiten el valor inválido
Aumentar el conjunto de competencias El componente aprende a manejar más casos como parte de su operación normal, en vez de tratarlos como fallas

La última es la menos conocida y la que más vamos a usar esta semana. El conjunto de competencias de un componente es el conjunto de situaciones en las que sabe operar. Un servicio que solo sabe responder cuando su cache está arriba tiene un conjunto de competencias pequeño. Si aprende a responder también con la cache caída, la caída de la cache dejó de ser, para él, una falta.

Degradar en vez de caer

Qué es esencial

Degradar es decidir, de antemano, qué parte del servicio se puede perder sin perder el servicio. Esa decisión tiene dos mitades. La técnica es de estructura: lo prescindible tiene que estar separado de lo esencial de modo que su falta no se propague. La otra mitad no es técnica.

En Tinkuy. Si el servidor de correo no responde, la compra podría completarse y el correo salir después: el comprador tiene su entrada, y el correo es una copia. Si el reporte de ventas no responde, la venta no debería enterarse. En la versión 0 ninguna de las dos cosas se cumple: el correo se envía dentro de la transacción de la compra, y si falla, la compra se deshace. Qué es esencial (¿se puede vender sin enviar el correo?, ¿se puede vender sin poder cobrar, anotando la deuda?) no lo decide quien programa: es una decisión de negocio, y el arquitecto la tiene que preguntar.

Qillqa, el servicio de esta semana, nos da un caso más pequeño para medir. Con la cache puesta, GET /titles depende ahora de dos cosas: PostgreSQL y Redis. En la semana 2 vimos que las disponibilidades en serie se multiplican, así que, tal cual, el endpoint quedó menos disponible que antes de la cache. Y es una dependencia rara: los datos están en PostgreSQL. Redis solo tiene una copia. ¿Qué debe pasar cuando Redis se cae?

La cache caída, medida

make cache-down responde con un experimento. Levanta el servicio con cache, le manda 40 pedidos por segundo durante 9 segundos, mata Redis en el segundo 3 con svc kill redis y lo vuelve a iniciar en el segundo 6. Lo hace dos veces, con las dos respuestas posibles a una cache que no responde.

La primera es la que sale sola si nadie lo piensa: el error de Redis sube como cualquier excepción y termina en un 500.

$ make cache-down
CACHE_ON_ERROR=fail: 40 pedidos por segundo a GET /titles
  s   200   500   hit  miss  bypass   p50      suceso
  0    40     0    40     0     0    2.1 ms   
  1    40     0    39     1     0    1.8 ms   
  2    40     0    40     0     0    1.5 ms   
  3     0    40     0     0     0    1.5 ms   svc kill redis
  4     0    40     0     0     0    1.5 ms   
  5     0    40     0     0     0    1.5 ms   
  6    17    23    16     1     0    2.4 ms   svc start redis
  7    40     0    40     0     0    2.4 ms   
  8    40     0    40     0     0    2.2 ms   
pedidos: 360, con error: 143 (39.7 %)

Durante los tres segundos sin Redis, todos los pedidos fallan. PostgreSQL estuvo sano todo el tiempo y tenía la respuesta; el servicio no se la pidió. Una falta en un componente opcional se convirtió en una falla total del endpoint.

La segunda respuesta trata el error de Redis como un caso que el servicio sabe manejar: si la cache no responde, se consulta la base de datos (src/cache.ts):

      let cached: string | null;
      try {
        cached = await client.get(fullKey);
      } catch (error) {
        if (variant.onCacheError === 'degrade') {
          // Degradar: sin cache el pedido es más lento, pero se responde.
          counters.bypasses += 1;
          return { body: await compute(), outcome: 'bypass' };
        }
        counters.failures += 1;
        throw new CacheUnavailableError(error);
      }
CACHE_ON_ERROR=degrade: 40 pedidos por segundo a GET /titles
  s   200   500   hit  miss  bypass   p50      suceso
  0    40     0    40     0     0    2.4 ms   
  1    40     0    39     1     0    2.1 ms   
  2    40     0    40     0     0    3.3 ms   
  3    40     0     0     0    40   10.0 ms   svc kill redis
  4    40     0     0     0    40    8.7 ms   
  5    40     0     0     0    40    8.3 ms   
  6    40     0    17     1    22    7.9 ms   svc start redis
  7    40     0    40     0     0    2.1 ms   
  8    40     0    40     0     0    2.3 ms   
pedidos: 360, con error: 0 (0.0 %)

Ningún error. Durante la caída las respuestas salen de la base de datos (columna bypass) y la mediana sube a varias veces la de antes: el servicio está degradado, no caído. Cuando Redis vuelve, el cliente se reconecta solo y la cache se llena otra vez. Quien miraba el catálogo no vio nada, salvo una lista algo más lenta.

Animación en tres etapas con un cliente que envía 40 pedidos por segundo a GET /titles, Qillqa al centro y, a la derecha, Redis, que tiene una copia, y PostgreSQL, que tiene los datos. Etapa 1, Redis arriba: Qillqa pregunta a Redis, hay hit, y el cliente recibe 200 con x-cache: hit; PostgreSQL no recibe nada. Etapa 2, Redis caído con CACHE_ON_ERROR=fail: Redis no responde, rotulado como la falta; la llamada de Qillqa a Redis termina en una cruz y la excepción sube, rotulada como el error; el cliente recibe 500, rotulado como la falla, mientras PostgreSQL sigue sano y nadie le pregunta. Etapa 3, Redis caído con CACHE_ON_ERROR=degrade: la misma falta y el mismo error, pero el catch de Qillqa consulta PostgreSQL y el cliente recibe 200 con x-cache: bypass, rotulado como sin falla. Abajo, lo que midió make cache-down en los tres segundos sin Redis: con fail, 40 de 40 pedidos por segundo con 500, p50 de 1.5 ms y 143 de 360 pedidos con error, 39.7 %; con degrade, 40 de 40 con 200 por bypass, p50 de 8.3 a 10.0 ms y 0 de 360 con errorAnimación en tres etapas con un cliente que envía 40 pedidos por segundo a GET /titles, Qillqa al centro y, a la derecha, Redis, que tiene una copia, y PostgreSQL, que tiene los datos. Etapa 1, Redis arriba: Qillqa pregunta a Redis, hay hit, y el cliente recibe 200 con x-cache: hit; PostgreSQL no recibe nada. Etapa 2, Redis caído con CACHE_ON_ERROR=fail: Redis no responde, rotulado como la falta; la llamada de Qillqa a Redis termina en una cruz y la excepción sube, rotulada como el error; el cliente recibe 500, rotulado como la falla, mientras PostgreSQL sigue sano y nadie le pregunta. Etapa 3, Redis caído con CACHE_ON_ERROR=degrade: la misma falta y el mismo error, pero el catch de Qillqa consulta PostgreSQL y el cliente recibe 200 con x-cache: bypass, rotulado como sin falla. Abajo, lo que midió make cache-down en los tres segundos sin Redis: con fail, 40 de 40 pedidos por segundo con 500, p50 de 1.5 ms y 143 de 360 pedidos con error, 39.7 %; con degrade, 40 de 40 con 200 por bypass, p50 de 8.3 a 10.0 ms y 0 de 360 con error
La misma falta con dos finales. Con fail, el error de Redis llega al cliente como una falla; con degrade, el catch lo detiene en Qillqa y el pedido se responde por el camino lento.

En términos del catálogo se usaron tres tácticas: detección de excepciones (el catch), degradación (responder por el camino lento) y aumentar el conjunto de competencias (la cache caída pasó a ser un caso normal). La prueba test/redis-down.test.ts mata Redis de verdad y comprueba las dos variantes, además de que el cuerpo de la respuesta degradada es idéntico al de la versión sin cache.

Trade-off. Degradar a la base de datos no es gratis: cuando la cache se cae, la base de datos recibe de golpe toda la carga que la cache le ahorraba. A 40 pedidos por segundo no se nota. Si el origen solo aguanta el tráfico real con la cache puesta, degradar le traslada la caída a la base de datos, que es peor, porque de ella dependen también las compras. La alternativa, fallar rápido en las lecturas para proteger el origen, puede ser la decisión correcta: es lo que hace CACHE_ON_ERROR=fail, y por eso es una opción y no un error del código. Cuál conviene depende de una medición que ya saben hacer: ¿qué p95 y qué errores da el servicio sin cache con la carga del escenario? La semana 11 vuelve sobre esto.

El cliente que espera en silencio

El experimento anterior esconde un detalle que en el laboratorio les puede costar un rato. Para poder decidir entre fallar y degradar, primero hay que enterarse de que Redis no responde. Y el cliente de Redis para Node.js, con su configuración por omisión, no avisa: guarda en una cola los comandos que se envían mientras no hay conexión, y los manda cuando la conexión vuelve. make offline-queue lo muestra (errors/redis-offline-queue.ts):

$ make offline-queue
Por omisión (con cola):
  con Redis caído, el GET sigue pendiente después de 2000 ms
  con Redis de vuelta, ese mismo GET respondió null a los 2219 ms
  un GET nuevo, ya reconectado, respondió null
Con disableOfflineQueue:
  con Redis caído, el GET falló a los 0 ms: The client is offline
  un GET nuevo, ya reconectado, respondió null

Con la cola, el GET ni falla ni responde: espera. Para un programa por lotes eso es cómodo. Para un pedido HTTP es la peor de las tres posibilidades: el catch que degrada nunca se ejecuta, porque no hay excepción, y los pedidos se acumulan esperando a un Redis que puede tardar minutos. Con disableOfflineQueue: true, el comando falla de inmediato y el servicio puede decidir.

Es la lección de la rama detectar en pequeño: sin detección no hay recuperación. Y vale más allá de Redis. Un cliente de cualquier servicio tiene una política para cuando el servicio no está (esperar, reintentar, fallar), casi siempre elegida por quien escribió la biblioteca pensando en otro caso de uso. Hay que saber cuál es. Queda además un caso que esta configuración no cubre: un Redis que acepta la conexión y no responde. Para ese hace falta un timeout por comando, y es la misma situación de la pasarela lenta.

El retry: táctica y riesgo

Reintentar es la táctica de recuperación más barata de escribir: un bucle. Si la falta fue transitoria (un paquete perdido, un reinicio de dos segundos), el segundo intento sale bien y nadie se entera. Por eso aparece en todas partes, muchas veces sin que nadie lo haya decidido: lo trae el cliente HTTP, el driver de la base de datos, el SDK del proveedor.

Tiene dos riesgos, y cada uno tiene su semana.

Puede duplicar la operación. En la semana 5 vimos que, desde quien llama, un pedido perdido y una respuesta perdida se ven igual. Si lo que se perdió fue la respuesta, la operación ya se hizo, y reintentar la hace otra vez: dos cobros, dos órdenes, dos correos. Un retry solo es seguro sobre operaciones que se pueden repetir sin cambiar el resultado, y lograr eso para una compra es el tema de la idempotencia, en la semana 12.

Puede multiplicar la carga sobre un servicio que ya no da más. Si un servicio está lento porque está saturado, cada cliente que se cansa de esperar y reintenta le agrega trabajo justo cuando menos puede atenderlo. Y si hay varias capas que reintentan, los intentos se multiplican entre sí. Con dd capas, cada una con hasta aa intentos, un solo pedido del usuario puede llegar a producir, en la última capa,

ad pedidos.a^{d} \text{ pedidos.}

Con tres intentos en cada una de tres capas (el navegador, el API y el cliente de la pasarela), son 33=273^{3} = 27 llamadas a la pasarela por cada clic, todas sobre un servicio que falló precisamente porque tenía demasiado trabajo. Así una falta transitoria, que habría pasado sola en unos segundos, se vuelve una falla que se sostiene a sí misma: el servicio no se recupera porque los reintentos no lo dejan.

En la industria. El capítulo 22 del libro de SRE de Google, Addressing Cascading Failures, describe ese mecanismo con un ejemplo: un backend que recibe un poco más de lo que puede atender rechaza el exceso, los clientes reintentan lo rechazado, y los reintentos se suman a la carga del segundo siguiente, que a su vez produce más rechazos. Entre las medidas que recomienda están limitar los intentos por pedido, poner un tope de reintentos por cliente y reintentar en una sola capa, no en todas.

Trade-off. El retry mejora la disponibilidad frente a faltas transitorias y puede empeorar el rendimiento, y con él la disponibilidad, frente a una sobrecarga. La alternativa, no reintentar y devolver el error, traslada la decisión a quien llamó, que suele tener menos información. El punto medio (pocos intentos, espera creciente entre ellos, en una sola capa) es el tema de la semana 14.

Seguridad

Tres propiedades y un escenario

La seguridad se suele resumir en tres propiedades, que en inglés forman la sigla CIA:

  • Confidencialidad: los datos solo los ve quien está autorizado a verlos. Un extraño no puede leer la orden de otra persona.
  • Integridad: los datos y el sistema solo los cambia quien está autorizado, y de las formas permitidas. Nadie se pone a sí mismo el precio de una entrada.
  • Disponibilidad: el sistema sigue respondiendo a sus usuarios legítimos aunque alguien intente impedirlo. Es la misma disponibilidad de la sección anterior, con una diferencia: aquí la falta es intencional, y quien la causa se adapta a las defensas.

Un escenario de seguridad tiene las mismas seis partes que cualquier otro, con contenido propio. La fuente es un atacante, que puede venir de fuera o de dentro de la organización (un empleado, un servicio propio que fue tomado). El estímulo es el ataque: un intento de leer, cambiar o tumbar algo. La medida responde tres preguntas: cuánto daño se hizo (qué datos se expusieron o se alteraron), cuánto tardó en detectarse y cuánto tardó la recuperación.

Un atacante externo (fuente) envía pedidos a GET /orders/:id recorriendo los ids (estímulo) contra la API pública (artefacto), en operación normal (entorno). El sistema rechaza los pedidos de órdenes que no son de quien las pide y registra el intento (respuesta); ningún dato de otro comprador sale del sistema, y el recorrido se detecta en menos de un minuto (medida).

Como en rendimiento, sin la medida no hay escenario: “el sistema debe ser seguro” no se puede comprobar ni refutar.

Detectar, resistir, reaccionar y recuperarse

Las tácticas de seguridad se agrupan en cuatro ramas, que siguen la historia de un ataque. Sirve la analogía con un edificio: una alarma (detectar), una cerradura (resistir), un vigilante que actúa cuando suena la alarma (reaccionar) y un seguro para después (recuperarse).

Detectar ataques:

Táctica Qué se hace
Detectar intrusos Se compara el tráfico o el comportamiento con patrones conocidos de ataque, o con lo que es normal para ese sistema
Detectar denegación de servicio Se compara el volumen y la forma de los pedidos que llegan con el perfil habitual
Verificar la integridad de los mensajes Sumas de verificación, hashes o firmas permiten saber si un mensaje o un archivo fue alterado

Resistir ataques:

Táctica Qué se hace
Identificar actores Saber de quién viene cada pedido: un usuario, un servicio, una dirección
Autenticar actores Comprobar que quien dice ser alguien lo es: una contraseña, un token, un certificado
Autorizar actores Comprobar que ese actor puede hacer esa operación sobre ese recurso
Limitar el acceso Que cada actor y cada componente lleguen solo a los recursos que necesitan
Limitar la exposición Reducir la superficie de ataque: menos puntos de entrada, menos componentes que ven los datos sensibles
Cifrar los datos En tránsito y guardados, para que quien los intercepte o los robe no los pueda leer
Separar entidades Poner lo sensible aparte de lo demás: otro proceso, otra base de datos, otra red
Validar la entrada Comprobar todo lo que llega de afuera antes de usarlo
Cambiar las credenciales por defecto No dejar ningún usuario, contraseña o clave con el valor con que vino instalado

Reaccionar a ataques:

Táctica Qué se hace
Revocar el acceso Cortar el acceso de un actor o de una credencial cuando se sospecha un ataque
Restringir el inicio de sesión Limitar los intentos fallidos: bloquear por un tiempo después de varios
Informar Avisar a quien opera el sistema, y a los afectados cuando corresponde

Recuperarse de ataques:

Táctica Qué se hace
Auditoría Guardar un registro de quién hizo qué, para reconstruir el ataque, medir el daño y encontrar al responsable
Las tácticas de disponibilidad Volver a un estado bueno conocido: las de la sección anterior sirven aquí tal cual

Tinkuy ya usa dos tácticas de la rama de resistir, y conviene reconocerlas antes del laboratorio: valida la entrada de POST /orders campo por campo (src/orders/validation.ts) y todas sus consultas son parametrizadas. Cuáles faltan es el paso 8.

Validar la entrada, medido

La regla de la guía de estilo del curso, “nunca se arma SQL concatenando texto de quien llama”, es la táctica validar la entrada aplicada al punto donde más daño hace no aplicarla. El programa errors/sql-concat.ts busca los títulos de una ciudad de las dos maneras:

// MAL: el texto de quien llama pasa a ser parte de la consulta.
`… WHERE b.city = '${city}' ORDER BY 1`
// BIEN: la consulta es fija y el texto viaja aparte, como un dato.
`… WHERE b.city = $1 ORDER BY 1`, [city]

Con una ciudad de verdad dan lo mismo, y por eso el error no se nota en las pruebas habituales. Con un texto escrito por un atacante, no:

$ make sql-concat
city = Cusco
  concatenando: 6 filas; la primera: {"name":"Agua","author":"José María Arguedas"}
  con parámetro: 6 filas   (una ciudad)
city = x' OR '1'='1
  concatenando: 31 filas; la primera: {"name":"Agua","author":"José María Arguedas"}
  con parámetro: 0 filas   (todo el catálogo)
city = x' UNION SELECT rolname, 'superusuario: ' || rolsuper FROM pg_roles WHERE rolcanlogin --
  concatenando: 1 filas; la primera: {"name":"postgres","author":"superusuario: true"}
  con parámetro: 0 filas   (otra tabla)

El segundo texto cierra la comilla y agrega una condición que siempre es verdadera: la consulta devuelve todo el catálogo. El tercero es peor: une a la respuesta el contenido de otra tabla, una del sistema, y el “título” que vuelve es el nombre de un usuario de la base de datos. En la versión parametrizada, los mismos textos son solo nombres de ciudades que no existen.

La categoría a la que pertenece este ataque, la inyección, figura desde hace años en el OWASP Top 10, la lista de los riesgos más frecuentes en aplicaciones web que mantiene la fundación OWASP. Es una buena lectura complementaria por una razón de arquitectura: casi todas sus categorías corresponden a una táctica de la rama de resistir que faltó.

Los principios de Saltzer y Schroeder

En 1975, Jerome Saltzer y Michael Schroeder publicaron The Protection of Information in Computer Systems, que incluye una lista de principios de diseño para mecanismos de protección. El artículo trae ocho; seis se siguen citando casi sin cambios medio siglo después.

Principio Qué dice En un sistema como Tinkuy
Economía de mecanismo El mecanismo de protección debe ser tan simple y pequeño como se pueda, porque sus errores no se ven en el uso normal y hay que encontrarlos revisándolo Un solo lugar donde se decide el acceso, no una comprobación distinta en cada handler
Valores por defecto seguros El acceso se decide por permiso y no por exclusión: lo que nadie autorizó está prohibido Un endpoint nuevo exige sesión salvo que alguien lo declare público, y no al revés
Mediación completa Todo acceso a todo objeto se comprueba, cada vez No basta comprobar al iniciar sesión: GET /orders/:id comprueba que la orden es de quien la pide
Diseño abierto La seguridad no debe depender de que el diseño sea secreto, sino de claves que sí se pueden proteger y cambiar Que los ids de las órdenes sean difíciles de adivinar no reemplaza a la autorización
Separación de privilegios Un mecanismo que exige dos llaves es más robusto que uno que exige una Un reembolso grande lo pide una persona y lo aprueba otra
Mínimo privilegio Cada programa y cada usuario opera con el menor conjunto de privilegios que necesita para su trabajo El servicio de reportes se conecta con un usuario que solo puede leer

El de valores por defecto seguros trae un argumento que vale la pena conocer. Un error en un mecanismo que da permisos tiende a fallar negando el acceso, y alguien se queja pronto. Un error en un mecanismo que quita permisos tiende a fallar permitiendo el acceso, y puede pasar inadvertido durante años. De los dos diseños, conviene el que falla haciendo ruido.

El de mediación completa trae, en el propio artículo, una advertencia que toca lo que hicimos en la primera sesión: toda propuesta de ganar rendimiento recordando el resultado de una comprobación de autorización debe mirarse con desconfianza, porque si los permisos cambian, lo recordado queda viejo. Es el dato viejo de la cache, con consecuencias de seguridad.

Mínimo privilegio, medido

En el contenedor del curso todo se conecta a PostgreSQL con el usuario postgres, que es administrador. Para un curso es cómodo. Como diseño, significa que cualquier error en cualquier parte del código, o cualquier inyección como la de arriba, se ejecuta con permiso para todo. El ataque anterior leyó pg_roles porque el usuario de la conexión podía.

make privilege crea un rol para un servicio de reportes, que solo necesita leer, y prueba qué puede hacer (security/least-privilege.sql):

$ make privilege
…
SET ROLE w06_reports;
SET
SELECT count(*) AS prestados FROM copies WHERE status = 'loaned';
 prestados 
-----------
      2905
(1 row)

UPDATE copies SET status = 'available';
psql:security/least-privilege.sql:24: ERROR:  permission denied for table copies
DROP TABLE copies;
psql:security/least-privilege.sql:25: ERROR:  must be owner of table copies
SELECT rolname, rolpassword FROM pg_authid LIMIT 1;
psql:security/least-privilege.sql:26: ERROR:  permission denied for table pg_authid
RESET ROLE;
RESET

El rol lee lo que necesita. El UPDATE que habría marcado todos los ejemplares como disponibles, el DROP TABLE y la lectura de las contraseñas guardadas son rechazados por la base de datos. Lo importante es quién los rechaza: no depende de que el código del servicio de reportes esté bien escrito, ni de que alguien haya revisado todas sus consultas. La táctica es limitar el acceso, y el principio que la justifica es el de mínimo privilegio: limita el daño de un accidente o de un error, además del de un ataque.

Eso contesta la sexta pregunta de repaso de la guía: un servicio de reportes que se conecta como administrador viola el mínimo privilegio, y lo corrige limitar el acceso con un rol propio. Lo que cuesta: un rol por servicio hay que crearlo, darle permisos cuando el esquema cambia y guardar su credencial en algún lado. Con un solo usuario para todo, ese trabajo no existe.

La seguridad es estructura

Las tácticas de la rama de resistir tienen algo en común: casi todas necesitan un lugar donde aplicarse. Autenticar y autorizar suponen un punto por el que pasan todos los pedidos. Limitar el acceso supone que los componentes están separados y que se sabe cuál necesita qué. Limitar la exposición supone poder contar cuántos componentes ven un dato. Ese lugar se llama límite de confianza (trust boundary): la línea que separa lo que el sistema controla y da por bueno de lo que no. Todo lo que cruza un límite de confianza se identifica, se autentica, se valida.

Las preguntas de seguridad de un arquitecto son por eso preguntas sobre la estructura:

  • ¿Dónde están los límites de confianza? ¿Solo en el borde del sistema, o también entre sus partes?
  • ¿Qué componentes ven los datos más sensibles? Cada uno de ellos hay que auditarlo, protegerlo y vigilarlo.
  • ¿Quién puede hablar con quién, y con qué credenciales?

En Tinkuy. El número de la tarjeta entra por el servidor HTTP, pasa por el módulo de órdenes y llega al de pagos, que lo envía a la pasarela. Los tres viven en el mismo proceso y usan la misma conexión a la base de datos, de modo que un error en cualquier parte del monolito ocurre “al lado” de la tarjeta. Que solo el módulo de pagos hable con la pasarela ya reduce el código que hay que auditar. Sacarlo a un servicio propio lo reduce más, porque entonces el límite deja de ser una convención entre módulos y pasa a ser un proceso con sus propias credenciales: es la táctica separar entidades, y una razón más, que no es de rendimiento ni de despliegue, para la extracción de P4.

Error común. Tratar la seguridad como una capa que se agrega al final: “primero que funcione, después lo aseguramos”. Se puede agregar al final lo que no depende de la estructura: cifrar una conexión, cambiar una contraseña por defecto. No se puede agregar al final un límite de confianza, porque un límite de confianza es estructura: decide qué componentes existen, qué datos pasan por cada uno y con qué credenciales corre cada cual. Y la estructura, lo sabemos desde la semana 1, es lo que más cuesta cambiar.

Una táctica para un atributo cuesta otro

Al definir la táctica dijimos que apunta a un solo atributo y que su efecto sobre los demás hay que buscarlo. Con el catálogo recorrido, la tabla se puede llenar con casos de esta misma semana:

Táctica Atributo que mejora Lo que cuesta
Diferir el enlace (variantes por configuración) Modificabilidad Capacidad de prueba: más combinaciones que comprobar. Y una configuración mal puesta es una falla nueva
Pool de conexiones Rendimiento Un parámetro que elegir y que depende del despliegue. Y los pedidos que no alcanzan conexión esperan en una cola que hay que vigilar
Cache con TTL Rendimiento Consistencia: datos viejos durante el TTL. Disponibilidad, si la cache caída tumba el endpoint. Y una pieza más que operar
Redundancia Disponibilidad Dinero (otra máquina) y consistencia: dos copias de un dato pueden no decir lo mismo (semana 10)
Retry Disponibilidad ante faltas transitorias Rendimiento y disponibilidad ante una sobrecarga; corrección, si la operación no se puede repetir
Degradar a la base de datos Disponibilidad de las lecturas Carga sobre el origen, justo cuando la cache falta
Autenticar, autorizar y cifrar cada llamada Seguridad Latencia en cada pedido, y fricción para quien usa y para quien desarrolla
Mínimo privilegio Seguridad Operación: roles y credenciales que crear, rotar y mantener al día con el esquema

La columna de la derecha no es un argumento contra ninguna de estas tácticas. Es lo que hay que escribir junto a la decisión, con el formato de la semana 2: para cumplir tal escenario elegimos esto en vez de aquello; ganamos tanto; aceptamos tal costo. La próxima semana ese párrafo se convierte en un documento con nombre, el ADR.

Idea clave. No hay tácticas gratis. Si al elegir una no encuentran qué cuesta, todavía no terminaron de analizarla.

El código de la semana

Todo está en code/week-06/ y se usa dentro del contenedor del curso.

Carpeta o archivo Qué contiene
db/schema.sql, db/seed.sql Las tablas de Qillqa (branches, titles, copies) y sus datos, sin números al azar
src/variant.ts Las variantes y cómo se leen del entorno
src/db.ts La interfaz Db y sus dos implementaciones: una conexión por consulta, y un pool
src/titles.ts La lista de títulos, con N+1 y con una sola consulta; el detalle y el préstamo
src/cache.ts Cache-aside sobre Redis, con las dos respuestas a una cache caída
src/app.ts, src/main.ts El servidor HTTP de una variante, y el programa que lo levanta
load/titles.js, load/endpoints.js Los dos scripts de k6: carga sobre la lista, y latencia por endpoint (para Qillqa y para Tinkuy)
tools/ measure.ts (mide variantes y escribe la tabla), connect-cost.ts, db-curve.ts, stale.sh y cache-down.ts
errors/ Tres ejemplos que fallan a propósito: el JOIN que pierde un título, el SQL concatenado y el cliente de Redis con su cola
security/least-privilege.sql El rol que solo puede leer
results-template.md, security-checklist.md La tabla de resultados y la lista de preguntas de seguridad del laboratorio
test/ Las pruebas, que comprueban lo que afirma este capítulo

Los comandos:

Comando Qué hace
make Crea la base de datos arq_w06 con sus datos
make serve Levanta Qillqa en el puerto 3600 con la variante del entorno
make load, make endpoints k6 contra el Qillqa de make serve
make connections Las conexiones de PostgreSQL, cada segundo
make measure V="baseline single" Levanta cada variante, la mide y escribe su fila
make table, make curve Las tablas de este capítulo
make connect-cost, make db-curve Las dos mediciones directas sobre PostgreSQL
make stale, make cache-down, make offline-queue Los experimentos de la cache
make sql-concat, make privilege Los dos ejemplos de seguridad
make tinkuy-up, make tinkuy-endpoints, make tinkuy-explain, make tinkuy-down Una copia del Tinkuy inicial en build/tinkuy, para medirla
make test Revisa los tipos y corre las pruebas
make clean Borra las bases de datos, las claves w06:* de Redis y build/

Las variables de make serve son DB_MODE (connect o pool), POOL_SIZE, LIST_MODE (nplus1 o single), CACHE (off o redis), CACHE_TTL_S y CACHE_ON_ERROR (fail o degrade). Sin ninguna, el servicio arranca en la línea de base: sin pool, con N+1 y sin cache.

make test no necesita nada corriendo: usa su propia base de datos y sus propias claves de Redis, y levanta las variantes dentro del proceso de pruebas. La prueba de redis-down.test.ts mata Redis y lo vuelve a iniciar, así que no conviene correrla mientras otra terminal del mismo contenedor mide algo con cache.

$ make test
tsc -p .
redis listo.
W06_DB=arq_w06_test W06_PREFIX=w06test: node --test --test-concurrency=1 "test/*.test.ts"
✔ el primer pedido calcula y guarda (miss); el segundo sale de Redis (hit) sin tocar la base de datos (360.616501ms)
✔ cada filtro tiene su entrada: la lista de Cusco no sale de la entrada de la lista completa (82.494708ms)
✔ después de un préstamo, la lista en cache sigue mostrando el número viejo hasta que vence el TTL (1133.496459ms)
✔ todas las variantes responden lo mismo a GET /titles (3105.092334ms)
…
✔ la lista tiene los 31 títulos, también el que no tiene ejemplares (740.148376ms)
✔ N+1 hace 32 consultas por pedido (1 + 31 títulos) y la versión de una consulta hace 1 (39.36625ms)
✔ errors/list-inner-join.ts no es equivalente: pierde el título sin ejemplares (4.212042ms)
✔ sin pool, cada consulta abre una conexión: un pedido a GET /titles abre 32 (774.505293ms)
✔ con un pool de 2, 40 pedidos a la vez se atienden con 2 conexiones y PostgreSQL nunca ve más (925.753167ms)
✔ el pool cierra sus conexiones al cerrar el servicio (98.089166ms)
✔ con Redis caído, degrade responde desde la base de datos y fail responde 500; al volver Redis, la cache vuelve (683.425583ms)
✔ una consulta armada concatenando texto devuelve lo que el atacante quiera; la parametrizada, nada (95.816001ms)
✔ mínimo privilegio: el rol de reportes puede leer y no puede modificar ni borrar (129.74025ms)
✔ percentil por rango más cercano (1.877ms)
ℹ tests 18
ℹ pass 18
ℹ fail 0
…
ℹ duration_ms 15351.195007

Cada prueba lleva en el nombre la afirmación que comprueba. La que más conviene leer antes del laboratorio es test/equivalence.test.ts: levanta siete variantes a la vez y exige que respondan byte por byte lo mismo. Es la red que permite cambiar la capa de datos sin miedo, y es lo primero que les va a hacer falta cuando apliquen estas tácticas a su propio sistema.

Laboratorio: pool de conexiones y cache, medir antes y después

El laboratorio se hace en parejas, sobre su copia de Tinkuy (el repositorio del equipo), con el material de code/week-06/ como referencia. En este capítulo cada táctica se aplicó a Qillqa; en el laboratorio la aplican ustedes a un sistema más grande, con transacciones y con más endpoints, donde las mismas ideas piden decisiones que aquí no hizo falta tomar. Lleven la tabla de results-template.md desde el primer paso. No hay entrega esta semana, pero lo que midan y decidan es el punto de partida de P2.

Necesitan tres terminales en el mismo contenedor: Tinkuy y su pasarela, la carga, y una para mirar.

Paso 1: la línea de base. Con su Tinkuy recién levantado (make db, make gateway, make start), corran make load-browse tres veces y anoten p50, p95, throughput y errores de cada corrida. Durante una de ellas, miren cuántas conexiones tiene PostgreSQL: make connections, desde code/week-06/, las muestra cada segundo. Lo que este paso da es el número contra el que se compara todo lo demás, y una idea de cuánto varía solo: si entre dos corridas iguales el p95 cambia 20 %, una mejora de 10 % en un paso posterior no es una mejora.

Paso 2: dónde se va el tiempo. Corran el script por endpoint contra su Tinkuy (TARGET=tinkuy k6 run --quiet load/endpoints.js, o make tinkuy-endpoints) y el EXPLAIN ANALYZE de la consulta de disponibilidad (make tinkuy-explain). Comparen las dos cosas: lo que tarda el endpoint más lento y lo que tarda una de sus consultas. Luego lean el código de ese endpoint y cuenten cuántas consultas y cuántas conexiones usa un pedido. Antes de cambiar nada, escriban en la tabla cuál creen que es el cuello de botella, qué táctica le corresponde y qué esperan ver si tienen razón. Este es el paso que separa medir de adivinar.

Paso 3: mantener un pool. Cambien la capa de datos de su Tinkuy para que use un pg.Pool. La lectura complementaria de node-postgres muestra la API. Hay dos cosas que Qillqa no tiene y Tinkuy sí: las transacciones, que necesitan que varias consultas vayan por la misma conexión, y las pruebas, que necesitan que el proceso termine. Midan con tamaños 2, 10 y 50, y dibujen el p95 contra el tamaño. Este paso muestra las dos caras del pool: lo que ahorra y lo que limita. Miren otra vez make connections.

Paso 4: reducir el costo por pedido. Reescriban la lista de eventos para que obtenga la disponibilidad de todos los eventos en una sola consulta. Antes de medir, comprueben que la respuesta no cambió: las pruebas de Tinkuy tienen que seguir pasando, y conviene comparar la respuesta completa de antes y de después. Este paso muestra cuánto del tiempo era trabajo que no hacía falta.

Paso 5: mantener una copia de los datos. Guarden la respuesta de GET /events en Redis con un TTL de cinco segundos y midan. Después compren una entrada y consulten la lista y el detalle del evento durante esos cinco segundos. Escriban el trade-off con el formato de la semana 2: qué ve el comprador, para qué uso de la lista eso es aceptable y para cuál no.

Paso 6: la tabla. Completen una fila por táctica: p95, throughput, qué mejoró y qué costó. Respondan con sus números: ¿cuál dio más por menos? Y una pregunta que la tabla no responde sola: si solo pudieran quedarse con dos de las tres, ¿cuáles?

Paso 7: la cache se cae. Con la carga corriendo, ejecuten svc kill redis. Anoten qué le pasa a GET /events: ¿errores?, ¿pedidos que no vuelven? Lean El cliente que espera en silencio si el resultado los sorprende. Cambien su código para que una cache caída degrade a consultar la base de datos, repitan el experimento y llenen la sección La cache caída de la tabla. Vuelvan a iniciar Redis con svc start redis. Este paso muestra que agregar una pieza para el rendimiento cambió la disponibilidad, y que recuperarla fue una decisión aparte.

Paso 8: seguridad. Revisen su Tinkuy con security-checklist.md (o con el cuestionario del capítulo 11 del libro, si lo tienen). Para cada táctica, busquen la evidencia en el código, no en la memoria. Anoten las tres tácticas ausentes que más importan, ordenadas por el daño que evitarían, y para la primera escriban el escenario de seguridad completo.

Resumen

  • Una táctica es una decisión de diseño que influye sobre la respuesta a un estímulo de un atributo de calidad. Es más pequeña que un patrón, que empaqueta varias, y apunta a un solo atributo: su efecto sobre los demás es el trade-off.
  • El orden de trabajo es escenario, medición, táctica, medición. La táctica correcta para un cuello de botella que no es el que limita no cambia nada.
  • Modificabilidad: aumentar la cohesión (dividir un módulo, redistribuir responsabilidades), reducir el acoplamiento (encapsular, usar un intermediario, abstraer servicios comunes, restringir dependencias) y diferir el enlace. Cuanto más tarde se enlaza, más barato el cambio y más cara la infraestructura.
  • Rendimiento: el tiempo de un pedido es tiempo de procesamiento más tiempo bloqueado. Las tácticas controlan la demanda (limitar la tasa de llegada, limitar la respuesta, priorizar, reducir el costo de cada pedido, acotar el tiempo de ejecución) o administran los recursos (más recursos, concurrencia, copias del cómputo, copias de los datos, colas acotadas, planificación).
  • Un pool de conexiones ahorra el costo de abrir una conexión en cada consulta y pone un tope a la concurrencia sobre la base de datos. Más grande no es más rápido: pasado el punto en que la base de datos tiene todos sus recursos ocupados, más conexiones solo reparten el mismo trabajo entre más competidores.
  • Quitar un N+1 reduce el costo de cada pedido, y suele rendir más que una cache encima. Una cache ahorra latencia y carga, y abre el dato viejo y la invalidación. Una cache sobre una consulta mal escrita la esconde, no la arregla: vuelve en cada fallo de cache.
  • Disponibilidad: una falta es la causa, una falla es lo que ve el usuario. Las tácticas detectan (un timeout es la más simple), recuperan (redundancia, retry, degradación) y previenen (transacciones, sacar de servicio, aumentar el conjunto de competencias). Sin detección no hay recuperación.
  • Degradar es seguir ofreciendo lo esencial. Qué es esencial es una decisión de negocio. El retry recupera de faltas transitorias, y puede duplicar una operación y multiplicar la carga.
  • Seguridad: confidencialidad, integridad y disponibilidad. Las tácticas detectan, resisten, reaccionan y recuperan. Los límites de confianza son estructura, y por eso no se agregan al final.
  • No hay tácticas gratis: lo que una gana en un atributo lo paga en otro, y eso se escribe junto a la decisión.

Ejercicios

  1. Para cada decisión, digan si es una táctica, un patrón o un estilo, y por qué: (a) poner un timeout de 2 segundos en la llamada a la pasarela; (b) organizar el sistema en servicios que se comunican por eventos; (c) réplicas de lectura con failover automático; (d) prohibir con depcruise que http/ importe de db.ts. Para la que sea un patrón, nombren dos tácticas que empaqueta y el atributo de cada una.

  2. Un pedido tarda 400 ms: 30 ms de procesamiento y 370 ms esperando una conexión a la base de datos. (a) ¿Qué grupo de tácticas de rendimiento aplica, y cuál táctica en particular? (b) Alguien propone duplicar los servidores de aplicación. Expliquen qué pasaría con los 370 ms, y en qué caso el cambio empeoraría las cosas. (c) ¿Qué medición harían para confirmar su respuesta antes de tocar nada?

  3. Corran make curve tres veces en su máquina y anoten, para cada tamaño de pool, la mediana de los tres p95. (a) ¿A partir de qué tamaño deja de mejorar? (b) Corran make db-curve y comparen ese tamaño con el punto en que las consultas por segundo dejan de subir. (c) Su servicio va a correr con cuatro instancias contra una base de datos con max_connections de 100, que también usan un proceso de reportes y las herramientas de administración. ¿Qué tamaño de pool le pondrían a cada instancia? Muestren la cuenta.

  4. En errors/list-inner-join.ts hay un intento de quitar el N+1 que pierde un título. (a) Expliquen qué fila se pierde y en qué paso de la consulta. (b) Cambien solo el JOIN por un LEFT JOIN, sin tocar el WHERE, y corran la consulta en psql: ¿se arregló? ¿Por qué? (c) ¿Qué dato de ejemplo tendría que existir para que una prueba distinga la versión correcta de una que solo falla cuando todos los ejemplares de un título están prestados?

  5. Levanten Qillqa con DB_MODE=connect LIST_MODE=nplus1 CACHE=redis y corran make load mientras miran make connections en otra terminal. (a) Describan lo que pasa con las conexiones cada cinco segundos. (b) Expliquen por qué el p50 no lo muestra y qué columna del resumen de k6 sí. (c) Propongan dos formas de evitar que muchos pedidos recalculen la misma entrada a la vez, y digan qué cuesta cada una. No hace falta implementarlas: la semana 11 las desarrolla.

  6. La lista de Qillqa se guarda en la cache con una clave por ciudad. (a) Después de un préstamo en Cusco, ¿cuántas entradas de la cache quedaron con un dato viejo? (b) Alguien propone borrar la entrada al registrar el préstamo, en vez de esperar el TTL. ¿Qué entradas hay que borrar? ¿Qué módulo tendría que conocer las claves de la cache, y qué táctica de modificabilidad usarían para que ese conocimiento no se riegue? (c) ¿Qué pasa si el préstamo se confirma en la base de datos y el borrado de la clave falla?

  7. Den una táctica de detección, una de recuperación y una de prevención para cada una de estas faltas de Tinkuy, y digan qué cuesta cada una: (a) el servidor de correo tarda 30 segundos en responder; (b) el proceso de Tinkuy se queda sin memoria y muere durante una apertura de ventas.

  8. Un navegador reintenta hasta 2 veces, el API gateway hasta 3 y el servicio de órdenes hasta 3 al llamar a pagos (el número incluye el primer intento). (a) En el peor caso, ¿cuántas llamadas recibe pagos por un solo clic? (b) Si pagos atiende 100 pedidos por segundo y recibe 120, describan segundo a segundo qué pasa con la carga que recibe, suponiendo que todo lo rechazado se reintenta. (c) ¿En cuál de las tres capas dejarían el retry, y por qué en esa?

  9. Con make cache-down vieron las dos respuestas a una cache caída. (a) Midan Qillqa sin cache y con cache a la carga de make load, y calculen cuántas consultas por segundo recibiría PostgreSQL si la cache se cayera en ese momento con CACHE_ON_ERROR=degrade. (b) Escriban un escenario de disponibilidad, con sus seis partes, para el que degrade sea la decisión correcta, y otro para el que lo sea fail. (c) Propongan una tercera opción, intermedia, y digan qué táctica del catálogo es.

  10. Un servicio de reportes de Tinkuy se conecta a la base de datos con el usuario administrador y arma una de sus consultas concatenando el nombre de la ciudad que llega en la URL. (a) ¿Qué principios de Saltzer y Schroeder se violan, y qué táctica corrige cada violación? (b) Con make sql-concat y make privilege a la vista, expliquen qué puede hacer un atacante con cada una de las dos correcciones aplicada sola. (c) ¿Por qué conviene aplicar las dos, si cualquiera detiene el ataque del ejemplo?

  11. Dibujen los límites de confianza de Tinkuy v0: qué procesos hay, qué datos cruzan cada límite y con qué credenciales. Después dibujen los de un Tinkuy con los pagos en un servicio propio. Para cada dibujo, cuenten cuántos componentes ven el número de la tarjeta, y escriban qué táctica de seguridad hizo posible la diferencia y qué atributo la pagó.