KEDA autoescalado Kubernetes: escala por eventos

KEDA autoescalado Kubernetes: instalación con Helm, ScaledObject, métricas de Prometheus, exportación OpenTelemetry y eventos para observar el escalado.
KEDA autoscaling Kubernetes : échelle sur événements

KEDA autoescalado Kubernetes: el repositorio kedacore/keda describe KEDA como un componente de autoescalado dirigido por eventos, que cambia el número de réplicas de cualquier contenedor de un clúster de Kubernetes, incluso desde y hasta cero. La página del repositorio muestra unas 10 700 estrellas y unos 1600 forks a finales de octubre de 2026 (cifras redondeadas por GitHub), con licencia Apache 2.0.

Para un SRE el interés es sencillo: en lugar de seguir la CPU, se sigue lo que mide de verdad la carga, como una cola de mensajes o una consulta de Prometheus. El inconveniente es igual de claro: un componente más decide cuántos pods se ejecutan, así que hay que observarlo. Este artículo sigue el README y la documentación oficial de keda.sh (versión 2.21), y no afirma haber instalado KEDA.

Una precisión de honestidad: span.observer no ha probado KEDA. Los comandos vienen de la documentación, y las capturas vienen de keda.sh o reproducen al pie de la letra extractos de su documentación.

KEDA autoescalado Kubernetes: qué dice el repositorio

  • Proyecto: el README indica que KEDA es un proyecto graduado de la Cloud Native Computing Foundation (CNCF).
  • Licencia: Apache 2.0, verificada en el archivo LICENSE del repositorio el 26 de octubre de 2026.
  • Principio: según el README, KEDA ofrece un autoescalado fino, incluso desde y hasta cero, para cargas de Kubernetes dirigidas por eventos. Se configura con una definición de recurso personalizado (CRD).
  • Compatibilidad: la documentación indica que KEDA 2.21 se prueba con Kubernetes 1.34 a 1.36.
  • Cifras: estrellas y forks leídos en la página del repositorio, redondeados. La página no mostraba ninguna versión legible, así que no se cita un número de release.

Recorrido por el esquema de arquitectura

El esquema de la página «Concepts» de keda.sh muestra los tres componentes y su papel. Viene del sitio del propio proyecto, cuyo repositorio de documentación está bajo licencia Apache 2.0.

Esquema de arquitectura de KEDA en keda.sh: fuentes de eventos, keda-operator, keda-metrics-apiserver y keda-admission-webhooks, el API Server de Kubernetes, el Horizontal Pod Autoscaler, un Deployment y sus pods
Source : keda.sh

La documentación describe tres componentes:

  • keda-operator vigila los recursos de KEDA (ScaledObject, ScaledJob, TriggerAuthentication), gestiona el ciclo de vida del HPA y pasa la carga de 0 a 1 réplica y viceversa;
  • keda-metrics-apiserver expone métricas externas al API Server de Kubernetes, que consulta el HPA;
  • keda-admission-webhooks validan los recursos al aplicarlos, por ejemplo para rechazar dos ScaledObject sobre el mismo Deployment.

Así, KEDA amplía el Horizontal Pod Autoscaler (HPA) en lugar de sustituirlo. Las transiciones de 1 a N pasan por el HPA. Un punto que conviene recordar: la documentación precisa que el escalado a cero no se admite con disparadores de CPU o memoria.

Instalación paso a paso

Paso 1: Requisitos

Hace falta un clúster de Kubernetes dentro del rango probado, Helm instalado y permiso para instalar charts. El README menciona también Operator Hub y archivos YAML; lo que sigue usa la vía Helm de la documentación.

Paso 2: Instalar con Helm

helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda --namespace keda --create-namespace

Paso 3: Comprobar los pods

kubectl get pods -n keda

Deberías ver los pods de los componentes descritos arriba. La desinstalación se hace con helm uninstall keda --namespace keda; la página de despliegue imprime la opción con una raya corta, que debes sustituir por dos guiones simples.

Paso 4: Declarar un ScaledObject

Un ScaledObject enlaza una carga con uno o varios disparadores. El ejemplo siguiente es el de la página del scaler de Prometheus de la documentación.

Extracto de la documentación de KEDA: ejemplo de ScaledObject con un disparador prometheus, serverAddress, threshold y una consulta sum(rate(http_requests_total))
Source : keda.sh

La página de especificación da estos valores por defecto: pollingInterval 30 segundos, cooldownPeriod 300 segundos, minReplicaCount 0 y maxReplicaCount 100. El parámetro activationThreshold del scaler de Prometheus vale 0 por defecto. El campo fallback exige failureThreshold y replicas: fija un número de réplicas si el scaler falla de forma repetida.

Observar KEDA: métricas de Prometheus

Para saber si el autoescalado se comporta como se espera, la documentación indica que el operador, los webhooks de admisión y el servidor de métricas exponen métricas de Prometheus en el puerto 8080, en la ruta /metrics. Para conectar estas métricas con tu pila, consulta Prometheus y Dynatrace en Kubernetes.

Lista de nombres de métricas de Prometheus de KEDA tomados de la documentación: keda_scaler_active, keda_scaler_metrics_value, keda_scaler_metrics_latency_seconds, keda_scaler_detail_errors_total y otras, con un comentario por métrica
Source : keda.sh

