El mapa del blog: de la acometida eléctrica al token servido

Este blog empezó en marzo de 2026 con un puñado de artículos sobre Kubernetes y networking, y a estas alturas acumula más de 150 piezas que, vistas de una en una, parecen temas sueltos: PagedAttention, generadores diésel, OpenCost, SPIFFE, refrigeración por inmersión, RAGAS. No lo son. Todas describen el mismo objeto desde alturas distintas: una factoría de inferencia soberana, es decir, la máquina completa que convierte megavatios de la red eléctrica en tokens servidos a un usuario, con la propiedad y el control del dato dentro de casa.

Este artículo es el índice de esa máquina. Ordena lo publicado en diez capas, de abajo arriba, y en cada una enlaza lo que hay escrito. Sirve para tres cosas: encontrar un tema concreto, ver qué capas están cubiertas a fondo y cuáles quedan a medias, y elegir un recorrido de lectura según el problema que se tenga delante.

El mapa

La lectura del mapa es de abajo arriba, y el criterio para ordenarlo es la dependencia física: no hay motor de inferencia sin GPU alimentada y refrigerada, no hay RAG sin motor que sirva embeddings, no hay cumplimiento normativo demostrable sin observabilidad que registre lo que pasó. La capa 10 es la excepción y por eso aparece atravesándolo todo: coste, rendimiento y energía no son un piso del edificio, son la medida del edificio entero.

Capa 0 · Infraestructura física

La vertical más reciente, y la que cierra el círculo: el camino del vatio desde la acometida hasta el chip, y el camino del calor desde el chip hasta la atmósfera.

• La cadena de energía: redundancia, Tier, kW frente a kVA, PUE, densidad de la IA y el límite de la red.
• Los generadores: NFPA 110, transitorios, dimensionado, diésel frente a gas, combustible y paralelización.
• La conmutación: ATS frente a STS, la ventana ITIC, transición abierta y cerrada, y los caminos A y B.
• El SAI y el ride-through: topologías IEC 62040-3, eco-mode, volante de inercia, litio frente a plomo y las cargas pulsantes de la IA.
• El reto térmico: por qué la densidad de la IA rompió el aire, y el espectro de soluciones.
• El aire y sus límites: CRAC y CRAH, la geometría del caudal, la ley cúbica, contención, ASHRAE y las puertas traseras.
• El líquido directo al chip: placa fría, CDU, bucles TCS y FWS, química del refrigerante y fugas.
• La inmersión y el horizonte del megavatio: monofásica y bifásica, el muro de los PFAS y la microfluídica en el silicio.

Capa 1 · El nodo

Dentro de la máquina, antes de que exista ningún proceso: los buses, la memoria y la topología que deciden cuánto rendimiento acaba llegando al modelo.

• Topología PCIe, GPUDirect y ACS: los pasillos por los que viajan los tensores.
• NUMA, hugepages y aislamiento de CPU: por qué el vecino de socket te cuesta latencia.
• NVLink, NVSwitch y NCCL: el cable por el que se reparte un modelo grande.
• NUMA de red con Cilium y DraNet: la puerta de la cocina que nadie mira.
• CPU, Memory y Topology Manager en RKE2: cómo se pide una GPU con afinidad y sin sorpresas.
• SM, CUDA streams y CUDA graphs: dónde se pierde el tiempo dentro del acelerador.
• Entornos mixtos NVIDIA e Intel: del cluster homogéneo al parque real.
• Medir la potencia de una GPU: la metrología del sensor, que pertenece a la vez a esta capa y a la 10.

Capa 2 · Almacenamiento

• Estado del arte, rendimiento, seguridad y disponibilidad: la serie de cuatro sobre el almacenamiento que sostiene pesos, corpus y checkpoints.
• Del disco a la HBM: por qué arrancar un modelo tarda lo que tarda.
• Acelerar el cold start: de minutos a segundos con serialización y caché.

Capa 3 · El cluster

