Sobre el papel, tu clúster de Kubernetes tiene margen: las requests de CPU declaradas por tus contenedores de aplicación representan apenas la mitad de la capacidad de los nodos. Sin embargo, hay pods que se quedan en Pending con un mensaje Insufficient cpu, y el autoscaler de nodos añade máquinas antes de lo previsto. Antes de acusar al scheduler, hay que mirar de cerca lo que Kubernetes reserva realmente para cada pod: sus requests de CPU efectivas.
La cifra que se suma espontáneamente (la suma de las requests de los contenedores de aplicación) no es la que usa el scheduler. Kubernetes calcula un valor efectivo a nivel de pod, que tiene en cuenta los contenedores de inicialización, los sidecars nativos y, desde hace poco, los recursos declarados directamente en el pod. Este valor no aparece en ningún campo de la API: hay que recalcularlo.
Dynatrace SaaS hace este cálculo en la ingesta, para cada pod, sin configuración particular siempre que la monitorización de Kubernetes pase por un ActiveGate (solo Grail). Este artículo explica de dónde viene la diferencia, cómo localizarla con DQL en Grail y cómo integrarla en tus decisiones de capacidad.
Por qué la suma de los contenedores miente a veces
Un pod atraviesa dos fases. Durante la fase de inicialización, los init containers se ejecutan uno por uno, y cada uno debe terminar antes del siguiente. Durante la fase de ejecución, los contenedores de aplicación funcionan en paralelo, acompañados de los posibles sidecars nativos (init containers declarados con restartPolicy: Always, que arrancan pronto y siguen activos durante toda la vida del pod).
El scheduler debe garantizar que el pod podrá atravesar las dos fases en el mismo nodo. Por tanto, retiene el máximo entre:
- la suma de los contenedores de aplicación y de los sidecars (fase de ejecución);
- el init container más grande, aumentado con los sidecars declarados antes que él (fase de inicialización).
La misma lógica se aplica a los límites, que el kubelet impone después al cgroup del pod. En la mayoría de los casos, los init containers son ligeros (esperar una dependencia, obtener un secreto) y domina la fase de ejecución: la suma ingenua es correcta. La trampa aparece cuando la inicialización es más exigente que la propia aplicación.
Un ejemplo concreto
Tomemos un servicio de inferencia cuyo init container descarga y descomprime un modelo voluminoso, con una request de 2 núcleos, mientras que el contenedor de aplicación se conforma con 250m una vez que el modelo está en memoria. kubectl describe pod muestra 250m para el contenedor de aplicación. El scheduler, en cambio, ha reservado 2000m: ocho veces más. Multiplica por una veintena de réplicas y la diferencia se cuenta en nodos enteros. Las migraciones de esquema de base de datos ejecutadas en un init container producen exactamente el mismo efecto.
El caso de los recursos a nivel de pod
Kubernetes 1.34 ha pasado la funcionalidad PodLevelResources a beta, activada por defecto. Permite fijar requests y límites en el pod entero en lugar de contenedor por contenedor. Consecuencias que conviene conocer:
- un límite a nivel de pod puede ser inferior a la suma de los límites de los contenedores: cada contenedor parece tener margen, pero el cgroup del pod limita el conjunto. En memoria, eso significa un OOM kill que la vista por contenedor no permitía prever;
- una request a nivel de pod solo puede elevar la reserva: Kubernetes rechaza un valor inferior a la suma de los contenedores;
- requests y límites, CPU y memoria, se tratan de forma independiente: un mismo pod puede combinar valores a nivel de pod y valores calculados a partir de los contenedores.
Requests de CPU efectivas: lo que hace Dynatrace en la ingesta
Las métricas de recursos siguen almacenándose por contenedor en Grail: dt.kubernetes.container.requests_cpu, dt.kubernetes.container.requests_memory y sus equivalentes para los límites. Cada contenedor de aplicación y cada sidecar conserva su propia serie. Cuando la simple suma daría un valor erróneo, Dynatrace añade un punto de datos de compensación en la misma métrica, asociado al pod pero sin nombre ni tipo de contenedor. Este delta es positivo cuando domina la inicialización o cuando una request a nivel de pod eleva la reserva, y negativo cuando un límite a nivel de pod rebaja el techo. La compatibilidad depende de la versión del ActiveGate: sidecars nativos desde 1.339, compensación de los init containers a partir de 1.343, recursos a nivel de pod y overhead de RuntimeClass a partir de 1.345.
La ventaja de este enfoque: tus agregaciones existentes (suma por pod, por workload, por namespace, por nodo) pasan a ser correctas sin reescribirlas, y los valores por contenedor quedan intactos para el análisis detallado.
En la práctica
Paso 1 — Localizar los pods afectados
En un Notebook, busca las filas de compensación: son las que no tienen la dimensión dt.smartscape.container. Ojo, k8s.cluster.name, k8s.pod.name o k8s.workload.name son propiedades de la entidad y no dimensiones de la métrica: por eso se agrupa por dt.smartscape.* y después se recuperan esas propiedades con un lookup sobre Smartscape.
timeseries cpu = sum(dt.kubernetes.container.requests_cpu),
by: { dt.smartscape.k8s_pod, dt.smartscape.container },
from: now()-30m
| filter isNull(dt.smartscape.container)
| lookup [ smartscapeNodes "*" | filter type == "K8S_POD"
| fields id, cluster = k8s.cluster.name, pod = k8s.pod.name ],
sourceField: dt.smartscape.k8s_pod, lookupField: id
| fieldsAdd cluster = lookup.cluster, pod = lookup.pod, delta_millicores = arrayLast(cpu)
| filter cluster == "prod-eu"
| fields pod, delta_millicores
| sort delta_millicores desc
Los valores de CPU de esta métrica se expresan en millicores. Los deltas más altos señalan los pods cuya inicialización cuesta mucho más que la ejecución.
Paso 2 — Comparar el valor mostrado y el valor efectivo
Para un workload sospechoso, muestra el detalle por contenedor y el total. La suma de todas las filas, incluida la que no tiene contenedor, da la reserva efectiva.
timeseries cpu = sum(dt.kubernetes.container.requests_cpu),
by: { dt.smartscape.k8s_pod, dt.smartscape.container, k8s.container.type },
from: now()-30m
| lookup [ smartscapeNodes "*" | filter type == "K8S_POD"
| fields id, wl = k8s.workload.name, pod = k8s.pod.name ],
sourceField: dt.smartscape.k8s_pod, lookupField: id
| fieldsAdd wl = lookup.wl, pod = lookup.pod, millicores = arrayLast(cpu)
| filter wl == "model-server"
| fields pod, dt.smartscape.container, k8s.container.type, millicores
| sort pod asc
Repite el ejercicio con dt.kubernetes.container.limits_memory para los pods que usan recursos a nivel de pod: un delta negativo señala un techo de memoria más estricto de lo que dejan creer los contenedores.
Paso 3 — Corregir la causa, no el síntoma
Una vez identificados los pods, tienes varias opciones:
- sacar el trabajo pesado del init container a un
Jobde Kubernetes dedicado, ejecutado una vez por despliegue en lugar de en cada arranque de réplica; - revisar la request del init container: muchos están sobredimensionados «por seguridad» cuando una descarga está limitada sobre todo por la red;
- para los pods con límite de memoria a nivel de pod, comprobar que la suma de los consumos reales de los contenedores se mantiene por debajo del techo común.
Paso 4 — Recalibrar los dashboards de capacidad
Revisa tus Dashboards y consultas de capacidad: si ya suman la métrica por pod o por nodo, integran automáticamente los deltas. Si filtran por k8s.container.type o excluyen las filas sin dt.smartscape.container, subestiman la reserva. Un tile «diferencia entre la suma de aplicación y la reserva efectiva» por namespace es un buen indicador que seguir.
Buenas prácticas
- Basa el dimensionamiento de los pools de nodos en la reserva efectiva, nunca en la sola suma de los contenedores de aplicación.
- Ten presente que los umbrales de HPA expresados en porcentaje se apoyan en las requests de los contenedores: la reserva efectiva sirve, en cambio, para la ubicación y la capacidad.
- Agrupa por las dimensiones
dt.smartscape.*y asocia clúster, namespace o workload con unlookup: filtrar directamente pork8s.cluster.nameen untimeseriesno funciona. - Antes de adoptar
PodLevelResourcesa gran escala, prueba con unos pocos workloads y observa los deltas negativos en los límites de memoria. - Documenta en tus revisiones de capacidad los workloads con inicialización pesada: son los que falsean las estimaciones.
Preguntas frecuentes
¿Por qué kubectl no muestra la request efectiva del pod?
Porque este valor no existe en ningún campo de la API: el scheduler lo calcula a partir de los contenedores de aplicación, los init containers, los sidecars nativos y los posibles recursos a nivel de pod. kubectl describe pod muestra los valores declarados contenedor por contenedor.
¿Hay que reescribir mis consultas DQL de capacidad?
No, si ya suman la métrica por pod, workload, namespace o nodo: los deltas de compensación quedan integrados. Sí, si filtran por k8s.container.type o excluyen las filas sin dt.smartscape.container, porque entonces subestiman la reserva.
¿Qué significa un delta negativo?
Un límite fijado a nivel de pod es inferior a la suma de los límites de sus contenedores. Cada contenedor parece tener margen, pero el cgroup del pod limita el conjunto: en memoria, es un riesgo de OOM kill que la vista por contenedor no muestra.
Conclusión
La cifra mostrada por contenedor es exacta, pero no responde a la pregunta que se hace un equipo de plataforma: ¿cuánto ha reservado realmente el clúster? Al calcular el valor efectivo en la ingesta y exponerlo como delta en las métricas existentes, Dynatrace SaaS hace accesible esa respuesta con una simple agregación DQL. Con la generalización de los recursos a nivel de pod, este reflejo se vuelve indispensable para evitar malas sorpresas de planificación y OOM kills inexplicados.
Para ir más lejos: Your pod may be requesting 25× more CPU than you think — and Kubernetes won’t tell you (blog de Dynatrace, en inglés).
span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión.