Semana 6 — Tácticas: modificabilidad, rendimiento, disponibilidad y seguridad
Objetivos
- Explicar qué es una táctica y en qué se diferencia de un estilo o de un patrón, y ubicar una táctica en el árbol de su atributo.
- Elegir tácticas de modificabilidad y de rendimiento para un escenario, y comprobar con una medición antes y después que la táctica sirvió.
- Elegir tácticas de disponibilidad (detectar, recuperarse y prevenir fallas) y de seguridad (detectar, resistir, reaccionar y recuperarse de ataques) para un escenario.
- Reconocer que una táctica para un atributo cuesta otro, y escribir ese costo.
Sesión A — Tácticas de modificabilidad y de rendimiento
Lecturas:
- Software Architecture in Practice, cap. 8 Modifiability y cap. 9 Performance: en cada uno, el escenario general, el árbol de tácticas y el cuestionario.
Lecturas complementarias:
- node-postgres, Pooling.
- Software Architecture in Practice, cap. 12 Testability y cap. 5 Deployability.
Temas:
- Táctica: una decisión de diseño que influye sobre la respuesta a un estímulo de un atributo. Es más pequeña que un patrón: un patrón empaqueta varias tácticas. Y afecta a un solo atributo: su efecto sobre los demás es el trade-off que hay que mirar aparte. El libro organiza las tácticas de cada atributo en un árbol y trae un cuestionario para revisar un diseño.
- Tácticas de modificabilidad, repaso con nombre (semanas 3 y 4). Aumentar la cohesión: dividir un módulo, redistribuir responsabilidades. Reducir el acoplamiento: encapsular, usar un intermediario, abstraer servicios comunes, restringir dependencias. Diferir el enlace: decidir más tarde (configuración, registro de plug-ins, descubrimiento en ejecución). Cuanto más tarde se enlaza, más barato es el cambio y más cara la infraestructura que lo permite.
- Rendimiento: el estímulo es la llegada de eventos (periódica, esporádica o en ráfaga) y la respuesta se mide en latencia, throughput o tasa de pedidos perdidos. El tiempo de una petición se reparte en tiempo de procesamiento y tiempo bloqueado (esperando un recurso o a otro componente). Primero se mide dónde se va el tiempo; después se elige la táctica.
- Tácticas de rendimiento, primer grupo: controlar la demanda. Limitar la tasa de llegada (rate limiting), limitar la respuesta a eventos (colas con tamaño máximo), priorizar, reducir el costo de cada petición (un algoritmo mejor, menos idas y vueltas a la base de datos), acotar el tiempo de ejecución.
- Segundo grupo: administrar los recursos. Más recursos (escalar hacia arriba o hacia los lados); concurrencia; mantener varias copias del cómputo (réplicas detrás de un load balancer); mantener varias copias de los datos (cache, réplicas de lectura); acotar el tamaño de las colas; planificar el uso de un recurso escaso.
- El pool de conexiones como táctica: abrir una conexión a PostgreSQL cuesta una negociación y un proceso en el servidor; un pool las reutiliza y, además, pone un tope a la concurrencia sobre la base de datos. Cómo se elige el tamaño: más conexiones no es más rápido, y pasado cierto punto es más lento.
- N+1: una consulta para la lista y una más por cada elemento. Reducir el costo por petición (una sola consulta con agregación) suele rendir más que agregar una cache encima.
- Cache, primera vista: guardar el resultado de algo caro para no repetirlo. Lo que se gana (latencia, carga sobre la base de datos) y lo que se abre (datos viejos, invalidación). Se desarrolla en la semana 11.
- En Tinkuy: una conexión nueva por petición, y
GET /eventscon unCOUNTpor evento. Dos tácticas distintas para dos causas distintas. - Error común: optimizar sin medir. La táctica correcta para un cuello de botella que no es el que limita no cambia nada.
- Error común: poner una cache para esconder una consulta mal escrita. La consulta sigue ahí y aparece con cada fallo de cache.
Sesión B — Tácticas de disponibilidad y de seguridad
Lecturas:
- Software Architecture in Practice, cap. 4 Availability y cap. 11 Security: el escenario general, el árbol de tácticas y el cuestionario.
- Lectura libre: Saltzer y Schroeder, The Protection of Information in Computer Systems (1975), la sección de principios de diseño.
Lecturas complementarias:
- OWASP Top 10.
- Site Reliability Engineering, cap. 22, Addressing Cascading Failures.
Temas:
- Falta, error y falla: una falta (fault) es la causa (un disco dañado, un bug, una pasarela que no responde); una falla (failure) es lo que ve quien usa el sistema cuando deja de cumplir su especificación. La disponibilidad se diseña para que las faltas no lleguen a ser fallas, o para que duren poco.
- Tácticas de disponibilidad, primer grupo: detectar. Monitor, ping y eco, heartbeat, timestamp, monitoreo de condiciones, comprobación de cordura (sanity check), votación, detección de excepciones, autoprueba. Un timeout es la forma más simple de detectar que algo no respondió. Sin detección no hay recuperación.
- Segundo grupo: recuperarse. Preparación y reparación: redundancia (activa, pasiva o de repuesto), rollback, manejo de excepciones, retry, ignorar el comportamiento defectuoso, degradación (seguir ofreciendo lo esencial), reconfiguración. Reintroducción: modo sombra, resincronización del estado, reinicio escalonado.
- Tercer grupo: prevenir. Sacar un componente de servicio, transacciones, modelos predictivos, prevención de excepciones, aumentar el conjunto de competencias (que un componente tolere más casos).
- Degradar en vez de caer: en Tinkuy, si el servicio de correo no responde, la compra puede completarse y el correo salir después; si el reporte de ventas no responde, la venta no debería enterarse. Decidir qué es esencial es una decisión de negocio.
- El retry como táctica y como riesgo: reintentar recupera de una falta transitoria, y también puede duplicar una operación (por eso la idempotencia, semana 12) y multiplicar la carga sobre un servicio que ya está saturado (semana 14).
- Seguridad: confidencialidad, integridad y disponibilidad. El escenario tiene una fuente (alguien de fuera o de dentro), un ataque (el estímulo) y una medida: cuánto daño, cuánto tarda en detectarse, cuánto en recuperarse.
- Tácticas de seguridad. Detectar: detección de intrusos, de denegación de servicio, verificación de integridad de los mensajes. Resistir: identificar, autenticar y autorizar actores; limitar el acceso; limitar la exposición (reducir la superficie de ataque); cifrar; separar entidades; validar la entrada; cambiar las credenciales por defecto. Reaccionar: revocar el acceso, restringir el inicio de sesión, informar. Recuperarse: auditoría y las tácticas de disponibilidad.
- Principios de Saltzer y Schroeder que siguen vigentes: mínimo privilegio, valores por defecto seguros, mediación completa, economía de mecanismo, diseño abierto, separación de privilegios.
- La seguridad como decisión de arquitectura: dónde está el límite de confianza, qué componente ve los datos de la tarjeta, quién puede hablar con quién. En Tinkuy, que solo el módulo de pagos hable con la pasarela reduce la superficie que hay que auditar; es una razón más para sacarlo a un servicio en P4.
- Trade-offs: la redundancia mejora la disponibilidad y cuesta dinero y consistencia; cifrar y autenticar cada llamada mejora la seguridad y agrega latencia; el retry mejora la disponibilidad y puede empeorar el rendimiento.
- Error común: tratar la seguridad como una capa que se agrega al final. Los límites de confianza son estructura, y la estructura es lo que cuesta cambiar.
Laboratorio — Pool de conexiones y cache: medir antes y después
Referencias: node-postgres, Pooling; k6, Thresholds; documentación de Redis. Material: code/week-06/. En parejas, sobre su copia de Tinkuy.
- Línea de base: con Tinkuy recién levantado, correr
make load-browsetres veces y anotar p50, p95, throughput y errores. Mirar durante la corrida cuántas conexiones tiene PostgreSQL (SELECT count(*) FROM pg_stat_activity). - Encontrar dónde se va el tiempo: con el script de
code/week-06/que mide por endpoint, y conEXPLAIN ANALYZEsobre la consulta de disponibilidad. Fíjense en lo que dice el plan: ¿la consulta es lenta, o lo caro es otra cosa (cuántas veces se hace, cuánto cuesta cada conexión)? Escribir, antes de cambiar nada, cuál creen que es el cuello de botella y qué táctica le corresponde. - Táctica 1, mantener un pool: reemplazar la conexión por petición por un
pg.Pool. Medir de nuevo. Probar con tamaños 2, 10 y 50 y graficar el p95 contra el tamaño del pool. Con los 50 usuarios deload-browsecasi no se nota la diferencia entre 10 y 50: para ver la forma de la curva hace falta más carga, como la demake load-sale. - Táctica 2, reducir el costo por petición: reescribir
GET /eventspara que obtenga la disponibilidad de todos los eventos en una sola consulta. Medir de nuevo. - Táctica 3, mantener una copia de los datos: guardar la respuesta de
GET /eventsen Redis con un TTL de cinco segundos. Medir de nuevo. Después comprar una entrada y consultar la lista: ¿qué ve el comprador durante cinco segundos? Escribir el trade-off. - Llenar la tabla de
code/week-06/: una fila por táctica, con p95, throughput, lo que mejoró y lo que costó. ¿Cuál dio más por menos? - Disponibilidad: con la carga corriendo, ejecutar
svc kill redis. ¿Qué le pasa aGET /events? (Con la configuración por defecto, el cliente de Redis no falla: guarda los comandos en una cola y la petición se queda esperando.) Cambiar el código para que una cache caída degrade a consultar la base de datos en vez de devolver un error, y repetir. - Seguridad: revisar Tinkuy con el cuestionario de tácticas de seguridad del capítulo 11 y anotar tres tácticas ausentes, ordenadas por el daño que evitarían.
Entregas
Sin entregas esta semana. Las tácticas de este laboratorio son el punto de partida de P2, que se entrega en la semana 8.
Preguntas de repaso
- ¿En qué se diferencia una táctica de un patrón? Den un patrón y dos tácticas que empaqueta.
- Una petición tarda 400 ms: 30 ms de procesamiento y 370 ms esperando una conexión a la base de datos. ¿Qué grupo de tácticas de rendimiento aplica? ¿Qué pasaría si en vez de eso se agregaran más servidores de aplicación?
- ¿Por qué un pool de 200 conexiones puede rendir menos que uno de 20?
- Den una táctica de detección, una de recuperación y una de prevención de fallas para la pasarela de pagos de Tinkuy.
- Expliquen con un ejemplo cómo un retry puede convertir una falta transitoria en una falla mayor.
- ¿Qué principio de Saltzer y Schroeder viola un servicio de reportes que se conecta a la base de datos con el usuario administrador? ¿Qué táctica lo corrige?
Código de la semana
Compilar y probar dentro del contenedor del curso con make y make test.
Ejemplos (20)Errores (3)Pruebas (6)Compilación (3)
Ejemplos
Los programas que usan los apuntes y la clase.
# Tácticas de rendimiento: antes y después
Template de la tabla del laboratorio de la semana 6 (pasos 1 a 7). Copien este
archivo a `docs/measurements/` de su repositorio y llénenlo con sus números.
Un número sin su comando y su máquina no se puede comparar con nada.
## Condiciones
- Máquina:
- Sistema medido (commit):
- Script y carga (comando exacto, usuarios virtuales, duración):
- Datos (semilla, `make db` antes de cada corrida que escribe: sí / no):
- Corridas por fila: 3. Se anota la mediana de las tres, y entre paréntesis
la menor y la mayor.
## Hipótesis (se escribe antes de cambiar nada)
- El cuello de botella que creemos que limita:
- La evidencia (qué medición lo señala):
- La táctica que le corresponde, y de qué grupo es (controlar la demanda o
administrar los recursos):
- Lo que esperamos ver si tenemos razón:
## Tabla
| # | Táctica | Grupo | p50 de `GET /events` | p95 de `GET /events` | Throughput | Errores | Conexiones a PostgreSQL (máx.) | Qué mejoró | Qué costó |
|---|---|---|---|---|---|---|---|---|---|
| 0 | Ninguna (línea de base) | | | | | | | | |
| 1 | Pool de conexiones, tamaño 2 | | | | | | | | |
| 1 | Pool de conexiones, tamaño 10 | | | | | | | | |
| 1 | Pool de conexiones, tamaño 50 | | | | | | | | |
| 2 | Una sola consulta para la disponibilidad | | | | | | | | |
| 3 | Cache en Redis, TTL de 5 s | | | | | | | | |
"Qué costó" no puede quedar vacío ni decir "nada". Algunas preguntas para
encontrarlo: ¿qué configuración nueva hay que elegir y mantener?, ¿qué puede
ver ahora un comprador que antes no podía ver?, ¿de qué servicio nuevo
depende el endpoint?, ¿qué pasa en el primer pedido después de un reinicio?
## El tamaño del pool
| Tamaño | p50 | p95 | Throughput | Conexiones (máx.) |
|---|---|---|---|---|
| 2 | | | | |
| 10 | | | | |
| 50 | | | | |
- El tamaño que elegimos y por qué:
- Lo que pasaría con ese tamaño si corrieran cuatro instancias del servidor
contra la misma base de datos:
## La cache y el dato viejo
- Lo que ve un comprador en la lista durante los 5 s siguientes a una compra:
- Para quién es aceptable y para quién no:
- Lo que haríamos distinto si el TTL fuera de 60 s:
## La cache caída
| Comportamiento | Pedidos con error mientras Redis está caído | p95 mientras Redis está caído | Qué ve el comprador |
|---|---|---|---|
| Como estaba (antes de cambiar nada) | | | |
| Degradando a la base de datos | | | |
- Lo que cuesta degradar (¿qué recibe la base de datos cuando la cache se cae
en el peor momento?):
## Conclusión
- La táctica que dio más por menos, con los números que lo muestran:
- La que no volveríamos a aplicar, o aplicaríamos distinto:
- Lo que la medición no cubre (y por qué podría importar):# Revisión de tácticas de seguridad
Lista de preguntas para el paso 8 del laboratorio de la semana 6. Sigue los
cuatro grupos del catálogo de tácticas de seguridad (detectar, resistir,
reaccionar, recuperarse); las preguntas están escritas para el curso. El
cuestionario del libro (*Software Architecture in Practice*, cap. 11) cubre
lo mismo con más detalle: úsenlo si tienen el libro a la mano.
Para cada pregunta: **sí**, **no** o **en parte**; dónde se ve en el código o
en la configuración (archivo y línea); y, si la respuesta es no, qué daño
permite. "No aplica" también es una respuesta, con su porqué.
## Detectar ataques
| Táctica | Pregunta | ¿Sí / no / en parte? | Evidencia | Daño que permite su ausencia |
|---|---|---|---|---|
| Detectar intrusos | ¿Queda registro de quién hizo cada pedido y desde dónde? ¿Alguien o algo revisa ese registro buscando patrones anormales? | | | |
| Detectar denegación de servicio | ¿El sistema nota que una fuente manda muchos más pedidos de lo normal? | | | |
| Verificar la integridad de los mensajes | ¿El sistema puede saber si un mensaje que recibe (un pedido, una respuesta de la pasarela) fue alterado en el camino? | | | |
## Resistir ataques
| Táctica | Pregunta | ¿Sí / no / en parte? | Evidencia | Daño que permite su ausencia |
|---|---|---|---|---|
| Identificar actores | ¿Cada pedido dice de quién es? | | | |
| Autenticar actores | ¿El sistema comprueba que quien dice ser alguien lo es? | | | |
| Autorizar actores | ¿Cada operación comprueba que ese actor puede hacerla sobre ese recurso (por ejemplo, ver esa orden)? | | | |
| Limitar el acceso | ¿Cada componente llega solo a lo que necesita? ¿Con qué usuario se conecta a la base de datos y qué puede hacer ese usuario? | | | |
| Limitar la exposición | ¿Cuántos puntos de entrada hay? ¿Cuántos componentes ven los datos más sensibles (la tarjeta)? | | | |
| Cifrar los datos | ¿Los datos viajan cifrados entre el cliente y el servidor, y entre el servidor y la pasarela? ¿Qué datos sensibles se guardan, y cómo? | | | |
| Separar entidades | ¿Lo sensible está separado de lo demás (otro proceso, otra base de datos, otra red)? | | | |
| Validar la entrada | ¿Todo lo que llega de afuera se valida antes de usarse? ¿Alguna consulta SQL se arma con texto de quien llama? | | | |
| Cambiar las credenciales por defecto | ¿Queda algún usuario, contraseña o clave con el valor con que vino instalado? | | | |
## Reaccionar a ataques
| Táctica | Pregunta | ¿Sí / no / en parte? | Evidencia | Daño que permite su ausencia |
|---|---|---|---|---|
| Revocar el acceso | Si se descubre un actor malicioso o una credencial filtrada, ¿se le puede cortar el acceso sin detener el sistema? | | | |
| Restringir el inicio de sesión | ¿Hay un límite de intentos fallidos (de sesión, de pago, de códigos)? | | | |
| Informar | Cuando se detecta un ataque, ¿alguien se entera? ¿Quién y cómo? | | | |
## Recuperarse de ataques
| Táctica | Pregunta | ¿Sí / no / en parte? | Evidencia | Daño que permite su ausencia |
|---|---|---|---|---|
| Auditoría | ¿Se puede reconstruir, después de un incidente, qué hizo cada actor y en qué orden? | | | |
| Tácticas de disponibilidad | ¿Hay cómo volver a un estado bueno conocido (respaldo, rollback) si los datos fueron alterados? | | | |
## Resultado
Las tres tácticas ausentes que más importan, ordenadas por el daño que
evitarían. Para cada una: el escenario de seguridad en una línea (fuente,
ataque, daño) y en qué parte de la estructura habría que ponerla.
1.
2.
3.-- Qillqa: el catálogo de una red de bibliotecas. Un título (un libro) tiene
-- muchos ejemplares, y cada ejemplar está disponible o prestado.
CREATE TABLE branches (
id integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
name text NOT NULL UNIQUE,
city text NOT NULL
);
CREATE TABLE titles (
id integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
branch_id integer NOT NULL REFERENCES branches (id),
name text NOT NULL,
author text NOT NULL,
year integer NOT NULL
);
CREATE TABLE copies (
id integer PRIMARY KEY GENERATED BY DEFAULT AS IDENTITY,
title_id integer NOT NULL REFERENCES titles (id),
status text NOT NULL DEFAULT 'available' CHECK (status IN ('available', 'loaned'))
);
CREATE INDEX copies_title_idx ON copies (title_id);-- Datos de ejemplo de Qillqa. No usan números al azar: cada corrida carga
-- exactamente lo mismo, y por eso las pruebas pueden comparar respuestas.
INSERT INTO branches (id, name, city) VALUES
(1, 'Biblioteca Central', 'Lima'),
(2, 'Biblioteca del Rímac', 'Lima'),
(3, 'Biblioteca de San Blas', 'Cusco'),
(4, 'Biblioteca de Yanahuara', 'Arequipa');
INSERT INTO titles (id, branch_id, name, author, year) VALUES
( 1, 1, 'Los ríos profundos', 'José María Arguedas', 1958),
( 2, 1, 'La ciudad y los perros', 'Mario Vargas Llosa', 1963),
( 3, 1, 'Un mundo para Julius', 'Alfredo Bryce Echenique', 1970),
( 4, 1, 'Trilce', 'César Vallejo', 1922),
( 5, 1, 'Tradiciones peruanas', 'Ricardo Palma', 1872),
( 6, 1, 'El mundo es ancho y ajeno', 'Ciro Alegría', 1941),
( 7, 1, 'La palabra del mudo', 'Julio Ramón Ribeyro', 1973),
( 8, 1, 'Conversación en La Catedral', 'Mario Vargas Llosa', 1969),
( 9, 1, 'Los heraldos negros', 'César Vallejo', 1919),
(10, 1, 'Redoble por Rancas', 'Manuel Scorza', 1970),
(11, 2, 'Yawar fiesta', 'José María Arguedas', 1941),
(12, 2, 'La casa de cartón', 'Martín Adán', 1928),
(13, 2, 'No me esperen en abril', 'Alfredo Bryce Echenique', 1995),
(14, 2, 'Los inocentes', 'Oswaldo Reynoso', 1961),
(15, 2, 'Aves sin nido', 'Clorinda Matto de Turner', 1889),
(16, 2, 'Crónica de San Gabriel', 'Julio Ramón Ribeyro', 1960),
(17, 2, 'País de Jauja', 'Edgardo Rivera Martínez', 1993),
(18, 2, 'Los perros hambrientos', 'Ciro Alegría', 1939),
(19, 3, 'Comentarios reales de los incas', 'Inca Garcilaso de la Vega', 1609),
(20, 3, 'Todas las sangres', 'José María Arguedas', 1964),
(21, 3, 'Ollantay', 'Anónimo', 1770),
(22, 3, 'El pez de oro', 'Gamaliel Churata', 1957),
(23, 3, 'Cuentos andinos', 'Enrique López Albújar', 1920),
(24, 3, 'Agua', 'José María Arguedas', 1935),
(25, 4, 'La tía Julia y el escribidor', 'Mario Vargas Llosa', 1977),
(26, 4, 'Jorge, el hijo del pueblo', 'María Nieves y Bustamante', 1892),
(27, 4, 'Poemas humanos', 'César Vallejo', 1939),
(28, 4, 'Yaravíes', 'Mariano Melgar', 1831),
(29, 4, 'El sexto', 'José María Arguedas', 1961),
(30, 4, 'La serpiente de oro', 'Ciro Alegría', 1935);
-- Entre 200 y 590 ejemplares por título; de cada cuatro, uno está prestado.
INSERT INTO copies (title_id, status)
SELECT t.id,
CASE WHEN (n + t.id) % 4 = 0 THEN 'loaned' ELSE 'available' END
FROM titles t
CROSS JOIN LATERAL generate_series(1, 200 + (t.id * 37) % 400) AS n;
-- Un título sin ejemplares: tiene que aparecer en la lista, con cero.
INSERT INTO titles (id, branch_id, name, author, year) VALUES
(31, 4, 'El zorro de arriba y el zorro de abajo', 'José María Arguedas', 1971);
ANALYZE;// ¿Dónde se va el tiempo? Recorre los endpoints de un sistema y reporta la
// latencia de cada uno por separado. Sirve para Qillqa y para Tinkuy:
//
// make endpoints Qillqa (con make serve corriendo)
// make tinkuy-endpoints Tinkuy (con make tinkuy-up; es el paso 2 del laboratorio)
//
// TARGET=qillqa|tinkuy qué sistema se mide
// BASE_URL=... dónde está
//
// Solo lee: se puede repetir sin volver a crear la base de datos.
import http from 'k6/http';
import { check, sleep } from 'k6';
const TARGET = __ENV.TARGET || 'qillqa';
const BASE_URL = __ENV.BASE_URL || (TARGET === 'tinkuy' ? 'http://localhost:3000' : 'http://localhost:3600');
// Cada sistema: sus endpoints, con una función que arma la ruta.
const SYSTEMS = {
qillqa: {
'GET /titles': () => '/titles',
'GET /titles?city=': () => '/titles?city=Cusco',
'GET /titles/:id': () => `/titles/${1 + Math.floor(Math.random() * 31)}`,
},
tinkuy: {
'GET /events': () => '/events',
'GET /events/:id': () => `/events/${1 + Math.floor(Math.random() * 24)}`,
'GET /events/:id/seats': () => `/events/${1 + Math.floor(Math.random() * 24)}/seats`,
'GET /orders/:id': () => `/orders/${1 + Math.floor(Math.random() * 1303)}`,
'GET /reports/sales': () => `/reports/sales?eventId=${1 + Math.floor(Math.random() * 24)}`,
},
};
const endpoints = SYSTEMS[TARGET];
// k6 solo muestra en el resumen una métrica filtrada por etiqueta si tiene un
// umbral. Estos se cumplen siempre (max>=0): no juzgan nada, solo piden la fila.
const thresholds = {};
for (const name of Object.keys(endpoints)) {
thresholds[`http_req_duration{name:${name}}`] = ['max>=0'];
}
export const options = {
scenarios: {
readers: { executor: 'constant-vus', vus: Number(__ENV.VUS || 20), duration: __ENV.DURATION || '15s' },
},
thresholds,
summaryTrendStats: ['avg', 'med', 'p(95)', 'p(99)', 'max'],
};
export default function () {
for (const [name, path] of Object.entries(endpoints)) {
// La etiqueta `name` junta /titles/1, /titles/2... en una sola fila.
const response = http.get(`${BASE_URL}${path()}`, { tags: { name } });
check(response, { [`${name} responde 200`]: (r) => r.status === 200 });
sleep(0.2);
}
}// Gente mirando la lista de títulos de Qillqa: VUS usuarios virtuales piden
// GET /titles una y otra vez, con una pausa corta entre pedidos.
//
// make load (con Qillqa corriendo: make serve)
// VUS=50 DURATION=15s cuántos usuarios y por cuánto tiempo
// BASE_URL=http://localhost:3600 dónde está el servicio
//
// El script no cambia entre variantes: lo que cambia es el servicio. Por eso
// dos corridas se pueden comparar.
import http from 'k6/http';
import { check, sleep } from 'k6';
const BASE_URL = __ENV.BASE_URL || 'http://localhost:3600';
export const options = {
scenarios: {
readers: {
executor: 'constant-vus',
vus: Number(__ENV.VUS || 50),
duration: __ENV.DURATION || '15s',
},
},
summaryTrendStats: ['avg', 'med', 'p(95)', 'p(99)', 'max'],
};
export default function () {
const response = http.get(`${BASE_URL}/titles`, { tags: { name: 'GET /titles' } });
check(response, { 'GET /titles responde 200': (r) => r.status === 200 });
sleep(0.05);
}-- Mínimo privilegio con roles de PostgreSQL. El servicio de reportes solo
-- necesita leer, así que su rol solo puede leer. Lo que no puede hacer no
-- depende de que su código esté bien escrito.
--
-- make privilege
\set QUIET on
DO $$
BEGIN
IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname = 'w06_reports') THEN
CREATE ROLE w06_reports;
END IF;
END $$;
GRANT SELECT ON branches, titles, copies TO w06_reports;
\set QUIET off
\set ECHO queries
-- Como el usuario administrador (el que usa todo en el contenedor):
SELECT current_user;
-- Como el rol de reportes:
SET ROLE w06_reports;
SELECT count(*) AS prestados FROM copies WHERE status = 'loaned';
UPDATE copies SET status = 'available';
DROP TABLE copies;
SELECT rolname, rolpassword FROM pg_authid LIMIT 1;
RESET ROLE;import { createServer, type IncomingMessage, type Server, type ServerResponse } from 'node:http';
import type { AddressInfo } from 'node:net';
import { createCache, type Cache } from './cache.ts';
import { createDb, type Db } from './db.ts';
import { getTitle, listTitlesNPlusOne, listTitlesSingleQuery, loanCopy, type TitleFilter } from './titles.ts';
import type { Variant } from './variant.ts';
// El servicio completo para una variante. Las pruebas levantan varias
// variantes en el mismo proceso, por eso no hay estado global: cada app
// tiene su capa de datos y su cache.
export type App = {
variant: Variant;
db: Db;
cache: Cache | undefined;
/** Empieza a escuchar. Con el puerto 0, el sistema elige uno libre. */
listen(port: number): Promise<string>;
close(): Promise<void>;
};
function send(response: ServerResponse, status: number, body: string, headers: Record<string, string> = {}): void {
response.writeHead(status, {
'content-type': 'application/json; charset=utf-8',
'content-length': Buffer.byteLength(body),
...headers,
});
response.end(body);
}
function sendError(response: ServerResponse, status: number, code: string, message: string): void {
send(response, status, JSON.stringify({ error: { code, message } }));
}
export function createApp(variant: Variant): App {
const db = createDb(variant);
const cache = variant.cache === 'redis' ? createCache(variant) : undefined;
const listTitles = variant.list === 'single' ? listTitlesSingleQuery : listTitlesNPlusOne;
async function handleList(url: URL, response: ServerResponse): Promise<void> {
const city = url.searchParams.get('city') ?? undefined;
const filter: TitleFilter = { city };
const compute = async () => JSON.stringify({ titles: await listTitles(db, filter) });
if (!cache) {
send(response, 200, await compute(), { 'x-cache': 'off' });
return;
}
// Una entrada de cache por filtro: la clave lleva la ciudad.
const { body, outcome } = await cache.getOrCompute(`titles:${city ?? '*'}`, compute);
send(response, 200, body, { 'x-cache': outcome });
}
async function handle(request: IncomingMessage, response: ServerResponse): Promise<void> {
const url = new URL(request.url ?? '/', 'http://localhost');
const method = request.method ?? 'GET';
if (method === 'GET' && url.pathname === '/health') {
send(response, 200, JSON.stringify({ status: 'ok' }));
return;
}
if (method === 'GET' && url.pathname === '/titles') {
await handleList(url, response);
return;
}
if (method === 'GET' && url.pathname === '/stats') {
send(response, 200, JSON.stringify({ variant, db: db.counters, cache: cache?.counters ?? null }));
return;
}
const one = /^\/titles\/(\d+)$/.exec(url.pathname);
if (method === 'GET' && one) {
const title = await getTitle(db, Number(one[1]));
if (!title) return sendError(response, 404, 'NOT_FOUND', `No existe el título ${one[1]}`);
send(response, 200, JSON.stringify({ title }));
return;
}
const loans = /^\/titles\/(\d+)\/loans$/.exec(url.pathname);
if (method === 'POST' && loans) {
const titleId = Number(loans[1]);
const copyId = await loanCopy(db, titleId);
if (copyId === undefined) {
return sendError(response, 409, 'NO_COPIES', `No quedan ejemplares del título ${titleId}`);
}
send(response, 201, JSON.stringify({ loan: { titleId, copyId } }));
return;
}
sendError(response, 404, 'NOT_FOUND', `No existe ${method} ${url.pathname}`);
}
const server: Server = createServer((request, response) => {
handle(request, response).catch((error: unknown) => {
// Cualquier error que nadie manejó termina aquí, como un 500.
const message = error instanceof Error ? error.message : String(error);
if (!response.headersSent) sendError(response, 500, 'INTERNAL', message);
else response.destroy();
});
});
return {
variant,
db,
cache,
listen(port) {
return new Promise((resolve, reject) => {
server.once('error', reject);
server.listen(port, () => {
resolve(`http://localhost:${(server.address() as AddressInfo).port}`);
});
});
},
async close() {
await new Promise<void>((resolve) => {
server.close(() => resolve());
server.closeAllConnections();
});
await cache?.close();
await db.close();
},
};
}import { createClient } from 'redis';
import type { Variant } from './variant.ts';
// Cache-aside sobre Redis: se busca primero en la cache; si no está, se
// calcula, se guarda con un TTL y se devuelve. Nadie invalida: lo guardado
// vale hasta que vence.
export type CacheOutcome = 'hit' | 'miss' | 'bypass';
export type CacheCounters = {
hits: number;
misses: number;
/** Veces que Redis no respondió y se fue directo a la base de datos. */
bypasses: number;
/** Veces que Redis no respondió y el pedido falló. */
failures: number;
};
export type Cache = {
/** Devuelve el valor (como texto JSON) y de dónde salió. */
getOrCompute(key: string, compute: () => Promise<string>): Promise<{ body: string; outcome: CacheOutcome }>;
close(): Promise<void>;
counters: CacheCounters;
};
export class CacheUnavailableError extends Error {
constructor(cause: unknown) {
super('La cache no responde', { cause });
this.name = 'CacheUnavailableError';
}
}
export function createCache(variant: Variant): Cache {
const counters: CacheCounters = { hits: 0, misses: 0, bypasses: 0, failures: 0 };
const client = createClient({
url: variant.redisUrl,
// Sin esto, un comando enviado mientras Redis está caído se queda en una
// cola dentro del cliente hasta que Redis vuelva: el pedido ni falla ni
// responde. Con esto falla de inmediato, y se puede decidir qué hacer.
disableOfflineQueue: true,
socket: {
connectTimeout: 1000,
// El cliente sigue intentando reconectarse, cada vez un poco más tarde.
reconnectStrategy: (retries) => Math.min(100 * (retries + 1), 1000),
},
});
// Sin un manejador de 'error', la caída de Redis tumbaría el proceso.
client.on('error', () => {});
// No se espera la conexión: si Redis no está al arrancar, el servicio
// arranca igual y cada pedido decide según onCacheError.
client.connect().catch(() => {});
const ttl = variant.cacheTtlSeconds;
return {
counters,
async getOrCompute(key, compute) {
const fullKey = `${variant.keyPrefix}${key}`;
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);
}
if (cached !== null) {
counters.hits += 1;
return { body: cached, outcome: 'hit' };
}
counters.misses += 1;
const body = await compute();
try {
await client.set(fullKey, body, { EX: ttl });
} catch (error) {
// El valor ya está calculado: si no se pudo guardar, solo al
// degradar tiene sentido devolverlo.
if (variant.onCacheError !== 'degrade') {
counters.failures += 1;
throw new CacheUnavailableError(error);
}
}
return { body, outcome: 'miss' };
},
async close() {
// destroy() cierra sin esperar a Redis: sirve también cuando está caído.
client.destroy();
},
};
}import pg from 'pg';
import type { Variant } from './variant.ts';
// La capa de datos tiene una interfaz y dos implementaciones. El resto del
// servicio solo conoce la interfaz: por eso cambiar de una a otra no toca
// ninguna consulta.
export type DbCounters = {
/** Consultas enviadas a PostgreSQL. */
queries: number;
/** Conexiones que este proceso abrió. */
connectionsOpened: number;
};
export type Db = {
query<Row extends pg.QueryResultRow>(text: string, params?: unknown[]): Promise<Row[]>;
close(): Promise<void>;
counters: DbCounters;
};
// Con este nombre se reconocen las conexiones del servicio en pg_stat_activity.
export const APPLICATION_NAME = 'qillqa';
/**
* Una conexión nueva por consulta: se abre, se usa una vez y se cierra. Es lo
* que hace el Tinkuy inicial. No hay tope: cien consultas a la vez son cien
* conexiones.
*/
export function connectionPerQuery(database: string): Db {
const counters: DbCounters = { queries: 0, connectionsOpened: 0 };
return {
counters,
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();
}
},
async close(): Promise<void> {},
};
}
/**
* Un pool: las conexiones se abren una vez y se reutilizan. `max` es además
* un tope: si las `max` conexiones están ocupadas, la consulta siguiente
* espera su turno dentro del proceso, y PostgreSQL no se entera.
*/
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();
},
};
}
export function createDb(variant: Variant): Db {
return variant.db === 'pool' ? pooled(variant.database, variant.poolSize) : connectionPerQuery(variant.database);
}import { createApp } from './app.ts';
import { describeVariant, variantFromEnv } from './variant.ts';
// Levanta Qillqa con la variante que digan las variables de entorno:
// DB_MODE=pool POOL_SIZE=10 LIST_MODE=single CACHE=redis node src/main.ts
const port = Number(process.env.PORT ?? 3600);
const variant = variantFromEnv();
const app = createApp(variant);
const url = await app.listen(port);
if (process.env.W06_LOG !== 'off') console.log(`Qillqa en ${url}: ${describeVariant(variant)}`);
// Al terminar se cierran el servidor, la cache y las conexiones a PostgreSQL.
for (const signal of ['SIGINT', 'SIGTERM'] as const) {
process.once(signal, () => {
app.close().then(() => process.exit(0));
});
}import type { Db } from './db.ts';
// El catálogo: la lista de títulos con los ejemplares que quedan de cada uno,
// escrita de dos maneras que devuelven lo mismo.
export type TitleSummary = {
id: number;
name: string;
author: string;
year: number;
branch: { name: string; city: string };
availableCopies: number;
};
export type TitleFilter = { city?: string };
type TitleRow = {
id: number;
name: string;
author: string;
year: number;
branch_name: string;
branch_city: string;
};
function toSummary(row: TitleRow, availableCopies: number): TitleSummary {
return {
id: row.id,
name: row.name,
author: row.author,
year: row.year,
branch: { name: row.branch_name, city: row.branch_city },
availableCopies,
};
}
export async function countAvailableCopies(db: Db, titleId: number): Promise<number> {
const rows = await db.query<{ available: number }>(
`SELECT count(*)::int AS available FROM copies WHERE title_id = $1 AND status = 'available'`,
[titleId],
);
return rows[0]?.available ?? 0;
}
/**
* N+1: una consulta para la lista y una más por cada título. Con 31 títulos
* son 32 consultas, una después de otra.
*/
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;
}
/**
* Lo mismo en una consulta. El LEFT JOIN conserva los títulos sin ejemplares,
* y el FILTER cuenta solo los disponibles sin descartar la fila del título
* cuando todos están prestados.
*/
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));
}
export async function getTitle(db: Db, titleId: number): Promise<TitleSummary | undefined> {
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 t.id = $1`,
[titleId],
);
const row = rows[0];
if (!row) return undefined;
return toSummary(row, await countAvailableCopies(db, titleId));
}
/**
* Presta un ejemplar disponible del título. Devuelve el id del ejemplar, o
* undefined si no queda ninguno.
*/
export async function loanCopy(db: Db, titleId: number): Promise<number | undefined> {
const rows = await db.query<{ id: number }>(
`UPDATE copies
SET status = 'loaned'
WHERE id = (SELECT min(id) FROM copies WHERE title_id = $1 AND status = 'available')
AND status = 'available'
RETURNING id`,
[titleId],
);
return rows[0]?.id;
}// Las variantes del servicio. Cada campo es una decisión que la semana
// compara: cómo se consiguen las conexiones, cómo se arma la lista y si hay
// una cache delante. Se eligen al arrancar, con variables de entorno, sin
// tocar el código (diferir el enlace hasta el arranque).
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;
};
export const baseline: Variant = {
database: 'arq_w06',
db: 'connect',
poolSize: 10,
list: 'nplus1',
cache: 'off',
cacheTtlSeconds: 5,
onCacheError: 'fail',
redisUrl: 'redis://127.0.0.1:6379',
keyPrefix: 'w06:',
};
function oneOf<T extends string>(name: string, allowed: readonly T[], fallback: T): T {
const raw = process.env[name];
if (raw === undefined || raw === '') return fallback;
if (!(allowed as readonly string[]).includes(raw)) {
throw new Error(`La variable ${name} debe ser una de: ${allowed.join(', ')}; y es "${raw}"`);
}
return raw as T;
}
function positiveInt(name: string, fallback: number): number {
const raw = process.env[name];
if (raw === undefined || raw === '') return fallback;
const value = Number(raw);
if (!Number.isInteger(value) || value < 1) {
throw new Error(`La variable ${name} debe ser un entero positivo, y es "${raw}"`);
}
return value;
}
/**
* Lee la variante del entorno:
* DB_MODE=connect|pool POOL_SIZE=10
* LIST_MODE=nplus1|single
* CACHE=off|redis CACHE_TTL_S=5 CACHE_ON_ERROR=fail|degrade
*/
export function variantFromEnv(): Variant {
return {
...baseline,
database: process.env.W06_DB ?? baseline.database,
db: oneOf('DB_MODE', ['connect', 'pool'] as const, baseline.db),
poolSize: positiveInt('POOL_SIZE', baseline.poolSize),
list: oneOf('LIST_MODE', ['nplus1', 'single'] as const, baseline.list),
cache: oneOf('CACHE', ['off', 'redis'] as const, baseline.cache),
cacheTtlSeconds: positiveInt('CACHE_TTL_S', baseline.cacheTtlSeconds),
onCacheError: oneOf('CACHE_ON_ERROR', ['fail', 'degrade'] as const, baseline.onCacheError),
redisUrl: process.env.REDIS_URL ?? baseline.redisUrl,
keyPrefix: process.env.W06_PREFIX ?? baseline.keyPrefix,
};
}
/** La variante en una línea, para los mensajes y las tablas. */
export function describeVariant(variant: Variant): string {
const db = variant.db === 'pool' ? `pool de ${variant.poolSize}` : 'sin pool';
const list = variant.list === 'nplus1' ? 'N+1' : 'una consulta';
const cache =
variant.cache === 'redis' ? `cache TTL ${variant.cacheTtlSeconds} s (${variant.onCacheError})` : 'sin cache';
return `${db}, ${list}, ${cache}`;
}#!/usr/bin/env bash
# Las dos respuestas a una cache caída, una después de otra.
set -u
node tools/cache-down.ts fail
echo
node tools/cache-down.ts degrade// Redis se cae con carga corriendo. Levanta Qillqa con cache en el modo que
// se pida (fail o degrade), le manda 40 pedidos por segundo durante 9
// segundos, mata Redis en el segundo 3 y lo vuelve a iniciar en el segundo 6.
// Escribe una fila por segundo: cuántos pedidos respondieron 200, cuántos
// 500, de dónde salieron las respuestas y la mediana de la latencia.
//
// node tools/cache-down.ts fail
// node tools/cache-down.ts degrade (make cache-down corre los dos)
import { execFile, spawn } from 'node:child_process';
import { promisify } from 'node:util';
import { percentile } from './stats.ts';
const run = promisify(execFile);
const mode = process.argv[2];
if (mode !== 'fail' && mode !== 'degrade') {
console.error('Uso: node tools/cache-down.ts fail|degrade');
process.exit(2);
}
const PORT = 3603;
const BASE_URL = `http://localhost:${PORT}`;
const SECONDS = 9;
const PER_SECOND = 40;
const KILL_AT = 3;
const START_AT = 6;
type Sample = { second: number; status: number; cache: string; ms: number };
const server = spawn('node', ['src/main.ts'], {
env: {
...process.env,
PORT: String(PORT),
W06_LOG: 'off',
DB_MODE: 'pool',
LIST_MODE: 'single',
CACHE: 'redis',
CACHE_ON_ERROR: mode,
},
stdio: 'inherit',
});
const serverExit = new Promise((resolve) => server.once('exit', resolve));
async function waitForHealth(): Promise<void> {
for (let attempt = 0; attempt < 100; attempt += 1) {
try {
if ((await fetch(`${BASE_URL}/health`)).ok) return;
} catch {
// Todavía no escucha.
}
await new Promise((resolve) => setTimeout(resolve, 100));
}
throw new Error('El servicio no respondió en /health');
}
async function request(second: number): Promise<Sample> {
const start = performance.now();
try {
const response = await fetch(`${BASE_URL}/titles`);
await response.text();
return { second, status: response.status, cache: response.headers.get('x-cache') ?? '-', ms: performance.now() - start };
} catch {
return { second, status: 0, cache: '-', ms: performance.now() - start };
}
}
try {
await waitForHealth();
console.log(`CACHE_ON_ERROR=${mode}: ${PER_SECOND} pedidos por segundo a GET /titles`);
console.log(' s 200 500 hit miss bypass p50 suceso');
const pending: Promise<Sample>[] = [];
const events = new Map<number, string>();
const startedAt = performance.now();
for (let second = 0; second < SECONDS; second += 1) {
if (second === KILL_AT) {
await run('svc', ['kill', 'redis']);
events.set(second, 'svc kill redis');
}
if (second === START_AT) {
await run('svc', ['start', 'redis']);
events.set(second, 'svc start redis');
}
// Carga de tasa fija: los pedidos salen a su hora aunque los anteriores no hayan vuelto.
for (let i = 0; i < PER_SECOND; i += 1) {
const due = startedAt + (second + i / PER_SECOND) * 1000;
const wait = due - performance.now();
if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
pending.push(request(second));
}
}
const samples = await Promise.all(pending);
for (let second = 0; second < SECONDS; second += 1) {
const mine = samples.filter((sample) => sample.second === second);
const count = (test: (sample: Sample) => boolean) => String(mine.filter(test).length).padStart(5);
console.log(
`${String(second).padStart(3)} ${count((s) => s.status === 200)} ${count((s) => s.status === 500)} ` +
`${count((s) => s.cache === 'hit')} ${count((s) => s.cache === 'miss')} ${count((s) => s.cache === 'bypass')} ` +
`${`${percentile(mine.map((s) => s.ms), 50).toFixed(1)} ms`.padStart(8)} ${events.get(second) ?? ''}`,
);
}
const failed = samples.filter((sample) => sample.status !== 200).length;
console.log(`pedidos: ${samples.length}, con error: ${failed} (${((failed / samples.length) * 100).toFixed(1)} %)`);
} finally {
// Pase lo que pase, Redis queda arriba para lo que venga después.
await run('svc', ['start', 'redis']);
server.kill('SIGTERM');
await serverExit;
}// ¿Cuánto cuesta abrir una conexión? Corre la misma consulta 200 veces de dos
// maneras: abriendo y cerrando una conexión cada vez, y sobre una conexión que
// ya estaba abierta. La diferencia es lo que un pool ahorra en cada consulta.
//
// make connect-cost
// PGHOST=127.0.0.1 make connect-cost lo mismo por TCP en vez del socket local
import pg from 'pg';
import { percentile } from './stats.ts';
const DATABASE = process.env.W06_DB ?? 'arq_w06';
const ROUNDS = 200;
const QUERY = `SELECT count(*)::int AS available FROM copies WHERE title_id = $1 AND status = 'available'`;
async function timed(fn: () => Promise<void>): Promise<number> {
const start = performance.now();
await fn();
return performance.now() - start;
}
const withConnect: number[] = [];
for (let round = 0; round < ROUNDS; round += 1) {
withConnect.push(
await timed(async () => {
const client = new pg.Client({ database: DATABASE });
await client.connect();
await client.query(QUERY, [1 + (round % 30)]);
await client.end();
}),
);
}
const reused: number[] = [];
const client = new pg.Client({ database: DATABASE });
await client.connect();
for (let round = 0; round < ROUNDS; round += 1) {
reused.push(await timed(async () => void (await client.query(QUERY, [1 + (round % 30)]))));
}
await client.end();
const line = (label: string, samples: number[]) =>
`${label.padEnd(38)} p50 ${percentile(samples, 50).toFixed(2).padStart(6)} ms p95 ${percentile(samples, 95).toFixed(2).padStart(6)} ms`;
console.log(`${ROUNDS} consultas, una después de otra (host: ${process.env.PGHOST ?? 'localhost'})`);
console.log(line('conectar + consulta + cerrar', withConnect));
console.log(line('consulta sobre una conexión abierta', reused));
console.log(`razón entre las medianas: ${(percentile(withConnect, 50) / percentile(reused, 50)).toFixed(1)}`);// ¿Más conexiones es más rápido? Lanza la misma consulta directo a
// PostgreSQL, sin servidor HTTP de por medio, con 1, 2, 4 ... 64 conexiones
// trabajando a la vez, durante 2 segundos cada vez. Reporta cuántas consultas
// por segundo se completaron en total y cuánto tardó cada una.
//
// make db-curve
//
// La consulta recorre toda la tabla copies: es trabajo de procesador, que es
// el recurso por el que compiten las conexiones.
import os from 'node:os';
import pg from 'pg';
import { percentile } from './stats.ts';
const DATABASE = process.env.W06_DB ?? 'arq_w06';
const SECONDS = 2;
const QUERY = `SELECT branch_id, count(*) FROM copies c JOIN titles t ON t.id = c.title_id WHERE c.status = 'available' GROUP BY branch_id`;
async function run(connections: number): Promise<{ perSecond: number; p50: number; p95: number }> {
const clients = Array.from({ length: connections }, () => new pg.Client({ database: DATABASE }));
await Promise.all(clients.map((client) => client.connect()));
const samples: number[] = [];
const deadline = performance.now() + SECONDS * 1000;
await Promise.all(
clients.map(async (client) => {
while (performance.now() < deadline) {
const start = performance.now();
await client.query(QUERY);
samples.push(performance.now() - start);
}
}),
);
await Promise.all(clients.map((client) => client.end()));
return { perSecond: samples.length / SECONDS, p50: percentile(samples, 50), p95: percentile(samples, 95) };
}
console.log(`Procesadores que ve el contenedor: ${os.availableParallelism()}`);
console.log('conexiones consultas/s p50 por consulta p95 por consulta');
for (const connections of [1, 2, 4, 8, 16, 32, 64]) {
const result = await run(connections);
console.log(
`${String(connections).padStart(10)} ${result.perSecond.toFixed(0).padStart(11)} ${`${result.p50.toFixed(2)} ms`.padStart(16)} ${`${result.p95.toFixed(2)} ms`.padStart(16)}`,
);
}// Mide una o varias variantes de Qillqa con el mismo script de k6 y escribe
// una fila por variante: p50, p95, máximo, throughput, errores y el máximo de
// conexiones que el servicio tuvo abiertas en PostgreSQL durante la corrida.
//
// node tools/measure.ts baseline pool-10 single cache
// VUS=50 DURATION=15s node tools/measure.ts pool-2 pool-10 pool-50
//
// Cada variante corre en un proceso propio, recién levantado, y se detiene al
// terminar su medición.
import { spawn, type ChildProcess } from 'node:child_process';
import { mkdirSync, readFileSync } from 'node:fs';
import pg from 'pg';
const PORT = Number(process.env.MEASURE_PORT ?? 3601);
const BASE_URL = `http://localhost:${PORT}`;
const DATABASE = process.env.W06_DB ?? 'arq_w06';
// Las filas de la tabla de la semana. Cada una cambia una sola cosa respecto
// de alguna anterior.
const VARIANTS: Record<string, { label: string; env: Record<string, string> }> = {
baseline: { label: 'Sin pool, N+1 (línea de base)', env: { DB_MODE: 'connect', LIST_MODE: 'nplus1' } },
'pool-2': { label: 'Pool de 2, N+1', env: { DB_MODE: 'pool', POOL_SIZE: '2', LIST_MODE: 'nplus1' } },
'pool-5': { label: 'Pool de 5, N+1', env: { DB_MODE: 'pool', POOL_SIZE: '5', LIST_MODE: 'nplus1' } },
'pool-10': { label: 'Pool de 10, N+1', env: { DB_MODE: 'pool', POOL_SIZE: '10', LIST_MODE: 'nplus1' } },
'pool-20': { label: 'Pool de 20, N+1', env: { DB_MODE: 'pool', POOL_SIZE: '20', LIST_MODE: 'nplus1' } },
'pool-50': { label: 'Pool de 50, N+1', env: { DB_MODE: 'pool', POOL_SIZE: '50', LIST_MODE: 'nplus1' } },
'pool-90': { label: 'Pool de 90, N+1', env: { DB_MODE: 'pool', POOL_SIZE: '90', LIST_MODE: 'nplus1' } },
'single-nopool': { label: 'Sin pool, una consulta', env: { DB_MODE: 'connect', LIST_MODE: 'single' } },
single: { label: 'Pool de 10, una consulta', env: { DB_MODE: 'pool', POOL_SIZE: '10', LIST_MODE: 'single' } },
'cache-nplus1': {
label: 'Sin pool, N+1, cache de 5 s',
env: { DB_MODE: 'connect', LIST_MODE: 'nplus1', CACHE: 'redis', CACHE_ON_ERROR: 'degrade' },
},
cache: {
label: 'Pool de 10, una consulta, cache de 5 s',
env: { DB_MODE: 'pool', POOL_SIZE: '10', LIST_MODE: 'single', CACHE: 'redis', CACHE_ON_ERROR: 'degrade' },
},
};
type Row = { label: string; p50: number; p95: number; max: number; rps: number; failed: number; peak: number; queries: number };
async function waitForHealth(): Promise<void> {
for (let attempt = 0; attempt < 100; attempt += 1) {
try {
const response = await fetch(`${BASE_URL}/health`);
if (response.ok) return;
} catch {
// Todavía no escucha.
}
await new Promise((resolve) => setTimeout(resolve, 100));
}
throw new Error('El servicio no respondió en /health');
}
function waitForExit(child: ChildProcess): Promise<number | null> {
return new Promise((resolve) => child.once('exit', (code) => resolve(code)));
}
async function measure(name: string, monitor: pg.Client): Promise<Row> {
const variant = VARIANTS[name];
if (!variant) throw new Error(`No existe la variante "${name}". Variantes: ${Object.keys(VARIANTS).join(', ')}`);
const server = spawn('node', ['src/main.ts'], {
env: { ...process.env, ...variant.env, PORT: String(PORT), W06_LOG: 'off' },
stdio: 'inherit',
});
try {
await waitForHealth();
// Mientras k6 corre, se mira cada 100 ms cuántas conexiones tiene el servicio.
let peak = 0;
let sampling = true;
const sampler = (async () => {
while (sampling) {
const result = await monitor.query<{ n: number }>(
`SELECT count(*)::int AS n FROM pg_stat_activity WHERE application_name = 'qillqa'`,
);
peak = Math.max(peak, result.rows[0]?.n ?? 0);
await new Promise((resolve) => setTimeout(resolve, 100));
}
})();
const summaryFile = `build/summary-${name}.json`;
const k6 = spawn('k6', ['run', '--quiet', '--summary-export', summaryFile, 'load/titles.js'], {
env: { ...process.env, BASE_URL },
stdio: ['ignore', 'ignore', 'inherit'],
});
await waitForExit(k6);
sampling = false;
await sampler;
const stats = (await (await fetch(`${BASE_URL}/stats`)).json()) as { db: { queries: number } };
const summary = JSON.parse(readFileSync(summaryFile, 'utf8')) as {
metrics: {
http_req_duration: { med: number; 'p(95)': number; max: number };
http_reqs: { count: number; rate: number };
http_req_failed: { value: number };
};
};
const metrics = summary.metrics;
return {
label: variant.label,
p50: metrics.http_req_duration.med,
p95: metrics.http_req_duration['p(95)'],
max: metrics.http_req_duration.max,
rps: metrics.http_reqs.rate,
failed: metrics.http_req_failed.value,
peak,
queries: stats.db.queries / metrics.http_reqs.count,
};
} finally {
server.kill('SIGTERM');
await waitForExit(server);
}
}
function format(row: Row): string {
const ms = (value: number) => `${value.toFixed(1)} ms`.padStart(10);
return [
row.label.padEnd(40),
ms(row.p50),
ms(row.p95),
ms(row.max),
`${row.rps.toFixed(0)}/s`.padStart(8),
`${(row.failed * 100).toFixed(2)} %`.padStart(9),
String(row.peak).padStart(10),
row.queries.toFixed(1).padStart(9),
].join(' ');
}
const names = process.argv.slice(2);
if (names.length === 0) {
console.error(`Uso: node tools/measure.ts <variante>...\nVariantes: ${Object.keys(VARIANTS).join(', ')}`);
process.exit(2);
}
mkdirSync('build', { recursive: true });
const monitor = new pg.Client({ database: DATABASE, application_name: 'measure' });
await monitor.connect();
try {
console.log(`k6: ${process.env.VUS ?? 50} usuarios virtuales durante ${process.env.DURATION ?? '15s'}, GET /titles`);
console.log(
[
'variante'.padEnd(40),
'p50'.padStart(10),
'p95'.padStart(10),
'máx'.padStart(10),
'pedidos'.padStart(8),
'errores'.padStart(9),
'conexiones'.padStart(10),
'consultas'.padStart(9),
].join(' '),
);
for (const name of names) {
console.log(format(await measure(name, monitor)));
}
console.log('conexiones: el máximo que el servicio tuvo abiertas a la vez en PostgreSQL');
console.log('consultas: consultas a PostgreSQL por pedido HTTP, en promedio');
} finally {
await monitor.end();
}#!/usr/bin/env bash
# ¿Qué ve quien consulta la lista justo después de un préstamo? Levanta Qillqa
# con cache (TTL de CACHE_TTL_S segundos, 5 por omisión), presta un ejemplar
# del título 1 y mira la lista y el detalle cada segundo. La lista sale de la
# cache; el detalle, de la base de datos.
#
# make stale
set -u
export PORT=3602 W06_LOG=off DB_MODE=pool LIST_MODE=single CACHE=redis CACHE_TTL_S="${CACHE_TTL_S:-5}"
BASE_URL="http://localhost:$PORT"
redis-cli del w06:titles:* >/dev/null
node src/main.ts &
server=$!
trap 'kill $server 2>/dev/null; wait' EXIT
until curl -fs "$BASE_URL/health" >/dev/null 2>&1; do sleep 0.1; done
look() { # look <etiqueta>
local headers list detail
headers=$(mktemp)
list=$(curl -s -D "$headers" "$BASE_URL/titles" | jq '.titles[] | select(.id == 1) | .availableCopies')
detail=$(curl -s "$BASE_URL/titles/1" | jq '.title.availableCopies')
printf '%-22s lista: %s (x-cache: %s) detalle: %s\n' "$1" "$list" \
"$(grep -i '^x-cache' "$headers" | tr -d '\r' | cut -d' ' -f2)" "$detail"
rm -f "$headers"
}
look "antes del préstamo"
curl -s -X POST "$BASE_URL/titles/1/loans" ; echo
for second in $(seq 0 $((CACHE_TTL_S + 1))); do
look "$second s después"
sleep 1
done// Percentil por rango más cercano, como en la semana 2: el menor valor que
// tiene por debajo o igual al menos el p % de las muestras.
export function percentile(values: number[], p: number): number {
if (values.length === 0) throw new Error('No hay muestras');
const sorted = [...values].sort((a, b) => a - b);
const rank = Math.max(1, Math.ceil((p / 100) * sorted.length));
return sorted[rank - 1]!;
}Errores
Ejemplos con errores a propósito: no compilan, fallan o dan un resultado incorrecto. Los apuntes explican cada uno.
import type { Db } from '../src/db.ts';
// Un intento de quitar el N+1 que parece correcto y no devuelve lo mismo: el
// JOIN con copies y el filtro en el WHERE descartan los títulos que no tienen
// ningún ejemplar disponible. La lista sale más corta, sin error ninguno.
// La prueba de equivalencia (test/equivalence.test.ts) lo detecta.
export async function listTitlesInnerJoin(db: Db): Promise<{ id: number; availableCopies: number }[]> {
const rows = await db.query<{ id: number; available: number }>(
`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
ORDER BY t.name, t.id`,
);
return rows.map((row) => ({ id: row.id, availableCopies: row.available }));
}// El cliente de Redis con su configuración por omisión guarda en una cola los
// comandos que se envían mientras Redis está caído, y los manda cuando vuelve.
// Para un pedido HTTP eso significa quedarse esperando: ni error ni respuesta.
// Este programa mata Redis, envía un GET y mira qué pasa, con la cola y sin ella.
//
// make offline-queue
import { execFile } from 'node:child_process';
import { promisify } from 'node:util';
import { createClient } from 'redis';
const run = promisify(execFile);
const WAIT_MS = 2000;
async function attempt(label: string, disableOfflineQueue: boolean): Promise<void> {
const client = createClient({ url: process.env.REDIS_URL ?? 'redis://127.0.0.1:6379', disableOfflineQueue });
client.on('error', () => {});
await client.connect();
await run('svc', ['kill', 'redis']);
// Se le da un momento al cliente para notar que la conexión se cerró.
await new Promise((resolve) => setTimeout(resolve, 200));
const start = performance.now();
const elapsed = () => `${(performance.now() - start).toFixed(0)} ms`;
const get = client.get('w06:offline-queue').then(
(value) => `respondió ${JSON.stringify(value)} a los ${elapsed()}`,
(error: Error) => `falló a los ${elapsed()}: ${error.message}`,
);
const pendingNote = `sigue pendiente después de ${WAIT_MS} ms`;
const first = await Promise.race([
get,
new Promise<string>((resolve) => setTimeout(() => resolve(pendingNote), WAIT_MS)),
]);
console.log(`${label}\n con Redis caído, el GET ${first}`);
await run('svc', ['start', 'redis']);
if (first === pendingNote) console.log(` con Redis de vuelta, ese mismo GET ${await get}`);
// El cliente se reconecta solo; un GET nuevo vuelve a funcionar.
while (!client.isReady) await new Promise((resolve) => setTimeout(resolve, 50));
console.log(` un GET nuevo, ya reconectado, respondió ${JSON.stringify(await client.get('w06:offline-queue'))}`);
client.destroy();
}
await attempt('Por omisión (con cola):', false);
await attempt('Con disableOfflineQueue:', true);// Validar la entrada es una táctica para resistir ataques. Este programa
// busca los títulos de una ciudad de dos maneras: armando el SQL con el texto
// que llega de afuera, y con una consulta parametrizada. Con una ciudad de
// verdad dan lo mismo. Con un texto escrito por un atacante, no.
//
// make sql-concat
import pg from 'pg';
const client = new pg.Client({ database: process.env.W06_DB ?? 'arq_w06' });
type Row = { name: string; author: string };
// MAL: el texto de quien llama pasa a ser parte de la consulta.
export async function titlesByCityConcat(db: pg.Client, city: string): Promise<Row[]> {
const result = await db.query<Row>(
`SELECT t.name, t.author FROM titles t JOIN branches b ON b.id = t.branch_id WHERE b.city = '${city}' ORDER BY 1`,
);
return result.rows;
}
// BIEN: la consulta es fija y el texto viaja aparte, como un dato.
export async function titlesByCity(db: pg.Client, city: string): Promise<Row[]> {
const result = await db.query<Row>(
`SELECT t.name, t.author FROM titles t JOIN branches b ON b.id = t.branch_id WHERE b.city = $1 ORDER BY 1`,
[city],
);
return result.rows;
}
export const ATTACKS = {
everything: `x' OR '1'='1`,
otherTable: `x' UNION SELECT rolname, 'superusuario: ' || rolsuper FROM pg_roles WHERE rolcanlogin --`,
};
if (import.meta.main) {
await client.connect();
try {
for (const [label, city] of [
['una ciudad', 'Cusco'],
['todo el catálogo', ATTACKS.everything],
['otra tabla', ATTACKS.otherTable],
] as const) {
const concat = await titlesByCityConcat(client, city);
const safe = await titlesByCity(client, city);
console.log(`city = ${city}`);
console.log(` concatenando: ${concat.length} filas; la primera: ${JSON.stringify(concat[0])}`);
console.log(` con parámetro: ${safe.length} filas (${label})`);
}
} finally {
await client.end();
}
}Pruebas
Comprueban lo que afirman los apuntes; se ejecutan con make test.
import assert from 'node:assert/strict';
import { after, before, test } from 'node:test';
import { createClient } from 'redis';
import type { TitleSummary } from '../src/titles.ts';
import { eventually, get, post, start, type Running } from './helpers.ts';
// Lo que el capítulo afirma de la cache: ahorra las consultas, y a cambio
// puede devolver un dato viejo durante el TTL.
const PREFIX = 'w06test:cache:';
const redis = createClient({ url: 'redis://127.0.0.1:6379' });
before(async () => {
await redis.connect();
});
after(async () => {
redis.destroy();
});
async function clear(): Promise<void> {
const keys = await redis.keys(`${PREFIX}*`);
if (keys.length > 0) await redis.del(keys);
}
function copiesOf(text: string, titleId: number): number {
const { titles } = JSON.parse(text) as { titles: TitleSummary[] };
return titles.find((title) => title.id === titleId)!.availableCopies;
}
async function withCache(ttl: number, fn: (running: Running) => Promise<void>): Promise<void> {
await clear();
const running = await start({ db: 'pool', list: 'single', cache: 'redis', cacheTtlSeconds: ttl, keyPrefix: PREFIX });
try {
await fn(running);
} finally {
await running.app.close();
}
}
test('el primer pedido calcula y guarda (miss); el segundo sale de Redis (hit) sin tocar la base de datos', async () => {
await withCache(30, async (running) => {
const first = await get(running, '/titles');
assert.equal(first.cache, 'miss');
const queriesAfterFirst = running.app.db.counters.queries;
assert.equal(queriesAfterFirst, 1);
const second = await get(running, '/titles');
assert.equal(second.cache, 'hit');
assert.equal(second.text, first.text);
assert.equal(running.app.db.counters.queries, queriesAfterFirst);
const ttl = await redis.ttl(`${PREFIX}titles:*`);
assert.ok(ttl > 0 && ttl <= 30, `la clave vence sola: TTL ${ttl}`);
});
});
test('cada filtro tiene su entrada: la lista de Cusco no sale de la entrada de la lista completa', async () => {
await withCache(30, async (running) => {
await get(running, '/titles');
const cusco = await get(running, '/titles?city=Cusco');
assert.equal(cusco.cache, 'miss');
assert.equal((JSON.parse(cusco.text) as { titles: unknown[] }).titles.length, 6);
assert.deepEqual((await redis.keys(`${PREFIX}*`)).sort(), [`${PREFIX}titles:*`, `${PREFIX}titles:Cusco`]);
});
});
test('después de un préstamo, la lista en cache sigue mostrando el número viejo hasta que vence el TTL', async () => {
await withCache(1, async (running) => {
const before = copiesOf((await get(running, '/titles')).text, 2);
// Si el pedido cae justo cuando la entrada venció, se repite el experimento.
let stale: number | undefined;
for (let attempt = 0; attempt < 5 && stale === undefined; attempt += 1) {
await get(running, '/titles');
const current = copiesOf((await get(running, '/titles')).text, 2);
assert.equal((await post(running, '/titles/2/loans')).status, 201);
const list = await get(running, '/titles');
if (list.cache === 'hit') {
stale = copiesOf(list.text, 2);
assert.equal(stale, current, 'la cache devuelve el número de antes del préstamo');
// El detalle no pasa por la cache: ya muestra uno menos.
const detail = JSON.parse((await get(running, '/titles/2')).text) as { title: TitleSummary };
assert.equal(detail.title.availableCopies, current - 1);
}
}
assert.notEqual(stale, undefined, 'se observó al menos una lectura vieja');
// Nadie invalida: el dato nuevo aparece cuando la entrada vence.
const fresh = await eventually(async () => {
const list = await get(running, '/titles');
const detail = JSON.parse((await get(running, '/titles/2')).text) as { title: TitleSummary };
return copiesOf(list.text, 2) === detail.title.availableCopies;
});
assert.ok(fresh, 'la lista alcanza al detalle después del TTL');
assert.ok(copiesOf((await get(running, '/titles')).text, 2) < before);
});
});import assert from 'node:assert/strict';
import { after, before, test } from 'node:test';
import { listTitlesInnerJoin } from '../errors/list-inner-join.ts';
import type { TitleSummary } from '../src/titles.ts';
import type { Variant } from '../src/variant.ts';
import { get, start, type Running } from './helpers.ts';
// Una táctica de rendimiento no cambia lo que el sistema responde. Estas
// pruebas levantan todas las variantes a la vez y comparan sus respuestas.
const VARIANTS: Record<string, Partial<Variant>> = {
'sin pool, N+1': { db: 'connect', list: 'nplus1' },
'sin pool, una consulta': { db: 'connect', list: 'single' },
'pool de 2, N+1': { db: 'pool', poolSize: 2, list: 'nplus1' },
'pool de 10, N+1': { db: 'pool', poolSize: 10, list: 'nplus1' },
'pool de 50, una consulta': { db: 'pool', poolSize: 50, list: 'single' },
'pool de 10, una consulta, cache': { db: 'pool', list: 'single', cache: 'redis', onCacheError: 'degrade' },
'sin pool, N+1, cache': { db: 'connect', list: 'nplus1', cache: 'redis', onCacheError: 'fail' },
};
const running = new Map<string, Running>();
before(async () => {
for (const [name, overrides] of Object.entries(VARIANTS)) {
// Cada variante con cache usa sus propias claves, para que ninguna lea lo que guardó otra.
running.set(name, await start({ ...overrides, keyPrefix: `w06test:eq:${running.size}:` }));
}
});
after(async () => {
for (const instance of running.values()) await instance.app.close();
});
for (const path of ['/titles', '/titles?city=Cusco', '/titles?city=Lima', '/titles?city=Puno', '/titles/7']) {
test(`todas las variantes responden lo mismo a GET ${path}`, async () => {
const reference = await get(running.get('sin pool, N+1')!, path);
assert.equal(reference.status, 200);
for (const [name, instance] of running) {
// Dos veces: con cache, la primera respuesta se calcula y la segunda sale de Redis.
for (const attempt of ['primera', 'segunda']) {
const reply = await get(instance, path);
assert.equal(reply.status, 200, `${name}, ${attempt} vez`);
assert.equal(reply.text, reference.text, `${name}, ${attempt} vez`);
}
}
});
}
test('la lista tiene los 31 títulos, también el que no tiene ejemplares', async () => {
for (const name of ['sin pool, N+1', 'pool de 50, una consulta']) {
const { titles } = JSON.parse((await get(running.get(name)!, '/titles')).text) as { titles: TitleSummary[] };
assert.equal(titles.length, 31, name);
assert.equal(titles.find((title) => title.id === 31)?.availableCopies, 0, name);
}
const puno = JSON.parse((await get(running.get('sin pool, N+1')!, '/titles?city=Puno')).text);
assert.deepEqual(puno, { titles: [] });
});
test('N+1 hace 32 consultas por pedido (1 + 31 títulos) y la versión de una consulta hace 1', async () => {
for (const [name, expected] of [
['pool de 10, N+1', 32],
['pool de 50, una consulta', 1],
] as const) {
const instance = running.get(name)!;
const before = instance.app.db.counters.queries;
await get(instance, '/titles');
assert.equal(instance.app.db.counters.queries - before, expected, name);
}
});
test('errors/list-inner-join.ts no es equivalente: pierde el título sin ejemplares', async () => {
const instance = running.get('pool de 10, N+1')!;
const wrong = await listTitlesInnerJoin(instance.app.db);
assert.equal(wrong.length, 30);
assert.equal(wrong.find((title) => title.id === 31), undefined);
});import { createApp, type App } from '../src/app.ts';
import { baseline, type Variant } from '../src/variant.ts';
// Las pruebas usan su propia base de datos y su propio prefijo de Redis
// (make test los pasa por el entorno).
export const TEST_DB = process.env.W06_DB ?? 'arq_w06_test';
export const TEST_PREFIX = process.env.W06_PREFIX ?? 'w06test:';
export function variant(overrides: Partial<Variant> = {}): Variant {
return { ...baseline, database: TEST_DB, keyPrefix: TEST_PREFIX, ...overrides };
}
export type Running = { app: App; url: string };
export async function start(overrides: Partial<Variant> = {}): Promise<Running> {
const app = createApp(variant(overrides));
return { app, url: await app.listen(0) };
}
export type Reply = { status: number; cache: string | null; text: string };
export async function get(running: Running, path: string): Promise<Reply> {
const response = await fetch(`${running.url}${path}`);
return { status: response.status, cache: response.headers.get('x-cache'), text: await response.text() };
}
export async function post(running: Running, path: string): Promise<Reply> {
const response = await fetch(`${running.url}${path}`, { method: 'POST' });
return { status: response.status, cache: response.headers.get('x-cache'), text: await response.text() };
}
/** Repite `check` hasta que devuelva true o pase el plazo. */
export async function eventually(check: () => Promise<boolean>, timeoutMs = 8000): Promise<boolean> {
const deadline = Date.now() + timeoutMs;
while (Date.now() < deadline) {
if (await check()) return true;
await new Promise((resolve) => setTimeout(resolve, 50));
}
return false;
}import assert from 'node:assert/strict';
import { test } from 'node:test';
import pg from 'pg';
import { get, start, TEST_DB } from './helpers.ts';
// Lo que el capítulo afirma del pool: reutiliza las conexiones y pone un tope.
test('sin pool, cada consulta abre una conexión: un pedido a GET /titles abre 32', async () => {
const running = await start({ db: 'connect', list: 'nplus1' });
try {
await get(running, '/titles');
assert.deepEqual(running.app.db.counters, { queries: 32, connectionsOpened: 32 });
} finally {
await running.app.close();
}
});
test('con un pool de 2, 40 pedidos a la vez se atienden con 2 conexiones y PostgreSQL nunca ve más', async () => {
const running = await start({ db: 'pool', poolSize: 2, list: 'nplus1' });
const monitor = new pg.Client({ database: TEST_DB, application_name: 'pool-test' });
await monitor.connect();
try {
let peak = 0;
let sampling = true;
const sampler = (async () => {
while (sampling) {
const result = await monitor.query<{ n: number }>(
`SELECT count(*)::int AS n FROM pg_stat_activity WHERE application_name = 'qillqa' AND datname = $1`,
[TEST_DB],
);
peak = Math.max(peak, result.rows[0]!.n);
}
})();
const replies = await Promise.all(Array.from({ length: 40 }, () => get(running, '/titles')));
sampling = false;
await sampler;
assert.ok(replies.every((reply) => reply.status === 200));
assert.equal(new Set(replies.map((reply) => reply.text)).size, 1, 'todas las respuestas son iguales');
assert.equal(running.app.db.counters.queries, 40 * 32);
assert.equal(running.app.db.counters.connectionsOpened, 2);
assert.equal(peak, 2);
} finally {
await monitor.end();
await running.app.close();
}
});
test('el pool cierra sus conexiones al cerrar el servicio', async () => {
const running = await start({ db: 'pool', poolSize: 5, list: 'single' });
await Promise.all(Array.from({ length: 10 }, () => get(running, '/titles')));
await running.app.close();
const monitor = new pg.Client({ database: TEST_DB, application_name: 'pool-test' });
await monitor.connect();
try {
const result = await monitor.query<{ n: number }>(
`SELECT count(*)::int AS n FROM pg_stat_activity WHERE application_name = 'qillqa' AND datname = $1`,
[TEST_DB],
);
assert.equal(result.rows[0]!.n, 0);
} finally {
await monitor.end();
}
});import assert from 'node:assert/strict';
import { execFile } from 'node:child_process';
import { after, test } from 'node:test';
import { promisify } from 'node:util';
import { eventually, get, start } from './helpers.ts';
// Disponibilidad: qué le pasa a GET /titles cuando Redis se cae. La prueba
// mata Redis de verdad (svc kill redis) y lo vuelve a iniciar.
const run = promisify(execFile);
after(async () => {
// Si algo falló a la mitad, Redis no se queda caído.
await run('svc', ['start', 'redis']);
});
test('con Redis caído, degrade responde desde la base de datos y fail responde 500; al volver Redis, la cache vuelve', async () => {
const reference = await start({ db: 'pool', list: 'single', cache: 'off' });
const cached = { db: 'pool', list: 'single', cache: 'redis', keyPrefix: 'w06test:down:' } as const;
const degrade = await start({ ...cached, onCacheError: 'degrade' });
const fail = await start({ ...cached, onCacheError: 'fail' });
try {
const expected = await get(reference, '/titles');
// Con Redis arriba, las dos variantes usan la cache.
assert.ok(await eventually(async () => (await get(degrade, '/titles')).cache === 'hit'));
assert.ok(await eventually(async () => (await get(fail, '/titles')).cache === 'hit'));
await run('svc', ['kill', 'redis']);
// degrade: 200, el mismo cuerpo, y la respuesta salió de la base de datos.
assert.ok(await eventually(async () => (await get(degrade, '/titles')).cache === 'bypass'));
const queriesBefore = degrade.app.db.counters.queries;
const degraded = await get(degrade, '/titles');
assert.equal(degraded.status, 200);
assert.equal(degraded.cache, 'bypass');
assert.equal(degraded.text, expected.text);
assert.equal(degrade.app.db.counters.queries, queriesBefore + 1);
// fail: el mismo pedido es un 500, aunque la base de datos está sana.
assert.ok(await eventually(async () => (await get(fail, '/titles')).status === 500));
const failed = await get(fail, '/titles');
assert.equal(failed.status, 500);
assert.match(failed.text, /La cache no responde/);
// Lo que no pasa por la cache sigue respondiendo en las dos.
assert.equal((await get(fail, '/titles/7')).status, 200);
await run('svc', ['start', 'redis']);
// Los clientes se reconectan solos: vuelve a haber hit en las dos.
assert.ok(await eventually(async () => (await get(degrade, '/titles')).cache === 'hit'), 'degrade vuelve a usar la cache');
assert.ok(await eventually(async () => (await get(fail, '/titles')).cache === 'hit'), 'fail vuelve a responder');
assert.equal((await get(fail, '/titles')).text, expected.text);
assert.ok(degrade.app.cache!.counters.bypasses > 0);
assert.ok(fail.app.cache!.counters.failures > 0);
} finally {
await reference.app.close();
await degrade.app.close();
await fail.app.close();
}
});import assert from 'node:assert/strict';
import { execFile } from 'node:child_process';
import { test } from 'node:test';
import { promisify } from 'node:util';
import pg from 'pg';
import { ATTACKS, titlesByCity, titlesByCityConcat } from '../errors/sql-concat.ts';
import { percentile } from '../tools/stats.ts';
import { TEST_DB } from './helpers.ts';
const run = promisify(execFile);
test('una consulta armada concatenando texto devuelve lo que el atacante quiera; la parametrizada, nada', async () => {
const client = new pg.Client({ database: TEST_DB });
await client.connect();
try {
assert.equal((await titlesByCityConcat(client, 'Cusco')).length, 6);
assert.equal((await titlesByCity(client, 'Cusco')).length, 6);
assert.equal((await titlesByCityConcat(client, ATTACKS.everything)).length, 31);
assert.equal((await titlesByCity(client, ATTACKS.everything)).length, 0);
const leaked = await titlesByCityConcat(client, ATTACKS.otherTable);
assert.ok(leaked.some((row) => row.name === 'postgres'), 'la consulta leyó pg_roles');
assert.equal((await titlesByCity(client, ATTACKS.otherTable)).length, 0);
} finally {
await client.end();
}
});
test('mínimo privilegio: el rol de reportes puede leer y no puede modificar ni borrar', async () => {
const { stdout, stderr } = await run('psql', ['-X', '-d', TEST_DB, '-f', 'security/least-privilege.sql']);
const output = stdout + stderr;
assert.match(output, /prestados/);
assert.match(output, /permission denied for table copies/);
assert.match(output, /must be owner of table copies/);
assert.match(output, /permission denied for table pg_authid/);
// El intento de UPDATE no cambió nada.
const client = new pg.Client({ database: TEST_DB });
await client.connect();
try {
const result = await client.query<{ n: number }>(`SELECT count(*)::int AS n FROM copies WHERE status = 'loaned'`);
assert.ok(result.rows[0]!.n > 0);
} finally {
await client.end();
}
});
test('percentil por rango más cercano', () => {
const samples = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100];
assert.equal(percentile(samples, 50), 50);
assert.equal(percentile(samples, 95), 100);
assert.equal(percentile([7], 99), 7);
});Compilación
Cómo se compilan y ejecutan los ejemplos.
# Semana 6: tácticas. Un servicio pequeño, Qillqa (el catálogo de una red de
# bibliotecas), con variantes que se eligen por variables de entorno, para
# medir cada táctica antes y después. Se usa dentro del contenedor del curso.
#
# make crea la base de datos arq_w06 con sus datos de ejemplo
# make test revisa los tipos (tsc) y corre las pruebas (test/*.test.ts)
# make serve levanta Qillqa en http://localhost:3600 con la variante
# que digan las variables (ver abajo)
# make load k6 contra el Qillqa de make serve: 50 usuarios, 15 s
# make endpoints k6 con las métricas separadas por endpoint
# make connections cuántas conexiones tiene PostgreSQL, cada segundo
# make measure V="baseline pool-10" levanta cada variante, la mide y escribe
# una fila por variante (no necesita make serve)
# make table las filas de la tabla de la semana (unos 2 min)
# make curve el p95 según el tamaño del pool (2, 5, 10, 20, 50 y 90), con
# 200 usuarios virtuales: más de los que PostgreSQL acepta
# make connect-cost cuánto cuesta abrir una conexión, comparado con una consulta
# make db-curve consultas en paralelo directo a PostgreSQL: 1, 2, 4 ... 64
# make stale presta un ejemplar y mira la lista durante el TTL
# make cache-down mata Redis con carga corriendo: fallar y degradar
# make offline-queue el cliente de Redis con su configuración por omisión
# make sql-concat una consulta armada concatenando texto, y su ataque
# make privilege mínimo privilegio con roles de PostgreSQL
# make tinkuy-up copia Tinkuy en build/tinkuy y lo levanta con su pasarela
# make tinkuy-endpoints k6 por endpoint contra ese Tinkuy (paso 2 del laboratorio)
# make tinkuy-explain EXPLAIN ANALYZE de la consulta de disponibilidad de Tinkuy
# make tinkuy-down detiene Tinkuy y la pasarela
# make clean borra la base de datos, las claves w06:* de Redis y build/
#
# Variables de make serve (y de node src/main.ts):
# DB_MODE=connect|pool una conexión por consulta, o un pool (connect)
# POOL_SIZE=10 tamaño del pool
# LIST_MODE=nplus1|single una consulta por título, o una sola (nplus1)
# CACHE=off|redis cache de GET /titles en Redis (off)
# CACHE_TTL_S=5 cuánto vale una entrada de la cache
# CACHE_ON_ERROR=fail|degrade si Redis no responde: error, o base de datos (fail)
#
# Variables de las mediciones: VUS=50 DURATION=15s (make curve usa VUS=200)
#
# Nada de esto modifica el Tinkuy del curso (../../tinkuy).
TINKUY ?= ../../tinkuy
V ?= baseline
DB = arq_w06
# psql no avisa cuando la base de datos que se va a borrar todavía no existe.
PGOPTIONS = --client-min-messages=warning
export PGOPTIONS
.PHONY: all db test serve load endpoints connections measure table curve connect-cost db-curve \
stale cache-down offline-queue sql-concat privilege \
tinkuy-up tinkuy-endpoints tinkuy-explain tinkuy-down clean
all: db
db:
@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB) WITH (FORCE)" -c "CREATE DATABASE $(DB)"
@psql -q -d $(DB) -v ON_ERROR_STOP=1 -f db/schema.sql -f db/seed.sql
@psql -At -d $(DB) -c "SELECT format('Base de datos $(DB): %s sedes, %s títulos, %s ejemplares (%s disponibles)', \
(SELECT count(*) FROM branches), (SELECT count(*) FROM titles), count(*), \
count(*) FILTER (WHERE status = 'available')) FROM copies"
# Las pruebas usan su propia base de datos y sus propias claves de Redis, y
# levantan las variantes dentro del proceso de pruebas: no necesitan nada
# corriendo. La última mata Redis y lo vuelve a iniciar.
test:
tsc -p .
@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB)_test WITH (FORCE)" -c "CREATE DATABASE $(DB)_test"
@psql -q -d $(DB)_test -v ON_ERROR_STOP=1 -f db/schema.sql -f db/seed.sql
@svc start redis
W06_DB=$(DB)_test W06_PREFIX=w06test: node --test --test-concurrency=1 "test/*.test.ts"
serve:
node src/main.ts
load:
k6 run --quiet load/titles.js
endpoints:
k6 run --quiet load/endpoints.js
connections:
@while true; do \
psql -At -d postgres -c "SELECT to_char(now(), 'HH24:MI:SS') || ' conexiones: ' || count(*) || ' (activas: ' || count(*) FILTER (WHERE state = 'active') || ')' FROM pg_stat_activity WHERE backend_type = 'client backend' AND pid <> pg_backend_pid()"; \
sleep 1; \
done
measure:
@node tools/measure.ts $(V)
table:
@node tools/measure.ts baseline pool-10 single-nopool single cache-nplus1 cache
curve:
@VUS=$${VUS:-200} node tools/measure.ts baseline pool-2 pool-5 pool-10 pool-20 pool-50 pool-90
connect-cost:
@node tools/connect-cost.ts
db-curve:
@node tools/db-curve.ts
stale:
@bash tools/stale.sh
cache-down:
@bash tools/cache-down.sh
offline-queue:
@node errors/redis-offline-queue.ts
sql-concat:
@node errors/sql-concat.ts
privilege:
@psql -X -d $(DB) -f security/least-privilege.sql 2>&1
build/tinkuy:
mkdir -p build
cp -r $(TINKUY) $@
tinkuy-up: build/tinkuy
$(MAKE) --no-print-directory -C build/tinkuy db
@cd build/tinkuy && (node tools/fake-gateway.ts > ../gateway.log 2>&1 & echo $$! > ../gateway.pid)
@cd build/tinkuy && (node src/main.ts > ../tinkuy.log 2>&1 & echo $$! > ../tinkuy.pid)
@sleep 1
@curl -s http://localhost:3000/health ; echo
tinkuy-endpoints:
TARGET=tinkuy k6 run --quiet load/endpoints.js
tinkuy-explain:
psql -d tinkuy -c "EXPLAIN (ANALYZE, BUFFERS OFF) SELECT count(*)::int AS available FROM seats WHERE event_id = 1 AND status = 'available'"
tinkuy-down:
@-kill `cat build/tinkuy.pid build/gateway.pid 2>/dev/null` 2>/dev/null ; rm -f build/tinkuy.pid build/gateway.pid
clean: tinkuy-down
@psql -q -d postgres -c "DROP DATABASE IF EXISTS $(DB) WITH (FORCE)" -c "DROP DATABASE IF EXISTS $(DB)_test WITH (FORCE)" \
-c "DROP ROLE IF EXISTS w06_reports"
@-redis-cli --scan --pattern 'w06*' 2>/dev/null | xargs -r redis-cli del >/dev/null 2>&1
rm -rf build{
"private": true,
"type": "module"
}{
"compilerOptions": {
"target": "es2024",
"lib": ["es2024"],
"module": "nodenext",
"moduleResolution": "nodenext",
"types": ["node"],
"strict": true,
"noEmit": true,
"allowImportingTsExtensions": true,
"erasableSyntaxOnly": true,
"verbatimModuleSyntax": true,
"skipLibCheck": true
},
"include": ["src", "tools", "test", "errors"]
}