• vLLM en Kubernetes: la pieza de inferencia que sí escala.
• Operators de inferencia LLM: OME, vLLM Production Stack y compañía.
• El cluster GPU como plataforma multi-tenant: de máquina compartida a servicio.
• Compartir una GPU: time-slicing, MPS y MIG: las tres formas de partir un acelerador.
• Volcano y Kueue: gang scheduling, colas y cuotas.
• Autoscaling con HPA y KEDA: escalar por métricas que signifiquen algo.
• Servir varios modelos en una GPU: co-residencia, swap y sleep.
• Capacity planning on-premise: del SLO al número de nodos.
• GitOps del stack con Flux: operar la plataforma como código.
• Cilium BGP en RKE2 y eBPF de cero a Cilium: la red por debajo de todo lo anterior.

Capa 4 · El motor de inferencia

El bloque más denso del blog: vLLM abierto en canal, pieza a pieza.

• KV cache y PagedAttention: la memoria de trabajo y su gestor de bloques.
• Continuous batching y el scheduler step: cómo se arma cada ronda de trabajo.
• Optimizar el prefill y optimizar el decode: las dos fases y sus mandos.
• El backend de atención y FlashAttention: el núcleo del cálculo.
• Prefix cache: ingeniería del hit rate y batch sizing con grid search: los dos ajustes que más rendimiento regalan.
• Disaggregated serving y una réplica grande o muchas pequeñas: las decisiones de topología.
• Contexto largo y KV offloading: la jerarquía de memoria del KV cuando la ventana no cabe en la HBM.
• Structured output y function calling: sujetar la salida del modelo.
• Servir modelos de razonamiento: el borrador invisible que pagas igual.
• Multimodal on-premise con vLLM y servir embeddings y rerankers con TEI: los otros modelos del stack.
• El roofline invertido: por qué un modelo pequeño no se optimiza igual que uno grande.

Capa 5 · El modelo

Todo lo que se le hace al modelo antes de servirlo, o mientras se sirve.

• Quantization para inferencia, FP8 end-to-end, cuantización agresiva sub-4-bit y cuantizar en caliente.
• Poda y destilación: reducir sin amputar, y enseñar a un modelo pequeño.
• MoE en inferencia y arquitecturas nativas para device.
• Multi-LoRA serving, QLoRA y multi-LoRA al límite y el runbook QLoRA completo.
• Speculative decoding y self-speculative con early exit.
• Alignment moderno: DPO, KTO, ORPO y SimPO.
• Fine-tuning continuo y retrain: cerrar el bucle.

Capa 6 · Datos y RAG

• Ingesta documental del PDF al chunk indexado y curación del corpus.
• Embeddings en 2026 y reranker con hybrid retrieval.
• PostgreSQL y Qdrant en la ingestión, Debezium y CDC y RAG sobre Kafka.
• Caché semántica: el recepcionista con memoria.
• RAG en CPU y RAG agresivo en modelos pequeños.
• Evaluar un RAG sin engañarse: RAGAS y el golden dataset.
• Ontologías y knowledge graphs y data versioning con DVC y lakeFS.

Capa 7 · Plano de control y entrega

• Elegir el gateway OSS y el router de inferencia L7: la centralita por delante del motor.
• KServe y el Open Inference Protocol: el plano de control estándar.
• Registro y distribución de modelos con OCI y ORAS: dónde viven los bytes.
• Canary, blue-green y shadow: desplegar un modelo sin romper el servicio.
• Prompt versioning: el contrato que evita el susto.
• MCP por dentro y ponerle autenticación con Keycloak.
• Montar un asistente soberano end-to-end, con todas las piezas anteriores funcionando juntas, es el ejercicio que cierra esta capa y está pendiente de publicación.

Capa 8 · Observabilidad y evaluación

• Tracing con OpenTelemetry GenAI e instrumentar vLLM con OTel.
• Langfuse por dentro: el centro de clasificación de trazas.
• Observabilidad GPU con DCGM y anatomía de las métricas DCGM y vLLM.
• Evals: la capa después del tracing y LLM-as-judge.
• Runbooks de incident response: de la alerta a la acción.
• Hubble, AgentSight y detección de drift con eBPF: observar sin instrumentar.

Capa 9 · Seguridad, confianza y cumplimiento

