Este curso es la parte práctica de Kubernetes 101, un libro en español que construye una tienda entera sobre Kubernetes, pieza a pieza. Son 55 laboratorios repartidos en 15 módulos, siete de ellos challenges. El último cierra el curso: el reto final. Cada módulo es el laboratorio del capítulo correspondiente y siguen el mismo recorrido que el índice.

No hace falta el libro para hacer el curso. Es abierto y es gratis, las lecciones se explican solas y si has llegado buscando practicar con Kubernetes estás en el sitio correcto.

Lo que encontrarás en el libro y no aquí es lo que no cabe en una terminal: los 54 diagramas —el ciclo de una petición dentro del kube-apiserver no se ve con kubectl—, el apéndice «Desde cuándo funciona cada pieza», que te dice en qué versión entró cada cosa y en qué estado está hoy, una chuleta de kubectl de 16 páginas ordenada por lo que quieres hacer y no por orden alfabético, un glosario de siglas y un índice analítico para volver. Y el porqué: de dónde sale cada decisión y qué falla en silencio cuando no la tomas.

Y hay un trozo del libro que también es gratis, sin registro ni correo: 31 páginas en PDF con el capítulo de Arquitectura de Kubernetes —que aquí no tiene módulo propio— y el Apéndice D: El clúster por dentro completo, que es el capítulo del módulo 14, con sus ocho diagramas tal y como aparecen impresos. Si quieres ver cómo se explica esto en el libro antes de plantearte nada, descárgalo y decides tú: javivela.dev/libros/kubernetes-101.

Es el mismo sistema

El libro construye una tienda, pieza a pieza, y aquí la construyes tú con las manos. Los nombres son los mismos, así que si has leído el capítulo ya sabes qué esperar:

Y los Namespaces del libro. Desde la primera lección trabajas dentro de tienda, aunque no lo notes: el contexto ya apunta ahí, así que en la mayoría de las lecciones no tendrás que escribir -n. Verás la bandera solo donde importa de verdad, cuando un comando cruza de Namespace o cuando la herramienta lo exige, como en Helm. plataforma aparece cuando toca, que es cuando una pieza no cabe en tienda: el agent y su hostPath, y el gateway que publica el tráfico de todos. El módulo de Seguridad es donde por fin lo miras de frente.

Qué capítulo corresponde a cada módulo

Casi todos los módulos son uno a uno con su capítulo, pero hay tres excepciones que conviene tener claras si vas siguiendo el libro:

• Fundamentos cubre dos capítulos: Hablar con el clúster (el 3) y Objetos de Kubernetes (el 4). Se hacen del tirón porque el primero es kubectl y el segundo es lo que kubectl manipula.
• El clúster por dentro cubre el capítulo 2, Arquitectura de Kubernetes, y el Apéndice D. El capítulo presenta los componentes; el apéndice los recorre uno a uno, y el laboratorio es el mismo.
• Reto final no corresponde a ningún capítulo. Es el examen.

Si te has descargado las 31 páginas gratuitas, ahí están precisamente el capítulo 2 y el Apéndice D: son el texto del módulo 14.

Cuatro diferencias con el libro, a propósito

Los laboratorios tienen que arrancar de verdad en un playground compartido, y eso obliga a unas cuantas concesiones. El libro describe el sistema completo; aquí verás la versión que cabe en dos nodos. Ninguna cambia lo que se aprende, pero conviene que las sepas para no pensar que te has equivocado al copiar:

• Las imágenes. El libro usa tienda/web:1.4.2 y tienda/api:2.1.0, que son nombres ilustrativos. Aquí verás ghcr.io/iximiuz/labs/nginx:alpine, una imagen real espejada en el registro de la plataforma. La pieza es la misma; lo que cambia es que esta existe y arranca. La excepción es el módulo de Contenedores: ahí construyes tú la tienda/api:2.1.0 de verdad y la publicas en el registro del playground, así que durante ese módulo el nombre del libro es literal.
• Los puertos. Esa imagen es un nginx y escucha en el 80, no en el 8080 del libro. Los Services y las probes de las lecciones apuntan al 80. La api que construyes en Contenedores sí escucha en el 8080, como en el libro.
• El clúster, y cómo se llaman sus nodos. El mapa del libro dibuja tres nodos y los llama node-1, node-2 y node-3. El playground de k3s trae dos nodos programables y los llama node-01 y node-02, con el cero delante: los nombres los pone la plataforma al registrar los nodos y no se pueden cambiar. Así que si copias un comando del libro tal cual (kubectl describe node node-1, nodeName: node-3) obtendrás un NotFound; escribe el nombre que veas en kubectl get nodes y listo. Y donde el libro reparte tres réplicas de cache entre tres nodos, aquí verás dos entre dos: la regla que aprendes es exactamente la misma, y en el libro el mapa del capítulo 12 enseña el reparto completo. Varias lecciones dependen además de que sean exactamente dos, porque con un tercero un drenado que aquí se bloquea encontraría sitio y dejaría de demostrar nada.
• El recomendador nunca llega a arrancar, y su laboratorio va más lejos que el libro. Es la pieza que pide una GPU con Dynamic Resource Allocation, y aquí no hay ninguna. Aun así los tipos de resource.k8s.io son núcleo de la API y están en el playground, así que la lección de Scheduling recorre el mecanismo entero: la reclamación se crea, el scheduler va diciendo qué le falta, y llegas a publicar un dispositivo de mentira a mano —algo que el libro no hace— para ver al selector CEL descartar la GPU que no llega a los 24 GiB. El Pod se queda a un paso, en el driver, porque eso ya no se simula con YAML.

El módulo que el libro no tiene

Este curso no repite el libro: lo continúa. Hay un módulo que no se corresponde con ningún capítulo, y es justamente el que no se puede hacer leyendo.

• Reto final. No hay capítulo que corresponda porque no hay nada nuevo que aprender: apagas el kube-scheduler de un clúster vivo y diagnosticas qué deja de funcionar y qué sigue funcionando, que no es lo que casi nadie espera. Es el examen de todo lo anterior.

Y hay tres donde el libro llega hasta la mitad y el laboratorio hace la otra. En Extensibilidad, el capítulo define el CRD Promocion de la tienda, explica qué hace un operador y por qué un CRD sin él no significa nada; aquí lo escribes: el operador entero, en Go y con controller-runtime, y ves la reconciliación funcionando delante de ti. En Contenedores, el capítulo da por hecha la imagen tienda/api:2.1.0 desde la primera página; aquí la construyes tú, capa a capa, la conviertes en multistage y la publicas en el registro del clúster. Y en Scheduling, el capítulo explica cómo se reclama un dispositivo con Dynamic Resource Allocation; aquí llegas a publicar uno a mano —algo que el libro no hace— para ver al selector CEL descartar la GPU que no da la talla.

El clúster por dentro, el penúltimo módulo, es el laboratorio del capítulo 2 y del Apéndice D. Va al final por la misma razón que el apéndice: los componentes del control plane se explican en el libro allí donde hacen falta —kube-proxy con el Service, el kube-scheduler con el scheduling— y solo cuando ya los has usado todos merece la pena verlos juntos. Es además el único módulo, junto al reto final, que corre sobre un clúster kubeadm en vez de k3s: hace falta para ver cada componente por separado.

Cómo funciona

• El curso combina dos formatos. Los tutoriales te guían paso a paso con el YAML explicado en preguntas y respuestas. Los challenges —siete en total— te sueltan sin guion: la mayoría te entrega un clúster con algo roto para que lo arregles, y alguno te pide construir la pieza o romperlo tú. Es donde de verdad se aprende.
• Cada lección arranca un clúster de Kubernetes real en tu navegador, sin instalar nada en tu máquina.
• La verificación es automática: el curso registra tu progreso a medida que superas las tareas.
• Avanza a tu ritmo y retómalo donde lo dejaste desde tu dashboard.

Sobre este curso y el libro

Los dos cuentan la misma historia desde lados distintos: el curso te pone a hacer las cosas y el libro explica por qué son como son.

