KUBERNETES & UPGRADES · 16 de noviembre de 2026

Upgrade de Kubernetes en AKS, EKS y GKE: qué se rompe y en qué orden comprobarlo

Qué se rompe en un upgrade de Kubernetes en AKS, EKS y GKE: Helm, CRD, PDB y webhooks que los detectores no ven, y el orden para comprobarlo.

Una flecha hacia arriba sobre una pila de tres bloques horizontales, sobre un fondo de líneas onduladas

Qué puede romperse en un upgrade gestionado

En un clúster gestionado, el proveedor actualiza el control plane. Lo que puede romperse está en lo que el proveedor no mira: los manifiestos guardados en releases de Helm, las versiones de tus CRD, los PodDisruptionBudgets que bloquean el drenado y los webhooks que dependen de los nodos que estás drenando.

Los detectores de cada proveedor ven las llamadas recientes a la API, no tu inventario. Por eso el trabajo se hace antes de lanzar el upgrade y en un orden concreto.

En este artículo:

Qué hace cada proveedor cuando un PodDisruptionBudget bloquea el drenado: el mismo PDB, tres resultados distintos.
Las cuatro fuentes de APIs obsoletas y cuál de ellas ve cada detector.
Un orden de operaciones, los patrones que atascan el drenado y los webhooks que bloquean sus propios pods.

Esperar tiene fecha de caducidad

El proyecto Kubernetes mantiene ramas de parches para las tres versiones menores más recientes. A 16/11/2026 son la 1.37, la 1.36 y la 1.35. La 1.34 llegó a fin de vida el 27/10/2026 (kubernetes.io/releases). Cada proveedor tiene su calendario, y el de AKS ya tiene una fecha por escrito.

A partir del 1 de junio de 2027, AKS actualizará automáticamente los clústeres que sigan en una versión no soportada cuando termine el periodo de gracia de 60 días. Según su documentación, ese upgrade no respeta la ventana de mantenimiento, no se detiene por uso de APIs obsoletas y puede saltarse un PodDisruptionBudget que bloquee el drenado (AKS: detener upgrades por cambios de API). Si llegas tarde, esas protecciones no se aplican.

GKE pausa la actualización automática a la siguiente versión menor cuando detecta uso de APIs obsoletas y no la reanuda hasta pasar 30 días sin detectarlo. También avisa de que no garantiza ni detectar todo el uso ni que la pausa ocurra siempre. Para bloquear un upgrade de forma fiable remite a las exclusiones de mantenimiento (GKE: deprecations).

Las reglas de cada capa: Kubernetes fija el marco y cada proveedor lo cambia

La política de desfase de versiones de Kubernetes marca el marco:

kube-apiserver no puede saltarse versiones menores, ni siquiera en un clúster de una sola instancia.
kubelet y kube-proxy nunca pueden ser más nuevos que el apiserver y pueden ir hasta tres versiones menores por detrás (dos si son anteriores a la 1.25).
kubectl está soportado a ±1 versión menor del apiserver.
Orden: primero el apiserver, después controller-manager y scheduler y, al final, los kubelet.

Cada proveedor añade sus propias reglas, y ahí está la diferencia:

ComportamientoAKSEKSGKE
Detección de APIs obsoletasBloquea el upgrade de versión menor del control plane (destino 1.26 o posterior) si vio uso en las últimas 12 h. No cuenta get/list/watch*Upgrade insights* con ventana móvil de 30 días. El bloqueo que exigía --force está revertido temporalmentePausa el auto-upgrade y lo reanuda tras 30 días sin uso, sin garantía
PDB que impide drenar un nodoEspera el *drain timeout* (30 min por defecto, de 5 min a 24 h) y detiene el upgrade. Un PUT posterior lo reanudaEn grupos de nodos gestionados: a los 15 min falla con PodEvictionFailure. Con force borra los pods. (EKS Auto Mode respeta los PDB.)Con la estrategia *surge* (la predeterminada), respeta el PDB hasta 1 h y después desaloja a la fuerza