La captura reutiliza los nombres de la documentación; los comentarios son de span.observer. Algunas lecturas útiles:

  • keda_scaler_active vale 1 cuando el scaler está activo y 0 en caso contrario: es la señal «KEDA ve carga».
  • keda_scaler_metrics_value da el valor que usa el HPA para calcular su objetivo.
  • keda_scaler_metrics_latency_seconds mide el tiempo de lectura de la fuente; una deriva alarga el bucle de escalado.
  • keda_scaler_detail_errors_total, keda_scaled_object_errors_total y keda_scaled_job_errors_total cuentan los errores por scaler, ScaledObject y ScaledJob.
  • keda_scaler_empty_upstream_responses_total cuenta las respuestas vacías de la fuente, por ejemplo una consulta de Prometheus sin resultados.
  • keda_scaled_object_paused vale 1 si un ScaledObject está en pausa.

La documentación señala que un operador sin ningún scaler solo expone keda_build_info; las demás aparecen con tus scalers. Las etiquetas de alta cardinalidad (namespace, scaled_resource, trigger_name, metric_name) se activan con --enable-high-cardinality-metrics-labels=true en el Deployment keda-operator: mide antes el coste de almacenamiento.

OpenTelemetry y eventos de Kubernetes

En cuanto a OpenTelemetry, la documentación describe una integración experimental, disponible desde la versión 2.12. Son métricas enviadas a un Collector, no trazas. Se activa la exportación con el argumento --enable-opentelemetry-metrics=true del operador y se indica el Collector con la variable de entorno OTEL_EXPORTER_OTLP_ENDPOINT (el ejemplo de la página es http://opentelemetry-collector.default.svc.cluster.local:4318). OTEL_EXPORTER_OTLP_PROTOCOL elige HTTP o gRPC. Los nombres cambian de forma, por ejemplo keda.scaler.active. Consulta también el Collector de OpenTelemetry en Kubernetes y OpenTelemetry y Prometheus.

KEDA también emite eventos de Kubernetes, listados en su referencia. Los más útiles en operación:

  • KEDAScaleTargetActivated y KEDAScaleTargetDeactivated (Normal): el destino pasa a 1 o a 0;
  • KEDAScaleTargetActivationFailed y KEDAScaleTargetDeactivationFailed (Warning): el cambio ha fallado;
  • KEDAScalerFailed (Warning): un scaler no logra crear o comprobar su fuente de eventos;
  • ScaledObjectCheckFailed (Warning): falla la validación de un ScaledObject;
  • ScaledObjectFallbackActivated: el repliegue está activo;
  • ScaledObjectPaused y ScaledObjectUnpaused: pausa o reanudación.

Para inspeccionar lo que recibe el HPA, la documentación del servidor de métricas da kubectl get --raw "/apis/external.metrics.k8s.io/v1beta1". Para pausar un ScaledObject usa la anotación autoscaling.keda.sh/paused: "true", que congela el número actual de instancias. Las alertas sobre estas señales se parecen a alertas de Kubernetes sobre nodos, pods y cuotas.

Límites y puntos abiertos

  • No hay escalado a cero con disparadores de CPU y memoria, según la documentación.
  • La integración con OpenTelemetry está marcada como experimental; la página lista además métricas obsoletas. Comprueba los nombres en tu versión.
  • La página de GitHub mostraba estrellas redondeadas y ninguna release legible al leerla: consulta las releases antes de fijar una versión.
  • Un scaler que pierde su fuente puede decidir de forma sorprendente: configura fallback y vigila los errores.
  • KEDA no sustituye el dimensionamiento de las solicitudes de recursos: consulta solicitudes de CPU efectivas de los pods.

Buenas prácticas

  • Alerta sobre keda_scaler_detail_errors_total y keda_scaler_metrics_latency_seconds antes de la carga, no después.
  • Mantén desactivadas las etiquetas de alta cardinalidad mientras no las necesites.
  • Define fallback para las cargas críticas y prueba la pausa en preproducción.
  • Vincula el número de réplicas a un SLO: el autoescalado sirve al presupuesto de errores, no al revés.

Preguntas frecuentes

¿KEDA sustituye al Horizontal Pod Autoscaler?

No. Según la documentación, lo amplía: el operador crea y gestiona el HPA, que lee las métricas externas que proporciona KEDA.

¿Qué métricas expone KEDA?

Métricas de Prometheus en el puerto 8080, ruta /metrics, para el operador, los webhooks y el servidor de métricas. También existe una exportación experimental a OpenTelemetry.

¿Se puede bajar a cero réplicas?

Sí, con disparadores dirigidos por eventos. La documentación precisa que no es posible con disparadores de CPU o memoria.

Conclusión

KEDA vincula el número de pods a los eventos que importan, siempre que supervises sus scalers como cualquier componente de producción. Fuentes: repositorio kedacore/keda y documentación de keda.sh.

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.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
Cindy agent IA open source : installer, API locale, limites

Cindy agente de IA de código abierto: instalar, API local y límites

Next Post
ThinkRail IDE vibe coding : installer, observer, limites

ThinkRail IDE vibe coding: instalar, observar y límites

Related Posts