Si no tienes el libro, el curso funciona igual: es abierto, es gratis y no hay nada que validar. Cuando termines un módulo y te quede la sensación de «vale, ha funcionado, pero ¿por qué?», esa pregunta es exactamente la que contesta el libro. Está en javivela.dev/libros/kubernetes-101, con 31 páginas descargables para juzgarlo antes, y si el curso te ha servido esa es la mejor forma de apoyarlo.

Si tienes el libro, ve capítulo a capítulo: al final de cada uno se indica el módulo que le corresponde. El orden de aquí es el mismo.

Un par de cosas honestas. Este curso se ofrece tal cual, sin garantía de disponibilidad ni de funcionamiento futuro: Kubernetes y las herramientas que usa cambian, y los escenarios pueden romperse. Se mantienen con el mejor esfuerzo posible. La plataforma que aloja los laboratorios es un tercero: el autor no participa en ella ni en su gestión, y el funcionamiento y el tratamiento de datos son responsabilidad suya. El enlace de alta que aparece en la página del libro es un enlace de referido, y si te registras a través de él el autor puede recibir una contrapartida de la plataforma; no cambia nada para ti, porque el curso es gratuito. Si encuentras algo roto, avísame.

El programa

1. Contenedores (capítulo 1): cómo se apila una imagen en capas y por qué el orden del Dockerfile decide si una reconstrucción tarda segundos o minutos, hasta construir y publicar la tienda/api:2.1.0 que el resto del curso da por hecha.
2. Fundamentos (capítulos 3 y 4): web como tu primer Pod, tu primer Pod roto, y labels, selectors y annotations.
3. Workloads (capítulo 5): el módulo más largo, con ocho lecciones y dos challenges. Las probes de api, requests, limits y QoS, web convertido en Deployment con rollout y rollback, la db como StatefulSet, el agent como DaemonSet, init containers y sidecars, y las tareas finitas (backups y reports).
4. Escalado (capítulo 6): el HPA que escala api y el VPA que arregla al holgazan.
5. Red (capítulo 7): los Services con DNS interno, el Ingress de web con Traefik (el controlador que trae k3s; el libro usa NGINX en sus ejemplos, pero el objeto Ingress es el mismo y solo cambian las anotaciones), el gateway con Gateway API, las NetworkPolicies que aíslan la db y CoreDNS.
6. Configuración (capítulo 8): el ConfigMap web-config y el Secret db-credentials, el challenge de las credenciales del registro privado, y la Downward API que le cuenta a la api quién es y dónde corre.
7. Almacenamiento (capítulo 9): emptyDir, PersistentVolumeClaims y StorageClasses, con el disco de la db.
8. Seguridad (capítulo 10): Namespaces, RBAC y la ServiceAccount del agent, y Pod Security Admission sobre tienda.
9. Policies (capítulo 11): las ResourceQuotas y LimitRanges que ponen presupuesto al Namespace tienda.
10. Scheduling (capítulo 12): afinidades, taints y tolerations, prioridad y preemption, el reparto de cache entre nodos, el PDB de web y el drenado de nodos, y la GPU que el recomendador reclama con Dynamic Resource Allocation.
11. Trabajando con el clúster (capítulo 13): depuración imperativa en formato misión, el flujo declarativo con Kustomize, Helm y los comandos que no salen en los manuales.
12. Extensibilidad (capítulo 14): define el CRD Promocion de la tienda y escribe el operador que le da vida, en Go y con controller-runtime.
13. Observabilidad (capítulo 15): Events, métricas con kubectl top, y el despliegue de un stack real con Prometheus, Grafana, Loki y VictoriaMetrics en el Namespace observabilidad.
14. El clúster por dentro (capítulo 2 y Apéndice D): la sala de máquinas, sobre un clúster kubeadm de verdad, con cada componente enlazado al sitio del libro que lo explica.
15. Reto final (sin capítulo): apaga el scheduler y diagnostica el clúster a corazón abierto.

Qué necesitas

Un navegador y una cuenta gratuita en iximiuz Labs, que es donde corren los clústeres. Nada más: el clúster, kubectl y el editor de código ya están preparados en cada lección, y no hay ningún código ni cupón que introducir. Empieza por el módulo Fundamentos: creas un Pod en la primera pantalla, sin instalar nada en tu máquina.