Fuentes: AKS API breaking changes, AKS rolling upgrades, EKS update cluster, EKS managed node update, GKE node pool upgrade strategies.

Fíjate en la segunda fila. El mismo PodDisruptionBudget produce tres resultados distintos: en AKS se detiene el upgrade con el pool a medias, en EKS (grupos de nodos gestionados) el upgrade falla y en GKE solo ganas una hora. Si tu plan de disponibilidad da por hecho que «el PDB lo protege», en GKE, con upgrades *surge*, no es así más allá de 60 minutos.

EKS añade dos matices. Su guía pide que los nodos gestionados y los de Fargate estén en la misma versión menor que el control plane antes de subirlo. En la misma página también describe que, con kubelet 1.25 o superior, el clúster puede avanzar hasta tres versiones sin tocar el kubelet. Planifica con la regla más estricta. Además, EKS permite volver a la versión menor anterior durante los 7 días siguientes al upgrade; pasado ese plazo, toca crear un clúster nuevo y migrar (EKS update cluster).

Cuatro sitios donde se esconde una API obsoleta (y los detectores solo miran uno)

Los detectores de los proveedores son útiles, pero solo ven peticiones a la API. Tus problemas pueden estar en cuatro sitios distintos.

1. Llamadas en vivo: controladores, pipelines y operadores

Son las que ven los detectores y la métrica apiserver_requested_deprecated_apis. Esta métrica existe desde la 1.19 e incluye la etiqueta removed_release, que indica en qué versión dejará de servirse cada API (blog de Kubernetes, 2020).

bashENGINEERING
kubectl get --raw /metrics | grep apiserver_requested_deprecated_apis
# Formato ilustrativo de la salida:
# apiserver_requested_deprecated_apis{group="...",removed_release="1.xx",resource="...",subresource="",version="v1beta1"} 1

Tiene una limitación sutil. AKS excluye las lecturas (get/list/watch) de su detección, así que un controlador que solo *observa* una API obsoleta no bloquea el upgrade y aun así dejará de funcionar después.

2. Manifiestos en Git que no se aplican a diario

Un entorno de recuperación, un CronJob que se vuelve a aplicar una vez al trimestre o un chart que nadie toca desde hace un año. Ningún detector los ve hasta que alguien los aplica.

bashENGINEERING
grep -rnE '^apiVersion: (policy/v1beta1|batch/v1beta1|autoscaling/v2beta[12]|flowcontrol\.apiserver\.k8s\.io/v1beta[123])' ./manifiestos

La expresión usa ejemplos de la guía oficial de migración. Adáptala a tu salto de versión.

3. Manifiestos guardados en releases de Helm

Helm guarda en el clúster el manifiesto de cada release. Si contiene una API ya eliminada, el siguiente helm upgrade falla con *«current release manifest contains removed kubernetes api(s) for this kubernetes version»*. No hay ninguna llamada a la API que detectar, así que ningún detector del proveedor lo ve. Helm recomienda actualizar los charts *antes* de actualizar el clúster. Si ya llegaste tarde, propone editar el manifiesto guardado o usar el plugin mapkubeapis (Helm: Kubernetes APIs).

bashENGINEERING
helm list -A -o json | jq -r '.[] | "\(.namespace) \(.name)"' |
while read -r ns rel; do
  helm get manifest "$rel" -n "$ns" | grep -E '^apiVersion:' | sort -u | sed "s|^|$ns/$rel  |"
done

4. Versiones de CRD

La guía oficial cubre las APIs integradas de Kubernetes. Las versiones de tus CRD (cert-manager, operadores de bases de datos, Argo CD…) las decide cada proyecto. Para retirar una versión, el procedimiento oficial exige que la nueva tenga storage: true y que la antigua ya no aparezca en status.storedVersions antes de quitarla de spec.versions (versionado de CRD).

