Dónde acaba cada Pod
El scheduler es la pieza que decide en qué máquina (nodo) arranca cada Pod. Primero descarta las que no sirven y luego elige la mejor de las que quedan.
El problema: muchos Pods, varias máquinas
En la lección 02 viste que el kube-scheduler decide el nodo de cada Pod nuevo, y que sólo decide: quien lo arranca es el kubelet de ese nodo. En esta lección vemos cómo decide, y todas las formas que tienes de influir en su decisión.
Piensa en un camarero que sienta a los clientes en un restaurante. Cuando llega un grupo, primero descarta las mesas que no valen: demasiado pequeñas, reservadas, sin trona para el bebé. Después, entre las que quedan, elige la mejor: la menos llena, la más tranquila, la que le pidieron. Y no sirve la comida: sólo indica la mesa. El scheduler es ese camarero; los nodos son las mesas.
Cómo decide: filtrar y puntuar
Cada vez que aparece un Pod sin nodo asignado, el scheduler hace dos pasos:
- Filtrar (filtering): tacha los nodos donde el Pod no puede ir. Por ejemplo, los que no tienen hueco suficiente o los que llevan una restricción que el Pod no acepta.
- Puntuar (scoring): a los nodos que quedan les pone nota según sus preferencias (el más descargado, el que ya tiene la imagen descargada…) y elige el de mayor nota.
Luego apunta el resultado en el API server (esto se llama binding) y el kubelet de ese nodo arranca el Pod. Si después de filtrar no queda ningún nodo, el Pod se queda en estado Pending (esperando) hasta que aparezca hueco.
El papel de los requests
Ya lo viste en la lección 05: para saber si un Pod «cabe» en un nodo, el scheduler suma los requests (las reservas) de los Pods que ya están ahí. No mira el consumo real ni los limits. Si un Pod pide 2 CPU y ningún nodo tiene 2 CPU sin reservar, se queda en Pending, aunque las máquinas estén casi paradas.
Influir en la decisión: las herramientas
Normalmente dejas que el scheduler elija solo. Pero a veces necesitas mandar: «esta aplicación necesita una tarjeta gráfica», «no pongas las dos copias de la base de datos en la misma máquina», «este nodo es sólo para el equipo de pagos». Para eso hay varias herramientas. Piensa en ellas como tres familias:
| Familia | Quién la pone | Qué dice | Herramientas |
|---|---|---|---|
| Atraer | El Pod | «Quiero ir a nodos así» | nodeSelector, node affinity |
| Juntar o separar | El Pod | «Ponme cerca (o lejos) de estos otros Pods» | pod affinity, pod anti-affinity, topology spread |
| Repeler | El nodo | «Aquí no entra nadie, salvo quien tenga permiso» | taints y tolerations |
Atraer: nodeSelector y node affinity
Todo empieza con las etiquetas (labels) de la lección 03, pero puestas en los nodos. Por ejemplo, a los nodos con tarjeta gráfica se les pone la etiqueta gpu=true, y a los que están en Madrid, zona=madrid.
nodeSelector: la forma sencilla
El Pod dice: «sólo puedo ir a nodos con esta etiqueta». Es un sí o no estricto.
spec: nodeSelector: gpu: "true" # sólo nodos con la etiqueta gpu=true
node affinity: la forma flexible
Hace lo mismo, pero con más opciones, y sobre todo permite distinguir entre obligatorio y preferible:
- requiredDuringSchedulingIgnoredDuringExecution: obligatorio. Si ningún nodo lo cumple, el Pod se queda en Pending. Es como el nodeSelector pero con más posibilidades («zona Madrid o Barcelona», «cualquier zona menos Valencia»).
- preferredDuringSchedulingIgnoredDuringExecution: preferible. El scheduler intenta cumplirlo dándole más nota a esos nodos, pero si no puede, coloca el Pod en otro sitio.
Los nombres asustan, pero se leen así: «obligatorio (o preferido) al colocar, ignorado durante la ejecución». La segunda mitad quiere decir que si la etiqueta del nodo cambia después, el Pod que ya está corriendo no se mueve.
Una aplicación de vídeo: obligatorio que el nodo tenga tarjeta gráfica (sin ella no funciona) y preferible que esté en la zona de Madrid (va algo más rápido para los usuarios de allí, pero en otra zona también sirve).
Juntar o separar: pod affinity y anti-affinity
Aquí el Pod no habla de nodos, sino de otros Pods:
- Pod affinity (afinidad): «ponme en el mismo sitio que los Pods con esta etiqueta». Útil cuando dos piezas hablan mucho entre sí, por ejemplo una web y su caché.
- Pod anti-affinity (antiafinidad): «no me pongas en el mismo sitio que los Pods con esta etiqueta». Lo típico es separar las copias de una misma aplicación para que, si cae un nodo, no caigan todas a la vez.
«El mismo sitio» puede significar el mismo nodo, la misma zona o la misma región. Se decide con un campo llamado topologyKey, que apunta a una etiqueta del nodo.
Topology spread: repartir de forma equilibrada
Las topology spread constraints (reglas de reparto) son una forma más cómoda de conseguir lo mismo que la antiafinidad. En vez de «nunca dos juntos», dicen «repárteme de forma equilibrada entre zonas (o nodos), sin que la diferencia entre la que más tiene y la que menos supere tal número». Ese número se llama maxSkew.
Tienes 6 copias de tu web y 3 zonas. Con maxSkew: 1, Kubernetes las reparte 2-2-2. Nunca dejaría 4-1-1, porque la diferencia sería 3.
Repeler: taints y tolerations
Hasta ahora era el Pod quien elegía. Con los taints es al revés: es el nodo el que pone un cartel de «prohibido el paso».
- Un taint (literalmente, «mancha») se pone en un nodo: «aquí no se coloca ningún Pod».
- Una toleration (tolerancia) se pone en un Pod: «a mí no me importa esa mancha, puedo ir ahí».
El taint es el cartel de «Sólo personal autorizado» en una puerta. La toleration es la tarjeta de acceso. Sin tarjeta no entras. Pero tener la tarjeta no te obliga a entrar en esa sala: te deja entrar si te toca, y puedes seguir trabajando en cualquier otra.
Cada taint tiene un efecto que dice cómo de estricto es:
| Efecto | Qué pasa con los Pods sin toleration |
|---|---|
| NoSchedule | No se colocan Pods nuevos aquí. Los que ya estaban, se quedan. |
| PreferNoSchedule | Se intenta no colocarlos aquí, pero si no hay otro sitio, se colocan. Es la versión blanda. |
| NoExecute | No se colocan Pods nuevos y además se echa a los que ya estaban corriendo. |
Una toleration no obliga a un Pod a ir a un nodo con taint: sólo se lo permite. Si quieres que un Pod vaya sólo a los nodos de GPU y que nadie más los use, combinas las dos cosas: un taint en el nodo (para echar a los demás) y node affinity en el Pod (para atraerlo).
Y recuerda quién lleva qué: taint en el nodo, toleration en el Pod.
Kubernetes usa taints él mismo. Los nodos del plano de control suelen llevar un taint para que no se coloquen ahí las aplicaciones normales. Y cuando un nodo deja de responder, Kubernetes le pone un taint de tipo NoExecute para que sus Pods se vayan a otros nodos.
Cuando no hay sitio: prioridad y expulsión
¿Qué pasa si el clúster está lleno y llega un Pod importante? Por defecto se quedaría esperando en Pending. Para evitarlo existe la prioridad (priority):
- Se crea una PriorityClass: un nombre con un número. Cuanto más alto el número, más importante.
- Cada Pod indica qué PriorityClass tiene.
- Si un Pod de prioridad alta no cabe, el scheduler puede echar Pods de prioridad más baja para hacerle hueco. Esto se llama expulsión preventiva (preemption).
No confundas prioridad con clases de QoS (lección 05). La prioridad decide quién se coloca y a quién se expulsa al colocar Pods nuevos. La QoS decide a quién se mata primero cuando a un nodo se le acaba la memoria.
Resumen en cinco frases
- El kube-scheduler elige el nodo de cada Pod en dos pasos: filtrar los que no valen y puntuar los que quedan.
- Para saber si un Pod cabe, suma los requests, no el consumo real; si no cabe en ningún sitio, se queda en Pending.
- nodeSelector y node affinity atraen un Pod a nodos con ciertas etiquetas, de forma obligatoria (required) o preferible (preferred).
- Pod affinity junta Pods, pod anti-affinity y topology spread los separan y reparten.
- Los taints (en el nodo) repelen, las tolerations (en el Pod) permiten entrar sin obligar, y la prioridad permite expulsar Pods menos importantes.
Términos del examen
- kube-scheduler
- La pieza que decide en qué nodo va cada Pod. No lo arranca.
- Filtering
- Primer paso: descartar los nodos donde el Pod no puede ir.
- Scoring
- Segundo paso: puntuar los nodos que quedan y elegir el mejor.
- Binding
- Apuntar en el API server el nodo elegido para el Pod.
- Pending
- Estado de un Pod que todavía no tiene nodo (o no ha arrancado).
- nodeSelector
- Forma sencilla de exigir nodos con una etiqueta concreta.
- Node affinity
- Forma flexible de atraer un Pod a ciertos nodos, obligatoria o preferible.
- required… / preferred…
- Obligatorio frente a preferible. «IgnoredDuringExecution»: no mueve Pods ya en marcha.
- Pod affinity
- Colocar un Pod cerca de otros Pods.
- Pod anti-affinity
- Colocar un Pod lejos de otros Pods.
- topologyKey
- Qué significa «el mismo sitio»: mismo nodo, misma zona…
- Topology spread constraints
- Reglas para repartir Pods de forma equilibrada; maxSkew es la diferencia máxima.
- Taint
- Restricción en un nodo que repele a los Pods.
- Toleration
- Permiso en un Pod para ir a un nodo con taint. Permite, no obliga.
- NoSchedule · PreferNoSchedule · NoExecute
- Efectos del taint: no colocar, intentar no colocar, no colocar y echar a los que están.
- PriorityClass
- Nombre con un número que marca la importancia de un Pod.
- Preemption
- Expulsar Pods de menor prioridad para hacer hueco a uno de mayor prioridad.
Comprueba que lo has entendido
1. What are the two main phases the kube-scheduler uses to choose a node?
- Pulling and running
- Filtering and scoring
- Binding and evicting
- Draining and cordoning
Ver respuesta
B. Primero filtra (descarta los nodos que no valen) y después puntúa los que quedan para elegir el mejor.
2. Where are taints and tolerations applied?
- Taints on Pods, tolerations on nodes
- Both on nodes
- Taints on nodes, tolerations on Pods
- Both on Services
Ver respuesta
C. El taint es el cartel de «prohibido el paso» y va en el nodo. La toleration es la tarjeta de acceso y la lleva el Pod.
3. A Pod has a toleration for the taint on node A. What does this guarantee?
- The Pod will always be scheduled on node A
- The Pod is allowed to be scheduled on node A, but may run elsewhere
- No other Pod can run on node A
- Node A will reserve resources for the Pod
Ver respuesta
B. La tolerancia permite, no obliga. Para forzar que vaya a ese nodo hay que añadir node affinity o nodeSelector.
4. You want the three replicas of a database to never run on the same node. What should you use?
- Pod affinity
- Pod anti-affinity
- nodeSelector
- A PreferNoSchedule taint
Ver respuesta
B. La antiafinidad separa Pods entre sí. Así, si cae un nodo, no caen todas las copias. Las topology spread constraints serían otra opción válida, pero no está entre las respuestas.
5. A high-priority Pod cannot be scheduled because the cluster is full. What can the scheduler do?
- Increase the node's CPU automatically
- Evict lower-priority Pods to make room (preemption)
- Run the Pod on the control plane without limits
- Delete the PriorityClass
Ver respuesta
B. Es la expulsión preventiva (preemption): se echan Pods de menor prioridad para hacer hueco al importante. Los expulsados vuelven a esperar sitio.