Los objetos con los que se trabaja
En Kubernetes no se arrancan contenedores a mano: se describen «objetos» (qué quieres que funcione y cómo) y Kubernetes se encarga de que existan y sigan funcionando.
Qué es un objeto
En la lección anterior viste que Kubernetes trabaja comparando lo que quieres con lo que hay. Lo que quieres se escribe en forma de objetos: fichas que describen una pieza del sistema. «Quiero tres copias de mi tienda web», «quiero una tarea que haga una copia de seguridad cada noche», «quiero esta configuración disponible para mis aplicaciones».
Cada tipo de objeto sirve para una cosa. En esta lección vas a conocer los que más salen en el examen, empezando por el más pequeño.
El Pod: la unidad mínima
Kubernetes nunca maneja contenedores sueltos. Los mete siempre dentro de un Pod (Pod), que es la pieza más pequeña que Kubernetes sabe arrancar. Casi siempre un Pod lleva un solo contenedor, pero puede llevar varios si tienen que trabajar muy pegados.
Si un contenedor es una persona, el Pod es un piso compartido. Quienes viven en el mismo piso comparten la dirección postal, el wifi y la nevera. Si se mudan, se mudan juntos.
Los contenedores de un mismo Pod comparten la dirección de red (se hablan entre ellos por localhost), pueden compartir carpetas (volúmenes) y siempre van juntos al mismo servidor.
Dentro de un Pod hay dos ayudantes típicos:
- Init container (init container): un contenedor que corre antes que los demás, hace una tarea de preparación (esperar a que exista la base de datos, descargar un fichero…) y termina. Si hay varios, corren de uno en uno y en orden. Hasta que no acaban bien, el contenedor principal no arranca.
- Sidecar (sidecar): un contenedor que acompaña al principal durante toda su vida para darle un servicio extra, como enviar sus registros a otro sitio o hacer de intermediario de red. El nombre viene del sidecar de las motos: el sidecar no conduce, pero va pegado a la moto.
Los Pods, igual que los contenedores, son efímeros. Si un Pod muere, Kubernetes no lo resucita: crea otro Pod nuevo, con otro nombre y normalmente otra IP. Por eso casi nunca se crean Pods sueltos, sino a través de un controlador que los vigila. Es justo lo que viene ahora.
Los controladores: los que vigilan a los Pods
Un Pod suelto que se cae, se queda caído. Para que Kubernetes los mantenga vivos se usan controladores (workload resources): objetos que dicen «quiero tantos Pods de este tipo» y se encargan de crearlos, sustituirlos si fallan y actualizarlos.
ReplicaSet y Deployment: copias idénticas
Un ReplicaSet (ReplicaSet) tiene una sola obsesión: que haya exactamente N copias de un Pod. Si le pides tres y una se cae, crea otra. Si de pronto hay cuatro, borra una.
Un Deployment (Deployment) está un escalón por encima: gestiona ReplicaSets por ti y añade lo que hace falta en el día a día, sobre todo actualizar a una versión nueva sin cortar el servicio y volver atrás si algo sale mal.
Piensa en una cadena de cafeterías. El ReplicaSet es el encargado que se asegura de que siempre haya tres camareros en sala: si uno se va a casa enfermo, llama a otro.
El Deployment es la jefa de zona. Cuando cambia el uniforme, no echa a todos los camareros a la vez: va sustituyéndolos de uno en uno por camareros con el uniforme nuevo, y si el uniforme nuevo resulta un desastre, vuelve al antiguo.
En la práctica casi nunca se crea un ReplicaSet a mano. Se crea un Deployment y él crea los ReplicaSets. La cadena es siempre: Deployment → ReplicaSet → Pods.
StatefulSet: copias con nombre y memoria
Los Pods de un Deployment son intercambiables, como los camareros: da igual cuál te atienda. Pero hay aplicaciones en las que cada copia es distinta y tiene sus propios datos, como una base de datos repartida en tres servidores. Para eso está el StatefulSet (StatefulSet):
- Cada Pod tiene un nombre fijo y numerado: db-0, db-1, db-2. Si db-1 se cae, el que lo sustituye se vuelve a llamar db-1.
- Cada Pod tiene su propio disco, que no se borra si el Pod se cae: el nuevo db-1 recupera el disco del anterior.
- Se arrancan en orden (primero el 0, luego el 1…) y se apagan en orden inverso.
- Cada Pod tiene una dirección de red estable por su nombre.
Un Deployment son los camareros de la cafetería: cualquiera vale. Un StatefulSet son los médicos de cabecera de un centro de salud: cada uno tiene su consulta numerada y los historiales de sus pacientes. Si el de la consulta 1 se jubila, el sustituto ocupa la consulta 1 y hereda los mismos historiales.
DaemonSet: uno en cada servidor
Un DaemonSet (DaemonSet) no pide un número de copias: pide una copia en cada servidor (nodo) del clúster, o en los que elijas. Si se añade un servidor nuevo, le pone su copia automáticamente; si se quita, la copia desaparece con él.
Se usa para tareas que tienen que estar en todas partes: recoger los registros de cada servidor, medir su consumo, o piezas de red como kube-proxy.
Job y CronJob: tareas que terminan
Todo lo anterior son aplicaciones que deben estar siempre encendidas. Pero a veces quieres algo que haga un trabajo y acabe: procesar un lote de facturas, mandar un correo masivo, hacer una copia de seguridad.
- Un Job (Job) arranca uno o varios Pods para hacer una tarea hasta que termine bien. Si falla, lo reintenta (hasta un límite de reintentos). Cuando acaba, el Pod queda en estado «completado» y no se vuelve a arrancar.
- Un CronJob (CronJob) es un Job programado: crea un Job nuevo cada vez que toca, según un horario. Por ejemplo, 0 3 * * * significa «todos los días a las 3 de la mañana». El nombre viene de cron, el programador de tareas clásico de Linux.
Una tienda online usaría a la vez: un Deployment para la web (copias idénticas), un StatefulSet para la base de datos (cada copia con sus datos), un DaemonSet para recoger los registros de cada servidor, un Job para importar el catálogo nuevo una vez, y un CronJob para la copia de seguridad de cada noche.
¿Qué controlador uso para…?
| Necesito… | Uso | Ejemplo |
|---|---|---|
| Varias copias idénticas e intercambiables, con actualizaciones sin corte | Deployment | Una web, una API |
| Mantener N copias (lo crea el Deployment por mí) | ReplicaSet | Casi nunca a mano |
| Copias con nombre fijo, orden y disco propio | StatefulSet | Bases de datos, Kafka |
| Una copia en cada servidor | DaemonSet | Recoger registros, monitorizar nodos |
| Una tarea que termina | Job | Importar datos, una migración |
| Una tarea que se repite con horario | CronJob | Copia de seguridad nocturna |
Etiquetas y selectores: cómo se encuentran las cosas
Con cientos de Pods en marcha, ¿cómo sabe un ReplicaSet cuáles son «sus» Pods? Con etiquetas.
- Una etiqueta (label) es una pareja clave y valor que se pega a cualquier objeto: app: tienda, entorno: produccion, version: v2. Un objeto puede llevar todas las que quieras.
- Un selector (selector) es un filtro sobre esas etiquetas: «todos los Pods con app: tienda». Así es como un ReplicaSet cuenta sus Pods, o como un Service (lección 07) decide a qué Pods mandar el tráfico.
Las etiquetas son como las pegatinas de colores en las cajas de una mudanza: «cocina», «frágil», «habitación de Ana». El selector es la orden que das a quien descarga: «todas las cajas con pegatina de cocina, a la cocina». No importa cuántas cajas haya ni cómo se llamen: se buscan por la pegatina.
Junto a las etiquetas existen las anotaciones (annotations): también son parejas clave y valor, pero sirven para apuntar información (quién es el responsable, un enlace a la documentación, instrucciones para una herramienta), no para buscar. Los selectores no pueden filtrar por anotaciones.
Etiqueta = para identificar y seleccionar. Anotación = para describir, sin poder seleccionar. Si una pregunta habla de «agrupar», «filtrar» o «seleccionar» objetos, la respuesta es labels.
Cómo se ve todo junto en un fichero
Así se escribe un Deployment. No tienes que memorizarlo: fíjate sólo en cómo las etiquetas de la plantilla coinciden con el selector.
apiVersion: apps/v1 kind: Deployment # qué tipo de objeto es metadata: name: tienda-web namespace: ventas # en qué «carpeta» vive spec: replicas: 3 # quiero 3 copias selector: matchLabels: app: tienda # mis Pods son los que tengan esta etiqueta… template: # …y así se fabrica cada Pod metadata: labels: app: tienda # …que es la que se les pone al crearlos spec: containers: - name: web image: tienda-web:2.1
Namespaces: carpetas dentro del clúster
Un Namespace de Kubernetes (Namespace) es una forma de dividir un clúster en zonas, como carpetas. Sirve para separar equipos (ventas, marketing), entornos (pruebas, producción) o aplicaciones.
- Dentro de un namespace, los nombres no se pueden repetir; en namespaces distintos, sí. Puede haber un Deployment tienda-web en «pruebas» y otro con el mismo nombre en «produccion».
- A cada namespace se le pueden poner permisos (quién puede tocar qué) y límites de consumo (lección 05).
- Un clúster nuevo trae cuatro: default (donde va todo si no dices nada), kube-system (las piezas internas de Kubernetes), kube-public (información pública, legible por todos) y kube-node-lease (latidos de los nodos para saber que siguen vivos).
No confundas este Namespace de Kubernetes con los namespaces de Linux de la lección 01. Los de Linux son las paredes que aíslan un contenedor; los de Kubernetes son carpetas para ordenar objetos. Además, los namespaces de Kubernetes no aíslan la red por sí solos: por defecto, un Pod de «pruebas» puede hablar con uno de «produccion». Para cortar eso hacen falta NetworkPolicies (lección 07).
Algunos objetos no viven en ningún namespace porque son de todo el clúster (cluster-scoped): los nodos, los PersistentVolumes y los propios namespaces.
Configuración y secretos: ConfigMap y Secret
Una buena práctica es no meter la configuración dentro de la imagen. Así la misma imagen sirve para pruebas y para producción, y sólo cambia la configuración que se le da al arrancar. Kubernetes tiene dos objetos para eso:
- ConfigMap (ConfigMap): guarda configuración normal, que no es secreta: el idioma por defecto, la dirección de otro servicio, el nivel de detalle de los registros.
- Secret (Secret): guarda datos delicados: contraseñas, claves de acceso, certificados.
Los dos se le pasan al contenedor de una de estas dos formas: como variables de entorno o como ficheros que aparecen dentro del contenedor.
El ConfigMap es el tablón de anuncios de la oficina: horarios, teléfonos internos, normas. Cualquiera puede leerlo. El Secret es la caja fuerte donde están las llaves y las claves. Pero cuidado: tal como viene de serie, es una caja fuerte con la puerta entornada.
Los valores de un Secret se guardan en base64, y base64 no es cifrado: es sólo otra forma de escribir el texto, y cualquiera lo descodifica en un segundo. Por defecto, los Secrets se guardan sin cifrar en la base de datos del clúster (etcd).
Para protegerlos de verdad hay que activar el cifrado en reposo (encryption at rest), limitar con permisos (RBAC) quién puede leerlos, o usar un gestor de secretos externo. Lo veremos en la lección 08.
Resumen en cinco frases
- El Pod es la pieza mínima: uno o varios contenedores que comparten red, carpetas y servidor; puede llevar init containers y sidecars.
- Los Pods son efímeros, así que se crean a través de controladores: Deployment (que maneja ReplicaSets), StatefulSet, DaemonSet, Job y CronJob.
- Las etiquetas identifican objetos y los selectores los eligen por esas etiquetas; las anotaciones sólo describen.
- Los Namespaces son carpetas para ordenar el clúster, separar equipos y poner permisos y límites.
- La configuración va en ConfigMaps y los datos delicados en Secrets, que por defecto sólo están en base64, no cifrados.
Términos del examen
- Pod
- La unidad mínima de Kubernetes: uno o varios contenedores que comparten red y almacenamiento.
- Init container
- Contenedor que corre y termina antes de que arranquen los principales.
- Sidecar
- Contenedor ayudante que acompaña al principal dentro del mismo Pod.
- ReplicaSet
- Mantiene un número fijo de copias de un Pod.
- Deployment
- Gestiona ReplicaSets: copias, actualizaciones sin corte y vuelta atrás.
- Rolling update
- Actualizar sustituyendo Pods poco a poco.
- Rollback
- Volver a la versión anterior.
- StatefulSet
- Copias con nombre fijo, orden de arranque y disco propio.
- DaemonSet
- Una copia del Pod en cada nodo.
- Job
- Tarea que se ejecuta hasta terminar bien.
- CronJob
- Crea Jobs según un horario.
- Namespace
- Carpeta lógica dentro del clúster.
- Cluster-scoped
- Objeto de todo el clúster, fuera de cualquier namespace.
- Label
- Etiqueta clave-valor para identificar y agrupar objetos.
- Selector
- Filtro que elige objetos por sus etiquetas.
- Annotation
- Información descriptiva; no se puede seleccionar por ella.
- ConfigMap
- Configuración no secreta para las aplicaciones.
- Secret
- Datos delicados; codificados en base64, no cifrados por defecto.
Comprueba que lo has entendido
1. What is the smallest deployable unit in Kubernetes?
- Container
- Pod
- Deployment
- Node
Ver respuesta
B. Kubernetes no arranca contenedores sueltos: siempre los mete en un Pod. El Deployment está por encima (gestiona Pods) y el nodo es el servidor donde corren.
2. You need to run exactly one log collector Pod on every node of the cluster. Which resource should you use?
- Deployment
- StatefulSet
- DaemonSet
- CronJob
Ver respuesta
C. El DaemonSet pone una copia en cada nodo, y la añade sola cuando entra un nodo nuevo. Un Deployment reparte copias donde quepan, sin garantizar una por nodo.
3. Which resource provides Pods with stable names, ordered startup and their own persistent storage?
- ReplicaSet
- StatefulSet
- Job
- DaemonSet
Ver respuesta
B. El StatefulSet da a cada Pod un nombre numerado fijo (db-0, db-1…), los arranca en orden y le asigna su propio disco. Es lo típico para bases de datos.
4. Which statement about Kubernetes Secrets is true by default?
- They are encrypted with AES in etcd
- Their values are only base64-encoded, not encrypted
- They cannot be mounted as files
- They can only be read by the cluster administrator
Ver respuesta
B. Base64 es una codificación, no un cifrado: cualquiera puede descodificarlo. Para cifrarlos hay que activar el cifrado en reposo y limitar el acceso con RBAC.
5. How does a Deployment know which Pods belong to it?
- By the Pod names
- By annotations on the Pods
- By a label selector that matches the Pods' labels
- By the namespace they run in
Ver respuesta
C. Los controladores encuentran sus Pods con un selector de etiquetas. No miran el nombre, y por las anotaciones no se puede seleccionar.