bashENGINEERING
kubectl get crd -o custom-columns='CRD:.metadata.name,SERVIDAS:.spec.versions[*].name,ALMACENADAS:.status.storedVersions'

Si una versión que va a desaparecer en la próxima versión del operador sigue en ALMACENADAS, el orden importa: primero migras los objetos y después actualizas el operador.

Si te mueves entre la 1.33 y la 1.37, el foco cambia

El 16/11/2026, la sección más reciente de la guía de migración de APIs era la de la v1.32. Si te mueves entre 1.33 y 1.37, el riesgo ya no está tanto en las APIs integradas como en los CRD, los add-ons y los cambios de comportamiento del proveedor. Un ejemplo: en AKS Standard, al subir un node pool a 1.37 o posterior, LocalDNS puede activarse si el pool no tiene un perfil explícito, y si usas DNS personalizado hay que comprobar que responde por UDP y TCP en el puerto 53 (AKS rolling upgrades). No lo encontrarás en el changelog de Kubernetes.

El orden de operaciones

1. Elige la versión de destino y lee las notas del proveedor de cada salto.

2. Haz inventario de las cuatro fuentes y corrige en Git. Despliega esas correcciones con la versión actual del clúster, no el día del upgrade. Así, si algo falla, sabes que lo ha causado tu cambio y no el upgrade.

3. Comprueba la compatibilidad de los add-ons que gestionas tú (ingress, cert-manager, drivers CSI, autoscaler, motor de políticas) con la versión de destino, según la matriz de cada proyecto. En EKS, por ejemplo, Cluster Autoscaler debe ir en la versión que coincide con la versión menor del clúster.

4. Revisa los PDB y los webhooks (siguientes apartados).

5. Sube solo el control plane y observa. AKS lo permite con --control-plane-only, salvo que tengas activado el auto-upgrade del clúster (AKS control plane). El control plane de EKS necesita hasta cinco IP libres en sus subredes.

6. Actualiza los node pools uno a uno, empezando por los no productivos. Comprueba cuota e IP libres: los nodos extra de AKS consumen cuota y, con Azure CNI, IP de la subred. Para producción, AKS recomienda un *max surge* del 33 %. En GKE, por defecto, maxSurge=1 y maxUnavailable=0.

7. Actualiza los add-ons gestionados (en EKS, VPC CNI, CoreDNS y kube-proxy) y los clientes (kubectl a ±1 versión).

Drenar nodos: tres patrones que bloquean el upgrade

minAvailable igual al número de réplicas, o maxUnavailable: 0. La documentación lo dice sin rodeos: así exiges *cero* desalojos voluntarios (configurar PDB).
Una aplicación en CrashLoopBackOff protegida por un PDB. Con la política por defecto (IfHealthyBudget), los pods en ejecución que no están sanos solo se desalojan si la aplicación no está ya degradada. La propia documentación avisa de que esto puede bloquear el drenado. unhealthyPodEvictionPolicy: AlwaysAllow es estable desde la 1.31. Lo que cedes es que los pods de una aplicación ya degradada pueden no llegar a estar sanos.
En EKS, varios PDB sobre el mismo pod o un Deployment que tolera todos los taints. Ambos aparecen en la lista de causas de PodEvictionFailure.

Nuestro criterio para un servicio sin estado con tres réplicas (no es una recomendación de la documentación):

yamlENGINEERING
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: api
  namespace: tienda
spec:
  maxUnavailable: 1
  unhealthyPodEvictionPolicy: AlwaysAllow
  selector:
    matchLabels:
      app.kubernetes.io/name: api

Combínalo con topologySpreadConstraints por nodo en el Deployment. Con whenUnsatisfiable: ScheduleAnyway el reparto es una preferencia y no una garantía; con DoNotSchedule se garantiza, a cambio de que un pod pueda quedarse en Pending si no hay nodos suficientes. Si las tres réplicas caen en el mismo nodo, el PDB funciona como debe y aun así el drenado de ese nodo se queda esperando.