• Guardrails y safety y LLM Guard: las líneas de defensa alrededor del modelo.
• Hardening y secretos del stack soberano.
• Aislar agentes de IA del workspace y el runbook con bubblewrap y Tetragon, con Tetragon como base.
• Firma, procedencia y AIBOM e identidad y aislamiento con SPIFFE y Confidential Containers.
• ISO/IEC 42001, el EU AI Act artículo por artículo y el mapeo cruzado ENS, 42001 y AI Act.
• Cumplimiento en sanidad y en defensa: la misma infraestructura ante dos marcos sectoriales.

Capa 10 · Coste, rendimiento y energía

El track de datos, escrito con un formato distinto al resto del blog: tablas, cifras y fuente verificable, sin analogías. Son los artículos que sostienen una decisión de inversión.

FinOps: modelo de coste y estado del arte, OpenCost a fondo, Kubecost frente a OpenCost, del GPU-hora al coste por token, chargeback y showback, el coste del GPU idle, cloud GPU y neoclouds, TCO completo on-premise y FinOps multi-tenancy con LiteLLM.

Benchmarking: frameworks y métricas, catálogo de herramientas, GuideLLM y el SLO bajo carga, GenAI-Perf a fondo, cómo leer MLPerf Inference, sesgo de medición y reproducibilidad, benchmarks de calidad y la frontera de Pareto entre motores.

Energía: medir la potencia de la GPU, energía por token en España, frameworks de benchmarking energético, medir en producción con Kepler y DCGM, MLPerf Power, leaderboards de Wh por token, del vatio al carbono, palancas de eficiencia y la energía en el TCO y en la regulación.

Síntesis: los tres ejes y la identidad que los une, on-premise soberano frente a hyperscalers, con datos, del SLO al número de GPUs y el harness reproducible.

A esa lista se suman dos piezas de coste que no son de GPU: el coste de los agentes con durable execution y el coste por petición del gateway.

Los mapas maestros

Cinco artículos anteriores hacen de plano general y siguen siendo la mejor puerta de entrada para quien llega nuevo:

• El pipeline LLMOps de seis etapas: el mapa maestro del ciclo de vida.
• Las siete capas del stack on-premise: la versión de arquitectura de este mismo mapa.
• Anatomía de una petición LLM en producción: una request real atravesando todas las capas.
• Cinco niveles de madurez de la plataforma y siete fases de despliegue greenfield: dónde estás y qué toca después.
• El catálogo OSS ficha por ficha y el catálogo paralelo frente a los hyperscalers: qué herramienta para cada etapa.
• MLOps para LLMs en 2026: el panorama de partida.

Cuatro recorridos

Voy a montar la primera plataforma. Panorama y pipeline de seis etapas, siete capas del stack, siete fases de despliegue, capacity planning, vLLM en Kubernetes, gateway, observabilidad con OTel y Langfuse, y guardrails antes de abrir la puerta.

Tengo el cluster y no me llega el rendimiento. Anatomía de una petición, KV cache y PagedAttention, prefill y decode, prefix cache, batch sizing, GuideLLM para encontrar el punto de saturación, sesgo de medición para no engañarte con los números, y la frontera de Pareto entre motores.

Tengo que justificar la inversión ante dirección. Los tres ejes, TCO on-premise, coste por token, GPU idle, on-premise frente a hyperscalers, dimensionar y justificar, y el harness reproducible para que las cifras aguanten una auditoría.

Me toca la sala, no el software. La cadena de energía, los generadores, el reto térmico, el aire y sus límites, el líquido directo al chip, la inmersión, y de ahí a almacenamiento y a la topología del nodo.

Lo que falta

El mapa también sirve para ver los huecos, y hay seis identificados:

• Portal interno y autoservicio: Backstage y la experiencia de desarrollador sobre la plataforma.
• Comparativa de bases vectoriales: Milvus, Qdrant, pgvector y OpenSearch con datos, más allá de las menciones sueltas.
• Kubeflow a fondo, que aparece citado pero nunca desarrollado.
• Lakehouse para RAG: Iceberg y Trino como sustrato del corpus.
• Knative y scale-to-zero para inferencia intermitente.
• Gestión fuera de banda: OpenBMC, Redfish y DCIM, que es justo el puente entre la capa 0 y la capa 3.

Ver también

• Empieza aquí: la ruta de lectura por perfil y por vertical, incluidas las de Kubernetes y networking que este mapa deja fuera.
• Anatomía de una petición LLM en producción: si solo vas a leer un artículo del blog, que sea ese.