Persisted Queries Automáticas a Escala: 90.9% de Tasa de Aciertos, p95 12 ms, +125% de Rendimiento sobre un Schema GraphQL de 135 mil Líneas — $0 MXN al Mes de Gasto Externo
Autor: David Mireles Organización: LOUST.PRO — Plataforma CMS Empresarial Fecha: Marzo de 2026 (producción); julio de 2026 (revisión v2) Clasificación: Caso de Estudio Técnico — Ingeniería de Rendimiento y Sistemas Distribuidos Versión: 2.0
Este caso de estudio documenta el diseño, implementación y evolución 2026 de un sistema empresarial de Persisted Queries Automáticas (APQ) construido sobre Apollo Server v4 con Redis como backend de caché. El sistema corre contra un schema GraphQL de 135,504 líneas auto-generado a partir de un modelo Prisma de 707 entidades, que produce 2,089 tipos de query.
En producción: 90.9% de tasa de aciertos, 75% de reducción de payload, eliminación del 100% del costo de parse + validate para queries en caché, y +125% de rendimiento (200 → 450 req/s). El sistema incluye un auto-calentamiento de 5 fases que pre-cachéa 2,130 queries al arranque, auto-reparación vía Mapa de Trazas de Entidad, invalidación por hash de schema, y resiliencia con 3 capas de circuit breaker con detección de inundación APQ.
La revisión v2 de 2026 integra cuatro pasadas de endurecimiento que cambian materialmente el perfil de producción:
- Componentes de caché de Next.js 16 (directiva
'use cache'+cacheLife()/cacheTag()+revalidateTag()) reemplazan las llamadas previas por-request deunstable_cache. La combinación empuja la tasa de aciertos sostenida por encima del 90% incluso en rutas frías y elimina la brecha de deduplicación entrefindManyUser(take: 5)yfindManyUser(take: 10)(limitación #2 de §6.2 en v1). - Capa de IndexedDB + Service Worker en el navegador del cliente cachéa la respuesta GraphQL resuelta con clave
(operationName, hash de variables)para perfilescacheLife: 'hours'y'days', reduciendo las solicitudes con origen en el servidor en aproximadamente un 40% adicional encima de la capa APQ (§4.6). - Contadores atómicos Lua-EVAL en Redis (
HGETALL+HINCRBY+HSETen un único EVAL de 1 RTT) reemplazan el pipeline previo de 3 RTT, eliminando una clase de carreras TOCTOU en los contadores de circuit breaker por operación. - Runner de compilación auto-hospedado (
compile-runner) reemplaza GitHub-hosted Actions para el paso de introspección de schema, eliminando la dependencia en tiempo de construcción de los minutos de GitHub Actions que los pipelines de PR con schema de 50 GB+ habían alcanzado hacia el segundo trimestre de 2026.
Stack: Apollo Server v4, Redis 7, Prisma 6.x, Nginx (Brotli q11), componentes de caché de Next.js 16, scripts Lua EVAL en Redis, flota de runners auto-hospedados.
Problema de negocio: auto-generar el schema GraphQL desde Prisma produce sistemas con cientos de modelos y miles de operaciones. Cada solicitud incurre en costo determinista de parse + validate (3–13 ms) más ancho de banda desperdiciado al retransmitir cuerpos de query idénticos. APQ con auto-calentamiento elimina ambos costos.
Resultado: 90.9% de tasa de aciertos a escala, 75% de reducción de payload, latencia p95 de 12 ms (vs 25 ms sin APQ), +125% de rendimiento (200 → 450 req/s), $0 MXN al mes de gasto externo.
Un servidor no debería re-interpretar la misma intención del cliente miles de veces al día.
Todo cliente — un dashboard, un portal, una wiki, una app móvil — formula las mismas preguntas una y otra vez. La pregunta llega como texto; el servidor la traduce a un plan ejecutable; el plan produce una respuesta. La traducción es determinista: la misma pregunta produce siempre el mismo plan. Y sin embargo el servidor la repite en cada llegada: 15,230 veces al día en el tenant medido en este documento, y 38.9 millones de veces al día si la instancia sostiene su throughput nominal de 450 req/s durante 24 horas.
Esa repetición paga tres costos que no compran nada a cambio:
- CPU de traducción. Convertir el texto de una consulta en un plan ejecutable cuesta 3–13 ms contra un schema de 135 mil líneas. Es CPU que no resuelve nada: solo descifra lo que ya estaba descifrado.
- Ancho de banda. La consulta viaja en texto plano —254 B medidos— aunque el identificador que la nombra mide 64 B. Con 15,230 solicitudes/día la diferencia es 2.90 MB/día de texto idéntico (§4.4).
- Superficie de entrada arbitraria. Si el servidor acepta texto libre del cliente, cualquier cliente puede pedir trabajo ilimitado: la superficie de denegación de servicio coincide con la superficie de la API.
La arquitectura que documenta este caso elimina las tres con una sola decisión: la intención del cliente se nombra con un hash determinista, y el servidor conserva el artefacto compilado de esa intención. El texto deja de viajar por el cable y deja de interpretarse en cada llegada: se convierte en un identificador. Todo lo demás —auto-calentamiento, invalidación por hash de schema, circuit breaker por operación, capa cliente— es consecuencia de haber hecho esa primera sustituir.
La pregunta que un equipo de plataforma se hace antes de decidir si implementa esto es quantitative: con el mismo servidor, ¿cuántos clientes más sostengo?. Las constantes del caso salen de la medición de 30 días de §4.1, §4.3 y §4.4; el modelo de abajo las combina y declara sus supuestos.
Constantes medidas.
| Constante | Valor | Fuente |
|---|---|---|
| Costo de parse + validate por solicitud | 3–13 ms | §2.2, §4.1 |
| Tasa de acierto APQ | 90.9% | §4.1 |
| Throughput de la instancia sin APQ | 200 req/s | §4.1 |
| Throughput de la instancia con APQ | 450 req/s | §4.1 |
| Latencia del camino de acierto / de fallo | 2.1 ms / 7 ms | §4.3 |
| Cuerpo de consulta / identificador | 254 B / 64 B | §4.1 |
| Tráfico acumulado del tenant medido | 15,230 req/día | §4.4 |
Referencia del modelo. Para traducir req/s a usuarios concurrentes hace falta una tasa de solicitudes por usuario. Se usa una instancia de 4 vCPU como referencia de aritmética. Esto es una hipótesis declarada para el modelo, no una medición del hardware de producción: lo que sí es medición de este sistema es el throughput, la tasa de acierto y la latencia.
Paso 1 — Qué parte de la máquina se va en traducir. Con el punto medio del rango de parse + validate (6 ms):
| Escenario | req/s | CPU de traducción | % de los 4 vCPU |
|---|---|---|---|
| Sin APQ | 200 | 200 × 6 ms = 1.20 s/s = 1.20 cores | 30% |
| Con APQ, al mismo throughput | 200 | 200 × 0.091 × 6 ms = 0.11 s/s = 0.11 cores | 2.7% |
| Con APQ, al throughput real | 450 | 450 × 0.091 × 6 ms = 0.25 s/s = 0.25 cores | 6.1% |
Es decir: 1.09 de los 4 cores —el 27% de la instancia— dejaron de traducir texto y pasaron a resolver negocio. La diferencia restante entre el +30% de cores liberados y el +125% de throughput viene del camino completo: el acierto cuesta 2.1 ms contra 7 ms del fallo (§4.3), de modo que el servidor no solo economiza traducción, evita además resolución y serialización.
Paso 2 — Usuarios activos por instancia. "Usuario activo sostenido" se define por perfil de producto, no de forma abstracta:
| Perfil de producto | Solicitudes por usuario activo | Con APQ (450 req/s) | Sin APQ (200 req/s) | Ganancia |
|---|---|---|---|---|
| Dashboard SaaS B2B — 12 consultas al abrir, refresco cada 30 s | 2.0 /min | 13,500 | 6,000 | 2.25× |
| Portal corporativo con contenido y comentarios | 0.5 /min | 54,000 | 24,000 | 2.25× |
| Wiki interna con búsqueda y permisos por rol | 0.2 /min | 135,000 | 60,000 | 2.25× |
| Blog corporativo con CDN — origen medido post-caché | 0.05 /min | 540,000 | 240,000 | 2.25× |
Derivación de la primera fila: 450 req/s ÷ (2.0 req/min ÷ 60 s/min) = 450 ÷ 0.0333 = 13,500 usuarios activos concurrentes; con 200 req/s, 6,000. Las demás filas usan la misma fórmula. La ganancia es 2.25× en las cuatro filas porque el límite sigue siendo el req/s; lo que cambia entre perfiles es qué tan lejos está el origen del cuello de botella real — en las filas de wiki y blog, con CDN delante, el promedio importa menos que la capacidad de ráfaga.
Paso 3 — El eje que no es req/s: difusión y conexiones persistentes. Los productos con SSE o WebSocket no siguen la aritmética anterior: el límite pasa a ser descriptores de archivo y memoria por conexión. Ahí el mismo principio se traduce a otra forma —1 resolución + N lecturas de caché en lugar de N resoluciones:
| Escenario | Sin caché de respuesta | Con caché de respuesta |
|---|---|---|
| Panel en vivo: 1 evento → 10,000 suscriptores | 10,000 ejecuciones de resolver | 1 ejecución + 10,000 lecturas de ~0.1 ms |
| Notificación de precio → 10,000 carritos | 10,000 serializaciones | 1 serialización + 10,000 lecturas |
El costo por suscriptor cae del orden de 2–7 ms —el camino completo de §4.3— a ~0.1 ms por lectura de Redis: entre 20× y 70× menos CPU por suscriptor, independiente de la tasa de acierto de APQ. La condición es que exista un identificador determinista del evento que se pueda cachear; sin él, cada suscriptor paga la resolución completa.
Paso 4 — El eje temporal: arranque en frío. El tráfico de blog, wiki y e-commerce se dispara después de un despliegue, de una campaña o de un enlace viral. En ese instante la caché está vacía y cada solicitud paga traducción completa. El auto-calentamiento de 5 fases (§3.2) deja 2,130 queries pre-compiladas antes de aceptar tráfico, y el costo de arranque cold pasa de U × (3–13 ms + RTT) a U × 0.05 × (3–13 ms + RTT): un factor 20 en el peor caso de usuarios simultáneos tras el despliegue.
Lectura económica. Con la misma carga, el sistema necesita 2.25× menos instancias para sostener la misma latencia —9 nodos se vuelven 4— o, con el mismo número de nodos, 6,000 usuarios por instancia se vuelven 13,500. El gasto externo del sistema es de $0 MXN/mes porque todo el instrumental (Redis, runner de compilación, auto-calentamiento) corre sobre infraestructura propia: lo que se ahorra es CPU propia, no una factura de terceros.
El caso de este documento usa GraphQL porque el problema original venía de un CMS con schema auto-generado, pero el mecanismo no pertenece a GraphQL. Es un mecanismo de tres piezas:
- Identidad determinista de la intención. Un hash del texto de la consulta —o de la consulta normalizada junto con sus parámetros— produce un identificador estable que dos clientes que piden lo mismo comparten.
- Almacén del artefacto compilado. El documento parsed, el plan de ejecución o el statement preparado que corresponde a esa identidad.
- Almacén de la respuesta con ciclo de vida. La respuesta resuelta, con TTL, invalidación por cambio de esquema y política de expulsión declarada.
Cada stack tiene sus tres piezas con nombres distintos:
| Stack | Identidad de la intención | Artefacto compilado | Caché de respuesta |
|---|---|---|---|
| GraphQL + APQ | SHA-256 del texto de la query | Documento parsed + validado | Redis con TTL e invalidación por hash de schema |
| SQL sobre PostgreSQL | Texto SQL con parámetros | Plan del planner, con plan cache por backend | No hay caché de resultados nativa: es una capa de aplicación |
| SQL sobre SQLite | Texto SQL del statement | Statement preparado, persistente entre llamadas | No hay caché de resultados nativa: page cache + WAL |
| Supabase (PostgreSQL + PostgREST) | Ruta y parámetros firmados | Plan del planner + pool de PgBouncer | Plan cache del servidor + caché en el edge |
| REST sobre HTTP | ETag y Cache-Control |
No aplica | CDN y caché de respuesta del servidor |
| Componentes de caché de Next.js 16 | cacheTag y clave de ruta |
Segmento de caché compilado | cacheLife, con perfiles stale/revalidate/expire |
La equivalencia es uno a uno en costo y en riesgo:
- GraphQL paga parse + validate en cada solicitud porque el cliente manda texto. SQL paga parse + plan en cada solicitud solo si no usa statements preparados —que es el estado por defecto de muchos clientes HTTP que interpolan parámetros y de varios ORM en su camino sin cachear.
- GraphQL necesita invalidación por hash de schema porque el schema es código desplegado. SQL necesita invalidación por cambio de catálogo —una tabla de versión de migraciones, o el aviso de recarga de catálogo—: el mismo problema con otro disparador.
- GraphQL necesita una política de expulsión en Redis. SQL la tiene dentro del servidor —el page cache de SQLite, el CLOCK-sweep de
shared_buffersen PostgreSQL— y esa política es invisible hasta que se convierte en el problema.
La respuesta operativa a «no uso Apollo GraphQL, ¿cuál es el workaround?» es que no hace falta ninguno: no hace falta GraphQL, ni Apollo, ni Redis. Hacen falta un identificador determinista, un almacén y una política de ciclo de vida. Quien opera SQL clásico ya tiene las tres piezas en otra forma; lo que este caso añade es la disciplina de medirlas, de calentarlas al arranque y de declarar su política de expulsión. El desarrollo completo —el camino de PostgreSQL, SQLite y Supabase, la analogía de expulsión en cada capa, el comportamiento ante una inundación de claves nuevas y la aritmética de capacidad con conexiones persistentes— está en el Apéndice G.
GraphQL permite a los clientes solicitar exactamente los datos que necesitan. Esa flexibilidad tiene un costo en schemas grandes: cada solicitud debe incluir la cadena completa de la query en el cuerpo HTTP. Para schemas de este tamaño:
- Ancho de banda desperdiciado. Una query de listado típica con campos anidados ocupa 200–2,000 bytes. Ejecutada 1,000×/día, son 200 KB–2 MB de texto idéntico.
- CPU en parse + validate. Cada solicitud requiere que el servidor parsee la cadena de la query en un AST y la valide contra el schema. En un schema de 135 mil líneas esto consume 3–13 ms por solicitud.
- Superficie de denegación de servicio. Las queries arbitrarias permiten ataques de complejidad profundamente anidados que evaden los límites de velocidad por ruta.
El CMS de LOUST.PRO usa un schema GraphQL auto-generado a partir de Prisma:
| Métrica | Valor |
|---|---|
| Líneas de schema GraphQL | 135,504 |
| Modelos Prisma | 707 |
| Tipos de query (findMany, findFirst, count, findUnique) | 2,089 |
| Mutaciones (create, update, delete) | ~2,121 |
| Operaciones totales | ~4,210 |
| Tamaño de schema compilado | 3.1 MB |
- Reducir el ancho de banda para queries repetitivas en >70%
- Eliminar la sobrecarga de parse + validate para queries en caché
- Implementar auto-calentamiento que se adapte a cambios de schema con cero intervención manual
- Diseñar resiliencia contra fallas en cascada
- Mantener tasa de aciertos >80% en producción
APQ es un protocolo donde el cliente envía un hash SHA-256 de la query en lugar de la cadena completa. El handshake:
sequenceDiagram
autonumber
participant C as Cliente
participant S as Apollo Server
participant R as Redis
Note over C,R: Primera solicitud (cache miss)
C->>S: POST { extensions: { persistedQuery: { sha256Hash: "abc123" } } }
S->>R: HGET <prefix>:apq:query:abc123
R-->>S: nil
S-->>C: 200 { errors: [{ message: "PersistedQueryNotFound" }] }
C->>S: POST { query: "query { findManyUser { id name email } }",<br/>extensions: { persistedQuery: { sha256Hash: "abc123" } } }
S->>R: HSET <prefix>:apq:query:abc123 query="..." operationName="FindManyUser"
S->>S: parse+validate AST + ejecutar resolvers
S-->>C: 200 { data: { findManyUser: [...] } }
Note over C,R: Solicitudes posteriores (cache hit)
C->>S: POST { extensions: { persistedQuery: { sha256Hash: "abc123" } } }
S->>R: HGETALL <prefix>:apq:query:abc123
R-->>S: { query, hitCount, lastHitAt }
S->>S: omitir parse+validate, ejecutar AST pre-construido
S-->>C: 200 { data: {...} }
Reducción de payload. Una query de 254 bytes colapsa a un hash de 64 bytes = reducción del 75% solo en el cuerpo de la solicitud. Combinado con Brotli q11 en la respuesta, el egreso de origen baja otro ~70% en cache hits.
flowchart LR
subgraph "Sin APQ (línea base)"
A1[Parsear cadena a AST<br/>3-5 ms] --> A2[Validar AST vs schema<br/>2-8 ms]
A2 --> A3[Resolver variables<br/>variable]
A3 --> A4[Serializar a JSON<br/>1-2 ms]
A4 --> A5[Transportar respuesta<br/>1-5 ms]
end
subgraph "Con APQ (cache hit)"
B1[Lookup de hash HGETALL<br/>~0.1 ms] --> B2[Ejecutar AST pre-construido<br/>variable]
B2 --> B3[Serializar a JSON<br/>1-2 ms]
B3 --> B4[Transportar respuesta<br/>1-5 ms]
end
A1 -.->|7-20 ms total| A5
B1 -.->|2.1-7.1 ms total| B4
style A1 fill:#7c2d12,color:#fff
style A2 fill:#7c2d12,color:#fff
style B1 fill:#0a4d2e,color:#fff
Sin APQ: 7–20 ms de sobrecarga por solicitud (excluyendo resolvers). Con APQ en cache hit: 2.1–7.1 ms. El ahorro de 5–13 ms es determinista, no probabilístico — cada cache hit elimina exactamente el mismo trabajo.
El patrón Circuit Breaker (Nygard 2018, Fowler 2014) previene fallas en cascada en sistemas distribuidos.
stateDiagram-v2
[*] --> CLOSED
CLOSED --> OPEN: fallas > umbral<br/>(5 en 30s)
OPEN --> HALF_OPEN: timeout transcurrido<br/>(30s)
HALF_OPEN --> CLOSED: solicitud de prueba exitosa
HALF_OPEN --> OPEN: solicitud de prueba falla
note right of CLOSED: operación normal
note right of OPEN: fail-fast todas las solicitudes
note right of HALF_OPEN: probar con tráfico limitado
La regla de transición está parametrizada por operación:
donde
En el segundo trimestre de 2026 el lado cliente de Next.js migró de unstable_cache al modelo de componentes de caché:
// app/api/graphql/route.ts (lado cliente)
import { cacheLife, cacheTag } from 'next/cache';
async function getUsers(take: number) {
'use cache';
cacheLife('hours'); // perfil: fresh+revalidate+expire
cacheTag('users', `users-take-${take}`);
const data = await apolloClient.query({
query: FIND_MANY_USER,
variables: { take },
});
return data.findManyUser;
}La combinación cierra dos limitaciones de v1:
- Limitación #2 de §6.2 ("sin dedup de queries equivalentes"):
revalidateTag('users-take-10')revalida solo el segmento(take=10), pero la caché se comparte entre lecturas con campos escalares traslapados. - Deriva de TTL:
cacheLife('hours')aplica un perfil ({ stale: 5min, revalidate: 1h, expire: 1d }) que la capa de aplicación puede auditar sin inspeccionar Redis directamente.
El lado servidor conserva la caché APQ como fuente de verdad; la caché de Next.js es una capa de respuesta en cliente montada encima, con clave (operationName, variables) después de la compresión APQ.
La caché de respuestas del lado navegador usa IndexedDB bajo un Service Worker, con perfiles de TTL idénticos a cacheLife:
graph TD
A[Solicitud del navegador] --> B{Service Worker<br/>fetch handler}
B -->|cache.match| C{IndexedDB<br/>idb-cache-v2}
C -->|hit + fresh| D[Devolver respuesta cacheada<br/>0 ms red]
C -->|hit + stale| E[Stale-while-revalidate:<br/>devolver cacheada + refresco en background]
C -->|miss| F[Reenviar a la red]
F --> G[Apollo Client + APQ]
G --> H[Origen: Apollo Server + Redis]
H --> F
F -->|200 OK| I["Cachear nueva respuesta en IndexedDB<br/>key = operationName + sha256(variables)"]
I --> D
style C fill:#0e7490,color:#fff
style H fill:#0a4d2e,color:#fff
Impacto medido en tráfico real (semana del 2026-06-22, un solo tenant):
- Tasa de acierto de IndexedDB: 38.4% (queries que el usuario ya vio en la última ventana de
cacheLife) - Tasa de acierto combinada APQ + IndexedDB: 94.1% de evasión de solicitudes con origen (vs 90.9% solo-APQ)
- Penalización de arranque en frío de IndexedDB: 2–6 ms (DOMException en la primera lectura mientras abre la DB); se amortiza después de la primera solicitud por sesión
La combinación es lo que hace que los "5–13 ms ahorrados por hit" de v1 se vuelvan "5–13 ms + 30–80 ms de salto completo de red" en el ~38% de las solicitudes que pegan primero en IndexedDB.
graph TB
subgraph CLIENT["Capa cliente"]
NC[App Next.js 16<br/>componentes de caché]
AC[Apollo Client<br/>APQ Link]
CB[Breaker del cliente<br/>por operación]
SW[Service Worker<br/>IndexedDB v2]
end
subgraph EDGE["Edge / proxy"]
NX[Nginx<br/>Brotli q11]
RL[Rate limiter<br/>100 req/10s]
end
subgraph SERVER["Capa servidor"]
AP[Apollo Server v4<br/>puerto <N>]
RP[Plugin de resiliencia<br/>CB + detector de inundación]
APQ[Adaptador de caché APQ]
SH[Validador de schema<br/>SHA-256]
WU[Calentamiento 5 fases]
end
subgraph CACHE["Capa de caché"]
RED[Redis 7]
LUA[Scripts Lua EVAL<br/>HGETALL+HINCRBY+HSET]
CB2[Breaker a nivel Redis<br/>5 fallas → 30s]
end
subgraph DATA["Capa de datos"]
PG[(PostgreSQL<br/>707 modelos Prisma)]
end
NC --> AC
SW --> AC
AC --> CB
CB -->|HTTP POST<br/>hash 64B| NX
NX --> RL
RL --> AP
AP --> RP
RP --> APQ
APQ -->|HSET/HGETALL| RED
APQ -->|EVAL atómico| LUA
RP --> CB2
SH --> RED
WU --> SH
WU --> APQ
AP --> PG
style CLIENT fill:#0c4a6e,color:#fff
style SERVER fill:#0a4d2e,color:#fff
style CACHE fill:#7c2d12,color:#fff
El calentamiento usa introspección del schema al 100% — cero nombres de campo hardcodeados. Las 5 fases producen en conjunto ~2,130 queries pre-cachadas, elevando la tasa de acierto en arranque en frío de 0% (sin APQ) a ~90% antes de que llegue tráfico orgánico.
| Fase | Operación | Queries | Estrategia de campos |
|---|---|---|---|
| 1 | findMany (todas) |
~697 | Los 5 campos escalares principales por tipo (siempre incluye id) |
| 2 | count (todas) |
~697 | Sin selección de campos (devuelve escalar) |
| 3 | findFirst (todas) |
~694 | Los 3 campos escalares principales por tipo |
| 4 | findUnique (disponibles) |
~37 | Con ID placeholder |
| 5 | Health check | 5 | Queries de verificación |
| Total | ~2,130 |
Teoría del costo de arranque en frío. Sin calentamiento, las primeras
Con el calentamiento pre-cachando las
Para
Introspección automática de campos:
// Descubre los campos escalares principales sin nombres hardcodeados.
function getScalarFields(typeName: string, maxFields = 5): string[] {
const type = schema.getType(typeName);
const fields = Object.values(type.getFields());
return fields
.filter(f => isScalarType(getNamedType(f.type))) // solo escalar
.sort((a, b) => {
if (a.name === 'id') return -1; // 'id' siempre primero
return a.name.localeCompare(b.name);
})
.slice(0, maxFields)
.map(f => f.name);
}Por eso el sistema sobrevive al churn del schema: renombres, adiciones y remociones se absorben por introspección, sin ningún paso manual de calentamiento de caché.
graph LR
subgraph "Capa 1: Plugin del servidor (por operación)"
L1a[Circuit breaker<br/>5 fallas / 30s]
L1b[Rate limiter<br/>100 req/10s/op]
L1c[Detector de inundación APQ<br/>50 miss/10s]
end
subgraph "Capa 2: A nivel Redis"
L2a[5 fallas → reset 30s]
L2b[Clasificación de error:<br/>RECUPERABLE / BUSY / NO_RECUPERABLE]
L2c[Fallback: LRU en memoria]
end
subgraph "Capa 3: Lado cliente"
L3a[CB global]
L3b[CB por operación]
L3c[Detección de estado CB del servidor<br/>→ dejar de reintentar]
L3d[Backoff exponencial + jitter]
end
L1a --> L2a
L2a --> L3a
L1c -.->|auto-flush<br/>+ re-warmup| SERVER[Apollo Server]
Ticks atómicos de CB con Lua-EVAL (v2). Los contadores de CB por operación solían requerir 3 RTT secuenciales (HGET estado, decidir umbral, HINCRBY luego HSET). Con Lua EVAL lo hacemos en 1 RTT:
-- lua/cb-tick.lua (tick atómico de CB por operación)
local key = KEYS[1]
local threshold = tonumber(ARGV[1])
local ttl_ms = tonumber(ARGV[2])
local cur = redis.call('HMGET', key, 'state', 'failures', 'opened_at')
-- Redis devuelve `false` para campos hash inexistentes; conversión defensiva
-- para que `now - opened_at` abajo nunca dispare `attempt to perform arithmetic on nil`.
local state = cur[1]
local failures = tonumber(cur[2]) or 0
local opened_at = tonumber(cur[3]) or 0
local now = tonumber(ARGV[3])
if state == 'OPEN' then
if now - opened_at >= ttl_ms then
state = 'HALF_OPEN'
else
return {'OPEN', failures}
end
end
local nf = redis.call('HINCRBY', key, 'failures', 1)
if nf >= threshold then
redis.call('HMSET', key, 'state', 'OPEN', 'opened_at', now)
return {'OPEN', nf}
end
redis.call('HMSET', key, 'state', state or 'CLOSED')
return {state or 'CLOSED', nf}Esto elimina una clase de carreras TOCTOU donde dos solicitudes concurrentes leen failures=4 y ambas incrementan a 5 sin que el umbral se cruce atómicamente.
Cuando una query de calentamiento falla porque el schema se movió, el sistema:
- Identifica la entidad que falla a partir del nombre de la query (por ej.
Warmup_findManyUser→User) - Consulta el Mapa de Trazas de Entidad parseado desde
prisma/introspected.prisma - Emite una traza diagnóstica completa hacia el operador
❌ Warmup_findManyUser
Error: Cannot query field "nonExistentField" on type "User"
┌── Trace ──────────────────────────────────────
│ Domain: <domain>
│ Prisma: prisma/introspected.prisma#<line>
│ Resolver: apollo/resolvers/<domain>/queries.ts
│ Mutations: apollo/resolvers/<domain>/mutations.ts
│ Index: apollo/resolvers/index.ts
│ GraphQL: schema/graphql/<domain>/
└───────────────────────────────────────────────
sequenceDiagram
participant S as Apollo Server
participant R as Redis
S->>S: calcular sha256(typeDefs) → hashActual
S->>R: GET <prefix>:apq:schema-hash
R-->>S: hashAlmacenado
alt hashActual == hashAlmacenado
S->>S: caché APQ preservada
S-->>S: log "Schema sin cambios"
else no coincide
S->>R: FLUSHDB (solo namespace APQ)
S->>S: re-calentamiento con el nuevo schema (2,130 queries)
S->>R: SET <prefix>:apq:schema-hash hashActual
S-->>S: log "Schema cambió, caché reconstruida"
end
Esto hace que la caché sobreviva los deploys sin pasos manuales de calentamiento. Si prisma migrate deploy agrega una columna, la introspección la recoge; si la quita, la caché se reconstruye limpiamente sin campos obsoletos.
El calentamiento de 5 fases no corre en CI; corre al arrancar el servidor. Pero la construcción por introspección del schema (prisma generate → introspected.prisma → tipos GraphQL) sí corre en CI, y hacia el segundo trimestre de 2026 el artefacto resultante excedía los 50 GB porque la introspección de 707 modelos agrupa fuentes de módulos Node en la caché de Actions.
Dos problemas resultaron:
- Minutos de GitHub-hosted runner quemados: cada PR corría la introspección en CI; el costo acumulado excedió la cuota de la organización durante tres semanas separadas.
- Tasa de falla de subida del artefacto: el artefacto de 50 GB frecuentemente fallaba al subir en runners GitHub-hosted por el tamaño efímero de disco, cayendo a reconstrucciones completas.
Solución: runner de compilación auto-hospedado compile-runner.
graph LR
subgraph "GitHub Actions (orquestación)"
GH[Workflow yaml<br/>runs-on: compile-runner]
end
subgraph "Flota auto-hospedada (controlada por el operador)"
REG[Registro de runner<br/>labels: compile-runner, prisma, bigdisk]
DISK[/opt/build-cache<br/>Volumen persistente del runner/]
CACHE[Caché de build<br/>persistente entre runs]
end
GH --> REG
REG --> DISK
REG --> CACHE
Propiedades clave:
- Caché local persistente.
/opt/build-cachesobrevive entre jobs; las restauraciones desde disco local son 50–200× más rápidas que re-descargar de la caché de Actions de GitHub. - Etiqueta big-disk. Solo los runners con
bigdisk(espacio libre suficiente para el output completo de introspección) reciben los jobs de introspección. Los runners más pequeños en la flota manejan trabajo más ligero. - Cero minutos de GitHub Actions. Los runners auto-hospedados no consumen la cuota mensual de minutos de Actions de la organización.
- Reproducible. La clave de caché se calcula por contenido (sha256 de
package.json+prisma/schema.prisma); los hits de caché son deterministas.
Esto es lo que hace sostenible al paso de construcción por introspección a la escala de 707 modelos. Sin él, cada PR de schema quemaría minutos de Actions o se caería por el límite de tamaño de subida del artefacto.
El stack combinado v1 + v2 tiene tres rutas de solicitud distintas, cada una con conteo de hops y presupuestos de latencia medibles. El siguiente diagrama muestra qué paga cada solicitud, con las anotaciones ~Xms por hop derivadas de trazas de producción (timing del plugin de Apollo Server + timing del evento fetch del Service Worker + MONITOR de Redis muestreado a 1 µs).
sequenceDiagram
autonumber
participant C as Cliente<br/>(Next.js 16)
participant SW as Service Worker<br/>(IndexedDB v2)
participant E as Edge<br/>(nginx Brotli)
participant AS as Apollo Server<br/>(stack de plugins)
participant APQ as Adaptador APQ<br/>+ circuit breaker
participant R as Redis 7<br/>(Lua EVAL)
participant DB as Prisma → PG
Note over C,DB: Ruta A — rápida: hit de caché del cliente (~38% de las lecturas)
C->>SW: GET (operationName, vars)
SW->>SW: idb-cache-v2.match + fresh? (~1 ms)
SW-->>C: 200 OK respuesta cacheada
Note over C,DB: Ruta B — típica: miss de SW, hit de APQ (~55% del resto)
C->>AS: POST { persistedQuery: { sha256 } } (~64 B)
AS->>APQ: hook preResolve (~0.1 ms)
APQ->>R: EVAL cb-tick (state, failures) (~0.1 ms)
R-->>APQ: state=CLOSED, failures=0
APQ->>R: HGETALL apq:query:<sha> (~0.1 ms)
R-->>APQ: AST cacheado + operationName
APQ->>DB: omite parse+validate, ejecuta prisma ($resolver)
DB-->>APQ: filas de resultado
APQ-->>AS: JSON serializado
AS->>E: 200 JSON
E-->>C: transporte Brotli q11
Note over C,DB: Ruta C — fría: miss de APQ (~5%)
C->>AS: POST { cuerpo de query + sha256 } (~254 B)
AS->>APQ: parse + validate + populate (~8–13 ms)
APQ->>R: HSET apq:query:<sha> ...
APQ->>DB: ejecuta resolvers
APQ-->>AS: resultado
AS-->>C: 200 JSON
El diagrama expone la asimetría de la superficie de optimización: la ruta A elimina 5 saltos distintos de red/proceso y ahorra aproximadamente 30–80 ms versus la ruta B; la ruta C es la única que invoca realmente el pipeline de parse+validate. La tasa de acierto en producción del 90.9% está dominada por las rutas A y B; la ruta C es la cola larga (5% miss rate).
Para equipos de 3+ ingenieros que corren GraphQL multi-tenant sobre schemas auto-generados, el presupuesto de optimización se mapea a dónde vive el peso del clúster: la ruta A depende de la instalación del Service Worker + esquema de IndexedDB; la ruta B depende del throughput de Redis; la ruta C depende del CPU del Apollo Server. Migrar una ruta a la vez es el orden de adopción con menos riesgo.
Mudar el build fuera de GitHub-hosted runners es la mitad de la historia. La otra mitad — y la que determina si el runner es una superficie de CI predecible o un vecino ruidoso — es cómo los procesos del runner se aíslan de cualquier otra cosa que comparta el mismo host. Una vez que el runner corre sobre hardware controlado por el operador (laptop, VPS, bare-metal, o nodo de k8s), la pregunta deja de ser "quién paga los minutos" y pasa a ser "quién paga cuando el runner compite con tráfico que yo no agendo".
La respuesta, en producción, es slices de cgroup v2 bajo systemd. El servicio del runner corre como hijo de una slice custom (compile-runner.slice), y cada job que aterriza en el runner hereda la política de recursos de la slice:
graph LR
HOST[/sys/fs/cgroup<br/>cgroup v2 unificado/]
HOST --> SLICE[compile-runner.slice<br/>CPUWeight, MemoryHigh, TasksMax]
SLICE --> SVC[actions.runner.*.service<br/>listener persistente]
SVC --> JOB1[job scope 1<br/>Prisma generate]
SVC --> JOB2[job scope 2<br/>pnpm install]
SVC --> JOB3[job scope 3<br/>compile runner probe]
JOB1 -.Monitoreado por PSI.-> PSI[cpu.pressure<br/>io.pressure<br/>memory.pressure]
JOB2 -.Monitoreado por PSI.-> PSI
JOB3 -.Monitoreado por PSI.-> PSI
El template de la unit de slice (drop-in bajo /etc/systemd/system/compile-runner.slice.d/resources.conf o inline en el archivo de la slice):
# /etc/systemd/system/compile-runner.slice
[Unit]
Description=Compile runner slice — aislamiento cgroup v2 para runner auto-hospedado de Actions
[Slice]
CPUAccounting=yes
MemoryAccounting=yes
IOAccounting=yes
TasksAccounting=yes
# cpu.weight (1–10000, default 100) es prioridad RELATIVA bajo contención.
# Úsalo para mantener los builds adelante del tráfico interactivo; no es un cap duro.
CPUWeight=400
# memory.high dispara reclaim + throttling sin matar por OOM.
# memory.max es el techo duro donde el kernel puede invocar OOM.
# La brecha entre ambos es el buffer-absorbente para picos legítimos
# (Prisma generate, pnpm install con muchos workers).
MemoryHigh=12G
MemoryMax=16G
# pids.max / TasksMax: pnpm install + workers de compilación de Node pueden
# dispersarse a miles de procesos. Sin un techo, una herramienta desbocada
# puede fork-bombardear el host.
TasksMax=4096
# io.weight es la prioridad de I/O relativa a slices hermanas.
# io.latency target=<usec> opcional puede proteger latencia en un
# dispositivo específico bajo contención, pero solo si el scheduler del
# dispositivo lo soporta realmente.
IOWeight=200Después de systemctl daemon-reload && systemctl restart actions.runner.<org>.service, cada job aterriza en la jerarquía de la slice. Verifica con:
systemd-cgls compile-runner.slice
# Busca el servicio del runner y sus job scopes hijos.
cat /sys/fs/cgroup/compile-runner.slice/cpu.weight
cat /sys/fs/cgroup/compile-runner.slice/memory.high
cat /sys/fs/cgroup/compile-runner.slice/memory.max
cat /sys/fs/cgroup/compile-runner.slice/pids.maxnice y taskset son hints del scheduler de CPU; no afectan la presión de memoria, no limitan el fan-out de procesos, no aíslan el I/O de disco, y no proveen métricas. Un build que sobrepasa nice -n 19 aún hará OOM al host. Un build pinned con taskset aún competirá por la caché L3 con cada sibling pinned. cgroup v2 unifica los controllers de CPU, memoria, I/O y PID bajo un modelo jerárquico único de accounting, y PSI (/proc/pressure/cpu, io, memory) te da tiempo de stall — no solo utilización. La utilización te dice "el CPU está 95% ocupado"; PSI te dice "tu job pasó 12% del wallclock esperando por contención". Esa distinción es la diferencia entre una métrica que mueve un dashboard y una métrica que mueve una acción.
Prisma generate, pnpm install con muchos workers, y tsc --build para monorepos grandes tienen todos picos legítimos de memoria. Si pones memory.max al techo del pico, un solo PR inusual puede OOM-matar al runner a mitad del job, abortando el build y dejando al runner en estado inconsistente. Si pones memory.max muy alto y dependes de memory.high, el kernel hace throttle al cgroup (fuerza reclaim) sin matar al proceso. El resultado: una penalización de 2–5% de latencia para jobs en estado estable a cambio de nunca perder un build por un pico transitorio.
| Escenario | Solo memory.max |
memory.high + memory.max |
|---|---|---|
| Build en estado estable | Techo duro, puede abortar | Throttle de reclaim, build completa |
| Pico (ej. Prisma generate en PR con schema pesado) | OOM kill, runner inconsistente | memory.high dispara reclaim, el proceso se frena pero sobrevive hasta memory.max |
| Host bajo presión de memoria | OOM kill se propaga dentro de la slice | Slice se ve afectada primero, host estable |
El patrón: memory.high = ~70-80% de memory.max, con memory.max ajustado para dejar espacio al kernel del host, journald, y agentes de observabilidad. Ajusta memory.high al p99 del estado estable observado; ajusta memory.max al p99.9 de los picos observados.
La forma más barata de comparar políticas de slice es envolver un solo build en un scope aislado y medir:
systemd-run --scope \
--unit=compile-runner-probe \
-p CPUQuota=50% \
-p MemoryHigh=4G \
-p MemoryMax=6G \
-p TasksMax=2048 \
-- \
pnpm prisma generate
# Mientras corre el probe, en otra shell:
systemctl show compile-runner-probe.scope \
-p CPUUsageNSec -p MemoryPeak -p TasksCurrent -p Result
# Y el cgroup mismo reporta:
CG=$(systemctl show -p ControlGroup --value compile-runner-probe.scope)
cat "$CG/cpu.stat" # nr_throttled, throttled_usec, usage_usec
cat "$CG/memory.events" # high, max, oom, oom_kill
cat "$CG/memory.pressure" # avg10/avg60/avg300 de stall de memoria
cat "$CG/io.pressure" # tiempo de stall de I/ORepite el probe con CPUQuota=100%, 200%, 400% y compara tiempo wall-clock del job vs throttling de cpu.stat. El punto de cruce — donde quitar la cuota ya no reduce wall-clock — es la respuesta empírica a "¿cuánto CPU necesita realmente este job sin contención?" Multiplica por un factor de seguridad (1.5× a 2×) y tienes un valor defendible de CPUWeight (para coexistencia normal) o CPUQuota (para techo duro).
Ancla diagnóstica #6. Si tu compile runner compite con tráfico interactivo u otros jobs batch en el mismo host y aún NO le has asignado un
cpu.weightdistinto del default 100, ese default significa "sin prioridad relativa" — tu build va a perder cada ronda de contención contra cualquier workload interactivo que aparezca, y el síntoma es p95 de duración de job inexplicablemente variable durante horario laboral. El fix es una línea en un drop-in de systemd. Si PSIcpu.pressure:someen tu slice muestra >5% en horario laboral y <1% fuera de él, la contención es real; si muestra <2% en ambas ventanas, la varianza viene de otro lado ycpu.weightno va a ayudar.
Ancla diagnóstica #7. Si tu p95 de duración de job de CI varía más de 2× entre horario laboral y fuera de horario, NO es un bug del runner — es contención no aislada. Antes de culpar a la imagen del runner, al gestor de paquetes, o a la herramienta de build, mide PSI sobre la slice. Un
cpu.pressure:some avg300consistentemente arriba de ~3% en horario laboral con un pico correspondiente deio.pressure:somealrededor de la restauración de caché es la prueba del crimen. Sin esa medición, cada optimización va a ser un pálpato.
Tres propiedades que suelen darse por supuestas y que en este diseño son explícitas porque de ellas depende la operación desatendida: el ciclo de caché debe poder ejecutarse dos veces sin efecto adicional, un cambio de schema debe invalidar lo que cambió y no todo lo demás, y el coste en RAM de la caché es un presupuesto explícito, no un efecto secundario.
Idempotencia significa que repetir una operación produce el mismo estado final, no un estado distinto por haberla repetido. En este sistema las cuatro operaciones del ciclo son idempotentes por construcción:
| Operación | Mecanismo que la hace idempotente | Qué pasa si se repite |
|---|---|---|
| Calentamiento | Escritura por hash de contenido (SETNX) sobre una clave derivada del schema |
Converge al mismo conjunto; las escrituras repetidas no duplican ni alteran entradas |
| Invalidación por hash de schema | Se compara el hash almacenado con el hash actual antes de actuar | Si el hash no cambió, la operación es un no-op con log explícito |
| Reparación automática (§3.4) | Diagnóstico por traza y reintento del registro que falló | Reejecuta el mismo diagnóstico sobre el mismo fallo; no acumula efectos |
| Transición del circuit breaker (§2.3) | La regla es una función pura del estado y de los contadores | Dos evaluaciones sobre el mismo estado dan el mismo estado siguiente |
Por qué importa: la reparación automática y el recalentamiento corren programados, no bajo supervisión humana. Si el proceso muere a mitad de un recalentamiento, el siguiente intento debe converger desde el estado parcial sin duplicar entradas ni dejar el registro de queries a medias. Sin idempotencia, la recuperación de un fallo de arranque se convierte en un segundo incidente.
La invalidación descrita en §3.5 es gruesa: el hash del schema cambia, se vacía el namespace APQ completo y se recalientan las 2,130 queries. Es correcta y es simple, pero su coste no es proporcional al cambio: una columna nueva en una entidad de 707 obligaba a recompilar el catálogo entero.
El mecanismo que permite acotarlo ya existe en el sistema: el Mapa de Trazas de Entidad (§3.4), que registra qué entidad toca cada query de calentamiento. Con ese mapa, la invalidación puede pasar de todo el schema a el radio de impacto del cambio:
graph TD
A[Cambio de schema detectado] --> B[Calcular el hash por entidad<br/>en vez de un hash global]
B --> C[Consultar el Mapa de Trazas<br/>de Entidad]
C --> D[Set de queries afectadas<br/>por las entidades tocadas]
D --> E[Invalidar solo ese set]
E --> F[Recalentar solo ese set]
F --> G[Verificar hash global<br/>y registrar el resultado]
La aritmética del radio de impacto, con los números de este sistema: el conjunto calentado son 2,130 queries sobre 707 entidades, es decir ≈3 queries por entidad. Un cambio que toca una sola entidad invalida ≈3 queries en lugar de 2,130 — una reducción del radio de impacto de dos órdenes de magnitud, y el tiempo de revalidación pasa de "recatalogar el schema" a "recompilar tres artefactos".
La condición de validez es que el mapa de trazas sea autoritativo: si una query no está trazada, la invalidación granular la omite y queda un artefacto compilado contra un schema que ya no existe. Por eso el diseño mantiene dos niveles:
- Nivel granular — invalida y recalienta el set afectado por el cambio, y es idempotente por construcción: reejecutarlo sobre el mismo cambio no invalida nada adicional.
- Nivel grueso — flush completo más recalentamiento de las 2,130 queries. Se usa como fallback cuando el mapa de trazas no cubre el cambio, cuando el hash global no puede reconciliarse con los hashes por entidad, o cuando la verificación posterior al recalentamiento granular falla.
Es decir: la invalidación fina es la ruta normal y la completa es el red de seguridad, no al revés. La operación que decide entre ambas es el hash: si el hash global del schema cambió y la reconciliación por entidad no cuadra, el sistema degrada a la completa.
Este mecanismo no ahorra RAM: la consume. El ahorro es de CPU y de egreso de red; la memoria del registro de queries es el precio que se paga por ese ahorro. La pregunta operativa no es "¿cuánta RAM ahorro?" sino "¿cuánta RAM estoy dispuesto a convertir en CPU liberada?".
Las cifras medidas en este sistema:
| Magnitud | Valor | Fuente |
|---|---|---|
| Tamaño del registro APQ | 98.5 KB para 2,135 queries (~47 B por query) | §4.1 |
| RAM de Redis en el límite documentado | 2,135 × ~50 B ≈ 107 KB; a 100K queries únicas, ~5 MB | §6.2 |
| CPU de traducción liberada a 200 req/s | 1.09 cores (de 1.20 a 0.11) | §1.2 |
| CPU de traducción liberada a 450 req/s | 2.45 cores (de 2.70 a 0.25) | §1.2 |
El resultado que decide la inversión es el tipo de cambio: el mismo registro de 98.5 KB libera 1.09 cores a 200 req/s y 2.45 cores a 450 req/s.
| Tráfico | RAM del registro | Cores liberados | RAM por core liberado |
|---|---|---|---|
| 200 req/s | 98.5 KB | 1.09 | 90 KB por core |
| 450 req/s | 98.5 KB | 2.45 | 40 KB por core |
Es decir, el mismo registro rinde el doble de CPU liberada por el mismo byte de RAM cuando el tráfico sube, porque el coste de RAM es lineal en el número de queries distintas mientras que el ahorro de CPU es proporcional al tráfico. De ahí la conclusión operacional: el registro de calentamiento se justifica por sí mismo a partir de un umbral de tráfico, y por debajo de ese umbral el RAM está pagando por un servicio que no se usa. Las dos salidas del problema son aumentar el tráfico (el mismo registro, más CPU liberada) o comprimir el registro (LZ4 + zstd en disco, el tier de §3.5), nunca ignorarlo.
En el lado del cliente el mismo razonamiento aparece con la capa de IndexedDB: el navegador paga RAM y disco por las respuestas cacheadas, y a cambio evita el salto completo de red de 30–80 ms por solicitud (§4.6).
| Métrica | Valor | Línea base (sin APQ) | Mejora |
|---|---|---|---|
| Tasa de acierto APQ | 90.9% | N/A | — |
| Tasa de acierto combinada APQ + IndexedDB (v2) | 94.1% | 0% | +94.1 pp |
| Queries pre-cachadas en calentamiento | 2,130 + 5 (cliente) | 0 | +2,135 |
| Tamaño de caché APQ | 98.5 KB | 0 | — |
| Ancho de banda por solicitud | ~64 B (hash) | ~254 B (query) | −75% |
| Parse + validate (cacheada) | 0 ms (eliminado) | 3–13 ms | −100% |
| Rendimiento | 450 req/s | 200 req/s | +125% |
| Latencia p95 | 12 ms | 25 ms | −52% |
| Gasto externo de caché | $0 MXN/mes | — | — |
graph LR
P1[Fase 1<br/>findMany<br/>697 queries] -->|95.2%| M[Global<br/>90.9%]
P2[Fase 2<br/>count<br/>697 queries] -->|93.8%| M
P3[Fase 3<br/>findFirst<br/>694 queries] -->|88.5%| M
P4[Fase 4<br/>findUnique<br/>37 queries] -->|72.1%| M
P5[Fase 5<br/>health<br/>5 queries] -->|99.9%| M
style P1 fill:#0a4d2e,color:#fff
style P2 fill:#0a4d2e,color:#fff
style P3 fill:#7c2d12,color:#fff
style P4 fill:#7c2d12,color:#fff
style P5 fill:#0a4d2e,color:#fff
style M fill:#082f49,color:#fff
La fase débil es findUnique (72.1%) — son las queries con un ID placeholder; en producción la mayor parte del tráfico pega en findMany, así que la debilidad se amortiza.
Solicitudes/segundo
0 100 200 300 400 500
├──────┼──────┼──────┼──────┼──────┤
│ │
Sin │████████████████████ │ 200 req/s
APQ │ │
│ │
APQ │████████████████████████████████████████████│ 450 req/s (+125%)
│ │
└──────────────────────────────────┘
Matemáticamente:
Con
Los 450 req/s observados exceden la cota analítica porque la ruta de resolver frío se comparte entre misses concurrentes (Apollo Server v4 agrupa los fetches del dataloader), dando un ~15% adicional de rendimiento bajo saturación.
| Escala | req/día | Sin APQ | Con APQ | Ahorro diario |
|---|---|---|---|---|
| Baja | 15,230 | 3.87 MB | 0.97 MB | 2.90 MB |
| Media | 100,000 | 25.4 MB | 6.35 MB | 19.05 MB |
| Alta | 1,000,000 | 254 MB | 63.5 MB | 190.5 MB |
| Hiper | 10,000,000 | 2.54 GB | 635 MB | 1.90 GB |
Más el salto completo de respuesta en el 90.9% de los cache hits: añade otros ~190 bytes/req de ahorro de egreso (el cuerpo de respuesta nunca se envía).
Incidente de marzo de 2026: Un solo componente [ComponenteA] ejecutaba findManyTeam en un ciclo cerrado sin debounce, generando ~200 req/s. La respuesta del sistema, totalmente automatizada:
gantt
title Recuperación automática de inundación APQ
dateFormat s
axisFormat %S s
section Detección
Inicia ciclo cerrado (200 req/s) :a1, 0, 10s
Umbral de inundación APQ cruzado (50/10s) :a2, after a1, 1s
section Recuperación
Auto-flush disparado :crit, a3, after a2, 1s
Re-calentamiento iniciado :a4, after a3, 5s
1395 queries re-cachadas :a5, after a4, 14s
Circuit breaker HALF_OPEN → CLOSED :a6, after a5, 1s
section Estable
Sistema estable, tráfico normal :milestone, after a6, 0s
Resultado del post-mortem: rate limiting por operación (100 req/10s/op) agregado para prevenir futuras inundaciones sin limitar tráfico legítimo.
El componente que disparó el incidente (anteriormente MarqueeTeams en el documento interno) demostró que un solo caller mal portado puede tirar abajo toda la caché sin aislamiento por operación.
Después de las cuatro pasadas de endurecimiento de v2 (componentes de caché de Next.js, IndexedDB, Lua EVAL, runners auto-hospedados), el ahorro acumulado en producción contra la línea base de v1:
| Vector | Ahorro | Mecanismo |
|---|---|---|
| CPU de parse + validate | 90.9% × (3–13 ms) por req = ~9 ms/req prom | APQ cache hit |
| Egreso de ancho de banda | 75% por cuerpo de solicitud | Hash SHA-256 APQ |
| Salto de origen desde IndexedDB | 38.4% × RTT completo (~30–80 ms) por req | Service Worker cache |
| Tick de CB con Lua EVAL | 2 RTT → 1 RTT = ~0.5 ms/evento-CB | Contador atómico |
| Minutos de GitHub Actions | 100% en PRs de introspección | Runner auto-hospedado |
| Subida de artefacto de build | 50 GB → caché local persistente | Runner auto-hospedado |
Agregado por escala de tráfico. La ventana de producción medida de 30 días corresponde a la escala baja (15,230 req/día). El ahorro de CPU de traducción es directo — req/día × 0.909 × 3–13 ms — y escala linealmente con el volumen:
| Escala | req/día | Egreso ahorrado | Egreso ahorrado en 30 días | CPU de traducción liberada | Horas-CPU/día |
|---|---|---|---|---|---|
| Baja (medida) | 15,230 | 2.90 MB/día | 87 MB | 42–180 s/día | 0.01–0.05 |
| Media | 100,000 | 19.05 MB/día | 571 MB | 4.5–19.7 min | 0.08–0.33 |
| Alta | 1,000,000 | 190.5 MB/día | 5.7 GB | 45–197 min | 0.76–3.3 |
| Hiper | 10,000,000 | 1.90 GB/día | 57 GB | 7.6–32.8 h | 7.6–32.8 |
Las cifras agregadas que se citan habitualmente para este mecanismo —~38 GB de egreso y ~12 horas-CPU/día— corresponden al extremo alto de la escala (10M req/día, 57 GB en 30 días), no al tenant medido: a 15,230 req/día el ahorro real es de ~2 minutos de CPU y ~87 MB de egreso en 30 días. La magnitud del mecanismo depende del volumen, no de la granularidad: 1,000 req/día liberan 3–12 s de CPU; 10,000 req/día liberan 27–118 s; 1M req/día liberan 0.8–3.3 horas.
Además: cero minutos de Actions quemados en PRs de introspección (runner auto-hospedado).
Ancla diagnóstica #1. Si tu panel de facturación muestra >30% de egreso en cuerpos de query — y tu schema tiene cientos de operaciones — la superficie de optimización aún no está instrumentada. La tasa de acierto es la primera métrica a aterrizar; el desglose por operación es la segunda; el costo de arranque en frío después de una rotación de schema es la tercera. Si las tres faltan, la superficie arquitectónica de arriba está del otro lado de una brecha de medición, no de una brecha de construcción.
El umbral de equilibrio entre una suscripción SaaS de GraphQL administrada y un build de ingeniería auto-hospedado es función de tres variables: costo de suscripción, costo de ingeniería, y el volumen de solicitudes cuyo presupuesto de latencia traducen los ahorros. El diagrama siguiente rastrea el costo acumulado en USD sobre una ventana de 12 meses para una configuración representativa (Apollo GraphOS Pro a $399/mes vs ~40h de ingeniería a $100/h amortizadas una vez a lo largo del ciclo de vida del schema).
graph LR
subgraph "Costo acumulado en 12 meses (un tenant @ ~10k req/día)"
M0[Mes 0<br/>$0]
subgraph "Apollo GraphOS Pro ($399/mes)"
A1[Mes 1<br/>$399] --> A3[Mes 6<br/>$2,394] --> A6[Mes 12<br/>$4,788]
end
subgraph "APQ auto-hospedado (una vez ~$4,000 + ~$15/mes Redis)"
S1[Mes 1<br/>$4,015] --> S3[Mes 6<br/>$4,090] --> S6[Mes 12<br/>$4,180]
end
end
style A6 fill:#7c2d12,color:#fff
style S6 fill:#0a4d2e,color:#fff
Los números arriba son ilustrativos; la fórmula en forma cerrada está en Teorema E.5 (Apéndice E). El mes de cruce depende linealmente de la razón (costo_ingeniería) / (costo_suscripción), y la varianza viene de cuántos doblamientos de crecimiento de volumen de solicitudes caben dentro de la ventana. Equipos cuya factura SaaS ha crecido >15% trimestre-a-trimestro ven el cruce medido en semanas; equipos que ya pagaron el costo de ingeniería y lo amortizaron ven los ahorros como inmediatos.
| Aspecto | APQ (este sistema) | Persisted Queries Estáticas |
|---|---|---|
| Registro de queries | Automático (primer miss) | Manual (tiempo de build) |
| Adaptación a cambios de schema | Automático (hash de schema) | Requiere re-build |
| Calentamiento | 5 fases automático | N/A |
| Seguridad | Allowlist dinámica | Allowlist estática (más segura) |
| Complejidad | Media | Baja |
| Mejor para | Schemas auto-generados (707 modelos) | Apps con queries fijas |
| Aspecto | APQ local (este sistema) | Apollo Studio |
|---|---|---|
| Costo | $0 MXN (Redis en host propio) | $99–399 USD/mes |
| Latencia de caché | <1 ms (Redis local) | 10–50 ms (nube) |
| Control | 100% auto-controlado | Dependiente del proveedor |
| Auto-calentamiento | ✅ 5 fases | ❌ Solo dirigido por cliente |
| Auto-reparación | ✅ Mapa de Trazas de Entidad | ❌ |
| Detección de inundación | ✅ 50 miss/10s | ✅ (básica) |
| Mejor para | Empresarial auto-hospedado | Equipos sin DevOps |
| Aspecto | APQ (a nivel de query) | CDN (a nivel de respuesta) |
|---|---|---|
| Granularidad | Por hash de query | Por URL/cabecera |
| Invalidación | Cambio de hash de schema | TTL o purga manual |
| Conocimiento de GraphQL | ✅ Entiende operaciones | ❌ Trata POST como opaco |
| Mutaciones | ✅ Excluidas automáticamente | ❌ Puede cachear incorrectamente |
| Mejor para | APIs GraphQL | APIs REST, activos estáticos |
El panorama SaaS para GraphQL a escala empaqueta el stack de optimización de arriba en ofertas administradas — caché de queries, introspección, validación de schema, enrutamiento federado, monitoreo. Ninguno agrupa todas las piezas portantes que la arquitectura en §3 entrega out of the box. Abajo está el mapa curado por el operador (evaluado en producción contra este schema en 2025–2026, con ingeniería inversa activa de páginas de precios, SLAs de latencia y divulgaciones de telemetría) de qué cubre cada uno, de dónde viene su costo de latencia, y el hueco que dejan.
| Proveedor | Precio por nivel (USD/mes) | Latencia de caché añadida | Egreso de telemetría | Lock-in | Lo que NO resuelve |
|---|---|---|---|---|---|
| Apollo GraphOS (sucesor de Studio) | Free → $399 → enterprise | 10–50 ms (round-trip a nube) | sí (traza de query anonimizada) | sí | Calentamiento en frío; CB por operación; invalidación Schema×Prisma hash; runners auto-hospedados |
| Hasura Cloud | Free → custom ($99–$999+) | 15–40 ms (capa de caché PG administrada) | sí | sí | Solo GraphQL (sin introspección Prisma); CB sub-schema |
| Stellate | $20–$300+ | 8–25 ms (caché edge) | parcial | sí | Estado atómico de CB por operación; aislamiento de clave multi-tenant |
| Grafbase | $0–$custom | 12–30 ms | sí | sí | Capa IndexedDB stale-while-revalidate; ticks atómicos de CB con Lua-EVAL |
| WunderGraph | $0–$800+ | 5–20 ms | parcial | sí | Auto-flush por hash de schema; capas nativas de caché federada |
| The Guild Hive | OSS free + enterprise managed | 5–15 ms | opcional | bajo | Caché de build persistente (50 GB+); combo CDN/precios completo |
| GraphCDN | $0–$custom | 3–10 ms | sí | sí | Rastreo de cambios de schema; contadores por operación de query |
Ancla diagnóstica #2. Si tu equipo tiene 3+ ingenieros, tu línea mensual de GraphQL administrado es >$200, y el schema se auto-genera a partir de un modelo Prisma de >100 entidades, el beneficio de latencia titular del proveedor es real, pero el calentamiento en frío al momento de deploy, el aislamiento del CB por operación, y la caché IndexedDB del lado cliente que sobrevive una ventana offline no están en la oferta. El umbral de equilibrio contra in-house está documentado en el Teorema E.5; la superficie arquitectónica de arriba es reproducible en tu entorno sin re-plataformar el schema contra un adaptador de proveedor.
La tabla de arriba es un marco de partida, no un veredicto. Para un equipo cuya carga principal es JSON read-heavy sobre un schema estable y cuyo headcount de operaciones es <2, la ruta administrada puede seguir siendo la llamada correcta. Para equipos cuya carga tiene características de ráfaga variable, rotación de schema, multi-tenant o presupuesto de latencia ajustado, la tabla es un triaje no una comparación.
-
El calentamiento es crítico. Sin calentamiento, la tasa de acierto inicial es 0% y tarda horas en subir arriba de 80% con solo tráfico orgánico. Con el calentamiento de 5 fases, arrancamos al ~90% antes de la primera solicitud del usuario.
-
keyPrefixde ioredis es una trampa. El prefijo aplica a comandos de datos (HSET,GET) pero NO aKEYS/SCAN. Fallas silenciosas de enumeración. La corrección es usar el patrón de doble prefijo<prefix>:<prefix>:apq:query:*para queries de SCAN. -
La introspección de schema elimina mantenimiento. Sobre un schema de 707 modelos que cambia con frecuencia, las queries de calentamiento hardcodeadas serían inmanejables. La introspección absorbe renombres, adiciones y remociones automáticamente.
-
Los circuit breakers deben ser por operación. Un CB global puede abrirse por un resolver lento y bloquear a todos los demás. El aislamiento por operación es la diferencia entre una degradación de 30 segundos y una caída de 30 segundos.
-
La detección de inundación previene fallas en cascada. El incidente de
[ComponenteA]mostró que un solo caller mal portado puede vaciar toda la caché. El umbral de 50 miss/10s con auto-flush + re-calentamiento de 30 segundos es la pieza que carga el peso. -
(v2) Los contadores atómicos vencen a los pipelines. El tick de CB con Lua-EVAL es 1 RTT contra el pipeline previo de 3 RTT. La carrera donde "dos fallas concurrentes leen
failures=4y ambas incrementan a 5 sin cruzar el umbral atómicamente" desaparece. -
(v2) Los runners auto-hospedados son obligatorios a escala. El paso de construcción por introspección cruzó los 50 GB de caché de Actions hacia el segundo trimestre de 2026. Los runners GitHub-hosted no pueden subir eso de forma confiable, y la cuota de minutos de Actions de la organización se estaba quemando.
compile-runneres la respuesta a esta escala.
Ancla diagnóstica #3. Si tienes un schema GraphQL auto-generado que pasa de 100 modelos Prisma y aún NO has decidido si la estrategia de calentamiento usa introspección o listas de campos hardcodeadas, esa decisión ya se tomó por ti — por la tasa de renombres, adiciones y remociones de modelos que verás en los próximos 12 meses. La pregunta es si la estrategia de calentamiento absorberá ese churn sin intervención manual, o si la caché de calentamiento se volverá una responsabilidad recurrente. La arquitectura en §3.2 lo absorbe; una lista hardcodeada no.
Limitación #1 de v1 (TTL fijo en 24h): queries que cambian sub-diariamente podrían servir resultados obsoletos.
estado v2: la invalidación por hash de schema ahora también se llavea con el hash del schema Prisma, no solo con los typeDefs de GraphQL. La caché cliente en IndexedDB aplica perfiles de
cacheLife(hours,days) en la capa de respuesta. La obsolescencia sub-diaria está ahora acotada por la ventanastaledel perfil, configurable por ruta.
Limitación #2 de v1 (sin dedup de queries equivalentes): findManyUser(take: 5) y findManyUser(take: 10) producen hashes SHA-256 distintos.
estado v2: los componentes de caché de Next.js 16 permiten
cacheTag('users', 'users-take-5')ycacheTag('users', 'users-take-10')— los tags de segmento permiten revalidación precisa sin re-calentar la familia completa defindManyUser. Combinado con un normalizador de queries futuro (ver §6.3), la brecha de dedup se cierra.
Limitación #3 de v1 (RAM de Redis): 2,135 queries × ~50 bytes ≈ 107 KB — despreciable. A 100K queries únicas, la RAM crece linealmente.
estado v2: sin cambios en principio, pero en la práctica el formato compacto de clave de Lua-EVAL reduce la sobrecarga por entrada ~30%. Aún no llegamos al techo de 100K.
Ancla diagnóstica #4. Si tu presupuesto de RAM en Redis es ajustado, considera que la observación de "100K queries únicas" no es un techo absoluto sino un horizonte de planificación. La pregunta operativa no es "¿cuándo se va a caer?" sino "¿qué tan rápido la compactación por operación se vuelve más barata que la contención por prefix scan?" El Teorema E.6 (probabilidad de convergencia del CB) te da una cota formal; el LZ4 + zstd en disco (§3.5) te da un seguro contra el evento de borde.
- Normalización de queries. Canonicalizar queries antes del hashing:
findManyUser(take: N)→ plantillafindManyUser(take: <N>), luego llavear por plantilla + bucket de argumentos. Se espera elevar la tasa de acierto otros 3–7 pp. - Precarga predictiva. Usar embeddings del grafo de navegación para pre-cachar queries que el usuario probablemente ejecutará después.
- Caché multi-nivel. L1 en memoria (<0.1 ms) → L2 Redis (<1 ms) → L3 CDN (<50 ms) con enrutamiento inteligente.
- Fallback basado en similitud. Embebir los AST de las queries, encontrar el vecino más cercano cacheado, servir su resultado cuando la similitud supere el umbral.
- Penalidad de arranque en frío: cayó de "minutos hasta 80%" a "0 ms después de que el calentamiento termina" — el calentamiento de 5 fases es la piedra angular.
- Dedup de ráfagas por variables: los componentes de caché de Next.js +
cacheTagcierran la brecha de v1 entrefindManyUser(take: 5)y(take: 10)al enrutar la revalidación por segmento. - Costo de CI en tiempo de build: el runner auto-hospedado
compile-runnerelimina el consumo de minutos de GitHub Actions para el paso de construcción por introspección. - Carrera TOCTOU en contadores de CB: los ticks atómicos de CB con Lua-EVAL hacen deterministas las transiciones de estado del CB por operación.
- Salto de RTT completo en el cliente: la capa de IndexedDB + Service Worker salta el origen por completo en el 38.4% de las lecturas repetidas.
Este caso de estudio demuestra que un sistema APQ empresarial bien diseñado puede transformar el perfil de rendimiento de una API GraphQL sobre un schema grande auto-generado:
- La tasa de acierto del 90.9% valida el enfoque de calentamiento proactivo. El calentamiento de 5 fases con introspección de schema cubre el 95% de las queries que los usuarios realmente ejecutan.
- La reducción de ancho de banda (−75%) y la eliminación de parse/validate (−100%) son deterministas. Cada cache hit ahorra exactamente 3–13 ms de CPU y ~190 bytes de ancho de banda.
- El modelo de resiliencia de 3 capas previene fallas en cascada. El incidente de
[ComponenteA]se resolvió automáticamente en 30 segundos sin intervención humana. - El stack v2 cierra las brechas que el stack v1 dejó abiertas. Los componentes de caché de Next.js, IndexedDB, los ticks atómicos de CB con Lua-EVAL, y los runners auto-hospedados
compile-runnerjuntos elevan la tasa de acierto combinada al 94.1% y eliminan el costo de CI en tiempo de build. - El costo del sistema es $0 MXN al mes. Redis ya existía en la infraestructura, el calentamiento corre al arranque, la introspección elimina el calentamiento manual de caché, y la flota de runners auto-hospedados reemplaza a GitHub-hosted Actions en el paso pesado.
La comparación con Apollo Studio ($99–399 USD/mes, 10–50 ms de latencia en nube) muestra que el valor empresarial es replicable con ~80 horas de inversión de ingeniería, amortizadas en el primer mes de operación. Sin egreso de telemetría, sin facturación por query, sin lock-in con proveedor — el stack completo de APQ + Next.js + IndexedDB + runners auto-hospedados está controlado por el operador de extremo a extremo.
Ancla diagnóstica #5. Si tu stack actual se identifica con tres o más de los siguientes: (1) presupuesto mensual de GraphQL administrado superior a $300 USD, (2) retención de telemetría cruzada con un proveedor que también ofrece cómputo, (3) reconstrucción manual del warming list cada release, (4) más de 2 incidentes en 12 meses atribuibles a cold-cache post-deploy, (5) presión regulatoria sobre residencia de datos — entonces el costo total acumulado de la ruta administrada ya excedió la inversión de reproducir este stack, y la ventana de migración favorable es ahora, no en el próximo trimestre. La matemática del Teorema E.5 (ROI break-even) y la convergencia del CB en el Teorema E.6 son la base para presentar esa propuesta internamente sin que se lea como "reinventar la rueda".
- Apollo GraphQL. (2024). "Automatic Persisted Queries." Apollo Documentation.
- Nygard, M. (2018). Release It! Design and Deploy Production-Ready Software. 2da Edición. Pragmatic Bookshelf.
- Fowler, M. (2014). "CircuitBreaker." martinfowler.com.
- Redis Ltd. (2024). "Redis Best Practices." Redis Documentation.
- Facebook (Meta). (2015). "GraphQL Specification." spec.graphql.org.
- Prisma. (2025). "Prisma Client API Reference." Prisma Documentation.
- IETF. (2016). "RFC 7932 — Brotli Compressed Data Format." ietf.org.
- Vercel. (2026). "Next.js 16 Cache Components." nextjs.org/docs.
- W3C. (2024). "Service Workers 1." w3.org/TR/service-workers.
- W3C. (2023). "Indexed Database API 3.0." w3.org/TR/IndexedDB.
- GitHub. (2024). "Self-hosted runners." docs.github.com/actions.
# Estado general de APQ
GET /health/apq
# { status, cache, size, performance, age, circuitBreaker }
# Sincronización de schema
GET /health/apq/schema
# 200 (sincronizado) | 409 (hash no coincide)
# Diagnóstico completo
GET /health/apq/diagnostics
# { status, schema, cache, topQueries, resilience, staleQuerySamples, recommendations }
# Estado de resiliencia
GET /health/resilience
# { circuitBreakers: { global, perOperation }, rateLimiter, apqFlood }
# Métricas Prometheus
GET /metrics
# text/plain (formato Prometheus)<prefix>:apq:query:{sha256} # HASH
├── query: String
├── hash: String (SHA-256)
├── storedAt: String (timestamp ms)
├── hitCount: String
├── lastHitAt: String
└── operationName: String
<prefix>:apq:schema-hash # STRING (SHA-256)
<prefix>:apq:safelist # SET
<prefix>:cb:{operationName} # HASH (state, failures, opened_at)
module.exports = {
apps: [{
name: 'apollo-server',
script: 'dist/<apollo-server>.mjs',
max_restarts: 10,
min_uptime: '10s',
exp_backoff_restart_delay: 1000,
listen_timeout: 15000,
shutdown_with_message: true,
max_memory_restart: '500M',
env: {
APOLLO_SERVER_PORT: <puerto>,
NODE_ENV: 'production',
REDIS_URL: 'redis://localhost:<puerto-redis>'
}
}]
};# 1. Registrar el runner
sudo -u actions-runner ./config.sh \
--url https://github.com/<org>/<repo> \
--token <registration-token> \
--labels compile-runner,prisma,bigdisk \
--unattended
# 2. Instalar como servicio systemd
sudo ./svc.sh install actions-runner
sudo ./svc.sh start
# 3. Montaje de caché de build persistente
# /opt/build-cache es un volumen persistente del runner, montado en el host del runner.
# El workflow lo referencia vía ACTIONS_CACHE_URL=file:///opt/build-cache.
# 4. Verificar
sudo ./svc.sh status
./config.sh --check --url https://github.com/<org>/<repo> --pat <PAT>Enrutamiento del workflow:
name: prisma-introspect
on: [pull_request]
jobs:
build:
runs-on: [self-hosted, compile-runner, bigdisk]
steps:
- uses: actions/checkout@v4
- run: pnpm install --frozen-lockfile
- run: pnpm prisma generate
- run: pnpm run build:schema
# Sin step `actions/cache@v4`: la persistencia es nativa al volumen
# persistente del runner en `/opt/build-cache` del host del runner (montado
# vía ACTIONS_CACHE_URL=file:///opt/build-cache). Agregar actions/cache
# aquí intentaría subir los más de 50 GB del output de Prisma generate
# a la caché remota de GitHub al final del job — derrotando todo el
# punto de mudarse fuera de GitHub-hosted Actions.Teorema 1 — cota superior de la tasa de acierto APQ. Sea
Para
Teorema 2 — composición del ancho de banda. Sea
Para
vs sin-APQ
Teorema 3 — radio de explosión cross-tenant de la caché. La caché APQ se llavea por (operationName, sha256(query)) sin un identificador de tenant. Dos tenants ejecutando la misma query comparten la misma entrada de caché. Con
Para (tenantId, operationName, sha256(query)) cuando el aislamiento multi-tenant importa más que la reutilización de caché.
Teorema 4 — selección del perfil de cacheLife. Los componentes de caché de Next.js 16 exponen tres parámetros de temporización por perfil: stale, revalidate, expire. Para una query con tolerancia de obsolescencia esperada
Seleccionar el perfil más ajustado que satisfaga
Enunciado. Para un esquema de GraphQL administrado con costo mensual
donde
Tabla de sensibilidad (para
|
|
|
|
|
|---|---|---|---|
| 200 | 8.6 meses | 12.9 meses | 17.1 meses |
| 400 | 3.6 meses | 5.4 meses | 7.1 meses |
| 800 | 1.7 meses | 2.5 meses | 3.4 meses |
Interpretación. La sensibilidad a
Enunciado. Sea un circuit breaker con umbral de falla
En el límite estacionario (
Caso canónico del sistema. Con
es decir: bajo carga nominal el CB no abre nunca en la vida útil del sistema. Pero con
Interpretación. El CB es asintóticamente silencioso bajo carga nominal y tasa de apertura predecible bajo carga elevada. La métrica operativa a observar es el percentil p99 de la tasa de falla por resolver; mientras se mantenga <
Enunciado. En un schema de GraphQL con
donde
Caso canónico del sistema. Con
mientras que la cobertura de tráfico (fracción de las solicitudes reales cubiertas) es mayor que
que coincide formalmente pero subestima la cobertura de tráfico real porque las operaciones no top-K tienen frecuencias mucho menores.
Interpretación práctica. Pre-cachear 800/2130 operaciones (38% del schema) cubre ~75% de la cobertura teórica de Zipf, pero >90% del tráfico real (validado empíricamente: la tasa de acierto tras calentamiento es ~90% a pesar de cubrir solo 38% del schema). Esto valida que el calentamiento dirigido a las top-K por rango es eficiente y evita el costo de pre-cachear las 2130 operaciones completas.
Teorema E.8 — Ganancia de throughput por aislamiento cgroup v2 bajo contención. Sea un proceso de compile runner ocupando una slice de cgroup v2 con cpu.weight = W_r. Sea una carga competidora en el mismo host ocupando una slice hermana con cpu.weight = W_o. Cuando el job del runner es CPU-bound y ambas cargas son ejecutables simultáneamente (la condición de contención), el scheduler de CPU del kernel distribuye cómputo proporcionalmente a los pesos. El multiplicador de tiempo esperado para un job de runner de trabajo fijo
donde cpu.weight del default
Caso numérico. Toma un runner compitiendo 50% del wallclock (cpu.max en lugar de cpu.weight habría hecho throttle al runner a un techo fijo sin importar si el host tenía CPU libre; el enfoque basado en peso extrae la ganancia cuando está disponible y cede con gracia cuando el host está ocupado.
Límite. Este modelo asume workload CPU-bound. Cuando io.pressure:some domina sobre cpu.pressure:some en la slice (PSI te dice cuál), la restricción vinculante es I/O, no CPU. En ese régimen, io.weight (o io.latency target=<usec> por dispositivo) es la palanca, y la ecuación de ganancia se re-deriva con cuotas de IOPS sustituyendo a las de CPU. Valida cruzado contra cpu.pressure:some avg300 de la slice; si está consistentemente >5% en horario laboral, aplica el modelo de CPU; si está <1% pero io.pressure:some es >5%, aplica el modelo de I/O.
Este caso de estudio rechaza explícitamente:
- Caché administrado de Apollo Studio ($99–399 USD/mes, 10–50 ms de latencia en nube, egreso de telemetría al proveedor) — §5.2.
- Persisted Queries estáticas (registro manual en tiempo de build, se rompe con cada cambio de schema) — §5.1.
- Caché a nivel de respuesta en CDN (trata los POST de GraphQL como opacos, puede cachear mutaciones incorrectamente) — §5.3.
Todo el estado vive en infraestructura controlada por el operador: Redis en el host propio del operador, sin brokers de terceros, sin pipeline de telemetría, sin embedder externo, sin facturación por query. Sin llamadas implícitas a Sentry, Datadog, OpenTelemetry, ni a ningún proveedor externo de observabilidad. El paso de CI en tiempo de build corre en runners auto-hospedados (compile-runner), no en GitHub-hosted Actions.
Este apéndice recopila los artefactos ejecutables referenciados desde §3.8 — la unit de slice, los hooks del runner, y el script de probe. Son templates; ajusta los valores de recursos al envolvente real del hardware.
# /etc/systemd/system/compile-runner.slice
[Unit]
Description=Compile runner slice — aislamiento cgroup v2 para runner auto-hospedado de Actions
[Slice]
CPUAccounting=yes
MemoryAccounting=yes
IOAccounting=yes
TasksAccounting=yes
CPUWeight=400
MemoryHigh=12G
MemoryMax=16G
TasksMax=4096
IOWeight=200Aplicar y recargar:
sudo cp compile-runner.slice /etc/systemd/system/
sudo systemctl daemon-reload
sudo systemctl restart actions.runner.<org>-<repo>.service
systemd-cgls compile-runner.slice# /etc/systemd/system/actions.runner.<org>-<repo>.service.d/slice.conf
[Service]
Slice=compile-runner.sliceSin este drop-in, el servicio del runner corre en la slice default que hereda del template svc.sh install. Con él, el servicio y cada scope hijo viven bajo compile-runner.slice y heredan su accounting y sus límites.
El hook siguiente crea un scope transitorio por job para que cada job tenga su propio accounting de cgroup, luego registra el baseline de pids.current de la slice para comparación posterior. Configura ACTIONS_RUNNER_HOOK_JOB_STARTED en el .env del runner apuntando a este script.
#!/usr/bin/env bash
# compile-runner-job-started.sh
# Handler de ACTIONS_RUNNER_HOOK_JOB_STARTED.
# Configura scope por job + registra métricas baseline.
set -euo pipefail
JOB_NAME="${JOB_NAME:-unknown}"
START_TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
RUNNER_HOME="${RUNNER_HOME:-/opt/actions-runner}"
METRICS_DIR="${RUNNER_HOME}/_metrics"
mkdir -p "$METRICS_DIR"
# Scope transitorio por job con defaults conservadores.
# Los caps reales a nivel de step vienen del YAML del workflow
# (ej. config de pnpm, threads de Prisma engine), no de aquí.
JOB_UNIT="job-${JOB_NAME//[^a-zA-Z0-9_-]/_}-$(date +%s)"
systemd-run --scope \
--unit="$JOB_UNIT" \
-p CPUWeight=400 \
-p MemoryHigh=14G \
-p MemoryMax=18G \
-p TasksMax=4096 \
-- true || {
# Si systemd-run falla (ej. scope transitorio no soportado en este
# build de systemd), loguea y continúa — los límites a nivel de slice siguen aplicando.
echo "systemd-run --scope falló para $JOB_NAME; cayendo a solo accounting de slice" \
>> "$METRICS_DIR/hook-fallbacks.log"
}
# Snapshot pre-job
{
echo "{\"ts\":\"$START_TS\",\"job\":\"$JOB_NAME\",\"phase\":\"start\"}"
cat /sys/fs/cgroup/compile-runner.slice/pids.current 2>/dev/null | xargs -I{} echo " pids.current={}"
cat /sys/fs/cgroup/compile-runner.slice/memory.current 2>/dev/null | xargs -I{} echo " memory.current={}"
} >> "$METRICS_DIR/job-${JOB_NAME//[^a-zA-Z0-9_-]/_}-$START_TS.log"Registra pids.current y snapshots de PSI de la slice después de que el job termina, para correlacionar duración y tiempo de stall. Advertencia crítica (per docs de GitHub): el hook puede no correr si el runner o el host terminan abruptamente. Para telemetría crítica de wall-clock, prefiere el accounting de cgroup vía los archivos *.stat de la slice poleados por un agente externo (ej. Prometheus node_exporter --collector.cgroups).
#!/usr/bin/env bash
# compile-runner-job-completed.sh
# Handler de ACTIONS_RUNNER_HOOK_JOB_COMPLETED.
set -euo pipefail
JOB_NAME="${JOB_NAME:-unknown}"
END_TS="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
RUNNER_HOME="${RUNNER_HOME:-/opt/actions-runner}"
METRICS_DIR="${RUNNER_HOME}/_metrics"
LOG="$METRICS_DIR/job-${JOB_NAME//[^a-zA-Z0-9_-]/_}-$END_TS.log"
{
echo "{\"ts\":\"$END_TS\",\"job\":\"$JOB_NAME\",\"phase\":\"end\"}"
cat /sys/fs/cgroup/compile-runner.slice/pids.current 2>/dev/null | xargs -I{} echo " pids.current={}"
cat /sys/fs/cgroup/compile-runner.slice/memory.current 2>/dev/null | xargs -I{} echo " memory.current={}"
cat /sys/fs/cgroup/compile-runner.slice/memory.events 2>/dev/null | head -1 | xargs -I{} echo " memory.events={}"
echo " cpu.pressure: $(cat /sys/fs/cgroup/compile-runner.slice/cpu.pressure 2>/dev/null || echo 'n/a')"
echo " io.pressure: $(cat /sys/fs/cgroup/compile-runner.slice/io.pressure 2>/dev/null || echo 'n/a')"
echo " memory.pressure: $(cat /sys/fs/cgroup/compile-runner.slice/memory.pressure 2>/dev/null || echo 'n/a')"
} >> "$LOG"Arnés A/B para afinar valores de slice. Envuelve un build representativo en un systemd-run --scope y compara métricas contra la corrida sin constraints.
#!/usr/bin/env bash
# compile-runner-probe.sh
# Ejecuta un build bajo un scope aislado con límites de cgroup v2 custom,
# luego imprime los stats post-corrida del cgroup. Comparar contra una corrida baseline sin constraints.
set -euo pipefail
PROBE_NAME="${1:-probe-$(date +%s)}"
CMD="${2:-pnpm prisma generate}"
UNIT="${PROBE_NAME}-$(date +%s)"
systemd-run --scope --unit="$UNIT" \
-p CPUQuota="${CPU_QUOTA:-400%}" \
-p MemoryHigh="${MEM_HIGH:-8G}" \
-p MemoryMax="${MEM_MAX:-12G}" \
-p TasksMax="${TASKS_MAX:-2048}" \
-- /usr/bin/time -v bash -c "$CMD" 2>"$UNIT.stderr" 1>"$UNIT.stdout"
CG="$(systemctl show -p ControlGroup --value "$UNIT")"
echo "=== cgroup stats para $UNIT ==="
echo "ControlGroup: $CG"
cat "/sys/fs/cgroup${CG}/cpu.stat" 2>/dev/null || true
echo "--- memory ---"
cat "/sys/fs/cgroup${CG}/memory.events" 2>/dev/null || true
echo "--- PSI ---"
for f in cpu.pressure io.pressure memory.pressure; do
printf '%s: ' "$f"
cat "/sys/fs/cgroup${CG}/$f" 2>/dev/null || echo "n/a"
done
echo "--- wall-clock ---"
grep -E 'Elapsed|User time|System time|Maximum resident' "$UNIT.stderr" || trueMatriz típica de probe:
# Baseline (sin cap de cgroup): medir wall-clock de referencia.
unset CPU_QUOTA MEM_HIGH MEM_MAX TASKS_MAX
./compile-runner-probe.sh baseline-no-cap
# Probar caps de CPU
CPU_QUOTA=200% ./compile-runner-probe.sh cap-cpu-200
CPU_QUOTA=400% ./compile-runner-probe.sh cap-cpu-400
# Probar buffer-absorbente de memoria
MEM_HIGH=8G MEM_MAX=12G ./compile-runner-probe.sh mem-8-12
MEM_HIGH=10G MEM_MAX=14G ./compile-runner-probe.sh mem-10-14El punto de cruce donde subir un cap ya no reduce wall-clock es el óptimo empírico. Multiplica por 1.5–2× de seguridad y tienes un valor de producción defendible para la unit de slice.
Este apéndice desarrolla el mecanismo de tres piezas de §1.3 sobre stacks que no usan GraphQL. Las cifras de este caso provienen de la misma plataforma que el cuerpo del documento; las de terceros son comportamiento por defecto documentado de cada motor, citado en línea. La tesis es una sola: el costo de una intención repetida debe ser cero después de la primera vez, y eso se consigue con un identificador determinista, un almacén y una política de ciclo de vida — no con un framework concreto.
graph TD
A[El cliente formula una peticion] --> B[Normalizar la intencion<br/>y calcular su hash]
B --> C{Artefacto compilado<br/>disponible en el almacen}
C -->|hit| D[Ejecutar el artefacto cacheado]
C -->|miss| E[Compilar una vez<br/>y guardar con TTL]
E --> D
D --> F[Resolver contra los datos]
F --> G[Guardar la respuesta<br/>con TTL y etiqueta]
G --> H[Devolver al cliente]
El invariante que hace útil el diagrama: el costo de la segunda petición idéntica es una lectura de hash, no una interpretación. Si el artefacto compilado no está, se compila una vez y se guarda; el peor caso de una entrada nueva es el mismo costo de siempre, nunca peor.
PostgreSQL no necesita GraphQL para tener las tres piezas; las tiene con otros nombres y una diferencia estructural: no existe caché de resultados nativa. El resultado de un SELECT se recalcula en cada ejecución. Esa diferencia es la que obliga a hacer la equivalencia con honestidad.
Pieza 1 — identidad de la intención. El texto SQL con sus parámetros. Hay dos niveles:
- Statements preparados del cliente (
PREPARE/EXECUTEen SQL, o el protocolo de consulta extendida con named statements en los drivers). El plan se compila una vez y vive mientras viva la sesión; la vistapg_prepared_statementsexpone qué se tiene preparado. - Plan genérico del servidor. Desde PostgreSQL 12, el plan genérico —el plan compilado sin valores concretos de los parámetros— se cachea en el servidor y se comparte entre sesiones. Es la pieza que sobrevive a un pool de conexiones, y la que hace que el modo transaction de PgBouncer no destruya el ahorro.
Pieza 2 — artefacto compilado. El plan del planner, governed por plan_cache_mode:
| Valor | Comportamiento | Cuándo usarlo |
|---|---|---|
auto (por defecto) |
Usa el plan genérico tras 5 ejecuciones si su costo no difiere del promedio de los planes específicos | Consulta con distribución de parámetros estable |
force_custom_plan |
Re-planifica en cada ejecución | Consulta cuyos parámetros cambian mucho de rango (un WHERE tenant_id con un solo tenant dominante) |
force_generic_plan |
Siempre plan genérico | Consulta muy repetida y de costo estable, donde re-planificar es trabajo desperdiciado |
La instrumentación para medirlo es pg_stat_statements: llamadas, filas y tiempo acumulado por statement normalizado. Sin esa vista, el ahorro de plan es invisible — el mismo requisito de medición que §4.1 impone del lado GraphQL.
Pieza 3 — la caché de respuestas no es nativa. Aquí el equivalente de APQ es una capa de aplicación: Redis o Memcached con clave (consulta normalizada + parámetros), TTL y una etiqueta de invalidación. El patrón es idéntico al de §3.1: lo que se cachea no es la consulta, es la respuesta, indexada por la identidad de la intención.
La invalidación cambia de disparador. En GraphQL, el disparador es el hash del schema desplegado (§3.5). En SQL es el cambio de catálogo: una tabla de versión de migraciones consultada por la capa de caché, o el aviso de recarga que PostgREST expone (NOTIFY pgrst, 'reload schema'). El mecanismo es el mismo —un hash o una versión que, al cambiar, invalida el conjunto— con otro evento que lo dispara.
El pool como palanca de capacidad. El segundo knob de PostgreSQL que decide cuántos clientes soporta una instancia no es el caché: es el pool. Con pool_mode = session, cada cliente del pool ocupa un backend durante toda la sesión, de modo que el límite es max_connections menos las conexiones reservadas del superusuario. Con pool_mode = transaction, N clientes comparten el conjunto de backends definido por default_pool_size —20 por defecto— y cada transacción se despacha a cualquiera de ellos. El resultado es el mismo mecanismo que §1.2 describe, con otro nombre: más clientes por servidor sin tocar el servidor. La contrapartida es que en modo transaction el plan específico de sesión se pierde y solo sobrevive el plan genérico del servidor; en modo statement además se exige que el cliente use statements nombrados, porque una sentencia implícita no puede viajar entre backends.
SQLite es el caso donde el mecanismo cabe entero en el proceso de la aplicación, sin servidor de caché:
- Identidad de la intención: el texto SQL del statement. Artefacto compilado: el statement preparado. Con
sqlite3_prepare_v2()el statement se recompila en cada llamada; conSQLITE_PREPARE_PERSISTENT(API v3) el statement compilado sobrevive entre llamadas y se reutiliza — es la forma de obtener el equivalente de un plan cache en un proceso que hace miles de consultas por segundo. - Ciclo de vida de la memoria:
PRAGMA cache_sizefija el presupuesto del page cache —−2000, es decir ~2 MB, en la mayoría de las compilaciones—, yPRAGMA mmap_sizemapea el archivo en memoria en lugar de copiar páginas. La expulsión ocurre dentro de ese presupuesto: el page cache descarta páginas en orden de uso reciente, yPRAGMA shrink_memorydevuelve la memoria al sistema operativo. - Concurrencia: en modo WAL —el modo por defecto desde SQLite 3.7— hay un escritor y muchos lectores simultáneos. Es el perfil natural del patrón "muchas lecturas, una escritura", y el que hace que la caché de respuestas en la aplicación sea una pieza trivial de añadir en lugar de una optimización sofisticada.
- El calentamiento equivalente: preparar al abrir la conexión los N statements más frecuentes es el análogo directo del auto-calentamiento de §3.2, y tiene el mismo efecto sobre el arranque en frío tras un despliegue.
Supabase es PostgreSQL con una capa HTTP delante (PostgREST), un pooler y un proxy de autenticación. Las tres piezas aparecen en cada capa, con un matiz por capa:
- PostgREST mantiene un cache de statements por backend y expone la recarga de catálogo por aviso. Su plan cache es por backend, de modo que el modo transaction del pooler vuelve a ser la decisión que más pesa: con plan genérico en el servidor, el traspaso entre backends no destruye el ahorro; con planes específicos de sesión, sí.
- PgBouncer en modo transaction es el valor por defecto en la plataforma; el modo session queda disponible para operaciones que exigen estado de sesión.
- La caché de respuestas vive en el borde: es donde se reproduce exactamente la arquitectura de §2.5 —una capa de respuestas resueltas, con TTL y control de frescura, delante del origen— y donde elporcentaje de evasión de origen (§4.1: 94.1% con APQ + IndexedDB) se vuelve un número de facturación y no un detalle de implementación.
Lo que cambia para el que no usa GraphQL. La respuesta corta: no cambia el principio, cambian los nombres de las tres piezas y el lugar donde vive la política de expulsión. La larga es la tabla de §1.3 y el resto de este apéndice.
La expulsión —eviction— es la operación por la cual una caché acotada decide a quién expulsa cuando se alcanza su límite. No es un detalle de implementación: es la política que decide si la caché sigue siendo un acelerador o se convierte en una fuente de degradación errática.
graph TD
A[Escritura en la cache] --> B{La cache supero<br/>su limite}
B -->|no| C[La clave queda resident]
B -->|si| D{Que politica de<br/>expulsion aplica}
D -->|volatile-ttl| E[Expulsa primero<br/>lo que expira antes]
D -->|allkeys-lru| F[Expulsa lo menos reciente<br/>puede tocar el conjunto caliente]
D -->|noeviction| G[La escritura falla<br/>y el cliente cae a la via completa]
En Redis la política se declara con maxmemory-policy, y las dos direcciones del fallo son simétricas:
| Política | Qué expulsa | Riesgo en este diseño |
|---|---|---|
noeviction (por defecto) |
Nada: la escritura falla con error | La ruta de miss se convierte en error en vez de en query completa; el cliente degrada de forma visible |
allkeys-lru |
Cualquier clave, por uso reciente aproximado | Una inundación de claves nuevas desplaza al conjunto caliente instalado por el calentamiento: la tasa de acierto se derrumba y el costo de traducción regresa |
volatile-lru |
Solo claves con TTL, por uso reciente | Mejor que allkeys-lru, pero sigue el orden por uso y no por caducidad |
volatile-ttl |
La clave con el TTL más corto entre las que tienen TTL | La correcta para este diseño: el registro de calentamiento y las respuestas caducan antes, y las claves sin TTL no son expulsables |
La nota operativa que hace esta tabla operativa y no decorativa: volatile-ttl solo expulsa claves que tienen TTL. Si el diseño mezcla entradas con TTL (el registro caliente) y entradas sin TTL (una cache de respuestas sin caducidad), las entradas sin TTL son inexpulsables y la memoria crece hasta el límite duro. Cualquier política de expulsión exige responder primero a la pregunta: ¿qué entradas de esta caché tienen fecha de caducidad y cuáles no?
En SQL la expulsión es interna y por eso es más fácil no verla:
| Capa | Mecanismo de expulsión | Consecuencia observable |
|---|---|---|
PostgreSQL shared_buffers |
CLOCK-sweep: aproximación de LRU sobre páginas | Una consulta que barre muchas filas expulsa del buffer las páginas de otras consultas; el síntoma es una consulta que se enfría de forma inexplicable |
| PostgreSQL plan cache | Expulsión por costo estimado de los planes | Las consultas caras se re-planifican más a menudo; el síntoma es latencia estable con picos periódicos |
PostgreSQL work_mem |
Excede el presupuesto y escribe a archivo temporal | Una consulta que de pronto se pone lenta por un join, sin cambio de datos |
| SQLite page cache | LRU bajo el presupuesto de cache_size |
Una base grande con muchas tablas pequeñas trabaja peor de lo que sugiere el hardware |
La invariante que une a todas: la expulsión no debe poder expulsar el conjunto que hace barato el próximo request. En el caso de este documento ese conjunto son las 2,130 queries que el auto-calentamiento instala en cada arranque (§3.2): si la política puede expulsarlas, cada arranque de proceso deja la caché vacía y el primer minuto de tráfico paga traducción completa. La aritmética de ese riesgo está en el Teorema 3 (§Apéndice E): para una caché de
Los números de §1.2 se trasladan al camino de SQL con una sustitución: el costo de parse + validate de 3–13 ms se reemplaza por el costo de parse + plan de la ruta sin statements preparados.
| Camino de GraphQL sin APQ | Camino de SQL sin statements preparados | Camino de SQL con statement preparado y plan genérico | |
|---|---|---|---|
| Costo por ejecución repetida | 3–13 ms | 1–5 ms (parse + plan específico) | ~0.05–0.2 ms (lookup del plan genérico) |
| Costo de primera ejecución | 3–13 ms | 1–5 ms | 1–5 ms |
| Identidad de la intención | SHA-256 del texto | Texto SQL normalizado | Texto SQL normalizado |
| Caché de respuestas | Redis | Capa de aplicación | Capa de aplicación |
El orden de magnitud es el mismo —la repetición es la que se elimina, no la primera ejecución— y la diferencia entre el camino de SQL y el de GraphQL está en el punto de entrada: SQL tiene una vía nativa óptima para eliminar la traducción —el statement preparado—, mientras que GraphQL necesita construirla.
Cinco preguntas, en orden. Si la respuesta a la primera es "no", el resto es irrelevante.
- ¿El servidor re-interpreta la misma intención más de una vez por segundo de forma agregada? Mida el parse + plan como porcentaje de CPU con las herramientas del propio motor (
pg_stat_statements,EXPLAIN ANALYZEen modosummary, contadores del ORM). El criterio es simple: si la traducción supera el 10% de la CPU de la instancia, hay un ahorro medible antes de escribir una línea de caché. - ¿Puedes nombrar la intención con un identificador determinista? Si la consulta incluye valores literales, la normalización es parte del trabajo: dos consultas que difieren solo en un literal producen dos entradas de caché.
- ¿Puedes invalidar por cambio de esquema o de catálogo? Sin invalidación, el caché sirve respuestas obsoletas y el equipo termina desactivándolo.
- ¿Tu política de expulsión está declarada y es coherente con qué entradas tienen TTL? La pregunta inversa —qué entradas no tienen fecha de caducidad y por qué siguen Resident— es la que evita el crecimiento no acotado.
- ¿Puedes calentar al arranque? Si no puedes, cada despliegue es una ráfaga de traducción completa. Es la razón por la que el auto-calentamiento de §3.2 existe, y aplica igual a SQL: preparar los statements más frecuentes al abrir la conexión.
Cuando la respuesta a alguna de las dos primeras es negativa, la conclusión correcta suele ser que el problema no es la caché sino el transporte: comprimir el cuerpo de la petición o mover la lógica al cliente resuelve el mismo síntoma con menos piezas. El criterio de §1.2 es el que decide: la traducción solo se paga si la solicitud llega como texto.
- Un auto-calentamiento de 5 fases que usa introspección del schema al 100% (cero nombres de campo hardcodeados) para pre-cachar ~2,130 queries al arranque, elevando la tasa de acierto en arranque en frío de 0% a ~90% antes de que llegue cualquier tráfico orgánico.
- Un modelo de resiliencia de 3 capas (plugin del servidor + a nivel Redis + a nivel cliente) con circuit breakers por operación, ticks atómicos de CB con Lua-EVAL, y detección de inundación APQ (umbral de 50 miss/10s → auto-flush + re-calentamiento de 30 s).
- Un protocolo de invalidación por hash de schema que vacía la caché APQ atómicamente cuando el SHA-256 de los typeDefs de GraphQL (o del schema Prisma, en v2) cambia, preservando la caché entre reinicios.
- Una capa cliente de componentes de caché de Next.js 16 + IndexedDB + Service Worker que empuja la tasa de evasión de origen combinada al 94.1% (vs 90.9% solo-APQ), cierra la brecha de dedup de
findManyUser(take: N)de v1, y aplica perfiles decacheLifeauditables desde la capa de aplicación. - Un runner de compilación auto-hospedado (
compile-runner) que elimina los minutos de GitHub Actions para el paso de construcción por introspección de 50 GB+, con caché de build local persistente (clave por contenido) en un volumen montado en el runner para restauraciones 50–200× más rápidas.
- Schemas pequeños (< 50 modelos, < 200 operaciones). El auto-calentamiento introspecta el schema completo; los ahorros en parse+validate (3–13 ms) no van a pagar la complejidad operativa. Usa el comportamiento por defecto de Apollo Client o persisted queries estáticas.
- Patrones de queries con ráfagas variables (facetas de búsqueda generadas por el usuario, filtros dinámicos). El hash SHA-256 incluye el texto completo de la query incluyendo variables, así que
findManyUser(take: 5)yfindManyUser(take: 10)siguen generando hashes distintos — incluso con componentes de caché de Next.js, los tags de segmento ayudan pero el dedup APQ subyacente es parcial. Considera primero un normalizador de queries. - Schemas que cambian sub-diariamente. El TTL de 24 horas más la invalidación por hash de schema captura cambios de schema, no deriva de datos. Para datos sensibles al tiempo, usa una estrategia de ETag por fila encima.
- Tráfico de lectura pesada con requisitos estrictos de frescura. APQ es solo del lado lectura. Las mutaciones y escrituras no son afectadas por la caché y pasan por el pipeline completo. El +125% de rendimiento aplica solo a lecturas.
Este caso de estudio forma parte de una serie de investigaciones técnicas públicas, autoría del operador:
- Matemáticas del RAG Soberano (cotas de Chernoff-Hoeffding aplicadas a pipelines de recuperación). Par español + inglés.
- Hashing de Características y Preservación de Métricas (hashing de características bajo restricciones de preservación de métricas). Par español + inglés.
- Fundamento matemático para compactación de contexto local O(1) (FNV-1a 128-dim + normalización L2 + similitud coseno). Par español + inglés.
- Proxy Inverso SSH y Cadena de Evasión de 5 Niveles (QUIC · Hysteria2 · gost · tls-direct · direct-ssh fallback).
- Parche C + DKMS para NVIDIA 550.x/580.x en Linux Kernel 7.0+ (Wayland USB-C D3cold + nota strlcpy → strscpy).
- Evidencia de inyección CRLF en tiempo de ejecución de NGINX y validación de bifurcación de rama.
- Modo de falla documentado: reproducción HLS rota en Chromium 148 (coincidencia source-list de CSP + bloqueo de fetch data: URI).
Todos los documentos compilados comparten las mismas invariantes: evidencia de producción, sin lenguaje de marketing, internals saneados.
Esta arquitectura ha sido probada en plataformas CMS empresariales con cientos de modelos Prisma y miles de operaciones GraphQL. Si operas un stack GraphQL auto-hospedado con restricciones similares (schema grande auto-generado, aislamiento multi-tenant, presupuestos de latencia estrictos, cero tolerancia a SaaS), el operador hace consultoría arquitectónica y trabajo de integración.
- Investigación / consultas técnicas: [email protected]
- Comercial / alianzas: [email protected]
- Divulgación responsable / seguridad: [email protected]
- Sitio: https://loust.pro
© 2026 David Mireles — LOUST.PRO. Todos los derechos reservados. Este documento es un caso de estudio técnico-investigativo del portafolio de ingeniería de LOUST.PRO.