bashENGINEERING
kubectl get pdb -A -o custom-columns='NS:.metadata.namespace,PDB:.metadata.name,PERMITIDOS:.status.disruptionsAllowed,POLITICA:.spec.unhealthyPodEvictionPolicy'

Cualquier fila con PERMITIDOS a 0 fuera de un incidente es un upgrade que se va a atascar.

Webhooks: pueden bloquear los pods que los sustituyen

Por defecto, los webhooks de admisión usan failurePolicy: Fail: si el webhook no responde, el apiserver rechaza la petición (buenas prácticas de webhooks). Durante un upgrade, los pods del webhook también se drenan. Si en ese momento no hay ninguna réplica disponible y el webhook intercepta la creación de pods, también rechaza los pods que sustituyen a los desalojados, incluidos los del propio webhook. La documentación describe este bloqueo mutuo y recomienda no interceptar kube-system, excluir el namespace del webhook y ejecutarlo en alta disponibilidad.

yamlENGINEERING
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingWebhookConfiguration
metadata:
  name: politicas-ejemplo
webhooks:
  - name: validar.politicas.example.com
    admissionReviewVersions: ["v1"]
    sideEffects: None
    failurePolicy: Fail
    timeoutSeconds: 5
    namespaceSelector:
      matchExpressions:
        - key: kubernetes.io/metadata.name
          operator: NotIn
          values: ["kube-system", "politicas-system"]
    rules:
      - apiGroups: ["apps"]
        apiVersions: ["v1"]
        operations: ["CREATE", "UPDATE"]
        resources: ["deployments"]
    clientConfig:
      service:
        name: politicas-webhook
        namespace: politicas-system
        path: /validate
        port: 443
bashENGINEERING
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations \
  -o custom-columns='NOMBRE:.metadata.name,FALLO:.webhooks[*].failurePolicy,NS_SELECTOR:.webhooks[*].namespaceSelector'

Si un webhook tiene Fail, no tiene selector de namespace y corre con una sola réplica, revísalo antes del upgrade.

Quien controla un webhook de admisión también puede leer, y si es de mutación modificar, todo lo que entra en el clúster. Lo tratamos en Seguridad en Kubernetes: por qué un clúster «seguro» deja pasar lo importante.

Errores habituales y cómo detectarlos

ErrorCómo detectarlo
Dar el upgrade por seguro porque el portal no muestra APIs obsoletasAKS no cuenta las lecturas, EKS usa una ventana de 30 días y GKE no garantiza la detección. Revisa las cuatro fuentes
Migrar APIs y hacer el upgrade el mismo díaRevisa el historial de despliegues: las correcciones de API deberían estar desplegadas antes, con la versión actual
Release de Helm con una API eliminada guardadaRecorre helm get manifest (comando de arriba)
PDB que no permite ningún desalojoColumna PERMITIDOS a 0 en kubectl get pdb -A
Aplicación degradada que bloquea el drenadoPods no Ready cubiertos por un PDB sin AlwaysAllow
«Desatascar» con force (EKS) o con el bypass de validación (AKS)En EKS borra pods sin respetar el PDB. En AKS, las llamadas a APIs eliminadas fallarán después
Quedarse sin cuota o sin IP para los nodos extraRevisa cuota del proveedor e IP libres en las subredes antes de la ventana
Olvidar los add-ons gestionados y kubectlVersiones de los add-ons comparadas con las recomendadas por el proveedor tras el upgrade

Comandos de comprobación (solo lectura)

bashENGINEERING
kubectl version
kubectl get nodes -o custom-columns='NODO:.metadata.name,KUBELET:.status.nodeInfo.kubeletVersion'
kubectl get --raw /metrics | grep apiserver_requested_deprecated_apis
kubectl get crd -o custom-columns='CRD:.metadata.name,ALMACENADAS:.status.storedVersions'
kubectl get pdb -A -o custom-columns='NS:.metadata.namespace,PDB:.metadata.name,PERMITIDOS:.status.disruptionsAllowed'
kubectl get validatingwebhookconfigurations,mutatingwebhookconfigurations -o custom-columns='NOMBRE:.metadata.name,FALLO:.webhooks[*].failurePolicy'
# AKS
az aks get-upgrades --resource-group <grupo> --name <cluster> --output table
# EKS: consola → Cluster insights → Upgrade insights
# GKE: insights y recomendaciones de deprecación en la consola

