La arquitectura de un clúster
Un clúster de Kubernetes es un grupo de ordenadores que trabajan como uno solo: unos deciden qué hay que hacer y los demás lo hacen.
De un contenedor a cientos
En la lección anterior viste que un contenedor es una caja con una aplicación dentro. Arrancar un contenedor a mano en un ordenador es fácil. El problema llega cuando tienes cientos de contenedores repartidos entre decenas de ordenadores: ¿quién decide dónde va cada uno?, ¿quién se da cuenta de que uno se ha caído a las tres de la mañana?, ¿quién lo vuelve a arrancar?
Eso es lo que hace Kubernetes. Se encarga de orquestar los contenedores: colocarlos, vigilarlos y sustituirlos cuando fallan, sin que una persona tenga que estar pendiente. Al conjunto de ordenadores que gestiona se le llama clúster (cluster).
Piensa en una cadena de restaurantes. Hay una oficina central que no cocina nada: recibe los encargos, decide qué cocina prepara cada plato, lleva el registro de todo y comprueba que se cumple. Y hay varias cocinas, que son las que hacen el trabajo de verdad.
En Kubernetes, la oficina central se llama plano de control (control plane) y cada cocina es un nodo (node). Usaremos este restaurante durante toda la lección.
Los recuadros morados son Pods (Pod). Un Pod es la unidad mínima que maneja Kubernetes: un envoltorio con uno o varios contenedores dentro. De momento basta con pensar «Pod = mi aplicación en marcha». En la lección 03 lo verás con calma.
El plano de control: la oficina central
El plano de control es el cerebro del clúster. No ejecuta tus aplicaciones: toma decisiones y guarda el estado de todo. Tiene cuatro piezas principales, y una quinta opcional.
kube-apiserver: la ventanilla única
El kube-apiserver es la puerta de entrada del clúster. Todo pasa por él: cuando tú das una orden, cuando un nodo informa de cómo va, cuando otra pieza del plano de control quiere saber algo. Nadie habla con nadie directamente; todos hablan con el API server.
Antes de aceptar una petición, comprueba quién eres (autenticación), si tienes permiso (autorización) y si lo que pides tiene sentido (validación). Si todo está bien, lo apunta en etcd.
Es la recepción de la oficina central. Los clientes, los encargados de cada cocina y los propios jefes de la oficina pasan siempre por recepción. Recepción comprueba tu identificación, apunta el encargo en el libro y te da el resguardo. Nadie entra al archivo por la puerta de atrás.
etcd: el libro de registro
etcd es la base de datos del clúster. Guarda absolutamente todo: qué aplicaciones hay, cuántas copias de cada una se quieren, en qué nodo está cada Pod, qué configuración tienen… Es una base de datos sencilla de tipo «clave y valor», como un fichero de fichas donde cada ficha tiene un nombre y un contenido.
Sólo el API server habla directamente con etcd. Las demás piezas le preguntan al API server.
etcd es la única pieza que guarda el estado del clúster. Si pierdes etcd sin copia de seguridad, pierdes la definición de todo el clúster. Por eso se hacen copias de seguridad de etcd y, en producción, se monta con varias copias, normalmente 3 o 5 (siempre un número impar, para que en caso de desacuerdo gane la mayoría).
kube-scheduler: el que reparte el trabajo
Cuando se crea un Pod nuevo, todavía no tiene nodo asignado. El kube-scheduler lo ve y decide en qué nodo debe ir. Para decidir mira cuánta CPU y memoria pide el Pod, cuánta le queda libre a cada nodo y si hay reglas especiales (por ejemplo, «este Pod necesita un nodo con tarjeta gráfica»).
El scheduler sólo decide; no arranca el Pod. Apunta «este Pod va al nodo 2» (a través del API server) y ahí termina su trabajo. Quien lo arranca de verdad es el kubelet del nodo 2. Es una pregunta trampa muy típica.
kube-controller-manager: los supervisores
El kube-controller-manager es un programa que agrupa muchos controladores (controllers). Cada controlador vigila un tipo de cosa y se asegura de que la realidad coincide con lo que se pidió. Algunos ejemplos:
- El controlador de réplicas: si pediste 3 copias de tu aplicación y sólo hay 2, crea otra.
- El controlador de nodos: si un nodo deja de dar señales de vida, lo marca como no disponible.
- El controlador de tareas (Job): crea los Pods de una tarea puntual y comprueba que termina.
Son los supervisores de la oficina, cada uno con su lista. Uno comprueba que cada restaurante tiene los camareros que tocan; otro llama a las cocinas que llevan un rato sin contestar. Ninguno cocina: sólo comparan lo que debería haber con lo que hay y piden que se corrija.
cloud-controller-manager: el que habla con la nube
Si el clúster está en una nube (Amazon, Google, Azure…), hay una pieza más: el cloud-controller-manager. Se encarga de pedirle cosas al proveedor de nube: un balanceador de carga para recibir tráfico de internet, un disco para guardar datos, o comprobar si una máquina virtual que hacía de nodo se ha borrado. Si montas el clúster en tus propios ordenadores, esta pieza no existe.
En muchos clústeres, las propias piezas del plano de control corren como contenedores. Y en producción el plano de control se suele repartir entre tres máquinas, para que el clúster siga funcionando aunque una se caiga.
Todos hablan con el API server
Esta es la idea más importante de la arquitectura, y conviene verla en un dibujo: el API server está en el centro y todas las demás piezas se comunican a través de él.
Los nodos: las cocinas
Un nodo es una máquina que ejecuta tus aplicaciones. Puede ser un ordenador físico o una máquina virtual en la nube; a Kubernetes le da igual. A estos nodos se les llama también nodos de trabajo (worker nodes). Cada uno tiene tres piezas:
kubelet: el encargado de cada cocina
El kubelet es un pequeño programa que corre en cada nodo. Pregunta al API server «¿qué Pods me tocan a mí?», pide al runtime que arranque sus contenedores, comprueba que siguen funcionando y informa del estado de vuelta al API server.
El kubelet sólo se ocupa de los contenedores que Kubernetes le ha encargado. Si alguien arranca un contenedor a mano en ese nodo, el kubelet no lo vigila.
container runtime: los cocineros
Es lo que viste en la lección 01: containerd o CRI-O. El kubelet le habla por el enchufe CRI y el runtime descarga las imágenes y arranca los contenedores.
kube-proxy: el que dirige el tráfico
El kube-proxy corre también en cada nodo y se ocupa de la red. Las aplicaciones en Kubernetes se encuentran unas a otras mediante unas direcciones fijas llamadas Services (lo veremos en la lección de redes). kube-proxy prepara las reglas de red de cada nodo para que, cuando alguien llama a esa dirección fija, la llamada llegue a uno de los Pods que están detrás.
El restaurante tiene un único número de teléfono para pedidos. kube-proxy es la centralita que pasa cada llamada a uno de los cocineros libres. Al cliente le da igual quién conteste: llama siempre al mismo número.
| Pieza | Dónde corre | En el restaurante | Qué hace |
|---|---|---|---|
| kube-apiserver | Plano de control | Recepción | Puerta de entrada; todo pasa por él. |
| etcd | Plano de control | Libro de registro | Guarda el estado de todo el clúster. |
| kube-scheduler | Plano de control | Jefe de reparto | Decide en qué nodo va cada Pod nuevo. |
| kube-controller-manager | Plano de control | Supervisores | Comparan lo pedido con lo real y corrigen. |
| cloud-controller-manager | Plano de control (sólo en nube) | El que llama al proveedor | Pide balanceadores, discos y máquinas a la nube. |
| kubelet | Cada nodo | Encargado de cocina | Arranca y vigila los Pods de su nodo, e informa. |
| kube-proxy | Cada nodo | Centralita | Reglas de red para que los Services lleguen a los Pods. |
| container runtime | Cada nodo | Cocineros | Descarga imágenes y ejecuta contenedores. |
Los complementos: CoreDNS y compañía
Además de las piezas básicas, un clúster necesita algunos complementos (addons) que se instalan aparte. El que más sale en el examen es CoreDNS.
- CoreDNS: la guía telefónica del clúster. Traduce nombres a direcciones. Gracias a él, una aplicación puede llamar a otra por su nombre, por ejemplo base-de-datos, sin saber en qué dirección IP está ahora mismo. CoreDNS es un proyecto graduado de la CNCF.
- Plugin de red (CNI): da a cada Pod su dirección de red y los conecta entre sí. Sin él, los Pods no pueden hablar. Ejemplos: Calico, Cilium, Flannel.
- metrics-server: recoge cuánta CPU y memoria gasta cada Pod. Lo necesita el autoescalado que verás en la lección 05.
- Dashboard: una web para ver el clúster con el ratón en vez de con comandos.
Qué pasa cuando pides algo
Vamos a juntar todas las piezas con un ejemplo real. Quieres arrancar tu tienda web con tres copias.
- Escribes en un fichero «quiero la tienda web, 3 copias» y se lo das a Kubernetes con kubectl apply.
- El API server comprueba que tienes permiso y que el fichero está bien, y lo apunta en etcd.
- Un controlador ve que se piden 3 Pods y no hay ninguno, y crea los 3 Pods (todavía sin nodo).
- El scheduler ve 3 Pods sin nodo y decide a qué nodo va cada uno.
- El kubelet de cada nodo ve que le ha tocado un Pod, pide al runtime que descargue la imagen y arranque el contenedor, e informa de que ya está funcionando.
Y si mañana se cae el nodo 2, el controlador ve que sólo hay 2 copias, crea otra, el scheduler la manda a un nodo sano y el kubelet la arranca. Tú no haces nada.
La idea clave: estado deseado y reconciliación
Lo que acabas de ver tiene nombre, y es probablemente el concepto más importante de Kubernetes.
En Kubernetes no das órdenes paso a paso («arranca un contenedor aquí, ahora otro allí»). Lo que haces es describir cómo quieres que esté el sistema («quiero 3 copias de la tienda»). Eso es el estado deseado (desired state). Kubernetes se encarga de llegar a ese estado y de mantenerlo. A esta forma de trabajar se le llama declarativa (declarative): declaras el resultado, no los pasos.
Para conseguirlo, cada controlador repite sin parar un bucle de tres pasos, el bucle de reconciliación (reconciliation loop o control loop):
Es un termostato. Tú no le dices «enciende la calefacción diez minutos». Le dices «quiero 21 grados» y él solo mira la temperatura, la compara con 21 y enciende o apaga. Si abres una ventana y baja la temperatura, vuelve a encender sin que se lo pidas.
| Imperativo | Declarativo | |
|---|---|---|
| Qué dices | Los pasos: «arranca uno, arranca otro» | El resultado: «quiero 3» |
| Si algo falla después | Te toca a ti arreglarlo | Kubernetes lo corrige solo |
| En la vida real | Dar indicaciones giro a giro | Poner la dirección en el GPS |
Si te preguntan cómo consigue Kubernetes recuperarse solo de los fallos (self-healing), la respuesta es esta: los controladores comparan continuamente el estado deseado con el estado actual y actúan para que coincidan. El estado deseado está guardado en etcd.
Resumen en cinco frases
- Un clúster tiene un plano de control, que decide, y nodos de trabajo, que ejecutan las aplicaciones.
- El plano de control lo forman el API server (la puerta), etcd (la memoria), el scheduler (el que reparte) y el controller-manager (los supervisores); en la nube se añade el cloud-controller-manager.
- Cada nodo tiene un kubelet (arranca y vigila sus Pods), un kube-proxy (la red de los Services) y un runtime (ejecuta los contenedores).
- Todas las piezas hablan sólo con el API server, y sólo el API server habla con etcd.
- Kubernetes es declarativo: describes el estado deseado y los controladores lo mantienen con un bucle de reconciliación sin fin.
Términos del examen
- Cluster
- El grupo de máquinas que Kubernetes gestiona como una sola.
- Control plane
- El plano de control: las piezas que deciden y guardan el estado.
- Node / worker node
- Una máquina (física o virtual) que ejecuta Pods.
- kube-apiserver
- La puerta de entrada del clúster. Todo pasa por él.
- etcd
- Base de datos clave-valor donde se guarda todo el estado del clúster.
- kube-scheduler
- Decide en qué nodo va cada Pod nuevo. No lo arranca.
- kube-controller-manager
- Agrupa los controladores que mantienen el estado deseado.
- cloud-controller-manager
- Conecta el clúster con el proveedor de nube.
- kubelet
- Agente de cada nodo: arranca y vigila los Pods que le tocan e informa.
- kube-proxy
- Mantiene en cada nodo las reglas de red de los Services.
- Addon
- Complemento que se instala aparte, como CoreDNS o el plugin de red.
- CoreDNS
- El DNS del clúster: traduce nombres de servicios a direcciones.
- Desired state
- El estado deseado: cómo quieres que esté el sistema.
- Declarative
- Forma de trabajar en la que describes el resultado, no los pasos.
- Reconciliation loop
- El bucle observar, comparar y actuar de cada controlador.
- Self-healing
- La capacidad de Kubernetes de recuperarse solo de fallos.
Comprueba que lo has entendido
1. Which component stores all cluster data, including the desired state?
- kube-scheduler
- kubelet
- etcd
- kube-proxy
Ver respuesta
C. etcd es el libro de registro del clúster: una base de datos clave-valor donde se guarda todo. Por eso es tan importante hacer copias de seguridad de etcd.
2. Which control plane component selects the node on which a newly created Pod will run?
- kube-controller-manager
- kube-scheduler
- kube-apiserver
- kubelet
Ver respuesta
B. El scheduler decide el nodo. Ojo: sólo decide; el que arranca el Pod en ese nodo es el kubelet.
3. Which agent runs on every node and makes sure that the containers of its Pods are running?
- kubelet
- kube-proxy
- etcd
- cloud-controller-manager
Ver respuesta
A. El kubelet es el encargado de cada cocina: recibe los Pods que le tocan, pide al runtime que los arranque, los vigila e informa. kube-proxy también está en cada nodo, pero se ocupa de la red.
4. Which component is the front end of the control plane and the only one that talks directly to etcd?
- kube-scheduler
- CoreDNS
- kube-controller-manager
- kube-apiserver
Ver respuesta
D. El API server es la ventanilla única. Todas las demás piezas, y tú con kubectl, pasan por él; y es el único que lee y escribe en etcd.
5. How does Kubernetes keep an application running with the requested number of replicas?
- The user must restart failed containers manually
- Controllers continuously compare the desired state with the current state and act on the difference
- etcd restarts failed Pods by itself
- kube-proxy creates new Pods when traffic increases
Ver respuesta
B. Es el bucle de reconciliación: observar, comparar y actuar, sin parar. etcd sólo guarda datos, no actúa, y kube-proxy sólo se ocupa de la red.