KCNA en ruta
Lección 06 · Fundamentos de Kubernetes (44 %)

Dónde acaba cada Pod

Tema del examen: SchedulingLectura: 15 min

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.

Imagínatelo así

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:

  1. 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.
  2. 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 scheduler filtra cuatro nodos, descarta dos, puntúa los otros dos y elige el de mayor nota Pod nuevopide 2 CPU 1 · Filtrar Nodo 1 · sólo 1 CPU libre Nodo 2 · 3 CPU libres Nodo 3 · reservado (taint) Nodo 4 · 6 CPU libres ✗✗ 2 · Puntuar Nodo 2 · nota 55 Nodo 4 · nota 82 ✓ gana el nodo 4: el Pod va ahí
Primero se tachan las mesas que no valen; después se elige la mejor de las que quedan.

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:

FamiliaQuién la poneQué diceHerramientas
AtraerEl Pod«Quiero ir a nodos así»nodeSelector, node affinity
Juntar o separarEl Pod«Ponme cerca (o lejos) de estos otros Pods»pod affinity, pod anti-affinity, topology spread
RepelerEl 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:

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.

Ejemplo

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:

«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.

Afinidad: la web y su caché en el mismo nodo. Antiafinidad: tres copias de la base de datos en tres nodos distintos Pod affinity: juntos Pod anti-affinity: separados Nodo 1 web caché se hablan mucho: mejor cerca Nodo 1 bd-0 Nodo 2 bd-1 Nodo 3 bd-2 si cae un nodo, quedan dos copias vivas
Afinidad para lo que conviene tener cerca; antiafinidad para no poner todos los huevos en la misma cesta.

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.

Ejemplo

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».

Imagínatelo así

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.

Un nodo con taint rechaza al Pod sin toleration y acepta al Pod que la tiene; el Pod con toleration también puede ir a nodos normales Nodo con GPU taint: gpu=true «sólo personal autorizado» Nodo normal Pod websin toleration ✗ ✓ Pod vídeocon toleration ✓ ✓
El Pod sin tarjeta no entra en el nodo de GPU. El Pod con tarjeta puede ir a los dos: la tolerancia permite, no obliga.

Cada taint tiene un efecto que dice cómo de estricto es:

EfectoQué pasa con los Pods sin toleration
NoScheduleNo se colocan Pods nuevos aquí. Los que ya estaban, se quedan.
PreferNoScheduleSe intenta no colocarlos aquí, pero si no hay otro sitio, se colocan. Es la versión blanda.
NoExecuteNo se colocan Pods nuevos y además se echa a los que ya estaban corriendo.
Ojo en el examen

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.

Para recordar

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):

Un Pod de prioridad alta no cabe; el scheduler expulsa un Pod de prioridad baja y ocupa su hueco Antes: nodo lleno webprioridad alta informesprioridad baja pagos · muy alta ← esperando sitio Después webprioridad alta pagosmuy alta «informes» se expulsa y vuelve a esperar sitio
Como en urgencias: el caso grave pasa delante, y el leve espera.
Ojo en el examen

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

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?

  1. Pulling and running
  2. Filtering and scoring
  3. Binding and evicting
  4. 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?

  1. Taints on Pods, tolerations on nodes
  2. Both on nodes
  3. Taints on nodes, tolerations on Pods
  4. 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?

  1. The Pod will always be scheduled on node A
  2. The Pod is allowed to be scheduled on node A, but may run elsewhere
  3. No other Pod can run on node A
  4. 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?

  1. Pod affinity
  2. Pod anti-affinity
  3. nodeSelector
  4. 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?

  1. Increase the node's CPU automatically
  2. Evict lower-priority Pods to make room (preemption)
  3. Run the Pod on the control plane without limits
  4. 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.