Si algún comando de proveedor no te devuelve lo esperado, consulta antes su página de documentación (enlazada abajo). Las opciones cambian.

Por dónde empezar

1. Haz el inventario de las cuatro fuentes (llamadas en vivo, Git, releases de Helm y CRD) y apunta qué API afecta a qué equipo.

2. Ejecuta kubectl get pdb -A y corrige todos los PDB con cero desalojos permitidos.

3. Lista los webhooks con failurePolicy: Fail y comprueba que excluyen kube-system y su propio namespace y que tienen más de una réplica.

4. Fija la fecha del próximo upgrade antes del fin de soporte de tu versión, sobre todo en AKS por el cambio de junio de 2027.

En Nubyron trabajamos los upgrades de Kubernetes en AKS, EKS y GKE: versiones, APIs deprecadas y ventanas acordadas. Si quieres contrastar tu inventario con otra mirada, escríbenos.

Fuentes (consultadas el 16/11/2026)

Kubernetes releases
Version skew policy (1.37)
Deprecated API migration guide
Warnings and deprecated API metric (2020, Kubernetes ≥1.19)
PodDisruptionBudget, unhealthyPodEvictionPolicy (estable desde la 1.31)
Admission webhook good practices
CRD versioning
Helm, Kubernetes APIs
AKS, stop upgrades on API breaking changes
AKS, control plane upgrade
AKS, rolling upgrades de node pools
EKS, update cluster
EKS, managed node update behavior
GKE, deprecations
GKE, node pool upgrade strategies

Las salidas de comandos son ilustrativas y no se han capturado de un clúster real. Las opciones y los plazos de cada proveedor cambian: comprueba siempre su documentación antes de actuar.

Preguntas frecuentes

¿Por qué puede fallar un upgrade de Kubernetes si el proveedor actualiza el control plane?

Porque el proveedor actualiza el control plane, pero no revisa tu inventario. Los manifiestos guardados en releases de Helm, las versiones de CRD, los PodDisruptionBudgets y los webhooks pueden bloquear o romper el upgrade, y los detectores del proveedor solo ven llamadas recientes a la API.

¿Qué pasa si un PodDisruptionBudget impide drenar un nodo?

Depende del proveedor. Según su documentación, AKS espera el tiempo de drenado (30 min por defecto) y detiene el upgrade; EKS, en grupos de nodos gestionados, falla a los 15 minutos; GKE, con la estrategia surge, respeta el PDB hasta 1 hora y después desaloja a la fuerza. Comprueba su documentación, porque las opciones cambian.

¿Ven los detectores de APIs obsoletas todo lo que se va a romper?

No. Ven peticiones a la API, y los límites varían: AKS no cuenta las lecturas, EKS usa una ventana de 30 días y GKE no garantiza la detección. Los manifiestos en Git, los guardados en releases de Helm y las versiones de CRD hay que revisarlos aparte.

¿Qué cambia en AKS a partir de junio de 2027?

Según la documentación de AKS, a partir del 1 de junio de 2027 actualizará automáticamente los clústeres en una versión no soportada tras un periodo de gracia de 60 días. Ese upgrade no respeta la ventana de mantenimiento, no se detiene por uso de APIs obsoletas y puede saltarse un PodDisruptionBudget.

¿Quieres contrastar tu inventario antes del próximo upgrade?

Trabajamos los upgrades de Kubernetes en AKS, EKS y GKE: versiones, APIs deprecadas y ventanas acordadas. Podemos revisar tu caso contigo y decirte por dónde empezar.

Ver upgrades de Kubernetes

Hablar con Nubyron ↗