Cuando un equipo de Data Science deja por fin listo para producción un gran modelo de lenguaje o de embeddings, suele aparecer la tentación de resolverlo «por la vía rápida»: coger un Dockerfile, meter dentro Python, FastAPI y la librería Transformers, escribir una ruta /predict y desplegar un manifiesto Deployment corriente en el clúster de Kubernetes.
La primera semana todo pinta de maravilla. Pero enseguida empieza la cruda rutina de la infraestructura:
- Sube la carga: el
HorizontalPodAutoscaler(HPA) integrado se guía por el uso de CPU o memoria del nodo. Sin embargo, la tarjeta gráfica GPU puede estar al 100% solo por la asignación del caché KV, ¡incluso aunque no haya peticiones en curso! El HPA empieza a multiplicar pods sin control, acaparando todas las tarjetas libres del clúster. - Por la noche llega la calma: no hay tráfico, pero los pods siguen levantados, reservando instancias con NVIDIA A100 o H100 a varios dólares la hora por cada acelerador.
- Toca desplegar una nueva versión de los pesos del modelo: ¿cómo desviar un 10% del tráfico a un canary sin saturar la memoria ni duplicar la infraestructura?
Para resolver estos problemas siguiendo un estándar industrial, la comunidad de la Cloud Native Computing Foundation (CNCF) creó el proyecto KServe (antes conocido como KFServing). Veamos la arquitectura de KServe, su integración con el runtime vLLM y la configuración paso a paso de un manifiesto InferenceService.
Arquitectura de KServe: ¿de qué piezas consta la plataforma?
KServe no es un simple binario aislado. Es un operador de Kubernetes que coordina con soltura tres capas fundamentales muy potentes:
- Capa de red (Istio Service Mesh): aporta enrutamiento inteligente del tráfico entrante, cifrado mTLS, división de flujos para lanzamientos canary (Traffic Splitting) y recogida detallada de métricas de latencia.
- Capa serverless (Knative Serving): asume el control del ciclo de vida de las réplicas, la interceptación de colas mediante el sidecar
queue-proxyy el escalado a cero (Scale-to-Zero) cuando no hay carga. - Capa de runtimes de inferencia: KServe soporta entornos de ejecución ya optimizados: vLLM, Triton Inference Server de NVIDIA, HuggingFace TGI, TorchServe y ONNX Runtime.
En lugar de ensamblar a mano pieza por pieza un Deployment, Service, Ingress, HPA y políticas de red, el ingeniero de plataforma declara un único Custom Resource: InferenceService.
Los creadores de la plataforma dividen el pipeline de procesamiento en tres eslabones lógicos:
- Transformer: servicio auxiliar de preprocesamiento (por ejemplo, tokenización de texto o redimensionado de imágenes) y posprocesamiento de resultados.
- Predictor: el núcleo de cómputo principal, donde residen los pesos del modelo y las GPU.
- Explainer: nodo especializado en interpretabilidad (LIME, SHAP) que explica la lógica de la decisión tomada por el modelo.
Esta separación permite mover la carga ligera de CPU (la tokenización) a nodos de cómputo baratos, dejando la costosa memoria de la GPU exclusivamente para el cálculo de tensores. También abordamos cómo diseñar bien la infraestructura para redes neuronales al analizar la aplicación de patrones de diseño de Kubernetes a cargas de trabajo de grandes modelos de lenguaje.
El papel de vLLM: batching continuo y PagedAttention
En los pipelines modernos de LLM, el cuello de botella casi siempre está en la gestión de la memoria de vídeo (VRAM). Las librerías tradicionales reservan memoria de forma estática para la longitud máxima de contexto, lo que provoca una fragmentación brutal: entre el 60% y el 80% de la VRAM acaba desperdiciándose sin uso.
Esquema arquitectónico del mecanismo PagedAttention y el batching continuo de vLLM: asignación dinámica de páginas de memoria del caché KV sin fragmentación de la VRAM.
El motor vLLM introdujo el algoritmo PagedAttention: la memoria para el caché Key-Value de atención se asigna dinámicamente en páginas de tamaño fijo, igual que las páginas de memoria virtual en los sistemas operativos. Combinado con el batching continuo (Continuous Batching), vLLM permite empaquetar en una sola GPU entre 2 y 4 veces más peticiones simultáneas con una latencia mínima hasta el primer token (TTFT).
KServe v0.14+ soporta vLLM como ServingRuntime nativo.
Guía paso a paso: despliegue de InferenceService
Despleguemos un servicio en producción para el modelo Qwen-2.5-7B-Instruct usando KServe y vLLM.
Paso 1: Preparación del clúster
Necesitarás un clúster de Kubernetes 1.28+ con los operadores NVIDIA GPU Operator, Istio, Knative Serving y KServe Operator instalados. El modelo ya está guardado de antemano en el bucket corporativo de S3 s3://ml-models/qwen-2.5-7b-instruct/.
Paso 2: Manifiesto InferenceService
Creamos el archivo qwen-inference.yaml:
apiVersion: serving.kserve.io/v1beta1
kind: InferenceService
metadata:
name: qwen-llm-service
namespace: ml-inference
annotations:
serving.kserve.io/autoscalerClass: "kpa"
autoscaling.knative.dev/target: "10"
autoscaling.knative.dev/metric: "concurrency"
spec:
predictor:
minReplicas: 1
maxReplicas: 5
model:
modelFormat:
name: vLLM
storageUri: "s3://ml-models/qwen-2.5-7b-instruct/"
resources:
limits:
cpu: "8"
memory: "32Gi"
nvidia.com/gpu: "1"
requests:
cpu: "4"
memory: "16Gi"
nvidia.com/gpu: "1"
args:
- "--model=/mnt/models"
- "--tensor-parallel-size=1"
- "--max-model-len=8192"
- "--gpu-memory-utilization=0.9"
Repasemos los parámetros clave:
storageUri: KServe lanza automáticamente un contenedor init auxiliarStorage Initializerque descarga los pesos del modelo desde S3 al volumen local del pod antes de arrancar vLLM.autoscaling.knative.dev/metric: "concurrency": el escalado no mira la CPU, sino el número de peticiones atendidas simultáneamente por réplica (objetivo: 10 sesiones paralelas).minReplicas: 1: para modelos grandes conviene mantener al menos una réplica caliente para que los usuarios no tengan que esperar un arranque en frío.
Aplicamos el manifiesto:
kubectl apply -f qwen-inference.yaml
Paso 3: Verificación del estado y prueba de inferencia
Comprobamos el estado del despliegue desde la CLI:
# Comprobamos el estado de los pods y la URL del servicio
kubectl get inferenceservice qwen-llm-service -n ml-inference
En la salida del comando, el campo READY debe pasar a True y en la columna URL aparecerá la dirección asignada al servicio.
Ahora probamos el modelo mediante el endpoint estándar compatible con OpenAI:
curl -s -X POST "http://istio-ingressgateway.istio-system.svc.cluster.local/v1/chat/completions" \
-H "Host: qwen-llm-service.ml-inference.example.com" \
-H "Content-Type: application/json" \
-d '{
"model": "qwen-llm-service",
"messages": [
{"role": "system", "content": "Ты опытный инженер-исследователь."},
{"role": "user", "content": "В чем главное преимущество PagedAttention?"}
],
"max_tokens": 128,
"temperature": 0.7
}'
Arranque en frío y compromisos de Scale-to-Zero
El escalado a cero (minReplicas: 0) es una idea magnífica sobre el papel: si por la noche no hay peticiones, los pods se apagan y la empresa no paga por el alquiler de las GPU.
Sin embargo, en la práctica el arranque en frío de un modelo de 15–30 gigabytes consta de tres fases:
- Lanzamiento del pod y planificación en el nodo (5–15 s).
- Descarga de los pesos desde S3 por la red interna del clúster (20–60 s).
- Carga de los tensores en la memoria de la GPU (VRAM) y compilación del grafo CUDA (15–30 s).
Al final, el primer cliente que llega puede esperar más de un minuto por su respuesta. Así que el equilibrio es sencillo: para tareas batch internas en segundo plano puedes fijar minReplicas: 0 sin miedo. Pero para bots conversacionales y servicios orientados al cliente mantén minReplicas: 1, dejando al autoescalado únicamente los picos de tráfico.


