Administrar el clúster
Administrar un clúster es instalarlo, mantenerlo al día, repartir bien los recursos entre las aplicaciones y dejar que crezca o encoja solo según la demanda.
Cómo se consigue un clúster
Antes de usar Kubernetes hay que tenerlo montado. Hay tres caminos, y la diferencia está en cuánto trabajo haces tú y cuánto te hacen otros.
Es como tener coche. Puedes montarlo tú pieza a pieza (aprendes mucho y lo controlas todo, pero cualquier avería es cosa tuya). Puedes hacer un renting: el coche es tuyo para usarlo, pero el mantenimiento lo hace la empresa. O puedes tener un coche de juguete para practicar en casa, que no sirve para ir al trabajo.
- kubeadm: la herramienta oficial de Kubernetes para montar un clúster «de verdad» en tus propias máquinas. Prepara el plano de control y une los nodos. Después, mantenerlo es cosa tuya.
- Clústeres gestionados (managed Kubernetes): el proveedor de nube se encarga del plano de control (el cerebro que viste en la lección 02): lo instala, lo vigila, lo actualiza. Tú sólo pones tus aplicaciones. Los tres grandes son EKS (Amazon), GKE (Google) y AKS (Microsoft Azure).
- Para pruebas: kind («Kubernetes in Docker», monta el clúster dentro de contenedores), minikube (un clúster de un solo nodo en tu portátil) y k3s (una versión ligera de Kubernetes, que también se usa en serio en equipos pequeños como Raspberry Pi o tiendas y fábricas).
Mantenerlo al día: las actualizaciones
Las versiones de Kubernetes tienen tres números, por ejemplo 1.31.2:
- 1 es la versión mayor (no cambia desde hace años).
- 31 es la versión menor (minor). Sale una nueva unas tres veces al año y trae novedades.
- 2 es el parche (patch): arreglos y seguridad, sin novedades.
Al actualizar hay dos reglas que conviene conocer:
- De una versión menor en una menor: de 1.30 a 1.31, y luego a 1.32. No se salta de 1.30 a 1.32 de golpe.
- Primero el plano de control, luego los nodos. El cerebro siempre va por delante (o a la par) de los trabajadores.
Para actualizar un nodo sin cortar el servicio, primero se le «vacía»: se le dice que no acepte trabajo nuevo y se mueven sus aplicaciones a otros nodos. Eso se llama drain (vaciar). Cuando está vacío, se actualiza, se le vuelve a abrir (uncordon) y se pasa al siguiente. Es como cerrar las cajas del supermercado de una en una para repararlas: la tienda nunca cierra.
Repartir los recursos: requests y limits
En un clúster conviven muchas aplicaciones en las mismas máquinas. Si no se pone orden, una aplicación glotona puede dejar a las demás sin memoria. Para evitarlo, cada contenedor puede declarar dos cifras:
- requests (lo que pide): lo mínimo que necesita para funcionar bien. Kubernetes se lo reserva. El scheduler (el que decide en qué nodo va cada cosa) usa esta cifra para elegir un nodo con hueco.
- limits (el tope): lo máximo que se le permite gastar.
Un restaurante. El request es la reserva de mesa: «somos cuatro». El restaurante te guarda esas cuatro sillas pase lo que pase, y no acepta más reservas de las que caben. El limit es lo máximo que dejan sentar en tu mesa: si hay sillas libres alrededor podéis ser cinco o seis, pero nunca más de ocho.
Las unidades
- CPU se mide en núcleos o en milinúcleos (millicores), con una m: 1000m es un núcleo entero, 500m es medio núcleo, 250m es un cuarto.
- Memoria se mide en bytes, normalmente en Mi (mebibytes) o Gi (gibibytes): 256Mi, 1Gi.
# Dentro de la descripción de un contenedor resources: requests: # lo que se le reserva cpu: 250m # un cuarto de núcleo memory: 256Mi limits: # lo máximo que puede gastar cpu: 500m # medio núcleo memory: 512Mi
¿Qué pasa si se pasa del límite?
Aquí está la parte que más se pregunta, porque CPU y memoria se comportan distinto:
- CPU: si quiere más de su límite, Kubernetes le frena (throttling). La aplicación va más lenta, pero no se cae.
- Memoria: si usa más de su límite, el sistema mata el contenedor. Su estado aparece como OOMKilled (Out Of Memory, sin memoria). Luego normalmente se reinicia.
El scheduler decide dónde colocar un Pod mirando los requests, no los limits ni el consumo real. Si un Pod pide 2 núcleos y ningún nodo tiene 2 núcleos libres sin reservar, el Pod se queda en Pending (esperando) aunque los nodos estén casi parados.
Las clases de calidad de servicio (QoS)
Según cómo pongas requests y limits, Kubernetes clasifica cada Pod en una de tres clases de calidad de servicio (QoS classes). Sirven para una cosa: decidir a quién echar primero si un nodo se queda sin memoria.
| Clase | Cuándo se da | Si falta memoria |
|---|---|---|
| Guaranteed garantizado | Todos sus contenedores tienen request y limit de CPU y memoria, y request = limit. | Sale el último. |
| Burstable puede estirarse | Tiene algún request o limit, pero no cumple lo de Guaranteed. | Sale en medio. |
| BestEffort lo que se pueda | Ningún contenedor tiene requests ni limits. | Sale el primero. |
Poner orden entre equipos: ResourceQuota y LimitRange
En una empresa, varios equipos comparten el mismo clúster, cada uno en su Namespace (su «carpeta», que viste en la lección 03). Para que ningún equipo acapare todo, hay dos herramientas que se confunden a menudo:
ResourceQuota es el presupuesto del departamento: «el equipo de Marketing no puede gastar más de 10.000 € en total este mes».
LimitRange es la norma de gastos por persona: «cada comida de empresa, entre 10 € y 50 €; si no pones nada en el ticket, se apuntan 20 €».
- ResourceQuota: limita el total de un Namespace (suma de CPU y memoria pedidas, número de Pods, de Services, de discos…). Si una nueva aplicación haría pasar el total, Kubernetes la rechaza.
- LimitRange: fija el mínimo, el máximo y los valores por defecto para cada contenedor o Pod dentro de un Namespace. Así, quien se olvide de poner requests y limits recibe unos razonables automáticamente.
Crecer y encoger solo: el autoescalado
Una tienda online tiene poco tráfico a las 4 de la mañana y muchísimo el Black Friday. Pagar servidores para el pico todo el año es tirar dinero; tener pocos el día del pico es perder ventas. Kubernetes puede ajustarse solo, de tres formas.
Un supermercado con colas en las cajas:
- Escalar en horizontal es abrir más cajas con más cajeros.
- Escalar en vertical es darle al cajero que ya hay una caja más rápida, con más espacio y mejor lector.
- Ampliar el local es construir más sitio para poner cajas cuando ya no caben más.
- HPA (Horizontal Pod Autoscaler): añade o quita copias (réplicas) de un Pod según una métrica, normalmente el uso de CPU. Ejemplo: «mantén la CPU media al 60 %; si sube, añade copias, hasta un máximo de 10». Viene incluido en Kubernetes, pero necesita un componente que mida el consumo, el metrics-server.
- VPA (Vertical Pod Autoscaler): cambia los requests y limits de los Pods para ajustarlos a lo que de verdad gastan. No crea copias: hace cada Pod más grande o más pequeño (normalmente reiniciándolo con las cifras nuevas). Es un complemento que se instala aparte.
- Cluster Autoscaler: añade o quita nodos (máquinas) del clúster. Actúa cuando hay Pods en Pending porque no caben en ningún nodo, y quita nodos que llevan tiempo casi vacíos. Funciona con proveedores de nube, que son los que pueden darte máquinas nuevas en minutos. Otra herramienta para lo mismo es Karpenter.
Black Friday a las 9:00. La tienda pasa de 100 a 5.000 visitas por minuto. La CPU de los Pods sube y el HPA pide pasar de 3 a 20 copias. Las 20 no caben en los nodos que hay, así que 8 se quedan en Pending. El Cluster Autoscaler lo ve y pide dos máquinas más a la nube. Al rato arrancan, los Pods pendientes se colocan y la tienda aguanta. Por la noche baja el tráfico y todo vuelve a encoger solo.
Horizontal = más copias. Vertical = más grande. Si la pregunta habla de «aumentar el número de réplicas», es HPA. Si habla de «ajustar CPU y memoria de los Pods», es VPA. Si habla de «añadir nodos», es Cluster Autoscaler. El HPA calcula el uso de CPU como porcentaje del request, así que sin requests no puede trabajar con CPU.
Resumen en cinco frases
- Un clúster se monta con kubeadm, se contrata gestionado (EKS, GKE, AKS) o se prueba en local con kind, minikube o k3s.
- Se actualiza de una versión menor en una, primero el plano de control y luego los nodos, vaciándolos de uno en uno.
- Los requests son la reserva que usa el scheduler; los limits son el tope: por CPU se frena, por memoria se mata (OOMKilled).
- Según requests y limits, cada Pod es Guaranteed, Burstable o BestEffort, y eso decide quién sale primero si falta memoria.
- ResourceQuota limita el total de un Namespace, LimitRange cada contenedor; HPA añade copias, VPA agranda Pods y Cluster Autoscaler añade nodos.
Términos del examen
- kubeadm
- Herramienta oficial para montar un clúster en tus propias máquinas.
- Managed Kubernetes
- Clúster en el que el proveedor de nube cuida el plano de control (EKS, GKE, AKS).
- kind · minikube · k3s
- Formas sencillas de tener un clúster para pruebas; k3s es además una versión ligera para equipos pequeños.
- Minor version
- El número del medio (1.31.2). Se actualiza de una en una.
- drain · cordon
- Vaciar un nodo de aplicaciones · marcarlo para que no reciba nuevas.
- requests
- Lo que un contenedor pide y se le reserva. Lo usa el scheduler.
- limits
- Lo máximo que un contenedor puede gastar.
- millicores (m)
- Milésimas de núcleo de CPU: 500m es medio núcleo.
- Throttling
- Frenar a un contenedor que quiere más CPU de su límite.
- OOMKilled
- Contenedor matado por pasarse de su límite de memoria.
- QoS class
- Guaranteed, Burstable o BestEffort: el orden de expulsión si falta memoria.
- ResourceQuota
- Tope total de recursos y objetos de un Namespace.
- LimitRange
- Mínimos, máximos y valores por defecto por contenedor en un Namespace.
- HPA
- Autoescalado horizontal: más o menos copias de un Pod.
- VPA
- Autoescalado vertical: más o menos CPU y memoria por Pod.
- Cluster Autoscaler
- Añade o quita nodos según haga falta.
- metrics-server
- Componente que mide el consumo de CPU y memoria; lo necesita el HPA.
Comprueba que lo has entendido
1. What happens when a container exceeds its memory limit?
- It is throttled and runs slower
- It is terminated with OOMKilled
- It is moved to another node automatically
- Its limit is raised automatically
Ver respuesta
B. La memoria que se pasa del límite no se puede frenar: el contenedor se mata y aparece como OOMKilled. El frenado (throttling) es lo que pasa con la CPU.
2. Which value does the kube-scheduler use to decide whether a Pod fits on a node?
- The container's limits
- The container's requests
- The node's current CPU usage
- The image size
Ver respuesta
B. El scheduler suma los requests (las reservas). Si no hay hueco reservable, el Pod se queda en Pending aunque los nodos estén poco usados.
3. A Pod has requests and limits set for CPU and memory in every container, and requests equal limits. What is its QoS class?
- BestEffort
- Burstable
- Guaranteed
- Critical
Ver respuesta
C. Request igual a limit en CPU y memoria en todos los contenedores da Guaranteed, la clase que se expulsa la última. «Critical» no es una clase de QoS.
4. Which object limits the total amount of CPU and memory that can be requested in a namespace?
- LimitRange
- ResourceQuota
- HorizontalPodAutoscaler
- PriorityClass
Ver respuesta
B. ResourceQuota es el presupuesto del departamento: el total del Namespace. LimitRange pone mínimos, máximos y valores por defecto a cada contenedor.
5. Traffic grows and you want Kubernetes to run more replicas of a Deployment automatically. What should you use?
- Vertical Pod Autoscaler
- Cluster Autoscaler
- Horizontal Pod Autoscaler
- kubeadm
Ver respuesta
C. Más réplicas es escalar en horizontal: HPA. El VPA hace cada Pod más grande, el Cluster Autoscaler añade nodos y kubeadm sirve para instalar.