Fundamentos De Docker y Kubernetes — De Cero a Capitán
Introduction
📋 Programa Detallado del Entrenamiento: De Cero a Capitán en Kubernetes
Workshop Oficial — Cloud Native Medellín 🏔️☕
- Repositorio Oficial en GitHub: https://github.com/edwinbermudez91/Fundamentos-Kubernetes
- 🎮 Simulador Visual Interactivo K8s: KubeCafé en GitHub Pages
- 📺 Grabaciones de Clases: Canal @CloudNativeColombia en YouTube
- Comunidad CNCF Medellín: https://community.cncf.io/cloud-native-medellin/
- Sitio Web: https://cloudnativemedellin.com/
- Duración: 6 Semanas (Módulos teórico-prácticos con retos interactivos)
- Nivel: Principiante a Intermedio (No se requiere experiencia previa en Kubernetes)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
🎯 Objetivos de Aprendizaje
Al finalizar este entrenamiento serás capaz de:
- Comprender a fondo qué es un contenedor y cómo el kernel de Linux (
namespacesycgroups) aísla procesos sin duplicar sistemas operativos. - Escribir
Dockerfilessiguiendo las mejores prácticas de la industria (imágenes ligeras, multi-stage builds, usuarios sin privilegiosroot). - Dominar la arquitectura interna de Kubernetes: Control Plane (
kube-apiserver,etcd,kube-scheduler,kube-controller-manager) y Worker Nodes (kubelet,kube-proxy, container runtime). - Diseñar, desplegar y depurar manifiestos declarativos en YAML para Pods, Deployments, Services, ConfigMaps, Secrets y Volúmenes.
- Gestionar el ciclo de vida de aplicaciones en producción: despliegues continuos sin caídas (Rolling Updates), autorreparación (Self-healing) y reversiones (Rollbacks).
- Configurar enrutamiento avanzado con Services (
ClusterIP,NodePort) eIngress. - Operar con resiliencia y seguridad: sondas de salud (
liveness/readiness), límites de consumo de CPU/RAM para evitarOOMKilled, y control de acceso basado en roles (RBAC). - Empaquetar aplicaciones complejas con Helm y desplegar una arquitectura multinivel lista para producción.
🗓️ Calendario Curricular por Módulos
🐳 Módulo 00: Fundamentos de Docker — De Código a Contenedor para Kubernetes
Descripción:
Antes de que Kubernetes pueda orquestar aplicaciones, necesitamos empaquetarlas de manera estándar e inmutable. En esta semana desmitificamos qué es un contenedor frente a una máquina virtual pesada y construimos nuestras primeras imágenes OCI, gestionamos redes, volúmenes, registros empresariales con Harbor y corremos modelos de IA en contenedores con Ollama.
- Conceptos Teóricos:
- La metáfora del tinto colombiano: café (código), receta (
Dockerfile), bolsa sellada (imagen), greca activa (contenedor). - Máquinas Virtuales vs. Contenedores: hipervisores vs. Kernel compartido de Linux.
- Tecnologías base del contenedor:
Namespaces(aislamiento de red, procesos PID y filesystem) yCgroups(límites de CPU y memoria). - Anatomía del
Dockerfile:FROM,WORKDIR,COPY,RUN,EXPOSE,ENV,CMDvsENTRYPOINT. - Buenas prácticas de seguridad y optimización: imágenes Alpine, usuario no-root (
USER),COPY --chown,dockerignorey gestión de señales PID 1 (SIGTERM). - Auditoría de vulnerabilidades con Trivy (CVEs en SO, dependencias y malas prácticas de Dockerfile).
- Registros OCI empresariales con Harbor: control de acceso (RBAC), Cuentas Robot y políticas de prevención.
- Inferencia de Inteligencia Artificial local en contenedores con Ollama (CPU y GPU).
- La metáfora del tinto colombiano: café (código), receta (
- Laboratorios Prácticos (6 Laboratorios Oficiales):
01-servidor-web-html: Servidor Nginx estático sobre Alpine Linux (~25 MB) y proceso en primer plano.02-app-python-api: API REST en Python con usuario sin privilegios (appuser), variablesENV,.dockerignorey UI web interactiva.03-redes-comunicacion-contenedores: Comunicación entre microservicios (Greca Backend y Carrito Cliente) en red bridge personalizada con resolución DNS interna por nombre.04-almacenamiento-y-volumenes: Persistencia real con Named Volumes (docker volume) vs Bind Mounts (-v) frente al almacenamiento efímero.05-registro-imagenes-harbor: Ciclo de distribución OCI completo: autenticación con Cuentas Robot,docker tag,docker pushy escaneo con Trivy en el portal.06-ia-local-ollama: Inferencia de LLM (Qwen2.5) en CPU con límites de memoria y cores,Modelfilepara asistente DevOps y API REST en127.0.0.1:11434.- Escaneo de seguridad obligatorio con Trivy CLI en cada imagen construida.
- Puente local a Kubernetes: cómo cargar imágenes locales en clústeres de Kind con
kind load docker-image.
- Los 5 Retos Rotos de la Semana 00:
Reto 01: Proceso en segundo plano apaga el contenedor (PID 1).Reto 02: Contenedor crashea por falta de variable de entorno (ENV).Reto 03: Contenedor vulnerable ejecutándose comoroot(Seguridad).Reto 04: Fuga de contraseñas y secretos por ausencia de.dockerignore.Reto 05: Conexión rechazada por enlazar a127.0.0.1y puerto desalineado.
🌱 Módulo 01: El Motor por Dentro y tu Primer Pod
Descripción:
Entendemos qué hace Kubernetes por debajo, cómo interactúan sus componentes internos (Control Plane vs. Worker Nodes) mediante la analogía de ☕ KubeCafé, y desplegamos nuestras primeras unidades de cómputo estructuradas en subsecciones prácticas que abarcan Pods básicos, Sidecars, recursos, sondas de salud, inferencia de IA local con Ollama y observabilidad ligera.
- Conceptos Teóricos:
- ¿Por qué necesitamos un orquestador? Caídas de servidores, balanceo de carga y escalabilidad automática.
- La metáfora de ☕ KubeCafé: Oficina de Gerencia (
Control Plane), Mesas de Barismo (Worker Nodes), Baristas (kubelet), Pedidos escritos (YAML) y Bandejas (Pods). - Arquitectura del Control Plane (Oficina de Gerencia):
kube-apiserver: Ventanilla única / Caja registradora (el único componente que habla conetcd).etcd: La base de datos clave-valor distribuida e inmutable (Libro contable).kube-scheduler: El despachador que evalúa CPU/RAM libre para ubicar la bandeja en la mesa adecuada.kube-controller-manager: El supervisor que reconcilia el estado actual con el deseado y garantiza auto-curación (Self-healing).
- Arquitectura del Worker Node (Mesa de Barismo):
kubelet: El barista líder en cada nodo que recibe órdenes de gerencia y cuida los contenedores.kube-proxy: Gestiona el enrutamiento y reglas de red local (iptables/IPVS).- Container Runtime:
containerdoCRI-O.
- Anatomía de un Pod: ¿Por qué Kubernetes no corre contenedores sueltos? Red compartida (
localhost), IP única y volúmenes compartidos. - Modo Imperativo vs. Declarativo: Pedido a viva voz (
k run,k exec) vs. Orden oficial escrita en Git (k apply -f). - El truco ninja de productividad: generación de plantillas YAML con
--dry-run=client -o yaml,--help,kubectl explain --recursivey exportación.
- Laboratorios Prácticos (Subsecciones):
Lab 0: Preparación del entorno con Kind,kubectl, aliaskcon autocompletado,kubectx/kubens,k9s,sterny consola visual Headlamp.Lab 1: Despliegue de un Pod básico Nginx y túnel de acceso seguro conkubectl port-forward.Lab 2: Pod multi-contenedor con patrón Sidecar comunicándose por volumen compartidoemptyDir.Lab 3: Dosificador de recursos (requests/limitsde CPU y RAM) y variables dinámicas con Downward API (spec.nodeName,status.podIP).Lab 4: Tareas bloqueantes previas coninitContainersy sondas de salud (readinessProbeylivenessProbe).Lab 5: Inferencia de Inteligencia Artificial local en CPU con Ollama (smollm2:135m), volumen de modelosemptyDiry API REST.Lab 6: Observabilidad sencilla: activación de Metrics Server en Kind (kubectl top), exportador oficial de Prometheus (:9113/metrics), logs estructurados JSON y radar de eventos.
- Retos Rotos de la Semana 01 (4 Retos Oficiales):
Reto 01: Pod con errores de imagen y puerto desalineado (ImagePullBackOff).Reto 02: Contenedor que crashea al instante (CrashLoopBackOff).Reto 03: Pod en estadoPendinginfinito por solicitud desmedida de recursos (Insufficient cpu/memory).Reto 04: Manifiesto con errores de sintaxis y campos no reconocidos (ValidationError).
🔄 Módulo 02: Despliegues Sin Caídas y Autorreparación
Descripción:
En producción los Pods son efímeros y nunca se despliegan de forma solitaria. En la analogía de KubeCafé, contratamos al Supervisor de Salón (Controller Manager + ReplicaSet) para garantizar que siempre haya baristas activos en la barra (Desired State vs Actual State) y cambiar recetas en caliente sin cerrar la cafetería (Zero Downtime).
- Conceptos Teóricos:
- De Pods aislados a controladores declarativos: Por qué nunca desplegar Pods sueltos en producción.
- Jerarquía de 3 niveles: Deployment (Estrategia) ➔ ReplicaSet (Reconciliación) ➔ Pods (Contenedores físicos).
ReplicaSet: Bucle de reconciliación permanente para garantizarNréplicas activas (Desired State).- Estrategias de actualización:
RollingUpdate: Relevo progresivo de Pods taza por taza conmaxSurgeymaxUnavailable.Recreate: Apagado total previo al 100%, ideal para migraciones de bases de datos o volúmenes exclusivos (ReadWriteOnce).
- Mecanismo de autorreparación (Self-healing): regeneración automática de Pods caídos o eliminados en milisegundos.
- Reversión instantánea (Rollback) con
kubectl rollout undoante versiones fallidas (ImagePullBackOffo errores críticos). - Estándar de producción: Usuario no privilegiado (
securityContext.runAsNonRoot), límites de recursos y sondaslivenessProbe/readinessProbe.
- Laboratorios Prácticos (5 Laboratorios Oficiales):
01-primer-deployment-replicas.yaml: Despliegue decafecito-appcon 3 réplicas balanceadas y prueba de autorreparación borrando Pods en vivo.02-rolling-update-cero-caidas.yaml: Despliegue deapi-pedidos-rollingconmaxSurge: 1,maxUnavailable: 0, readinessProbe y actualización en caliente conVERSION=v2.0.03-estrategia-recreate.yaml: Procesador batch (batch-procesador-recreate) con estrategiaRecreatepara evitar concurrencia de versiones.04-deployment-con-recursos-y-probes.yaml: Portal de clientes en producción (portal-clientes-prod) con usuario rootless (UID 10001), sondas HTTP yrevisionHistoryLimit.05-deployment-ia-inferencia.yaml: Microservicio del Barista IA (barista-ia) con API JSON de recomendaciones escalable horizontalmente.
- Los 4 Retos Rotos de la Semana 02 (+40 XP):
Reto 01:01-deployment-selector-roto.yaml— Incompatibilidad entrematchLabelsytemplate.metadata.labels.Reto 02:02-deployment-imagen-caida-rollback.yaml— Imagen inexistente (ImagePullBackOff), bloqueo del despliegue y solución con rollback.Reto 03:03-deployment-estrategia-invalida.yaml— Error tipográfico enRollingUpdatee indentación de parámetrosmaxSurge.Reto 04:04-deployment-yaml-identacion.yaml—apiVersionobsoleto (v1) e indentación rota en el bloquetemplate.spec.
🌐 Módulo 03: Conectando Todo: Redes en Kubernetes
Descripción:
Dado que los Pods nacen y mueren recibiendo IPs dinámicas impredecibles, necesitamos una capa de abstracción estable para la comunicación interna y externa.
- Conceptos Teóricos:
- El modelo de red de Kubernetes: "Cada Pod tiene su propia IP y todos los Pods se comunican entre sí sin NAT".
- Tipos de Services:
ClusterIP: IP interna virtual accesible únicamente dentro del clúster (ideal para bases de datos y microservicios internos).NodePort: Abre un puerto estático (rango 30000-32767) en cada nodo del clúster.LoadBalancer: Se integra con proveedores de nube para aprovisionar un balanceador externo.
- Service Discovery y CoreDNS: Resolución de nombres internos (
<servicio>.<namespace>.svc.cluster.local). - Ingress y Controladores de Ingress: Enrutamiento capa 7 (HTTP/HTTPS) basado en rutas (
/api,/web) y nombres de dominio con un solo punto de entrada.
- Laboratorios Prácticos:
- Exponer una aplicación interna con un Service
ClusterIP. - Conectar un Frontend con un Backend usando únicamente el nombre DNS del servicio.
- Configurar Nginx Ingress Controller en Kind y enrutar tráfico HTTP hacia múltiples servicios.
- Exponer una aplicación interna con un Service
- Reto Roto 03:
- Resolver un Service que no envía tráfico a sus Pods debido a un error en
targetPorty selector de etiquetas (labels).
- Resolver un Service que no envía tráfico a sus Pods debido a un error en
💾 Módulo 04: Configuración y Datos Persistentes
Descripción:
Las aplicaciones modernas deben desacoplar su código de su configuración (The Twelve-Factor App) y manejar datos persistentes que sobrevivan al ciclo de vida del contenedor.
- Conceptos Teóricos:
- Configuración desacoplada: Variables de entorno vs. archivos de configuración inyectados.
ConfigMaps: Almacenamiento de configuración en texto plano (puertos, endpoints, temas).Secrets: Almacenamiento seguro de credenciales, tokens y llaves (codificados en Base64 / integrables con KMS).- Almacenamiento efímero (
emptyDir) vs. almacenamiento persistente. - La tríada del almacenamiento en K8s:
PersistentVolume(PV): El disco físico aprovisionado en la infraestructura.PersistentVolumeClaim(PVC): El ticket de solicitud de almacenamiento que hace el Pod.StorageClass: Aprovisionamiento dinámico de discos bajo demanda.
- Laboratorios Prácticos:
- Inyección de variables de entorno y archivos de configuración con
ConfigMap. - Montaje seguro de credenciales con
Secret. - Despliegue de una base de datos con persistencia real usando
PVCy verificación de datos tras reiniciar los Pods.
- Inyección de variables de entorno y archivos de configuración con
- Reto Roto 04:
- Diagnóstico de un Pod con
CreateContainerConfigErrorpor unConfigMapKeyRefinexistente y un PVC que se queda en estadoPending.
- Diagnóstico de un Pod con
🛡️ Módulo 05: Salud, Límites y Seguridad Básica
Descripción:
Aprende a operar aplicaciones en entornos de producción reales con resiliencia, control de recursos y control de acceso.
- Conceptos Teóricos:
- Sondas de salud (Probes):
StartupProbe: Para aplicaciones lentas al arrancar.LivenessProbe: Detecta bloqueos o deadlocks y reinicia el contenedor.ReadinessProbe: Detiene el envío de tráfico a Pods que aún no están listos para responder.
- Tipos de verificación:
httpGet,tcpSocketyexec. - Gestión de recursos:
requests: Recursos mínimos garantizados para el agendamiento del Pod.limits: Techo máximo de CPU (estrangulamiento / throttling) y Memoria (OOMKilled).
- Aislamiento lógico con
Namespaces. - Seguridad básica con
RBAC:ServiceAccount,Role,ClusterRole,RoleBinding.
- Sondas de salud (Probes):
- Laboratorios Prácticos:
- Configuración de sondas
livenessyreadinessen una aplicación web. - Prueba de estrés de memoria para observar cómo actúa el kernel ante límites excedidos.
- Creación de un usuario con permisos de solo lectura (
read-only) en un namespace específico mediante RBAC.
- Configuración de sondas
- Reto Roto 05:
- Reparar un Pod que entra en bucle continuo de reinicios porque su
livenessProbeapunta a una ruta errónea.
- Reparar un Pod que entra en bucle continuo de reinicios porque su
🚀 Módulo 06: Empaquetado con Helm y Proyecto Final
Descripción:
En el mundo profesional no aplicamos decenas de archivos YAML sueltos. Utilizamos Helm, el gestor de paquetes de Kubernetes, para parametrizar, versionar y desplegar soluciones completas.
- Conceptos Teóricos:
- ¿Por qué Helm? El dolor de mantener múltiples YAMLs para desarrollo, staging y producción.
- Anatomía de un Helm Chart:
Chart.yaml: Metadatos del paquete.values.yaml: Valores por defecto configurables.templates/: Plantillas Go template que generan los manifiestos dinámicos.
- Comandos esenciales:
helm create,helm lint,helm install,helm upgrade,helm rollback,helm uninstall.
- Laboratorios Prácticos:
- Creación de un Chart personalizado desde cero.
- Parametrización de réplicas, imágenes, puertos y variables de entorno.
- Despliegue de dependencias externas (ej. Redis o PostgreSQL) usando repositorios de Charts comunitarios.
- Proyecto Final de Graduación:
- Despliegue de una arquitectura de 3 capas completa (Frontend web, API backend y Base de datos con volumen persistente, sondas de salud, Ingress y Helm).
- ¡Graduación oficial y obtención del rango de Capitán K8s en la comunidad! ⚓
🧭 Metodología de los "Retos Rotos"
Cada módulo semanal cuenta con su respectivo reto roto en el repositorio:
- Navega a la carpeta semanal correspondiente en el repositorio oficial.
- Identifica el error aplicando el archivo en tu clúster de laboratorio.
- Investiga con comandos de diagnóstico:
kubectl get,kubectl describe,kubectl logs. - Corrige el archivo en tu rama de trabajo y agrégalo en
aportes-comunidad/soluciones-retos/<tu-usuario>/. - Envía tu Pull Request para que sea revisado por los mentores de Cloud Native Medellín.
🐳 Semana 00 • Conceptos: Fundamentos de Docker (De Código a Contenedor)
🐳 Módulo 00: Fundamentos de Docker — De Código a Contenedor
📖 Lectura / Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Revisa este tutorial oficial en iximiuz Labs para marcar esta sección en verde:
Loading tutorial...
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Módulo: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad Oficial CNCF: Cloud Native Medellín en CNCF Community Groups
- Documentación Oficial: Docker Docs • Referencia de Dockerfile • Referencia de CLI
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
🎯 ¿Qué vas a dominar en esta unidad?
- Qué es realmente un contenedor y en qué se diferencia de una Máquina Virtual pesada.
- Cómo el Kernel de Linux aísla procesos usando Namespaces y limita recursos con Cgroups.
- Cómo escribir un
Dockerfiledesde cero con buenas prácticas (Alpine, usuario no-root,.dockerignore,exec form). - Construir redes bridge personalizadas y entender la resolución DNS interna por nombre entre contenedores.
- Almacenamiento efímero vs. Named Volumes (
docker volume) vs. Bind Mounts (-v). - Auditoría y escaneo de vulnerabilidades con Trivy (
HIGH,CRITICAL). - Ciclo de distribución OCI con Harbor: autenticación (
docker login), etiquetado (docker tag), publicación (docker push) y descarga (docker pull). - Inferencia de modelos de IA locales en CPU con Ollama, límites de recursos y consumo vía API REST.
- El truco fundamental para cargar imágenes locales en clústeres de Kind con
kind load docker-image.
☕ La Analogía del Tinto Colombiano
Para no enredarnos con términos extraños, piensa en cómo funciona un buen tinto en Medellín:
[ Granos de Café ] ➔ [ Receta: Dockerfile ] ➔ [ Bolsa Sellada: Imagen ] ➔ [ Greca Encendida: Contenedor ]
(Tu Código) (Instrucciones) (Plantilla Inmutable) (Proceso en Ejecución)
- Los Granos de café: Es tu código fuente (
app.py,index.html, etc.). La materia prima sin procesar. - El
Dockerfile(La Receta): Indica cómo tostar, moler y preparar el café paso a paso. - La Imagen de Docker (La Bolsa de café sellada): La bolsa de café molido sellada al vacío que compras en la tienda. Es inmutable: la construyes una vez y la puedes llevar a Medellín, Bogotá o Tokio; sabe exactamente igual en todas partes.
- El Contenedor (La Greca preparando el tinto): La greca encendida pasando agua caliente por el café molido. La aplicación viva y corriendo, lista para servir peticiones.
🧠 Máquinas Virtuales vs. Contenedores
- Máquina Virtual (VM): Incluye un sistema operativo completo (Guest OS) con su propio kernel encima de un hipervisor (VirtualBox, VMware). Pesa gigabytes y tarda minutos en arrancar.
- Contenedor: No duplica el sistema operativo. Comparte el Kernel de Linux del anfitrión y aísla los procesos con:
- Namespaces: Dan la ilusión de tener red propia, tabla de procesos propia (PID 1) y sistema de archivos propio.
- Cgroups (Control Groups): Establecen techos de consumo de CPU y memoria RAM para proteger al host.
🛠️ Comandos Esenciales de Docker
| Acción | Comando | ¿Qué hace? |
|---|---|---|
| Construir imagen | docker build -t mi-app:v1.0 . | Lee el Dockerfile en el directorio actual y crea la imagen con etiqueta mi-app:v1.0. |
| Listar imágenes | docker images | Muestra las imágenes almacenadas localmente. |
| Correr contenedor | docker run -d -p 8080:80 --name mi-servidor mi-app:v1.0 | -d: segundo plano, -p: mapeo de puerto (host:contenedor), --name: nombre amigable. |
| Ver contenedores activos | docker ps | Muestra qué contenedores están corriendo actualmente. |
| Ver todos (incluidos caídos) | docker ps -a | Permite revisar contenedores detenidos o con error. |
| Ver logs en vivo | docker logs -f mi-servidor | Sigue en tiempo real la salida estándar y errores de la aplicación. |
| Entrar a la terminal | docker exec -it mi-servidor sh | Abre una sesión interactiva dentro del contenedor. |
| Detener contenedor | docker stop mi-servidor | Envía una señal limpia SIGTERM para apagarlo. |
| Eliminar contenedor | docker rm mi-servidor | Borra el contenedor detenido del disco. |
| Crear red bridge | docker network create mi-red | Crea una red privada con resolución DNS automática por nombre. |
| Crear volumen | docker volume create mi-volumen | Crea un volumen administrado que persiste datos fuera del ciclo de vida del contenedor. |
| Etiquetar imagen | docker tag mi-app:v1.0 mi-registro.io/equipo/mi-app:v1.0 | Asigna un nuevo tag con la URL del registro de destino. |
| Iniciar sesión en registro | docker login mi-registro.io | Autentica contra un registro OCI como Harbor o Docker Hub. |
| Publicar imagen | docker push mi-registro.io/equipo/mi-app:v1.0 | Sube la imagen empaquetada al registro remoto. |
| Descargar imagen | docker pull mi-registro.io/equipo/mi-app:v1.0 | Descarga la imagen remota a tu máquina o nodo. |
| Escanear seguridad | trivy image --severity HIGH,CRITICAL mi-app:v1.0 | Analiza vulnerabilidades conocidas (CVEs) en la imagen. |
🚀 Preparación del Entorno: Clonar el Repositorio
Para ejecutar las prácticas de este módulo con total seguridad, evitar errores de contexto (context not found) o rutas relativas incorrectas, clona el repositorio oficial en tu terminal y sitúate en la raíz del proyecto:
# 1. Clonar el repositorio oficial del workshop
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
# 2. Entrar a la raíz del repositorio
cd Fundamentos-Kubernetes
!IMPORTANT 📁 Regla de Oro: Rutas Absolutas con
$PWD:
A lo largo de toda esta unidad, todos los comandos utilizan la variable de entorno$PWD(ej.$PWD/semana-00-fundamentos-docker/...) para construir la ruta absoluta exacta en tu sistema o en la terminal web de Labs.iximiuz.
Esto garantiza que puedes ejecutar cualquier comando desde la raíz del repositorio sin necesidad de cambiar de carpeta (cd) entre laboratorios, eliminando por completo los errores de archivos no encontrados.
🧭 Laboratorios Prácticos de este Módulo
Completa los laboratorios prácticos en las siguientes unidades del curso:
| Unidad | Laboratorio | Descripción |
|---|---|---|
| Lab 01 | Servidor Web Estático con Nginx | Nginx Alpine (~25 MB), proceso en primer plano y HTML. |
| Lab 02 | API en Python con Variables de Entorno | Usuario no-root (appuser), ENV, .dockerignore y UI interactiva. |
| Lab 03 | Redes en Docker y Microservicios | Red bridge custom (red-cafetera), DNS interno y comunicación Backend-Frontend. |
| Lab 04 | Almacenamiento y Volúmenes | Datos efímeros vs Named Volumes y Bind Mounts con persistencia real. |
| Lab 05 | Registro y Publicación con Harbor | Autenticación con Cuentas Robot, docker tag, push y auditoría Trivy. |
| Lab 06 | IA Local en Docker con Ollama | Inferencia de LLM (Qwen2.5) en CPU con límites cgroups y Modelfile DevOps. |
| Retos Rotos | Los 5 Retos Rotos de la Semana 00 | Depuración de fallos reales típicos de contenedores y puente a Kind. |
🐳 Semana 00 • Lab 1: Servidor Web Nginx en Alpine
🧪 Laboratorio 1: Servidor Web Estático con Nginx
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial de iximiuz Labs para validar tus conocimientos prácticos y marcar este módulo en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Aprende a empaquetar una página web estática dentro de un contenedor Nginx ultra ligero. Los archivos de este laboratorio se encuentran en:
📂 semana-00-fundamentos-docker/1.ejemplos/01-servidor-web-html/
1. Archivo HTML (index.html):
<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Mi Primer Contenedor Docker — Cloud Native Medellín</title>
<style>
:root {
--bg: #0d1117;
--card-bg: #161b22;
--border: #30363d;
--text: #c9d1d9;
--heading: #58a6ff;
--accent: #00c7b7;
--code-bg: #21262d;
}
* {
box-sizing: border-box;
margin: 0;
padding: 0;
}
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
background-color: var(--bg);
color: var(--text);
display: flex;
justify-content: center;
align-items: center;
min-height: 100vh;
padding: 1.5rem;
}
.card {
background: var(--card-bg);
border: 1px solid var(--border);
border-radius: 12px;
max-width: 600px;
width: 100%;
padding: 2.5rem;
box-shadow: 0 12px 28px rgba(0, 0, 0, 0.4);
text-align: center;
}
.badge {
display: inline-block;
background: rgba(0, 199, 183, 0.15);
color: var(--accent);
border: 1px solid var(--accent);
padding: 0.35rem 0.85rem;
border-radius: 9999px;
font-size: 0.85rem;
font-weight: 600;
margin-bottom: 1.25rem;
}
h1 {
color: var(--heading);
font-size: 1.85rem;
margin-bottom: 0.75rem;
}
p {
line-height: 1.6;
margin-bottom: 1.5rem;
}
.steps {
text-align: left;
background: var(--code-bg);
border-radius: 8px;
padding: 1.25rem 1.5rem;
margin-bottom: 1.5rem;
font-size: 0.95rem;
}
.steps ol {
padding-left: 1.2rem;
}
.steps li {
margin-bottom: 0.5rem;
}
.footer {
font-size: 0.85rem;
color: #8b949e;
border-top: 1px solid var(--border);
padding-top: 1.25rem;
}
</style>
</head>
<body>
<div class="card">
<span class="badge">🐳 Docker + ☸️ Kubernetes</span>
<h1>¡Hola desde tu Contenedor!</h1>
<p>
Si estás viendo esta página web servida por <strong>Nginx</strong>, significa que tu imagen de Docker fue empaquetada correctamente y está corriendo con éxito.
</p>
<div class="steps">
<strong>¿Qué acaba de ocurrir por debajo?</strong>
<ol>
<li>Docker leyó el <code>Dockerfile</code>.</li>
<li>Descargó la capa base oficial de <code>nginx:alpine</code>.</li>
<li>Copió este archivo <code>index.html</code> dentro de <code>/usr/share/nginx/html/</code>.</li>
<li>Expuso el puerto 80 y dejó el proceso escuchando en primer plano.</li>
</ol>
</div>
<div class="footer">
🏔️ Comunidad Cloud Native Medellín • De Cero a Capitán en Kubernetes ☕
</div>
</div>
</body>
</html>
2. Archivo Dockerfile:
# Usamos una imagen base oficial ultra ligera basada en Alpine Linux
FROM nginx:alpine
# Copiamos nuestro HTML al directorio público por defecto de Nginx
COPY index.html /usr/share/nginx/html/index.html
# Indicamos que el contenedor escucha en el puerto 80
EXPOSE 80
# Nginx arranca automáticamente en primer plano
CMD ["nginx", "-g", "daemon off;"]
3. Construye y corre el contenedor con ruta absoluta:
# 1. Construir la imagen referenciando la ruta absoluta del laboratorio
docker build -t mi-web-estatica:v1.0 $PWD/semana-00-fundamentos-docker/1.ejemplos/01-servidor-web-html
# 2. Correr el contenedor en segundo plano mapeando el puerto 8080:80
docker run -d -p 8080:80 --name mi-servidor-web mi-web-estatica:v1.0
# 3. Probar en terminal o abrir http://localhost:8080
curl -I http://localhost:8080
# 4. Inspeccionar los logs en vivo
docker logs -f mi-servidor-web
# 5. Entrar al contenedor con docker exec
docker exec -it mi-servidor-web sh
# 6. Auditar la imagen y la configuración con Trivy usando ruta absoluta
trivy image --severity HIGH,CRITICAL mi-web-estatica:v1.0
trivy config $PWD/semana-00-fundamentos-docker/1.ejemplos/01-servidor-web-html
# 7. Limpieza
docker rm -f mi-servidor-web
!TIP 🛡️ Requisito para el paso #6 (Instalación de Trivy):
Para instalar la herramienta Trivy en tu máquina (Homebrew en macOS, Linux, WSL) o correrla directamente sin instalar nada utilizando el contenedor efímero oficial (docker run aquasec/trivy), consulta la Guía Completa de Seguridad y Escaneo de Contenedores con Trivy.
🐳 Semana 00 • Lab 2: API REST en Python y Variables de Entorno
🧪 Laboratorio 2: API en Python con Variables de Entorno
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Aprende a crear y empaquetar un microservicio en Python parametrizado mediante variables de entorno que ofrece una experiencia interactiva dual:
- 🌐 En el Navegador: Interfaz web visual y animada con la taza de tinto paisa humeante, sonido con Web Audio API, simulador de variables de entorno y telemetría de Kubernetes.
- 📡 En Terminal o Kubernetes: Respuesta limpia en JSON para
curl, scripts y probes de salud (/health).
Los archivos de este laboratorio se encuentran en:
📂 $PWD/semana-00-fundamentos-docker/1.ejemplos/02-app-python-api/
1. Código de la Aplicación (app.py):
El microservicio utiliza únicamente la librería estándar de Python (http.server, sin frameworks pesados ni dependencias externas), lo que permite crear imágenes mínimas y ultra seguras.
"""
Servidor HTTP en Python sin dependencias externas (Standard Library).
Ideal para entender cómo empaquetar una aplicación con variables de entorno
y probarla primero en Docker y luego en Kubernetes.
Características:
- 🌐 Interfaz Web interactiva, animada y moderna para navegadores con la taza de tinto paisa humeante.
- 📡 Endpoint REST JSON para llamadas con curl, scripts y Kubernetes.
- 🩺 Endpoint de salud /health para probes de Kubernetes (Liveness y Readiness).
- 🛡️ Inspección de seguridad en tiempo de ejecución (UID / usuario no-root).
"""
import http.server
import json
import os
import socket
import sys
import time
import urllib.parse
# 1. Variables de entorno configurables
PORT = int(os.environ.get("PORT", 8080))
MENSAJE_DEFAULT = os.environ.get("MENSAJE", "¡Tinto recién colado! ☕")
COMUNIDAD = "Cloud Native Medellín 🏔️☕"
WORKSHOP = "De Cero a Capitán en Kubernetes"
START_TIME = time.time()
TINTOS_TOTALES = 1
# 2. Plantilla HTML interactiva con diseño moderno, animaciones CSS y Web Audio API
HTML_PAGE = """<!DOCTYPE html>
<html lang="es">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>☕ Cloud Native Medellín — Tinto Recién Colado</title>
<link rel="preconnect" href="https://fonts.googleapis.com">
<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
<link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700;800&family=JetBrains+Mono:wght@400;500;700&display=swap" rel="stylesheet">
<style>
:root {
--bg: #0a0e17;
--card-bg: rgba(18, 24, 38, 0.88);
--card-border: rgba(245, 158, 11, 0.25);
--coffee-gold: #f59e0b;
--coffee-warm: #d97706;
--coffee-dark: #78350f;
--accent-cyan: #06b6d4;
--accent-green: #10b981;
--accent-red: #ef4444;
--text-main: #f9fafb;
--text-muted: #9ca3af;
--code-bg: #030712;
}
* {
box-sizing: border-box;
margin: 0;
padding: 0;
}
body {
font-family: 'Outfit', -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
background: radial-gradient(circle at 50% 15%, rgba(217, 119, 6, 0.18), transparent 45%),
radial-gradient(circle at 85% 85%, rgba(6, 182, 212, 0.1), transparent 40%),
var(--bg);
color: var(--text-main);
min-height: 100vh;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
padding: 2rem 1rem;
overflow-x: hidden;
}
.container {
width: 100%;
max-width: 840px;
background: var(--card-bg);
border: 1px solid var(--card-border);
backdrop-filter: blur(24px);
-webkit-backdrop-filter: blur(24px);
border-radius: 28px;
padding: 2.8rem 2.2rem;
box-shadow: 0 30px 70px -15px rgba(0, 0, 0, 0.75),
0 0 40px -5px rgba(245, 158, 11, 0.18);
position: relative;
animation: fadeIn 0.8s cubic-bezier(0.16, 1, 0.3, 1);
}
@keyframes fadeIn {
from { opacity: 0; transform: translateY(24px) scale(0.98); }
to { opacity: 1; transform: translateY(0) scale(1); }
}
/* Badges Bar */
.badge-bar {
display: flex;
flex-wrap: wrap;
gap: 0.6rem;
justify-content: center;
margin-bottom: 1.5rem;
}
.badge {
display: inline-flex;
align-items: center;
gap: 0.45rem;
padding: 0.4rem 0.95rem;
border-radius: 9999px;
font-size: 0.82rem;
font-weight: 600;
letter-spacing: 0.3px;
border: 1px solid transparent;
transition: all 0.25s ease;
}
.badge-coffee {
background: rgba(245, 158, 11, 0.15);
color: var(--coffee-gold);
border-color: rgba(245, 158, 11, 0.4);
}
.badge-cyan {
background: rgba(6, 182, 212, 0.15);
color: var(--accent-cyan);
border-color: rgba(6, 182, 212, 0.4);
}
.badge-green {
background: rgba(16, 185, 129, 0.15);
color: var(--accent-green);
border-color: rgba(16, 185, 129, 0.4);
}
.pulse-dot {
width: 8px;
height: 8px;
border-radius: 50%;
background: var(--accent-green);
box-shadow: 0 0 10px var(--accent-green);
animation: pulse 1.8s infinite;
}
@keyframes pulse {
0%, 100% { opacity: 1; transform: scale(1); }
50% { opacity: 0.4; transform: scale(0.75); }
}
/* Header */
header {
text-align: center;
margin-bottom: 2rem;
}
h1 {
font-size: 2.3rem;
font-weight: 800;
line-height: 1.2;
background: linear-gradient(135deg, #ffffff 40%, var(--coffee-gold) 100%);
-webkit-background-clip: text;
-webkit-text-fill-color: transparent;
margin-bottom: 0.5rem;
}
.subtitle {
font-size: 1.05rem;
color: var(--text-muted);
}
/* Coffee Animation Showcase */
.coffee-showcase {
display: flex;
flex-direction: column;
align-items: center;
margin: 1.8rem 0;
position: relative;
}
.cup-wrapper {
position: relative;
width: 140px;
height: 125px;
display: flex;
justify-content: center;
align-items: flex-end;
cursor: pointer;
}
/* Steam animation */
.steam-container {
position: absolute;
top: -10px;
display: flex;
gap: 16px;
z-index: 10;
}
.steam-wisp {
width: 7px;
height: 52px;
background: linear-gradient(to top, rgba(255, 255, 255, 0.8), rgba(245, 158, 11, 0.35), transparent);
border-radius: 50% 50% 20% 20%;
filter: blur(3px);
animation: steamRise 2.5s infinite ease-out;
opacity: 0;
}
.steam-wisp:nth-child(1) { animation-delay: 0s; }
.steam-wisp:nth-child(2) { animation-delay: 0.8s; height: 60px; }
.steam-wisp:nth-child(3) { animation-delay: 1.6s; }
@keyframes steamRise {
0% {
transform: translateY(20px) scaleX(0.7) skewX(0deg);
opacity: 0;
}
30% {
opacity: 0.85;
}
70% {
transform: translateY(-28px) scaleX(1.5) skewX(10deg);
opacity: 0.35;
}
100% {
transform: translateY(-55px) scaleX(2.2) skewX(-12deg);
opacity: 0;
}
}
/* Coffee Cup CSS */
.coffee-cup {
position: relative;
width: 112px;
height: 74px;
background: linear-gradient(135deg, #f9fafb 0%, #e5e7eb 65%, #9ca3af 100%);
border-radius: 0 0 46px 46px;
box-shadow: inset 0 -6px 12px rgba(0, 0, 0, 0.25),
0 10px 24px rgba(0, 0, 0, 0.45);
z-index: 2;
transition: transform 0.2s cubic-bezier(0.175, 0.885, 0.32, 1.275);
}
.coffee-cup:hover {
transform: scale(1.04);
}
.cup-handle {
position: absolute;
right: -24px;
top: 10px;
width: 32px;
height: 42px;
border: 8px solid #f3f4f6;
border-left: none;
border-radius: 0 22px 22px 0;
box-shadow: 2px 2px 5px rgba(0, 0, 0, 0.25);
}
.cup-saucer {
position: absolute;
bottom: -7px;
width: 142px;
height: 14px;
background: linear-gradient(to bottom, #f3f4f6, #9ca3af);
border-radius: 50%;
box-shadow: 0 8px 18px rgba(0, 0, 0, 0.55);
z-index: 1;
}
.cup-liquid {
position: absolute;
top: 5px;
left: 10px;
right: 10px;
height: 20px;
background: radial-gradient(ellipse at center, #78350f 0%, #451a03 70%, #1f0d05 100%);
border-radius: 50%;
box-shadow: inset 0 2px 4px rgba(0, 0, 0, 0.9);
overflow: hidden;
}
.cup-crema {
position: absolute;
top: 3px;
left: 20%;
width: 32px;
height: 11px;
background: rgba(245, 158, 11, 0.4);
border-radius: 50%;
filter: blur(2px);
animation: cremaDrift 4s ease-in-out infinite alternate;
}
@keyframes cremaDrift {
0% { transform: scale(1) translateX(0); }
100% { transform: scale(1.2) translateX(14px); }
}
/* Message Callout */
.message-hero {
margin-top: 1.8rem;
background: rgba(0, 0, 0, 0.4);
border: 1px solid rgba(245, 158, 11, 0.35);
padding: 1.25rem 2rem;
border-radius: 18px;
text-align: center;
box-shadow: inset 0 2px 10px rgba(0, 0, 0, 0.5);
max-width: 90%;
width: 100%;
}
.message-label {
font-size: 0.75rem;
text-transform: uppercase;
letter-spacing: 1.5px;
color: var(--coffee-gold);
font-weight: 700;
margin-bottom: 0.45rem;
display: flex;
align-items: center;
justify-content: center;
gap: 0.4rem;
}
.message-text {
font-size: 1.55rem;
font-weight: 700;
color: #fff;
text-shadow: 0 0 24px rgba(245, 158, 11, 0.55);
transition: all 0.3s ease;
}
/* Counter Badge */
.counter-pill {
font-size: 0.88rem;
color: var(--coffee-gold);
background: rgba(245, 158, 11, 0.12);
border: 1px dashed rgba(245, 158, 11, 0.35);
padding: 0.45rem 1.2rem;
border-radius: 9999px;
display: inline-flex;
align-items: center;
gap: 0.5rem;
margin-top: 0.8rem;
}
/* Action Buttons */
.actions-row {
display: flex;
flex-wrap: wrap;
gap: 0.9rem;
justify-content: center;
margin: 1.8rem 0;
}
.btn {
appearance: none;
border: none;
cursor: pointer;
font-family: inherit;
font-size: 0.95rem;
font-weight: 600;
padding: 0.85rem 1.6rem;
border-radius: 14px;
display: inline-flex;
align-items: center;
gap: 0.5rem;
transition: all 0.25s cubic-bezier(0.16, 1, 0.3, 1);
}
.btn-primary {
background: linear-gradient(135deg, var(--coffee-gold), var(--coffee-warm));
color: #0b0f19;
box-shadow: 0 4px 18px rgba(245, 158, 11, 0.45);
}
.btn-primary:hover {
transform: translateY(-2px);
box-shadow: 0 8px 28px rgba(245, 158, 11, 0.65);
}
.btn-primary:active {
transform: translateY(0);
}
.btn-secondary {
background: rgba(255, 255, 255, 0.07);
color: var(--text-main);
border: 1px solid rgba(255, 255, 255, 0.14);
}
.btn-secondary:hover {
background: rgba(255, 255, 255, 0.14);
transform: translateY(-2px);
}
/* Presets Section */
.presets-section {
background: rgba(0, 0, 0, 0.25);
border: 1px solid rgba(255, 255, 255, 0.07);
border-radius: 18px;
padding: 1.35rem;
margin: 1.6rem 0;
}
.presets-title {
font-size: 0.85rem;
font-weight: 600;
color: var(--coffee-gold);
margin-bottom: 0.85rem;
display: flex;
align-items: center;
justify-content: space-between;
flex-wrap: wrap;
gap: 0.5rem;
}
.preset-chips {
display: flex;
flex-wrap: wrap;
gap: 0.55rem;
}
.chip {
background: rgba(255, 255, 255, 0.05);
border: 1px solid rgba(255, 255, 255, 0.1);
color: var(--text-main);
padding: 0.45rem 0.9rem;
border-radius: 10px;
font-size: 0.85rem;
cursor: pointer;
transition: all 0.2s ease;
font-family: inherit;
}
.chip:hover {
background: rgba(245, 158, 11, 0.18);
border-color: var(--coffee-gold);
transform: translateY(-1px);
}
/* Telemetry Grid */
.telemetry-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(180px, 1fr));
gap: 1rem;
margin: 1.8rem 0;
}
.telemetry-card {
background: rgba(0, 0, 0, 0.25);
border: 1px solid rgba(255, 255, 255, 0.07);
border-radius: 16px;
padding: 1.1rem 1.25rem;
transition: all 0.25s ease;
}
.telemetry-card:hover {
border-color: rgba(245, 158, 11, 0.35);
transform: translateY(-2px);
}
.telemetry-title {
font-size: 0.74rem;
color: var(--text-muted);
text-transform: uppercase;
letter-spacing: 0.8px;
margin-bottom: 0.4rem;
display: flex;
align-items: center;
gap: 0.35rem;
}
.telemetry-value {
font-family: 'JetBrains Mono', monospace;
font-size: 1.05rem;
font-weight: 600;
color: #fff;
word-break: break-all;
}
.safe-badge {
color: var(--accent-green);
display: inline-flex;
align-items: center;
gap: 0.3rem;
font-size: 0.9rem;
}
.danger-badge {
color: var(--accent-red);
display: inline-flex;
align-items: center;
gap: 0.3rem;
font-size: 0.9rem;
}
/* JSON Box */
.json-box {
margin-top: 1.6rem;
background: var(--code-bg);
border: 1px solid rgba(255, 255, 255, 0.1);
border-radius: 16px;
overflow: hidden;
}
.json-header {
background: rgba(255, 255, 255, 0.035);
padding: 0.7rem 1.2rem;
display: flex;
justify-content: space-between;
align-items: center;
border-bottom: 1px solid rgba(255, 255, 255, 0.07);
}
.json-header span {
font-size: 0.82rem;
font-family: 'JetBrains Mono', monospace;
color: var(--text-muted);
}
.btn-copy {
background: transparent;
border: none;
color: var(--coffee-gold);
font-family: inherit;
font-size: 0.82rem;
font-weight: 600;
cursor: pointer;
display: inline-flex;
align-items: center;
gap: 0.35rem;
padding: 0.3rem 0.65rem;
border-radius: 8px;
transition: background 0.2s;
}
.btn-copy:hover {
background: rgba(245, 158, 11, 0.15);
}
pre {
padding: 1.25rem;
font-family: 'JetBrains Mono', monospace;
font-size: 0.86rem;
line-height: 1.65;
overflow-x: auto;
}
pre .json-key { color: #f472b6; }
pre .json-str { color: #34d399; }
pre .json-num { color: #f59e0b; }
pre .json-bool { color: #a78bfa; }
footer {
text-align: center;
margin-top: 2rem;
font-size: 0.88rem;
color: var(--text-muted);
border-top: 1px solid rgba(255, 255, 255, 0.08);
padding-top: 1.35rem;
}
/* Animation when pouring coffee */
@keyframes coffeePour {
0% { transform: scale(0.95); opacity: 0.8; }
50% { transform: scale(1.08); opacity: 1; filter: drop-shadow(0 0 20px rgba(245, 158, 11, 0.85)); }
100% { transform: scale(1); opacity: 1; }
}
.pouring {
animation: coffeePour 0.65s cubic-bezier(0.175, 0.885, 0.32, 1.275);
}
</style>
</head>
<body>
<div class="container">
<div class="badge-bar">
<span class="badge badge-coffee">☕ Semana 00 • Docker</span>
<span class="badge badge-cyan">🏔️ Cloud Native Medellín</span>
<span class="badge badge-green"><span class="pulse-dot"></span> Pod Activo</span>
</div>
<header>
<h1>¡Tinto Paisa Containerizado!</h1>
<p class="subtitle">Workshop: De Cero a Capitán en Kubernetes</p>
</header>
<div class="coffee-showcase">
<div class="cup-wrapper" id="cupWrapper" onclick="colarTinto()" title="Haz clic para colar un tinto">
<div class="steam-container">
<div class="steam-wisp"></div>
<div class="steam-wisp"></div>
<div class="steam-wisp"></div>
</div>
<div class="cup-saucer"></div>
<div class="coffee-cup" id="coffeeCup">
<div class="cup-handle"></div>
<div class="cup-liquid">
<div class="cup-crema"></div>
</div>
</div>
</div>
<div class="message-hero">
<div class="message-label">☕ Variable de Entorno [ENV MENSAJE]</div>
<div class="message-text" id="mensajeDisplay">__MENSAJE__</div>
</div>
<div class="counter-pill">
<span>Tintos servidos por esta greca:</span>
<strong id="tintosCounter" style="font-size: 1.15rem; color: #fff;">__TINTOS__</strong>
</div>
</div>
<div class="actions-row">
<button class="btn btn-primary" id="btnColar" onclick="colarTinto()">
☕ ¡Colar otro Tinto!
</button>
<button class="btn btn-secondary" onclick="probarHealth()">
🩺 Probar /health
</button>
<button class="btn btn-secondary" onclick="verApiJson()">
📡 Ver Endpoint /api
</button>
</div>
<!-- Presets -->
<div class="presets-section">
<div class="presets-title">
<span>🎛️ Simular Variación de Variable de Entorno:</span>
<span style="font-size: 0.78rem; color: var(--text-muted); font-weight: 400;">Pruébalo en vivo</span>
</div>
<div class="preset-chips">
<button class="chip" onclick="cambiarMensaje('¡Tinto recién colado! ☕')">☕ ¡Tinto recién colado! ☕</button>
<button class="chip" onclick="cambiarMensaje('¡Tinto campesino con panela y canela! 🍯')">🍯 Tinto campesino con panela</button>
<button class="chip" onclick="cambiarMensaje('¡Perico bien cargado pal frío! 🥛')">🥛 Perico bien caliente</button>
<button class="chip" onclick="cambiarMensaje('¡Tinto caliente en el Metro San Antonio! 🚊')">🚊 Estación San Antonio</button>
<button class="chip" onclick="cambiarMensaje('¡De Cero a Capitán en Kubernetes! ☸️🚀')">☸️ De Cero a Capitán</button>
</div>
</div>
<!-- Telemetry -->
<div class="telemetry-grid">
<div class="telemetry-card">
<div class="telemetry-title">📦 Hostname / Pod</div>
<div class="telemetry-value">__HOSTNAME__</div>
</div>
<div class="telemetry-card">
<div class="telemetry-title">🔌 Puerto Activo</div>
<div class="telemetry-value">:__PUERTO__</div>
</div>
<div class="telemetry-card">
<div class="telemetry-title">🛡️ Proceso Contenedor</div>
<div class="telemetry-value" style="font-size: 0.95rem;">
__USUARIO_BADGE__
</div>
</div>
<div class="telemetry-card">
<div class="telemetry-title">⏱️ Uptime Contenedor</div>
<div class="telemetry-value" id="uptimeVal">0s</div>
</div>
</div>
<!-- Live JSON Box -->
<div class="json-box">
<div class="json-header">
<span>Respuesta Cruda de la API (JSON)</span>
<button class="btn-copy" onclick="copiarJson()">
<span id="copyIcon">📋</span> <span id="copyText">Copiar JSON</span>
</button>
</div>
<pre><code id="jsonCode"></code></pre>
</div>
<footer>
🏔️ <strong>Cloud Native Medellín</strong> • De Cero a Capitán en Kubernetes • Semana 00: Fundamentos de Docker ☕
</footer>
</div>
<script>
let tintosCount = __TINTOS__;
let startTime = Date.now();
let audioCtx = null;
let payload = {
mensaje: "__MENSAJE__",
comunidad: "Cloud Native Medellín 🏔️☕",
workshop: "De Cero a Capitán en Kubernetes",
hostname_o_pod: "__HOSTNAME__",
puerto: __PUERTO__,
usuario_proceso: "__USUARIO__",
es_root: __ES_ROOT__,
tintos_servidos: __TINTOS__,
orquestador: "Listo para correr en Kubernetes"
};
function renderJson() {
const codeEl = document.getElementById("jsonCode");
const jsonStr = JSON.stringify(payload, null, 2);
codeEl.innerHTML = jsonStr
.replace(/"(.*?)":/g, '<span class="json-key">"$1"</span>:')
.replace(/:\s*"(.*?)"/g, ': <span class="json-str">"$1"</span>')
.replace(/:\s*([0-9]+)/g, ': <span class="json-num">$1</span>')
.replace(/:\s*(true|false)/g, ': <span class="json-bool">$1</span>');
}
function playCoffeeSound() {
try {
if (!audioCtx) {
audioCtx = new (window.AudioContext || window.webkitAudioContext)();
}
if (audioCtx.state === 'suspended') {
audioCtx.resume();
}
const osc = audioCtx.createOscillator();
const gain = audioCtx.createGain();
osc.type = 'sine';
osc.frequency.setValueAtTime(587.33, audioCtx.currentTime);
osc.frequency.exponentialRampToValueAtTime(880, audioCtx.currentTime + 0.15);
gain.gain.setValueAtTime(0.15, audioCtx.currentTime);
gain.gain.exponentialRampToValueAtTime(0.001, audioCtx.currentTime + 0.35);
osc.connect(gain);
gain.connect(audioCtx.destination);
osc.start();
osc.stop(audioCtx.currentTime + 0.35);
} catch (e) {}
}
function colarTinto() {
tintosCount++;
document.getElementById("tintosCounter").innerText = tintosCount;
payload.tintos_servidos = tintosCount;
renderJson();
const cup = document.getElementById("coffeeCup");
cup.classList.remove("pouring");
void cup.offsetWidth;
cup.classList.add("pouring");
playCoffeeSound();
const btn = document.getElementById("btnColar");
const originalText = btn.innerText;
btn.innerText = "✨ ¡Tinto Servido! ☕";
setTimeout(() => { btn.innerText = originalText; }, 700);
}
function cambiarMensaje(nuevo) {
payload.mensaje = nuevo;
document.getElementById("mensajeDisplay").innerText = nuevo;
renderJson();
colarTinto();
}
function copiarJson() {
navigator.clipboard.writeText(JSON.stringify(payload, null, 2)).then(() => {
const copyText = document.getElementById("copyText");
copyText.innerText = "¡Copiado!";
setTimeout(() => { copyText.innerText = "Copiar JSON"; }, 2000);
});
}
function probarHealth() {
window.open('/health', '_blank');
}
function verApiJson() {
window.open('/api', '_blank');
}
// Cronómetro de Uptime en vivo
setInterval(() => {
const elapsed = Math.floor((Date.now() - startTime) / 1000);
const m = Math.floor(elapsed / 60);
const s = elapsed % 60;
document.getElementById("uptimeVal").innerText = m > 0 ? `${m}m ${s}s` : `${s}s`;
}, 1000);
renderJson();
</script>
</body>
</html>
"""
class SimpleHandler(http.server.BaseHTTPRequestHandler):
def do_GET(self):
global TINTOS_TOTALES
# 1. Endpoint de salud para Kubernetes (Liveness & Readiness probe)
if self.path == "/health":
self.send_response(200)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.end_headers()
uptime_seg = int(time.time() - START_TIME)
self.wfile.write(json.dumps({
"status": "ok",
"saludable": True,
"uptime_segundos": uptime_seg
}, indent=2).encode("utf-8"))
return
# 2. Información del proceso y usuario para verificar buenas prácticas
usuario = "desconocido"
uid = -1
try:
import pwd
uid = os.getuid()
usuario = pwd.getpwuid(uid).pw_name
except Exception:
usuario = os.environ.get("USER", "appuser")
es_root = (uid == 0)
hostname = socket.gethostname()
# Objeto de respuesta estándar
respuesta = {
"mensaje": MENSAJE_DEFAULT,
"comunidad": COMUNIDAD,
"workshop": WORKSHOP,
"hostname_o_pod": hostname,
"puerto": PORT,
"usuario_proceso": f"{usuario} (UID: {uid})",
"es_root": es_root,
"tintos_servidos": TINTOS_TOTALES,
"orquestador": "Listo para correr en Kubernetes"
}
# 3. Detección de cliente: Navegador Web vs. curl / API
accept = self.headers.get("Accept", "")
user_agent = self.headers.get("User-Agent", "")
url_parsed = urllib.parse.urlparse(self.path)
# Si el usuario explícitamente pide /api o ?format=json o viene de curl/wget sin pedir html:
quiere_json = (
url_parsed.path == "/api"
or "format=json" in url_parsed.query
or ("application/json" in accept and "text/html" not in accept)
or ("curl" in user_agent.lower() and "text/html" not in accept)
)
if not quiere_json:
# Respuesta interactiva y visual para navegadores
self.send_response(200)
self.send_header("Content-Type", "text/html; charset=utf-8")
self.end_headers()
if es_root:
badge_usuario = '<span class="danger-badge">⚠️ root (UID 0) — Inseguro</span>'
else:
badge_usuario = f'<span class="safe-badge">🛡️ {usuario} (UID {uid}) — Seguro</span>'
html_renderizado = HTML_PAGE
html_renderizado = html_renderizado.replace("__MENSAJE__", MENSAJE_DEFAULT)
html_renderizado = html_renderizado.replace("__HOSTNAME__", hostname)
html_renderizado = html_renderizado.replace("__PUERTO__", str(PORT))
html_renderizado = html_renderizado.replace("__USUARIO__", f"{usuario} (UID: {uid})")
html_renderizado = html_renderizado.replace("__USUARIO_BADGE__", badge_usuario)
html_renderizado = html_renderizado.replace("__ES_ROOT__", "true" if es_root else "false")
html_renderizado = html_renderizado.replace("__TINTOS__", str(TINTOS_TOTALES))
self.wfile.write(html_renderizado.encode("utf-8"))
else:
# Respuesta en formato JSON para terminal, curl y APIs
self.send_response(200)
self.send_header("Content-Type", "application/json; charset=utf-8")
self.end_headers()
self.wfile.write(json.dumps(respuesta, indent=2, ensure_ascii=False).encode("utf-8"))
def log_message(self, formato, *args):
# Logs formateados para docker logs y kubectl logs
sys.stdout.write(f"[{self.log_date_time_string()}] {formato % args}\n")
sys.stdout.flush()
if __name__ == "__main__":
servidor = http.server.HTTPServer(("0.0.0.0", PORT), SimpleHandler)
try:
import pwd
u_actual = pwd.getpwuid(os.getuid()).pw_name
uid_actual = os.getuid()
except Exception:
u_actual, uid_actual = "appuser", 10001
print(f"🚀 Servidor escuchando en http://0.0.0.0:{PORT} como '{u_actual}' (UID: {uid_actual})...")
print(f"☕ Mensaje configurado: '{MENSAJE_DEFAULT}'")
try:
servidor.serve_forever()
except KeyboardInterrupt:
print("\n🛑 Servidor detenido limpiamente.")
servidor.server_close()
!TIP Puedes revisar el código completo con la interfaz gráfica, animaciones y audio en
semana-00-fundamentos-docker/1.ejemplos/02-app-python-api/app.py.
2. Archivo Dockerfile (Buenas Prácticas de Seguridad):
# 1. Usamos una imagen base oficial con versión fijada (pinned tag) sobre Alpine Linux (~50MB)
FROM python:3.12-alpine
# 2. 🛡️ Buenas Prácticas de Seguridad: Crear usuario y grupo sin privilegios (Least Privilege)
RUN addgroup -g 10001 -S appgroup && \
adduser -u 10001 -S appuser -G appgroup
# 3. Carpeta de trabajo dentro del contenedor
WORKDIR /app
# 4. Copiamos el código asignando la propiedad directamente al usuario no-root (--chown)
COPY --chown=appuser:appgroup app.py .
# 5. Definimos variables de entorno por defecto
ENV PORT=8080
ENV MENSAJE="¡Hola desde mi contenedor en Cloud Native Medellín! 🏔️☕"
# 6. 🔒 Cambiamos al usuario sin privilegios antes del comando de inicio
USER appuser
# 7. Documentamos el puerto que escucha la aplicación
EXPOSE 8080
# 8. 🩺 Comprobación de salud (Health Check) para monitorear el estado del contenedor
# Mitiga la desconfiguración de seguridad/calidad al permitir que Docker detecte si la app responde
HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
CMD wget -q -O /dev/null http://localhost:8080/health || exit 1
# 9. Ejecutamos la aplicación en primer plano (PID 1) usando la forma exec (corchetes)
# Esto asegura que reciba señales del sistema operativo (SIGTERM) para apagado limpio
CMD ["python", "app.py"]
3. Archivo .dockerignore:
Evita que se empaqueten archivos innecesarios o secretos dentro de las capas de la imagen:
.env
*.log
.git/
__pycache__/
*.pyc
4. Construir y Probar el Contenedor con Rutas Absolutas:
# 1. Construir la imagen referenciando la ruta absoluta del microservicio
docker build -t mi-api-cnm:v1.0 $PWD/semana-00-fundamentos-docker/1.ejemplos/02-app-python-api
# 2. Correr el contenedor en puerto 8080
docker run -d -p 8080:8080 --name test-docker mi-api-cnm:v1.0
# 3. Probar en terminal (Respuesta JSON) o abrir http://localhost:8080 en el navegador
curl http://localhost:8080
# 4. Probar probe de salud de Kubernetes
curl http://localhost:8080/health
# 5. Comprobar que corre como usuario no-root (Seguridad)
docker exec -it test-docker whoami
# Salida: appuser (UID: 10001)
# 6. Sobrescribir variable de entorno en tiempo de ejecución con -e
docker run -d -p 8081:8080 -e MENSAJE="¡Saludos desde el Poblado en Medellín! ☕" --name test-docker-env mi-api-cnm:v1.0
curl http://localhost:8081
# 7. Auditar vulnerabilidades y configuración del Dockerfile con Trivy (ruta absoluta)
trivy image --severity HIGH,CRITICAL mi-api-cnm:v1.0
trivy config $PWD/semana-00-fundamentos-docker/1.ejemplos/02-app-python-api
# 8. Limpieza
docker rm -f test-docker test-docker-env
🐳 Semana 00 • Lab 3: Redes en Docker y Comunicación entre Microservicios
🧪 Laboratorio 3: Redes en Docker y Comunicación entre Microservicios
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
¿Cómo se comunican dos contenedores entre sí? Es muy común intentar conectar el Contenedor A con el Contenedor B usando http://localhost:8080, pero esto no funciona debido al aislamiento de red de cada contenedor.
☕ La Analogía Paisa: El Walkie-Talkie del Metro
Cada contenedor vive en su propio mundo aislado (Network Namespace): su propio localhost (127.0.0.1) solo se refiere a sí mismo.
Para que el carrito del Metro (carrito-san-antonio) le pida café a la greca central del sótano (greca-central), ambos deben sintonizar la misma frecuencia de radio (Docker Custom Bridge Network) y llamarse por su nombre:
Arquitectura de los Microservicios:
- Backend (
greca-backend:v1.0): Microservicio interno en puerto8080que mantiene el inventario de tintos. No necesita exponer puertos al host (-p). - Cliente (
carrito-cliente:v1.0): Microservicio en puerto8081que recibe peticiones externas y consulta agreca-central:8080utilizando el DNS interno de Docker.
Paso a paso práctico con Rutas Absolutas:
# 1. Construir las imágenes de ambos microservicios usando rutas absolutas
docker build -t greca-backend:v1.0 $PWD/semana-00-fundamentos-docker/1.ejemplos/03-redes-comunicacion-contenedores/backend-api
docker build -t carrito-cliente:v1.0 $PWD/semana-00-fundamentos-docker/1.ejemplos/03-redes-comunicacion-contenedores/cliente-app
# 2. Crear una red bridge personalizada (aislamiento y DNS automático por nombre)
docker network create red-cafetera
# 3. Iniciar el Backend (Greca Central) dentro de la red (puerto interno 8080)
docker run -d \
--name greca-central \
--network red-cafetera \
greca-backend:v1.0
# 4. Iniciar el Cliente (Carrito San Antonio) en la misma red conectando con el backend por nombre
docker run -d \
--name carrito-san-antonio \
--network red-cafetera \
-p 8081:8081 \
-e BACKEND_HOST="greca-central" \
carrito-cliente:v1.0
# 5. Probar la comunicación (Navegador en http://localhost:8081 o con curl)
curl http://localhost:8081
# 6. Inspeccionar la red para ver las IPs privadas asignadas a cada contenedor
docker network inspect red-cafetera
# 7. Escaneo de seguridad y configuración con Trivy usando rutas absolutas
trivy image --severity HIGH,CRITICAL greca-backend:v1.0
trivy image --severity HIGH,CRITICAL carrito-cliente:v1.0
trivy config $PWD/semana-00-fundamentos-docker/1.ejemplos/03-redes-comunicacion-contenedores/backend-api
trivy config $PWD/semana-00-fundamentos-docker/1.ejemplos/03-redes-comunicacion-contenedores/cliente-app
# 8. Limpieza
docker rm -f greca-central carrito-san-antonio
docker network rm red-cafetera
!NOTE ☸️ El Puente a Kubernetes:
En Kubernetes, las redes bridge de Docker son reemplazadas por el CNI (Container Network Interface) y los contenedores se descubren mediante Services (ClusterIP) gracias al servicio interno de CoreDNS.
🐳 Semana 00 • Lab 4: Almacenamiento y Volúmenes (Datos Persistentes)
🧪 Laboratorio 4: Almacenamiento y Volúmenes (Datos Efímeros vs. Persistentes)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Por defecto, los contenedores son efímeros e inmutables. Poseen una capa de lectura y escritura temporal (Copy-on-Write). Si un contenedor se elimina (docker rm), todo lo que escribió dentro de él se destruye.
☕ La Analogía Paisa: El Libro Contable del Carrito
Un carrito de tintos se puede dañar o cambiar, pero la libreta de cuentas (ventas.json) donde anotas las ventas no puede quemarse con el carrito. Necesitas guardarla en un casillero seguro: un volumen de Docker.
En este laboratorio utilizamos la aplicación de ventas app-ventas:v1.0 ubicada en 📂 $PWD/semana-00-fundamentos-docker/1.ejemplos/04-almacenamiento-y-volumenes/, la cual persiste registros en /app/datos/ventas.json.
🔨 Paso Previo: Construir la imagen con ruta absoluta
docker build -t app-ventas:v1.0 $PWD/semana-00-fundamentos-docker/1.ejemplos/04-almacenamiento-y-volumenes
🧪 Experimento 1: Sin Volumen (La Tragedia de los Datos Efímeros)
# 1. Iniciar contenedor sin montar volúmenes
docker run -d -p 8080:8080 --name test-efimero app-ventas:v1.0
# 2. Registrar ventas por HTTP
curl "http://localhost:8080/vender?tipo=Tinto+Campesino&cliente=Carlos"
curl "http://localhost:8080/vender?tipo=Perico&cliente=Mariana"
curl http://localhost:8080/api
# 3. Simular caída y destruir el contenedor
docker rm -f test-efimero
# 4. Volver a crear el contenedor
docker run -d -p 8080:8080 --name test-efimero app-ventas:v1.0
curl http://localhost:8080/api
# 💥 RESULTADO: "total_registros": 0. ¡Todos los datos se perdieron para siempre!
docker rm -f test-efimero
🧪 Experimento 2: Con Named Volume (Persistencia Real con docker volume)
# 1. Crear un volumen administrado por Docker
docker volume create datos-tintos
# 2. Iniciar el primer contenedor montando el volumen en /app/datos
docker run -d -p 8080:8080 --name carrito-1 -v datos-tintos:/app/datos app-ventas:v1.0
# 3. Registrar ventas
curl "http://localhost:8080/vender?tipo=Tinto+Especial&cliente=Don+Guillermo"
curl "http://localhost:8080/vender?tipo=Cafe+Origen&cliente=Sofia"
curl http://localhost:8080/api
# 4. ¡Destruir el contenedor sin piedad!
docker rm -f carrito-1
# 5. Iniciar un segundo contenedor completamente nuevo usando el MISMO volumen
docker run -d -p 8080:8080 --name carrito-2 -v datos-tintos:/app/datos app-ventas:v1.0
# 6. Consultar los datos en el nuevo contenedor
curl http://localhost:8080/api
# 🎉 ¡Todas las ventas de Don Guillermo y Sofía siguen intactas!
docker rm -f carrito-2
🧪 Experimento 3: Sincronización en vivo con Bind Mount (-v host:cont)
# 1. Crear carpeta local en tu máquina y darle permisos de escritura para el usuario no-root (UID 10001)
mkdir -p $PWD/mis-datos-locales
chmod 777 $PWD/mis-datos-locales
# 2. Montar la carpeta local en el contenedor usando ruta absoluta $PWD
docker run -d -p 8080:8080 --name carrito-bind -v "$PWD/mis-datos-locales:/app/datos" app-ventas:v1.0
# 3. Registrar una venta
curl "http://localhost:8080/vender?tipo=Tinto+con+Panela&cliente=Estudiante+Cloud+Native"
# 4. Comprobar que el archivo existe y se actualizó en tu máquina física
cat $PWD/mis-datos-locales/ventas.json
# 5. Limpieza
docker rm -f carrito-bind
docker volume rm datos-tintos
rm -rf $PWD/mis-datos-locales
!IMPORTANT 🛡️ Permisos en Bind Mounts con usuario no-root (UID 10001):
Como nuestroDockerfilesigue las mejores prácticas de seguridad ejecutándose conappuser(UID 10001), la carpeta montada del host requiere permisos de escritura (chmod 777) para permitirle al contenedor crear el archivoventas.json. Si no tiene permisos, el servidor responderá un error 500 explicativo indicando la solución.
🧪 Experimento 4: Escaneo de Seguridad y Configuración con Trivy
trivy image --severity HIGH,CRITICAL app-ventas:v1.0
trivy config $PWD/semana-00-fundamentos-docker/1.ejemplos/04-almacenamiento-y-volumenes
🐳 Semana 00 • Lab 5: Registro Harbor, Cuentas Robot y Políticas
🧪 Laboratorio 5: Registro y Publicación de Imágenes con Harbor
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Una vez construidas tus imágenes locales, necesitas distribuirlas a servidores de prueba, producción o a los nodos de tu clúster. Para ello usamos Harbor, el registro OCI empresarial de código abierto graduado de la CNCF.
📖 Guía Teórica y Despliegue Local:
Los manifiestos de este laboratorio se encuentran en📂 $PWD/semana-00-fundamentos-docker/1.ejemplos/05-registro-imagenes-harbor/.
Para detalles arquitectónicos de Harbor empresarial y Helm, consulta la Guía Empresarial de Harbor.
📦 Manifiesto de Despliegue Local (docker-compose.yml)
Este laboratorio utiliza un registro OCI local compatible v2 y una interfaz web para explorar los repositorios:
services:
# 📦 Registro OCI Local (Compatible con Docker Distribution Registry v2)
registry:
image: registry:2
container_name: registro-local
restart: unless-stopped
ports:
- "5001:5000"
environment:
REGISTRY_STORAGE_DELETE_ENABLED: "true"
REGISTRY_HTTP_SECRET: "secreto-registro-local-cnm"
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Origin: "['*']"
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Methods: "['HEAD', 'GET', 'OPTIONS', 'DELETE']"
REGISTRY_HTTP_HEADERS_Access-Control-Allow-Headers: "['Authorization', 'Accept', 'Cache-Control']"
REGISTRY_HTTP_HEADERS_Access-Control-Expose-Headers: "['Docker-Content-Digest']"
volumes:
- datos-registro:/var/lib/registry
networks:
- red-registro
# 🌐 Interfaz Gráfica Web para explorar repositorios y tags
registry-ui:
image: joxit/docker-registry-ui:2
container_name: registro-ui
restart: unless-stopped
ports:
- "8082:80"
environment:
- SINGLE_REGISTRY=true
- REGISTRY_TITLE=Registro Local Cloud Native Medellín
- DELETE_IMAGES=true
- SHOW_CONTENT_DIGEST=true
- NGINX_PROXY_PASS_URL=http://registry:5000
depends_on:
- registry
networks:
- red-registro
volumes:
datos-registro:
name: datos-registro-local
networks:
red-registro:
name: red-registro-local
Para levantar el entorno:
docker compose -f $PWD/semana-00-fundamentos-docker/1.ejemplos/05-registro-imagenes-harbor/docker-compose.yml up -d
Esto iniciará el registro OCI local en el puerto 5001 y la interfaz gráfica web en http://localhost:8082.
1. Iniciar Sesión en el Registro (docker login)
💡 Nota para la Opción B (Registro Local con Compose): Si estás usando el registro local (
localhost:5001), no necesitas autenticarte (no requiere contraseña). Puedes pasar directamente al Paso 2.
# Autenticación con credenciales o token de Cuenta Robot en Harbor (Opción A):
docker login harbor.cloudnative.local:8080 -u "robot$ci-deployer" -p "tu-token-secreto"
2. Etiquetar las Imágenes con Nomenclatura OCI (docker tag)
Docker necesita conocer el registro de destino mediante el prefijo del tag:
🏷️ Nomenclatura Obligatoria:
<host-registro>/<proyecto>/<nombre-imagen>:<tag>
# Si estás usando el registro local con Docker Compose (Opción B):
REGISTRO="localhost:5001"
PROYECTO="cafeteria"
# Si estás usando un servidor Harbor empresarial / remoto (Opción A):
# REGISTRO="harbor.cloudnative.local:8080"
# PROYECTO="cafeteria"
# Etiquetamos las imágenes construidas en los laboratorios anteriores:
docker tag mi-web-estatica:v1.0 ${REGISTRO}/${PROYECTO}/mi-web-estatica:v1.0
docker tag mi-api-cnm:v1.0 ${REGISTRO}/${PROYECTO}/mi-api-cnm:v1.0
docker tag greca-backend:v1.0 ${REGISTRO}/${PROYECTO}/greca-backend:v1.0
docker tag app-ventas:v1.0 ${REGISTRO}/${PROYECTO}/app-ventas:v1.0
# Verificar los alias creados (no duplican espacio en disco)
docker images | grep ${PROYECTO}
3. Publicar las Imágenes (docker push)
docker push ${REGISTRO}/${PROYECTO}/mi-api-cnm:v1.0
⚡ Reutilización de Capas: Si luego publicas
greca-backend:v1.0(que también está basada enpython:3.12-alpine), verás que Docker indicaLayer already exists, ahorrando ancho de banda y tiempo.
4. Inspección de Artefactos y Escaneo de Seguridad
Dependiendo del entorno que estés utilizando:
- En la UI del Registro Local (Opción B - http://localhost:8082):
Verás el namespacecafeteria/, tags, digest SHA-256 inmutable (sha256:b9b4ef6d...), tamaño y capas. Al ser un visor ultraligero de desarrollo, no incluye escáner integrado. - Escaneo de Vulnerabilidades con Trivy (CLI Local):
Para auditar la imagen directamente en tu máquina:(O condocker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:latest image mi-api-cnm:v1.0docker scout cves mi-api-cnm:v1.0). Gracias apython:3.12-alpine, obtendrás 0 vulnerabilidades de severidad alta o crítica. - En el Portal Web de Harbor (Opción A):
Verás el badge interactivo con el reporte de Trivy generado automáticamente al hacer push y podrás configurar la política "Prevent vulnerable images from running" para bloquear imágenes con fallos críticos.
5. Descargar y Ejecutar en Entorno Limpio (docker pull)
# 1. Eliminar la copia local para forzar la descarga de red
docker rmi ${REGISTRO}/${PROYECTO}/mi-api-cnm:v1.0
# 2. Descargar imagen fresca desde Harbor
docker pull ${REGISTRO}/${PROYECTO}/mi-api-cnm:v1.0
# 3. Correr el contenedor desde la imagen del registro
docker run -d -p 8080:8080 --name test-harbor ${REGISTRO}/${PROYECTO}/mi-api-cnm:v1.0
# 4. Probar respuesta y limpiar
curl http://localhost:8080
docker rm -f test-harbor
🐳 Semana 00 • Lab 6: IA Local en Docker con Ollama (Asistente DevOps)
🧪 Laboratorio 6: IA Local en Docker con Ollama (Asistente DevOps)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Aprende a ejecutar un Modelo de Lenguaje (LLM) dentro de un contenedor Docker en modo exclusivamente CPU, sin requerir GPUs ni controladores CUDA. Crearemos un asistente especializado llamado devops-mini y lo consultaremos por terminal y mediante su API REST.
📖 Guía Teórica de Referencia:
Para comprender la arquitectura de Ollama, aceleración por hardware, comparativas y dimensionamiento de modelos (1.5B, 3B, 7B), consulta la Guía de IA Local con Ollama.
1. Crear el Volumen y Levantar Ollama con Límites de Recursos
# 1. Crear volumen para persistir los modelos descargados
docker volume create ollama
# 2. Ejecutar Ollama con techo de memoria y núcleos de CPU
docker run -d \
--name ollama \
--restart unless-stopped \
--memory=1400m \
--cpus=3 \
-p 127.0.0.1:11434:11434 \
-v ollama:/root/.ollama \
ollama/ollama
| Parámetro | Propósito Técnico |
|---|---|
--memory=1400m | Límite estricto de memoria RAM vía cgroups para evitar congelar el host. |
--cpus=3 | Techo de núcleos de CPU asignados para inferencia. |
-p 127.0.0.1:11434:11434 | Publica la API únicamente en loopback local por seguridad. |
-v ollama:/root/.ollama | Persistencia de modelos ante eliminación del contenedor. |
2. Descargar y Probar el Modelo Base (qwen2.5:0.5b)
# Descargar el modelo ligero (~400 MB)
docker exec -it ollama ollama pull qwen2.5:0.5b
# Probar conversación interactiva en terminal (escribe /bye para salir)
docker exec -it ollama ollama run qwen2.5:0.5b
3. Crear el Asistente DevOps con un Modelfile
Un Modelfile permite personalizar el comportamiento del modelo igual que un Dockerfile personaliza una imagen:
FROM qwen2.5:0.5b
PARAMETER num_ctx 1024
PARAMETER num_predict 256
PARAMETER temperature 0.2
SYSTEM """
Eres un asistente DevOps conciso y experto en Linux, Docker y Kubernetes.
Respondes en español con comandos precisos y explicaciones breves sin rodeos.
"""
Crea el modelo personalizado utilizando el Modelfile del repositorio con ruta absoluta (o enviándolo por entrada estándar):
# Opción 1: Directamente desde el archivo del repositorio con ruta absoluta
docker exec -i ollama ollama create devops-mini -f /dev/stdin < $PWD/semana-00-fundamentos-docker/1.ejemplos/06-ia-local-ollama/Modelfile
# Opción 2: O crearlo inline en la terminal mediante heredoc
docker exec -i ollama ollama create devops-mini -f /dev/stdin << 'EOF'
FROM qwen2.5:0.5b
PARAMETER num_ctx 1024
PARAMETER num_predict 256
PARAMETER temperature 0.2
SYSTEM """
Eres un asistente DevOps conciso y experto en Linux, Docker y Kubernetes.
Respondes en español con comandos precisos y explicaciones breves.
"""
EOF
Verifica la lista de modelos:
docker exec -it ollama ollama list
4. Probar el Asistente devops-mini en la Terminal
docker exec -it ollama ollama run devops-mini "Dame los comandos para ver los logs de un contenedor caído en Docker."
5. Consumir la API REST de Ollama
En otra terminal o script de automatización, envía una consulta en formato JSON:
curl http://127.0.0.1:11434/api/chat \
-H "Content-Type: application/json" \
-d '{
"model": "devops-mini",
"messages": [
{ "role": "user", "content": "¿Qué diferencia hay entre CMD y ENTRYPOINT?" }
],
"stream": false
}'
6. Persistencia Real y Monitoreo de Recursos
# 1. Eliminar el contenedor
docker rm -f ollama
# 2. Recrearlo usando el mismo volumen 'ollama'
docker run -d --name ollama --restart unless-stopped \
--memory=1400m --cpus=3 \
-p 127.0.0.1:11434:11434 \
-v ollama:/root/.ollama \
ollama/ollama
# 3. Comprobar que los modelos no se perdieron
docker exec -it ollama ollama list
# 4. Monitorear consumo de RAM/CPU en tiempo real
docker stats ollama
# 5. Auditar si fue terminado por memoria (OOMKilled)
docker inspect ollama --format '{{.State.OOMKilled}}'
7. Auditoría de Seguridad con Trivy
trivy image --severity HIGH,CRITICAL ollama/ollama
8. Limpieza del Laboratorio
docker rm -f ollama
# (Opcional) Liberar espacio del volumen de modelos:
docker volume rm ollama
🐳 Semana 00 • Retos: El Puente a Kind y los 5 Retos Rotos de Docker
🌉 El Puente a Kubernetes: Cargar Imágenes Locales en Kind
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
- Repositorio del Taller: Fundamentos-Kubernetes / semana-00-fundamentos-docker
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Cuando uses un clúster local con Kind, Kubernetes por defecto intentará buscar las imágenes en Docker Hub o en registros remotos. Para usar imágenes construidas en tu computador sin publicarlas en internet:
# Carga la imagen local directamente dentro de los nodos del clúster Kind
kind load docker-image mi-api-cnm:v1.0 --name cnm-lab
¡Y en tus manifiestos de Kubernetes solo debes configurar imagePullPolicy: IfNotPresent!
🛠️ Guías y Recursos de Referencia (GitHub)
Para profundizar en los aspectos teóricos y buenas prácticas de producción, consulta las guías oficiales en el repositorio:
- 🛡️ Guía de Seguridad y Escaneo de Vulnerabilidades con Trivy: Auditoría de CVEs, mejores prácticas de Dockerfiles y comparación de distribuciones base.
- ⚓ Guía Empresarial de Harbor Registry: Arquitectura de microservicios, Cuentas Robot, políticas de retención y despliegue con Helm.
- 🤖 Guía de IA Local con Ollama: Aceleración por hardware, matriz de memoria de modelos LLM y directivas de seguridad corporativa.
- ☕ De un Tinto Colombiano a Kubernetes: La historia completa que conecta la venta de tinto en el Metro de Medellín con el Control Plane, Pods, Deployments y Services.
💥 Los 5 Retos Rotos de la Semana 00
En el repositorio oficial:
🔗 semana-00-fundamentos-docker/2.reto-roto/
Te enfrentarás a los 5 errores reales más frecuentes en contenedores. Cada reto incluye código que falla a propósito para que entrenes tus habilidades de diagnóstico:
| Reto | Tipo de Falla / Tema | Diagnóstico Clave | Enlace al Reto en GitHub |
|---|---|---|---|
| 01 | Proceso en segundo plano apaga el contenedor (PID 1) | docker ps -a muestra terminación inmediata. Nginx no corre con daemon off;. | 🔗 Ver Reto 01: Dockerfile Roto |
| 02 | Contenedor crashea por falta de variable de entorno (ENV) | docker logs revela excepción en Python por variable APP_SECRET_TOKEN ausente. | 🔗 Ver Reto 02: Variable Faltante |
| 03 | Contenedor vulnerable ejecutándose como root (Seguridad) | docker run whoami responde root (UID 0), violando las directivas de seguridad. | 🔗 Ver Reto 03: Contenedor Root |
| 04 | Fuga de contraseñas y secretos por falta de .dockerignore | COPY . . empaqueta archivos .env privados dentro de las capas de la imagen. | 🔗 Ver Reto 04: Archivos Secretos |
| 05 | Conexión rechazada por enlace a 127.0.0.1 y puerto desalineado | La app enlaza a localhost interno y rechaza conexiones externas del host. | 🔗 Ver Reto 05: Host Desalineado |
🧪 Comandos para probar los 5 Retos Rotos con Rutas Absolutas:
# Reto 01: Dockerfile Roto (Proceso en segundo plano apaga el contenedor)
docker build -t reto-docker-01 $PWD/semana-00-fundamentos-docker/2.reto-roto/01-dockerfile-roto
docker run -d --name test-reto-01 -p 8080:80 reto-docker-01
docker ps -a # Observa que se apaga inmediatamente (Exited 0)
docker rm -f test-reto-01
# Reto 02: Variable de Entorno Faltante
docker build -t reto-docker-02 $PWD/semana-00-fundamentos-docker/2.reto-roto/02-variable-entorno-faltante
docker run -d --name test-reto-02 reto-docker-02
docker logs test-reto-02 # Observa KeyError: 'APP_SECRET_TOKEN'
docker rm -f test-reto-02
# Reto 03: Contenedor Ejecutándose como Root
docker build -t reto-docker-03 $PWD/semana-00-fundamentos-docker/2.reto-roto/03-contenedor-como-root
docker run --rm reto-docker-03 whoami # Responde root en lugar de appuser
trivy image --severity HIGH,CRITICAL reto-docker-03
# Reto 04: Dockerignore Ausente y Fuga de Secretos
docker build -t reto-docker-04 $PWD/semana-00-fundamentos-docker/2.reto-roto/04-dockerignore-y-archivos-secretos
docker run --rm reto-docker-04 ls -la /app # Revela el archivo .env privado empaquetado
# Reto 05: Puerto y Host Desalineados
docker build -t reto-docker-05 $PWD/semana-00-fundamentos-docker/2.reto-roto/05-puerto-y-host-desalineado
docker run -d --name test-reto-05 -p 8080:8080 reto-docker-05
curl http://localhost:8080 # Fallo de conexión por enlazar a 127.0.0.1 y puerto 3000
docker rm -f test-reto-05
🏆 ¿Cómo enviar tus soluciones?
- Realiza un Fork de Fundamentos-Kubernetes.
- Clónalo y soluciona cada reto en tu máquina.
- Copia tus soluciones a
aportes-comunidad/soluciones-retos/<tu-usuario>/semana-00/. - Abre tu Pull Request para subir de rango en
ASISTENTES.md.
🌱 Semana 01 • Conceptos: Arquitectura de K8s y el Ciclo del Pod
🌱 Módulo 01: El Motor por Dentro y tu Primer Pod — Conceptos y Arquitectura
📖 Lectura / Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Revisa este tutorial oficial en iximiuz Labs para marcar esta sección en verde:
Loading tutorial...
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Módulo: Fundamentos-Kubernetes / semana-01-arquitectura
- Comunidad Oficial CNCF: Cloud Native Medellín en CNCF Community Groups
- Documentación Oficial: Kubernetes Docs (Español) • kubectl Cheat Sheet • Guía de Pods
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
🎯 ¿Qué vas a dominar en esta unidad?
- Por qué Docker por sí solo no basta en producción y por qué necesitamos un Orquestador de Contenedores.
- La arquitectura interna de Kubernetes: Control Plane (Oficina de Gerencia) vs. Worker Nodes (Mesas de Barismo).
- Qué es un Pod y por qué es la unidad atómica y mínima de despliegue en Kubernetes.
- La diferencia crítica entre el Modo Imperativo (Interactivo) y el Modo Declarativo (Producción / GitOps).
- El secreto de velocidad: uso de
--dry-run=client -o yaml,--help,kubectl explain --recursivey exportación a archivos. - La analogía unificada de ☕ KubeCafé y el glosario cotidiano para entender cada rol técnico.
☕ La Analogía de KubeCafé: La Oficina de Gerencia y las Mesas de Barismo
En la Semana 00 aprendimos a tostar el 🌱 Grano verde (Código), seguir la 📜 Receta (Dockerfile), empacar la 📦 Bolsa sellada (Imagen Docker) y servir una ☕ Taza de café (Contenedor).
Ahora en la Semana 01 abrimos nuestra cafetería de especialidad (KubeCafé), donde todo está organizado entre la 🏢 Oficina de Gerencia (Control Plane) y las 🪵 Mesas de Barismo (Worker Nodes):
💡 Palabras clave de la cafetería en lenguaje cotidiano:
- 👨🍳 Barista: Es la persona experta que prepara las bebidas de café detrás de la barra y maneja la cafetera (en Kubernetes es el
kubelet).- 🪵 Barismo / Mesa de barismo: El barismo es el oficio de preparar buen café. Una mesa de barismo es el mesón o estación de trabajo donde están conectados los cafeteras (CPU) y el agua (RAM) para preparar las tazas (representa un
Worker Nodeo servidor).- 🧾 Pedido / Orden: La solicitud escrita donde se detalla exactamente qué recursos o características necesita la aplicación (representa tu archivo manifiesto
.yaml).- 🥛 Sidecar (Acompañante): Como el vasito de agua que te sirven en la misma bandeja junto al café; es un contenedor auxiliar que acompaña al contenedor principal dentro del mismo
Pod.
| Componente Técnico | En ☕ KubeCafé | ¿Cuál es su función en la cafetería y en el clúster? |
|---|---|---|
| Contenedor | ☕ Taza de café servida | La bebida lista y ejecutándose en memoria/CPU. |
| Pod | 🍽️ Bandeja de servicio | Unidad mínima de K8s: lleva la ☕ taza de café principal + el 🥛 vaso de agua (Sidecar). Nunca se sirven tazas sueltas sin bandeja. |
| Worker Node | 🪵 Mesa de barismo | Estación de trabajo física o virtual con agua (RAM) y cafeteras (CPU). |
| Kubelet | 👨🍳 Barista de la mesa | Agente en cada nodo: recibe órdenes de gerencia y vigila que las tazas no se enfríen. |
| Control Plane | 🏢 Oficina de Gerencia | Coordina toda la cafetería sin preparar café directamente. |
| kube-apiserver | 🛎️ Caja / Mostrador | Ventanilla única: todos tus comandos (kubectl) y reportes entran por aquí. |
| etcd | 📖 Libro contable | Base de datos llave-valor inmutable donde se registran todas las órdenes activas y el estado de las mesas. |
| kube-scheduler | 📋 Despachador de mesas | Mira qué mesa de barismo tiene cafetera y agua libre para asignar la bandeja (Pod). |
| Controller Manager | 🧐 Supervisor de salón | Si una taza se derrama, detecta la falta y ordena preparar otra inmediatamente. |
👨💻 Tú (kubectl)
│
▼ 1. Envías tu orden (k apply -f pod.yaml)
🛎️ kube-apiserver (Caja Registradora) <───> 📖 etcd (Libro Contable)
│
▼ 2. Despachador busca mesa con CPU/RAM libre
📋 kube-scheduler ───> 🧐 Controller Manager (Vigila salud)
│
▼ 3. Ordena al barista preparar la bandeja
🪵 Worker Node (Mesa de Barismo)
└── 👨🍳 kubelet (Barista líder)
└── 🍽️ Pod (Bandeja: IP 10.244.0.5)
├── ☕ Contenedor Nginx (Puerto 80)
└── 🥛 Contenedor Sidecar (Proxy / Auxiliar)
⚖️ Modo Imperativo (Interactivo) vs. Modo Declarativo
En Kubernetes existen dos filosofías para crear y administrar recursos:
| Característica | ⚡ Modo Imperativo / Interactivo | 📜 Modo Declarativo (Producción / GitOps) |
|---|---|---|
| En ☕ KubeCafé | Pides en el mostrador a viva voz: "¡Sírvanme un espresso rápido!". | Entregas una orden escrita y firmada con la receta exacta que queda archivada. |
| ¿Qué le dices a K8s? | Cómo hacer algo mediante órdenes directas en la terminal. | Qué estado final deseas alcanzar descrito en un archivo .yaml. |
| Comandos típicos | k run, k create, k expose, k edit, k delete pod X | k apply -f archivo.yaml, k diff -f archivo.yaml, k delete -f archivo.yaml |
| Trazabilidad | ❌ Baja (si no guardas el comando, nadie sabe qué cambiaste). | ✅ Alta (el archivo YAML vive en Git con historial de commits y PRs). |
| Idempotencia | ❌ Si ejecutas k run mi-pod dos veces, la segunda vez falla (AlreadyExists). | ✅ Si ejecutas k apply -f pod.yaml 10 veces, K8s solo aplica cambios si los hay. |
| ¿Cuándo usarlo? | Laboratorios rápidos, diagnósticos en vivo y exámenes (CKA / CKAD). | Siempre en Producción, ambientes compartidos, CI/CD y GitOps. |
⚡ Creación Interactiva e Imperativa (k run, k exec)
Sin escribir una sola línea de YAML, puedes pedirle a Kubernetes que cree Pods o abrir consolas interactivas:
# 1. Crear un Pod rápido con etiquetas (labels) y puerto:
kubectl run pod-rapido --image=nginx:alpine --port=80 --labels="entorno=lab,semana=1"
# 2. Crear un Pod temporal de diagnóstico que se destruye solo al salir (--rm -it):
kubectl run debug-red --rm -it --image=busybox:1.36 --restart=Never -- sh
# Dentro puedes probar: nslookup kubernetes.default o wget -qO- http://localhost
# 3. Abrir terminal interactiva dentro de un Pod existente:
kubectl exec -it pod-rapido -- sh
🧪 El Truco Ninja: Generar YAML con --dry-run y Redirección (>)
Regla de Oro: Nunca escribas un manifiesto YAML desde una página en blanco. Usa
--dry-run=client -o yamlpara quekubectlte genere la plantilla oficial perfecta:
# 1. Ver en pantalla el YAML generado sin crear nada en el clúster:
kubectl run mi-servidor --image=nginx:alpine --port=80 --dry-run=client -o yaml
# 2. Exportar la plantilla a un archivo listo para versionar en Git:
kubectl run mi-servidor --image=nginx:alpine --port=80 --dry-run=client -o yaml > mi-servidor.yaml
# 3. Validar contra el API Server real sin guardar en etcd (--dry-run=server):
kubectl apply -f mi-servidor.yaml --dry-run=server
# 4. Exportar el YAML de un Pod que ya está corriendo en el clúster:
kubectl get pod hola-medellin -o yaml > hola-medellin-backup.yaml
📖 Diccionario Integrado: --help, kubectl explain y --recursive
Kubernetes incluye toda su documentación oficial dentro del comando kubectl:
# Consultar ejemplos reales de sintaxis:
kubectl run --help
kubectl apply --help
# Consultar la documentación y tipos de dato de cualquier campo YAML:
kubectl explain pod
kubectl explain pod.spec.containers
kubectl explain pod.spec.containers.resources
kubectl explain pod.spec.containers.livenessProbe
# Ver el árbol jerárquico completo de propiedades con --recursive:
kubectl explain pod --recursive
kubectl explain pod.spec --recursive | grep -i -C 3 "probe"
📄 Anatomía Estándar de un Manifiesto YAML
Todo objeto en Kubernetes se define con 4 campos raíz obligatorios:
apiVersion: v1 # 1. Versión de la API de Kubernetes (v1, apps/v1, etc.)
kind: Pod # 2. Tipo de objeto (Pod, Deployment, Service, etc.)
metadata: # 3. Metadatos de identificación
name: mi-primer-pod # Nombre único dentro del Namespace
labels: # Etiquetas clave-valor para agrupar y filtrar
app: kubecafe
semana: "1"
spec: # 4. Especificación: el estado deseado
containers:
- name: servidor-web
image: nginx:alpine
ports:
- containerPort: 80
🚀 Preparación del Entorno: Clonar el Repositorio
Para ejecutar las prácticas de este módulo con total seguridad, evitar errores de contexto (context not found) o rutas relativas incorrectas, clona el repositorio oficial en tu terminal y sitúate en la raíz del proyecto:
# 1. Clonar el repositorio oficial del workshop
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
# 2. Entrar a la raíz del repositorio
cd Fundamentos-Kubernetes
!IMPORTANT 📁 Regla de Oro: Rutas Absolutas con
$PWD:
A lo largo de toda esta unidad y en cada uno de sus laboratorios prácticos, todos los comandos utilizan la variable de entorno$PWD(ej.$PWD/semana-01-arquitectura/1.ejemplos/...) para construir la ruta absoluta exacta en tu sistema o en la terminal web de iximiuz Labs.
Esto garantiza que puedes ejecutar cualquier comando desde la raíz del repositorio sin necesidad de cambiar de carpeta (cd) entre laboratorios, eliminando por completo los errores de archivos no encontrados.
📑 Ruta de Aprendizaje del Módulo 01
Continúa con las subsecciones prácticas de este módulo:
- 🛠️ Módulo 01 — Preparación del Laboratorio (Kind, kubectl, k9s, stern, Headlamp)
- 🧪 Módulo 01 — Lab 1: Pod Básico y Acceso con Port-Forward
- 🧪 Módulo 01 — Lab 2: Pod Multi-Contenedor (Patrón Sidecar)
- 🧪 Módulo 01 — Lab 3: Recursos (Requests/Limits) y Variables de Entorno
- 🧪 Módulo 01 — Lab 4: InitContainers y Sondas de Salud (Liveness/Readiness)
- 🤖 Módulo 01 — Lab 5: Pod de Inferencia de IA Local con Ollama
- 📊 Módulo 01 — Lab 6: Observabilidad Sencilla (Prometheus + Logs JSON + Metrics Server)
- 💥 Módulo 01 — Los 4 Retos Rotos de la Semana 01
🌱 Semana 01 • Lab 0: Preparación del Clúster (Kind + Headlamp)
🛠️ Prepara tu Laboratorio de Kubernetes — Módulo 01
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/0.prepara-tu-laboratorio
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Alista en tu computador el kit completo de herramientas que utiliza un ingeniero Cloud Native en el día a día: Docker, kubectl, Kind, kubectx / kubens, k9s, stern y Headlamp.
🧱 Paso 0: Prerrequisito — Docker en Ejecución
Como utilizaremos Kind (Kubernetes in Docker), cada nodo de nuestro clúster correrá como un contenedor. Por lo tanto, es indispensable tener Docker activo.
Requisitos recomendados de tu máquina:
- CPU: Mínimo 2 vCPUs asignadas a Docker (recomendado 4 vCPUs).
- RAM: Mínimo 4 GB de RAM libres para Docker (recomendado 6 GB a 8 GB).
- Disco: Al menos 15 GB libres.
# Comprobar que Docker responda correctamente:
docker --version
docker ps
☸️ Paso 1: Instalar kubectl y Documentación Oficial
- 🌐 Documentación Principal (Español): https://kubernetes.io/es/docs/home/
- ⚡ Cheat Sheet Oficial: https://kubernetes.io/es/docs/reference/kubectl/cheatsheet/
Instalación según tu sistema operativo:
- 🍏 macOS:
brew install kubectl - 🐧 Linux (Ubuntu / Debian):
sudo apt-get update && sudo apt-get install -y apt-transport-https ca-certificates curl gnupg curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.32/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.32/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list sudo apt-get update && sudo apt-get install -y kubectl - 🪟 Windows (PowerShell Administrador):
winget install -e --id Kubernetes.kubectl
⌨️ Autocompletado con Tab y Alias k
Acelera tu velocidad configurando el alias k=kubectl con autocompletado en tu shell:
- En Zsh (
~/.zshrc):cat << 'EOF' >> ~/.zshrc autoload -Uz compinit && compinit source <(kubectl completion zsh) alias k=kubectl compdef __start_kubectl k EOF source ~/.zshrc - En Bash (
~/.bashrc):sudo apt-get update && sudo apt-get install -y bash-completion cat << 'EOF' >> ~/.bashrc source <(kubectl completion bash) alias k=kubectl complete -o default -F __start_kubectl k EOF source ~/.bashrc
🐳 Paso 2: Crear tu Clúster Local con Kind
Kind simula los nodos de Kubernetes usando simples contenedores de Docker, consumiendo una fracción de memoria frente a máquinas virtuales tradicionales.
Instalación de Kind:
- macOS:
brew install kind - Windows:
winget install Kubernetes.kindochoco install kind - Linux:
[ $(uname -m) = x86_64 ] && curl -Lo ./kind https://kind.sigs.k8s.io/dl/v0.27.0/kind-linux-amd64 chmod +x ./kind && sudo mv ./kind /usr/local/bin/kind
Crear clúster básico:
# Crear clúster con nombre cnm-lab
kind create cluster --name cnm-lab
# Verificar que el nodo esté Ready
kubectl get nodes
🚀 Clonar el Repositorio para Clústeres Avanzados:
Para utilizar los archivos de configuración multi-nodo o Ingress con rutas $PWD, asegúrate de clonar el repositorio oficial y situarte en su raíz:
# Clonar y entrar a la raíz
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
cd Fundamentos-Kubernetes
Crear clúster avanzado con recetas YAML de 0.prepara-tu-laboratorio/:
Los archivos de configuración se encuentran en:
📂 semana-01-arquitectura/0.prepara-tu-laboratorio/
# Clúster multi-nodo (1 Control Plane + 2 Workers):
kind create cluster --name cnm-multi --config $PWD/semana-01-arquitectura/0.prepara-tu-laboratorio/kind-multinode.yaml
# Clúster preparado para Ingress Nginx (puertos 80 y 443 expuestos):
kind create cluster --name cnm-ingress --config $PWD/semana-01-arquitectura/0.prepara-tu-laboratorio/kind-ingress.yaml
# Borrar un clúster cuando no lo uses:
kind delete cluster --name cnm-lab
🧰 Paso 3: Kit de Supervivencia CLI (kubectx, k9s y stern)
🔀 kubectx y kubens: Cambia de clúster y namespace en 1 segundo
- Instalación:
brew install kubectx(macOS/Linux) owinget install ahmetb.kubectx(Windows). - Uso:
# Cambiar de clúster: kubectx kind-cnm-lab kubectx - # Regresar al anterior # Cambiar de namespace por defecto: kubens kube-system kubens default
🐶 k9s: Panel interactivo en tu terminal
- Instalación:
brew install k9s(macOS/Linux) owinget install Inuits.k9s(Windows). - Uso: Ejecuta simplemente
k9s. - Atajos clave:
:pods(Ver pods) |:nodes(Ver nodos) |:ns(Cambiar namespace).d(Describe) |l(Logs) |s(Shell adentro) |Ctrl+d(Eliminar pod) |:q(Salir).
📢 stern: Logs de múltiples Pods en tiempo real
- Instalación:
brew install stern(macOS/Linux) owinget install stern.stern(Windows). - Uso:
stern hola # Tailing de todos los pods que contengan "hola" stern -l app=kubecafe # Filtrar por label stern . -n kube-system # Ver todos los logs del sistema
🖥️ Paso 4: Consola Visual Web con Headlamp
Para una visualización gráfica moderna y completa de tu clúster:
Opción A: Aplicación Nativa de Escritorio
- macOS:
brew install --cask headlamp - Windows:
winget install Kinvolk.Headlamp
Opción B: Como contenedor Docker local
docker run -d -p 9090:9090 -v ~/.kube/config:/.kube/config:ro headlamp-k8s/headlamp:latest
Abre en tu navegador: http://localhost:9090.
👉 Guía completa de Headlamp: semana-01-arquitectura/headlamp.md
🌱 Semana 01 • Lab 1: Mi Primer Pod en YAML y Port-Forward
🧪 Laboratorio 1: Mi Primer Pod y Acceso con Port-Forward
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En este laboratorio desplegarás tu primer Pod en Kubernetes, aprenderás a inspeccionarlo a fondo con kubectl y abrirás un túnel seguro con port-forward para acceder a la aplicación desde el navegador de tu computador.
El archivo de este laboratorio se encuentra en:
📂 semana-01-arquitectura/1.ejemplos/01-mi-primer-pod.yaml
☕ En KubeCafé: La Primera Bandeja
Representa servir la primera 🍽️ Bandeja con una ☕ Taza de Café (Nginx) expuesta en el puerto 80.
📄 1. Manifiesto YAML (01-mi-primer-pod.yaml)
apiVersion: v1
kind: Pod
metadata:
name: hola-medellin
labels:
comunidad: cloud-native-medellin
semana: "1"
spec:
containers:
- name: servidor-web
image: nginx:alpine
ports:
- containerPort: 80
🚀 2. Despliegue e Interacción Paso a Paso
A. Aplicar el manifiesto en el clúster:
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/01-mi-primer-pod.yaml
B. Verificar que el Pod esté en ejecución (Running):
kubectl get pods -o wide
- Observa la columna
STATUS: debe decirRunning. - Observa la columna
IP: Kubernetes le asignó una dirección IP privada interna dentro del clúster (ej.10.244.0.5).
C. Inspeccionar el ciclo de vida y eventos (describe):
kubectl describe pod hola-medellin
Fíjate en la tabla de Events al final:
Scheduled: El kube-scheduler asignó el Pod a un nodo disponible.Pulling: El kubelet inició la descarga de la imagennginx:alpine.Pulled: La imagen fue descargada con éxito.Created: El contenedor fue creado en containerd.Started: El proceso principal inició.
D. Acceder a la aplicación desde tu navegador local (port-forward):
Como la IP 10.244.0.5 solo existe dentro del clúster, creamos un túnel temporal que redirige el puerto 8080 de tu computador al puerto 80 del Pod:
kubectl port-forward pod/hola-medellin 8080:80
Abre en tu navegador: http://localhost:8080.
¡Verás la pantalla de bienvenida de Nginx servida desde tu clúster!
E. Inspeccionar logs y ejecutar comandos dentro del Pod:
# Ver los logs de peticiones HTTP:
kubectl logs -f hola-medellin
# Entrar a la terminal interactiva del contenedor:
kubectl exec -it hola-medellin -- sh
# Dentro del contenedor puedes ejecutar:
# / # nginx -v
# / # cat /etc/os-release
# / # exit
F. Limpieza:
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/01-mi-primer-pod.yaml
🌱 Semana 01 • Lab 2: Pod Multi-Contenedor (Patrón Sidecar)
🧪 Laboratorio 2: Pod Multi-Contenedor (Patrón Sidecar)
📖 Lectura / Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Revisa este tutorial oficial en iximiuz Labs para marcar esta sección en verde:
Loading tutorial...
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En este laboratorio aprenderás cómo dos o más contenedores pueden colaborar estrechamente dentro del mismo Pod, compartiendo almacenamiento temporal (emptyDir) y el mismo espacio de red (localhost).
El archivo de este laboratorio se encuentra en:
📂 semana-01-arquitectura/1.ejemplos/02-pod-multi-contenedor.yaml
☕ En KubeCafé: La Taza Principal y el Vaso de Agua
En KubeCafé, una bandeja (Pod) lleva la ☕ Taza Principal de Café (Nginx) acompañada de un 🥛 Vaso de Agua / Sidecar (Busybox) que va actualizando el contenido periódicamente.
┌─────────────────────────────────────────────────────────────┐
│ 🍽️ Pod: pod-dos-contenedores (IP Única / Localhost) │
│ │
│ ┌────────────────────────┐ ┌─────────────────────┐ │
│ │ ☕ Contenedor Principal│ │ 🥛 Contenedor Sidecar│ │
│ │ (servidor-web) │ │ (generador-contenido│ │
│ │ Nginx en puerto 80 │ │ Busybox bucle cada 5│ │
│ └───────────┬────────────┘ └──────────┬──────────┘ │
│ │ Lee y sirve │ Escribe │
│ ▼ ▼ │
│ ┌──────────────────────────────────────────────┐ │
│ │ 💾 Volumen Compartido: contenido-compartido │ │
│ │ (tipo: emptyDir) │ │
│ └──────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
📄 1. Manifiesto YAML (02-pod-multi-contenedor.yaml)
apiVersion: v1
kind: Pod
metadata:
name: pod-dos-contenedores
labels:
comunidad: cloud-native-medellin
semana: "1"
patron: sidecar
spec:
# Volumen temporal compartido entre los contenedores dentro del mismo Pod
volumes:
- name: contenido-compartido
emptyDir: {}
containers:
# Contenedor 1: Servidor web principal que sirve los archivos
- name: servidor-web
image: nginx:alpine
ports:
- containerPort: 80
volumeMounts:
- name: contenido-compartido
mountPath: /usr/share/nginx/html
# Contenedor 2: Sidecar que genera y actualiza periódicamente el contenido
- name: generador-contenido
image: busybox:1.36
command: ["/bin/sh", "-c"]
args:
- |
while true; do
cat <<EOF > /datos/index.html
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title>Pod Multi-contenedor</title>
<style>
body { font-family: sans-serif; background: #0f172a; color: #f8fafc; padding: 2rem; }
.card { background: #1e293b; border-radius: 8px; padding: 1.5rem; max-width: 600px; margin: auto; box-shadow: 0 4px 6px -1px rgba(0,0,0,0.3); }
.badge { background: #38bdf8; color: #0f172a; padding: 4px 8px; border-radius: 4px; font-weight: bold; }
code { background: #0f172a; padding: 2px 6px; border-radius: 4px; color: #38bdf8; }
</style>
</head>
<body>
<div class="card">
<h1>🚀 Hola desde un Pod con 2 Contenedores</h1>
<p><span class="badge">Patrón Sidecar</span> Cloud Native Medellín</p>
<hr style="border-color: #334155; margin: 1rem 0;">
<p>🕒 <strong>Última actualización:</strong> $(date)</p>
<p>📦 <strong>Generado por:</strong> Contenedor <code>generador-contenido</code> (Busybox)</p>
<p>🌐 <strong>Servido por:</strong> Contenedor <code>servidor-web</code> (Nginx)</p>
</div>
</body>
</html>
EOF
sleep 5
done
volumeMounts:
- name: contenido-compartido
mountPath: /datos
🚀 2. Despliegue y Pruebas
A. Aplicar el Pod:
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/02-pod-multi-contenedor.yaml
B. Observar la columna READY:
kubectl get pods
Notarás que la columna READY muestra 2/2, lo que confirma que ambos contenedores están corriendo dentro del mismo Pod.
C. Inspeccionar logs de un contenedor específico con -c:
Cuando un Pod tiene múltiples contenedores, debes especificar el nombre del contenedor con -c:
# Ver logs del servidor Nginx:
kubectl logs pod-dos-contenedores -c servidor-web
# Ver la salida del generador sidecar:
kubectl logs pod-dos-contenedores -c generador-contenido
# O ver los logs de ambos simultáneamente y a color con stern:
stern pod-dos-contenedores
D. Abrir túnel con port-forward:
kubectl port-forward pod/pod-dos-contenedores 8080:80
Abre en tu navegador http://localhost:8080 y refresca la página cada pocos segundos para ver la fecha/hora actualizarse dinámicamente.
E. Limpieza:
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/02-pod-multi-contenedor.yaml
🌱 Semana 01 • Lab 3: Recursos (Requests/Limits) y Variables de Entorno
🧪 Laboratorio 3: Recursos (Requests/Limits) y Variables de Entorno
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
Aprende a proteger la estabilidad de tu clúster mediante requests y limits de CPU y Memoria RAM, y a inyectar metadatos del clúster directamente en tu aplicación mediante la Downward API.
El archivo de este laboratorio se encuentra en:
📂 semana-01-arquitectura/1.ejemplos/03-pod-con-recursos-y-env.yaml
☕ En KubeCafé: El Dosificador de Agua y Granos
requests(Garantía mínima): Es la cantidad mínima de agua (RAM) y cafeteras (CPU) que el barista reserva en la mesa antes de preparar la taza. Si la mesa no tiene eso disponible, el Scheduler busca otra mesa.limits(Techo máximo): Si la taza se desborda y sobrepasa el límite de memoria, Kubernetes la cancela de inmediato (OOMKilled) para evitar que apague las demás tazas de la mesa.
📄 1. Manifiesto YAML (03-pod-con-recursos-y-env.yaml)
apiVersion: v1
kind: Pod
metadata:
name: pod-recursos-y-variables
labels:
comunidad: cloud-native-medellin
semana: "1"
tipo: produccion-ready
spec:
containers:
- name: app-demo
image: busybox:1.36
command: ["/bin/sh", "-c"]
args:
- |
echo "=== Contenedor con variables y límites configurados ==="
echo "Entorno: $ENTORNO_APP"
echo "Mensaje: $MENSAJE_BIENVENIDA"
echo "Nombre del Pod (Downward API): $MI_POD_NOMBRE"
echo "IP del Pod: $MI_POD_IP"
while true; do
echo "[$(date)] Pod '$MI_POD_NOMBRE' operando normalmente con memoria y CPU limitadas..."
sleep 15
done
env:
# Variables con valores literales directos
- name: ENTORNO_APP
value: "laboratorio-medellin"
- name: MENSAJE_BIENVENIDA
value: "Bienvenidos a Fundamentos de Kubernetes"
# Variables obtenidas dinámicamente de metadatos de Kubernetes (Downward API)
- name: MI_POD_NOMBRE
valueFrom:
fieldRef:
fieldPath: metadata.name
- name: MI_POD_IP
valueFrom:
fieldRef:
fieldPath: status.podIP
resources:
# Requests: recursos mínimos garantizados que el scheduler busca en el nodo
requests:
memory: "64Mi"
cpu: "50m"
# Limits: techo máximo de consumo (evita que un proceso sature el nodo)
limits:
memory: "128Mi"
cpu: "200m"
🚀 2. Despliegue y Comprobación
A. Aplicar el Pod:
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/03-pod-con-recursos-y-env.yaml
B. Verificar que el Pod esté en ejecución:
kubectl get pod pod-recursos-y-variables
C. Comprobar que las variables de entorno y Downward API se inyectaron:
# Opción 1: Ver los logs del script que imprime variables periódicamente:
kubectl logs pod-recursos-y-variables -f
# Opción 2: Consultar las variables de entorno dentro del contenedor:
kubectl exec pod-recursos-y-variables -- env | grep -E "ENTORNO|MENSAJE|MI_POD"
Verás valores reales como:
ENTORNO_APP=laboratorio-medellin
MENSAJE_BIENVENIDA=Bienvenidos a Fundamentos de Kubernetes
MI_POD_NOMBRE=pod-recursos-y-variables
MI_POD_IP=10.244.0.7
D. Inspeccionar los límites de recursos:
kubectl describe pod pod-recursos-y-variables | grep -A 8 "Limits:"
E. Limpieza:
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/03-pod-con-recursos-y-env.yaml
🌱 Semana 01 • Lab 4: InitContainers y Sondas de Salud (Liveness/Readiness)
🧪 Laboratorio 4: InitContainers y Sondas de Salud (Liveness/Readiness)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En este laboratorio dominarás dos conceptos fundamentales para la resiliencia en Kubernetes:
initContainers: Contenedores de inicialización que se ejecutan de forma secuencial y bloqueante antes de que arranque la aplicación principal.- Sondas de Salud (
Probes): Mecanismos para que Kubernetes sepa si la aplicación está lista para recibir tráfico (readinessProbe) y si continúa viva (livenessProbe).
Los archivos de este laboratorio se encuentran en:
📂 semana-01-arquitectura/1.ejemplos/04-pod-con-init-container.yaml
📂 semana-01-arquitectura/1.ejemplos/05-pod-con-health-checks.yaml
☕ En KubeCafé: Limpiar la Máquina y el Termómetro de Entrega
initContainer: Es la tarea previa obligatoria del barista: lavar el portafiltro y calentar el agua antes de colar la primera taza. Si el agua no calienta, no se sirve café.readinessProbe(¿Está lista la taza?): El mesero (Service) no lleva la bandeja a la mesa del cliente hasta que el café haya terminado de filtrarse (200 OK).livenessProbe(¿Sigue caliente el café?): Si el café se enfría o se daña, el supervisor retira la taza y ordena preparar una nueva automáticamente.
📄 1. Manifiesto con initContainers (04-pod-con-init-container.yaml)
apiVersion: v1
kind: Pod
metadata:
name: pod-con-init-container
labels:
comunidad: cloud-native-medellin
semana: "1"
patron: init-container
spec:
volumes:
- name: datos-inicio
emptyDir: {}
# 🧼 CONTENEDOR DE INICIALIZACIÓN: Se ejecuta primero y debe terminar con éxito (exit 0)
initContainers:
- name: inicializador
image: busybox:1.36
command: ["/bin/sh", "-c"]
args:
- |
echo "[InitContainer] Preparando archivos y verificando dependencias..."
sleep 4
cat <<EOF > /trabajo/index.html
<!DOCTYPE html>
<html>
<body style="font-family: sans-serif; background: #042f2e; color: #ccfbf1; padding: 2rem;">
<h2>✅ Inicialización Exitosa</h2>
<p>Este archivo fue generado por el <strong>initContainer</strong> antes de que Nginx iniciara.</p>
</body>
</html>
EOF
echo "[InitContainer] Finalizado con éxito."
volumeMounts:
- name: datos-inicio
mountPath: /trabajo
# ☕ CONTENEDOR PRINCIPAL: Solo arranca cuando el initContainer finaliza
containers:
- name: servidor-web
image: nginx:alpine
ports:
- containerPort: 80
volumeMounts:
- name: datos-inicio
mountPath: /usr/share/nginx/html
Probar el initContainer:
# 1. Aplicar el manifiesto y vigilar la transición en tiempo real:
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/04-pod-con-init-container.yaml && kubectl get pod pod-con-init-container -w
# Observa la columna STATUS mientras arranca:
# Verás primero 'Init:0/1' (dura 4s) y luego pasará a 'PodInitializing' y finalmente 'Running'.
# 2. Ver los logs del initContainer que ya finalizó:
kubectl logs pod-con-init-container -c inicializador
# 3. Comprobar que Nginx sirve la página generada por el initContainer:
kubectl port-forward pod/pod-con-init-container 8080:80
# Abre http://localhost:8080 o ejecuta: curl http://localhost:8080
📄 2. Manifiesto con Sondas de Salud (05-pod-con-health-checks.yaml)
apiVersion: v1
kind: Pod
metadata:
name: pod-con-health-checks
labels:
comunidad: cloud-native-medellin
semana: "1"
tipo: resiliencia
spec:
containers:
- name: servidor-saludable
image: nginx:alpine
ports:
- containerPort: 80
# 🌡️ READINESS PROBE: ¿Está listo para recibir tráfico?
readinessProbe:
httpGet:
path: /
port: 80
initialDelaySeconds: 3
periodSeconds: 5
# 🌡️ LIVENESS PROBE: ¿Sigue viva la aplicación?
livenessProbe:
httpGet:
path: /
port: 80
initialDelaySeconds: 5
periodSeconds: 10
Probar las sondas y simular Auto-Recuperación (Self-Healing):
# 1. Aplicar y observar el retardo inicial (initialDelaySeconds: 3):
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/05-pod-con-health-checks.yaml && kubectl get pod pod-con-health-checks -w
# Verás 0/1 durante 3 segundos y luego cambiará a 1/1 Running.
# 2. Inspeccionar la configuración de las sondas:
kubectl describe pod pod-con-health-checks | grep -E "Liveness|Readiness" -A 3
# 3. 🧪 Experimento de autorreparación: romper el archivo para forzar falla de sondas:
# En otra terminal renombra el index:
kubectl exec pod-con-health-checks -- mv /usr/share/nginx/html/index.html /usr/share/nginx/html/index.bak
# Observa cómo readinessProbe falla (pasa a 0/1 NotReady) y luego livenessProbe
# reinicia automáticamente el contenedor (la columna RESTARTS pasará a 1).
Limpieza:
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/04-pod-con-init-container.yaml
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/05-pod-con-health-checks.yaml
🌱 Semana 01 • Lab 5: Pod de Inferencia de IA Local con Ollama
🤖 Laboratorio 5: Pod de Inferencia de IA Local en Kubernetes con Ollama
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En la Semana 00 ejecutamos un modelo de Inteligencia Artificial local con Docker. Ahora en la Semana 01, llevamos ese motor de inferencia directamente a Kubernetes dentro de un Pod.
Aprenderás a desplegar un LLM (Modelo de Lenguaje) ejecutándose en modo CPU dentro de tu clúster de Kind, con almacenamiento temporal para modelos (emptyDir), límites estrictos de recursos y sondas de salud.
El archivo de este laboratorio se encuentra en:
📂 semana-01-arquitectura/1.ejemplos/06-pod-inferencia-ia-ollama.yaml
☕ En KubeCafé: El Barista Sommelier con IA
Es nuestro asistente inteligente dentro de la cafetería: responde preguntas sobre recetas y dudas de Kubernetes en tiempo real, 100% privado, sin costo por token y corriendo localmente en CPU.
👨💻 Tú (Terminal / curl)
│
▼ kubectl port-forward :11434
🍽️🤖 Pod: pod-inferencia-ia
├── ⚙️ Contenedor: motor-ollama (API REST :11434)
│ ├── ⚖️ Limits: 2Gi RAM / 2000m CPU
│ └── 🌡️ Probes: GET / :11434
└── 💾 Volumen emptyDir: /root/.ollama (Pesos GGUF)
📄 1. Manifiesto YAML (06-pod-inferencia-ia-ollama.yaml)
apiVersion: v1
kind: Pod
metadata:
name: pod-inferencia-ia
labels:
app: kubecafe-ia
componente: inferencia-llm
comunidad: cloud-native-medellin
semana: "1"
spec:
containers:
- name: motor-ollama
image: ollama/ollama:latest
ports:
- name: http-llm
containerPort: 11434
env:
- name: OLLAMA_HOST
value: "0.0.0.0:11434"
- name: OLLAMA_KEEP_ALIVE
value: "5m"
- name: OLLAMA_NUM_PARALLEL
value: "1"
resources:
requests:
memory: "512Mi"
cpu: "500m"
limits:
memory: "2Gi"
cpu: "2000m"
readinessProbe:
httpGet:
path: /
port: 11434
initialDelaySeconds: 5
periodSeconds: 10
livenessProbe:
httpGet:
path: /
port: 11434
initialDelaySeconds: 15
periodSeconds: 20
volumeMounts:
- name: cache-modelos-ia
mountPath: /root/.ollama
volumes:
- name: cache-modelos-ia
emptyDir: {}
🚀 2. Despliegue y Pruebas de Inferencia
A. Desplegar el Pod de IA en el clúster:
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/06-pod-inferencia-ia-ollama.yaml
# Esperar a que esté en Running y 1/1 Ready:
kubectl get pod pod-inferencia-ia -w
B. Descargar un micro-modelo ultra ligero (~90 MB):
Descargaremos smollm2:135m (solo ~90 MB), ideal para correr rápido en CPU:
kubectl exec -it pod-inferencia-ia -- ollama pull smollm2:135m
C. Opción 1: Chatear de forma interactiva en la terminal (exec):
kubectl exec -it pod-inferencia-ia -- ollama run smollm2:135m "Explain what a Kubernetes Pod is in two short sentences"
D. Opción 2: Consumir la API REST de Inferencia con curl:
Abre el túnel en una terminal:
kubectl port-forward pod/pod-inferencia-ia 11434:11434
Y en otra pestaña de tu terminal envíale un prompt JSON:
curl http://localhost:11434/api/generate -d '{
"model": "smollm2:135m",
"prompt": "Why do we use containers and Kubernetes?",
"stream": false
}'
E. Limpieza:
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/06-pod-inferencia-ia-ollama.yaml
🌱 Semana 01 • Lab 6: Observabilidad Sencilla (Prometheus + Logs JSON)
📊 Laboratorio 6: Observabilidad Sencilla en Kubernetes
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En este laboratorio aprenderás cómo implementar los 3 pilares de observabilidad (Métricas, Logs y Eventos) en un entorno local ligero como Kind, sin sobrecargar tu computador con plataformas pesadas.
El archivo de este laboratorio se encuentra en:
📂 semana-01-arquitectura/1.ejemplos/07-pod-observabilidad-metricas-logs.yaml
☕ En KubeCafé: Los 3 Instrumentos de la Cafetería
| Pilar | En ☕ KubeCafé | En nuestro Laboratorio |
|---|---|---|
| 1. Métricas | 📈 Manómetro de presión y balanza de agua/café | Metrics Server (kubectl top) + Exportador Prometheus (:9113/metrics) |
| 2. Logs | 📢 Comandas cantadas en voz alta en la barra | stern y kubectl logs -f con formato estructurado JSON |
| 3. Eventos y Trazabilidad | 📋 Libro de novedades e incidentes de gerencia | kubectl get events -w, k9s y consola visual Headlamp |
┌─────────────────────────────────────────────────────────────┐
│ 🍽️📊 Pod: pod-observabilidad-kubecafe │
│ │
│ ┌────────────────────────┐ ┌─────────────────────┐ │
│ │ ☕ Contenedor Principal│ │ 📢 Sidecar Logs JSON│ │
│ │ (app-cafetera) │◄─────┤ (simulador-pedidos) │ │
│ │ Nginx + /stub_status │ │ Petición cada 3 seg │ │
│ └───────────┬────────────┘ └─────────────────────┘ │
│ │ Lee métricas │
│ ▼ │
│ ┌────────────────────────┐ │
│ │ 📈 Sidecar Prometheus │ ──► Expone :9113/metrics │
│ │ (exportador-metricas) │ │
│ └────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
🛠️ Paso 1: Activar Metrics Server en Kind en 10 Segundos
Para poder usar kubectl top nodes y kubectl top pods, aplica estos dos comandos:
# 1. Instalar componentes de Metrics Server:
kubectl apply -f https://github.com/kubernetes-sigs/metrics-server/releases/latest/download/components.yaml
# 2. Habilitar certificados locales de Kind:
kubectl patch deployment metrics-server -n kube-system --type='json' \
-p='[{"op": "add", "path": "/spec/template/spec/containers/0/args/-", "value": "--kubelet-insecure-tls"}]'
Espera unos 20 segundos y prueba:
# Ver consumo de CPU y RAM de los nodos:
kubectl top nodes
# Ver consumo por Pod y por contenedor individual:
kubectl top pods --containers
📄 2. Manifiesto YAML (07-pod-observabilidad-metricas-logs.yaml)
apiVersion: v1
kind: Pod
metadata:
name: pod-observabilidad-kubecafe
labels:
app: kubecafe
componente: observabilidad
semana: "1"
spec:
initContainers:
- name: configurar-medidor-nginx
image: busybox:1.36
command:
- sh
- -c
- |
cat << 'EOF' > /etc/nginx/conf.d/default.conf
server {
listen 80;
location / {
root /usr/share/nginx/html;
index index.html;
}
location /stub_status {
stub_status on;
access_log off;
}
}
EOF
echo "<h1>☕ KubeCafe - Estacion Monitoreada</h1>" > /usr/share/nginx/html/index.html
volumeMounts:
- name: config-nginx
mountPath: /etc/nginx/conf.d
- name: html-nginx
mountPath: /usr/share/nginx/html
containers:
# 1. Contenedor Principal: Nginx
- name: app-cafetera
image: nginx:1.27-alpine
ports:
- name: http
containerPort: 80
resources:
requests:
memory: "32Mi"
cpu: "50m"
limits:
memory: "64Mi"
cpu: "150m"
volumeMounts:
- name: config-nginx
mountPath: /etc/nginx/conf.d
- name: html-nginx
mountPath: /usr/share/nginx/html
# 2. Sidecar de Métricas: Nginx Prometheus Exporter
- name: exportador-metricas
image: nginx/nginx-prometheus-exporter:1.3.0
args:
- "-nginx.scrape-uri=http://localhost:80/stub_status"
ports:
- name: metrics
containerPort: 9113
resources:
requests:
memory: "16Mi"
cpu: "25m"
limits:
memory: "64Mi"
cpu: "100m"
# 3. Sidecar de Logs Estructurados JSON y Tráfico
- name: simulador-pedidos
image: busybox:1.36
command:
- sh
- -c
- |
CONTADOR=1
while true; do
wget -qO /dev/null http://localhost:80/
FECHA=$(date -u +"%Y-%m-%dT%H:%M:%SZ")
printf '{"timestamp":"%s","nivel":"INFO","servicio":"kubecafe","pedido_id":%d,"bebida":"espresso","estado":"servido_200_ok"}\n' "$FECHA" "$CONTADOR"
CONTADOR=$((CONTADOR + 1))
sleep 3
done
resources:
requests:
memory: "16Mi"
cpu: "10m"
limits:
memory: "32Mi"
cpu: "50m"
volumes:
- name: config-nginx
emptyDir: {}
- name: html-nginx
emptyDir: {}
🚀 3. Despliegue y Pruebas de Observabilidad
A. Aplicar el Pod:
kubectl apply -f $PWD/semana-01-arquitectura/1.ejemplos/07-pod-observabilidad-metricas-logs.yaml
# Verificar que los 3 contenedores estén Ready (3/3):
kubectl get pods
B. Observar Logs JSON en tiempo real:
# Ver los logs del generador de tráfico:
kubectl logs -f pod-observabilidad-kubecafe -c simulador-pedidos
# O con stern viendo todos los contenedores simultáneamente a color:
stern pod-observabilidad-kubecafe
C. Consultar métricas en formato Prometheus:
Abre un túnel hacia el exportador:
kubectl port-forward pod/pod-observabilidad-kubecafe 9113:9113
En otra terminal o en tu navegador en http://localhost:9113/metrics:
curl -s http://localhost:9113/metrics | grep ^nginx_
Verás métricas oficiales incrementándose en cada petición:
nginx_connections_active 1
nginx_http_requests_total 35
nginx_up 1
D. Monitorear Eventos del Clúster en vivo:
kubectl get events --sort-by='.lastTimestamp' -w
E. Limpieza:
kubectl delete -f $PWD/semana-01-arquitectura/1.ejemplos/07-pod-observabilidad-metricas-logs.yaml
🌱 Semana 01 • Retos: Los 4 Retos Rotos de Pods y Diagnóstico
💥 Los 4 Retos Rotos de la Semana 01
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-01-arquitectura/2.reto-roto
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En este módulo te enfrentarás a 4 incidentes reales en Kubernetes. Cada archivo contiene fallos a propósito para que entrenes tus habilidades de diagnóstico con kubectl get, describe y logs:
| # | Archivo del Reto | ¿Qué pasó en ☕ KubeCafé? | Estado / Síntoma |
|---|---|---|---|
| 01 | 01-pod-con-errores.yaml | El barista buscó una 📦 bolsa de café con etiqueta mal escrita y puerto inválido. | ImagePullBackOff / Error de puerto |
| 02 | 02-pod-crashloop.yaml | La ☕ taza se sirve pero se derrama al instante porque el comando falla. | CrashLoopBackOff |
| 03 | 03-pod-pendiente-infinito.yaml | La orden del pedido pide 64 cafeteras (CPU) y ninguna 🪵 mesa tiene capacidad. | Pending (Insufficient cpu) |
| 04 | 04-pod-yaml-molesto.yaml | El archivo de pedido entregado en 🛎️ Caja (apiserver) tiene errores de escritura y formato YAML. | Error de validación al hacer apply |
🕵️♂️ Diccionario de Diagnóstico Rápido: ¿Qué le duele a mi Pod?
| Estado del Pod | En ☕ KubeCafé | ¿Qué significa técnicamente? | Comando para descubrir el culpable |
|---|---|---|---|
Pending | 📋 El Despachador (scheduler) dejó el pedido en sala de espera porque ninguna mesa tiene tanta agua o cafeteras libres. | Ningún Worker Node tiene suficiente RAM/CPU libre o hay una restricción (taint/nodeSelector). | kubectl describe pod <nombre> (Mira la tabla de Events al final). |
ImagePullBackOff / ErrImagePull | 👨🍳 El Barista (kubelet) fue a la bodega pero esa 📦 bolsa de café no existe o está bajo llave. | La imagen de Docker está mal escrita, el tag no existe o el repositorio es privado. | kubectl describe pod <nombre> (Revisa qué imagen intentó descargar). |
CrashLoopBackOff | ☕ La taza se sirve pero se cae al piso una y otra vez apenas el barista la suelta. | El contenedor arrancó, pero el proceso principal adentro terminó con error o se apagó. | kubectl logs <nombre> (Lee el error que arrojó la aplicación). |
Error de validación al hacer apply | 🛎️ La Caja Registradora (apiserver) rechazó la orden porque el formulario YAML está mal escrito o mal indentado. | El archivo YAML tiene un error de sintaxis, indentación o un campo mal escrito. | Usa kubectl explain pod --recursive o revisa la línea del error en terminal. |
🧪 Comandos para probar los 4 Retos Rotos con Rutas Absolutas
# Reto 01: Pod con Errores de Imagen y Puerto
kubectl apply -f $PWD/semana-01-arquitectura/2.reto-roto/01-pod-con-errores.yaml
kubectl get pods # Observa ImagePullBackOff
kubectl describe pod reto-01-imagen
kubectl delete -f $PWD/semana-01-arquitectura/2.reto-roto/01-pod-con-errores.yaml
# Reto 02: Pod con CrashLoopBackOff
kubectl apply -f $PWD/semana-01-arquitectura/2.reto-roto/02-pod-crashloop.yaml
kubectl get pods # Observa CrashLoopBackOff
kubectl logs reto-02-crash # Observa 'echho: not found'
kubectl delete -f $PWD/semana-01-arquitectura/2.reto-roto/02-pod-crashloop.yaml
# Reto 03: Pod Pendiente Infinito
kubectl apply -f $PWD/semana-01-arquitectura/2.reto-roto/03-pod-pendiente-infinito.yaml
kubectl get pods # Observa Pending perpetuo
kubectl describe pod reto-03-exigente # Observa '0/1 nodes are available: 1 Insufficient cpu, 1 Insufficient memory'
kubectl delete -f $PWD/semana-01-arquitectura/2.reto-roto/03-pod-pendiente-infinito.yaml
# Reto 04: YAML Molesto (Error de validación de sintaxis)
kubectl apply -f $PWD/semana-01-arquitectura/2.reto-roto/04-pod-yaml-molesto.yaml
# Observa error: error: error validating data: ValidationError(Pod.spec.containers[0]): unknown field "imaeg"
🏆 ¿Cómo solucionar los retos y ganar +40 XP en el Ranking?
- Crea tu solución copiando cada archivo corregido dentro de tu carpeta personal:
aportes-comunidad/soluciones-retos/<tu-usuario>/semana-01/:01-pod-con-errores.yaml(+10 XP)02-pod-crashloop.yaml(+10 XP)03-pod-pendiente-infinito.yaml(+10 XP)04-pod-yaml-molesto.yaml(+10 XP)
- Cada archivo resuelto que pase la validación estricta de contenido sumará +10 XP inmediatamente.
- Al completar los 4 retos de la Semana 01, ¡tu semana contará como 100% Completada para ascender a 🧭 Timonel o ⚓ Capitán K8s!
- Abre tu Pull Request y nuestro bot actualizará la tabla de posiciones en
ASISTENTES.md.
🔄 Semana 02 • Conceptos: Deployments, ReplicaSets y Autorreparación
🔄 Semana 02: Despliegues sin Caídas y Autorreparación
📖 Lectura / Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Revisa este tutorial oficial en iximiuz Labs para marcar esta sección en verde:
Loading tutorial...
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Módulo: Fundamentos-Kubernetes / semana-02-deployments
- Diapositivas (PDF): 2.KubeCafe-De-un-Pod-al-Deployment.pdf
- Comunidad Oficial CNCF: Cloud Native Medellín en CNCF Community Groups
- Documentación Oficial: Deployments en Kubernetes • ReplicaSets • Rollouts Cheat Sheet
- Canal de Grabaciones: YouTube @CloudNativeColombia
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
"En KubeCafé, si a un barista se le cae una jarra o se enferma a mitad del turno, no cerramos la tienda: hay un supervisor vigilando en todo momento que siempre haya exactamente tres baristas en la barra sirviendo café."
🎯 Objetivos de Aprendizaje
Al finalizar este módulo serás capaz de:
- Comprender la diferencia crucial entre un Pod y un Deployment, y por qué nunca debes desplegar Pods aislados en producción.
- Entender el rol del ReplicaSet como el mecanismo de reconciliación que garantiza el estado deseado (Desired State vs. Actual State).
- Comprobar la autorreparación (Self-Healing) en vivo: eliminar Pods manualmente y ver cómo el controlador los recrea en milisegundos.
- Dominar las estrategias de despliegue:
RollingUpdate(cero tiempo de inactividad conmaxSurgeymaxUnavailable).Recreate(todo o nada, ideal para migraciones de bases de datos o volúmenes exclusivosReadWriteOnce).
- Realizar Rollbacks instantáneos con
kubectl rollout undoante versiones fallidas conImagePullBackOffo errores fatales. - Configurar recursos (Requests/Limits) y Probes (Liveness/Readiness) para proteger la estabilidad de los nodos.
- Resolver los 4 retos rotos de la semana y acumular +40 XP en el marcador de la comunidad.
☕ La Analogía de KubeCafé: El Supervisor de Turno
En la Semana 01 aprendiste qué es un Pod: es el barista individual preparando tu taza de café.
¿El problema? Si el barista se resbala o se va a almorzar, nadie atiende a los clientes.
- Deployment: Es la orden de contratación y la receta del café. Define: "Quiero siempre 3 baristas con uniforme v1.0. Si sale el uniforme v2.0, cámbialos uno a uno sin parar la atención".
- ReplicaSet: Es el supervisor de barra que cuenta cuántos baristas hay trabajando en cada instante. Si hay 2, crea 1. Si hay 4, apaga 1.
- Pod: Es el contenedor en ejecución física dentro del nodo.
🚀 Preparación del Entorno: Clonar el Repositorio
Para ejecutar las prácticas de este módulo con total seguridad, evitar errores de contexto (context not found) o rutas relativas incorrectas, clona el repositorio oficial en tu terminal y sitúate en la raíz del proyecto:
# 1. Clonar el repositorio oficial del workshop
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
# 2. Entrar a la raíz del repositorio
cd Fundamentos-Kubernetes
!IMPORTANT 📁 Regla de Oro: Rutas Absolutas con
$PWD:
A lo largo de toda esta unidad, todos los comandos utilizan la variable de entorno$PWD(ej.$PWD/semana-02-deployments/1.ejemplos/...) para construir la ruta absoluta exacta en tu sistema o en la terminal web de iximiuz Labs.
Esto garantiza que puedes ejecutar cualquier comando desde la raíz del repositorio sin necesidad de cambiar de carpeta (cd) entre laboratorios.
🛠️ Comandos Esenciales para Deployments
| Comando | Descripción |
|---|---|
kubectl get deployments | Lista los deployments y sus réplicas deseadas/actuales |
kubectl describe deployment <nombre> | Muestra eventos, estrategia, selector y réplicas |
kubectl scale deployment <nombre> --replicas=5 | Escala horizontalmente el número de Pods |
kubectl rollout status deployment <nombre> | Monitorea en tiempo real el progreso de actualización |
kubectl rollout history deployment <nombre> | Muestra las revisiones del historial de despliegue |
kubectl rollout undo deployment <nombre> | Vuelve a la versión anterior inmediatamente |
kubectl rollout undo deployment <nombre> --to-revision=1 | Vuelve a una revisión específica |
kubectl rollout restart deployment <nombre> | Reinicia todos los Pods en secuencia ordenada |
🌟 Buenas Prácticas para Producción
- Nunca uses
replicas: 1en producción: Pierdes la alta disponibilidad durante reinicios de nodos. Usa mínimo 2 o 3. - Define siempre
requestsylimits: Evita que un Pod con fuga de memoria agote el nodo (OOMKilled a nivel de sistema). - Configura
readinessProbecon Rolling Updates: Si no defines un probe de preparación, Kubernetes asume que el Pod está listo en cuanto el contenedor inicia, enviándole tráfico antes de que la aplicación haya calentado. - No uses la etiqueta
:latesten producción: Hace imposible saber qué versión de código corre en cada revisión y dificulta los rollbacks fiables. Usa tags semánticos (ej:v1.2.3o hash de commit git). - Alinea siempre
matchLabelscontemplate.metadata.labels: La inmutabilidad del selector impedirá que apliques cambios si no coinciden.
🔄 Semana 02 • Lab 1: Primer Deployment, Self-Healing y Escalado en Vivo
🚀 Laboratorio 1: Tu Primer Deployment, Self-Healing y Escalado
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-02-deployments/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo el Controlador de Réplicas recrea un Pod eliminado:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
🎯 Objetivo del Laboratorio
Desplegar un servicio web con 3 réplicas garantizadas, observar la jerarquía Deployment ➔ ReplicaSet ➔ Pods, comprobar la autorreparación (Self-Healing) al eliminar un Pod en vivo y practicar escalado horizontal (imperativo y declarativo).
📄 Manifiesto: 01-primer-deployment-replicas.yaml
Ubicación en el repositorio:
📂 semana-02-deployments/1.ejemplos/01-primer-deployment-replicas.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: cafecito-app
labels:
app: cafecito
entorno: produccion
spec:
replicas: 3
selector:
matchLabels:
app: cafecito
template:
metadata:
labels:
app: cafecito
entorno: produccion
spec:
containers:
- name: servidor-web
image: nginx:alpine
ports:
- containerPort: 80
name: http
resources:
requests:
cpu: "50m"
memory: "64Mi"
limits:
cpu: "200m"
memory: "128Mi"
🛠️ Paso a Paso en Terminal
Paso 1: Verificar tu clúster y aplicar el Deployment
# Verificar nodos activos
kubectl get nodes
# Aplicar el primer Deployment desde la raíz del repositorio
kubectl apply -f $PWD/semana-02-deployments/1.ejemplos/01-primer-deployment-replicas.yaml
Paso 2: Observar la jerarquía (Deployment ➔ ReplicaSet ➔ Pods)
kubectl get deployments,replicasets,pods -l app=cafecito
Verás una salida similar a:
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/cafecito-app 3/3 3 3 20s
NAME DESIRED CURRENT READY AGE
replicaset.apps/cafecito-app-6d8bfd8858 3 3 3 20s
NAME READY STATUS RESTARTS AGE
pod/cafecito-app-6d8bfd8858-4k2lp 1/1 Running 0 20s
pod/cafecito-app-6d8bfd8858-9x7zm 1/1 Running 0 20s
pod/cafecito-app-6d8bfd8858-m8p1q 1/1 Running 0 20s
Paso 3: El Experimento de Autorreparación (Self-Healing) 🔥
Elige uno de los Pods automáticamente y bórralo a la fuerza:
# Guarda el nombre del primer Pod
POD_NAME=$(kubectl get pods -l app=cafecito -o jsonpath='{.items[0].metadata.name}')
echo "Borrando pod: $POD_NAME"
# Elimina el Pod manualmente
kubectl delete pod $POD_NAME
# Observa de inmediato: Kubernetes ya creó un reemplazo idéntico
kubectl get pods -l app=cafecito -o wide
💡 ¿Qué ocurrió?
El Controlador de Réplicas (kube-controller-manager) detectó en milisegundos queActual: 2 != Desired: 3y ordenó alkube-schedulerykubeletcrear un nuevo Pod idéntico para cumplir la promesa de 3 réplicas activas.
📈 Paso 4: Escalado Horizontal en Vivo (Hora Pico en KubeCafé)
¿Llegó la hora pico de la tarde y necesitamos duplicar la capacidad de atención?
Forma Imperativa (rápida para emergencias):
kubectl scale deployment cafecito-app --replicas=6
kubectl get pods -l app=cafecito -w
(Presiona Ctrl + C para salir del modo watch cuando los 6 Pods estén en Running).
Forma Declarativa (buena práctica GitOps en producción):
En 01-primer-deployment-replicas.yaml, cambia replicas: 3 a replicas: 4 y vuelve a aplicar:
kubectl apply -f $PWD/semana-02-deployments/1.ejemplos/01-primer-deployment-replicas.yaml
kubectl get deployments -l app=cafecito
🧹 Limpieza rápida del Lab 1
kubectl delete -f $PWD/semana-02-deployments/1.ejemplos/01-primer-deployment-replicas.yaml
🔄 Semana 02 • Lab 2: Rolling Update Cero Caídas y Rollback en 3 Segundos
🔄 Laboratorio 2: Rolling Update Cero Caídas y Rollback
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-02-deployments/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎯 Objetivo del Laboratorio
Desplegar una API de pedidos con estrategia RollingUpdate (maxSurge: 1, maxUnavailable: 0) y readinessProbe, actualizarla en caliente de v1.0 a v2.0 sin interrumpir el servicio, provocar un fallo intencional (ImagePullBackOff) y revertirlo en segundos con kubectl rollout undo.
📄 Manifiesto: 02-rolling-update-cero-caidas.yaml
Ubicación en el repositorio:
📂 semana-02-deployments/1.ejemplos/02-rolling-update-cero-caidas.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: api-pedidos-rolling
labels:
app: api-pedidos
spec:
replicas: 4
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1 # Máximo de Pods extra permitidos durante el cambio (5 Pods temporalmente)
maxUnavailable: 0 # 0 Pods apagados; garantiza 100% de disponibilidad continua
selector:
matchLabels:
app: api-pedidos
template:
metadata:
labels:
app: api-pedidos
version: "v1.0"
spec:
containers:
- name: api
image: python:3.12-alpine
env:
- name: VERSION
value: "v1.0"
command: ["sh", "-c"]
args:
- |
python -c '
import http.server, socketserver, os
class Handler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
version = os.environ.get("VERSION", "v1.0")
self.send_response(200)
self.send_header("Content-type", "application/json")
self.end_headers()
body = f"{{\"mensaje\":\"KubeCafe API {version} - Origen Huila\",\"estado\":\"sirviendo\"}}\n"
self.wfile.write(body.encode("utf-8"))
with socketserver.TCPServer(("", 8080), Handler) as httpd:
httpd.serve_forever()
'
ports:
- containerPort: 8080
name: api-port
readinessProbe:
httpGet:
path: /
port: 8080
initialDelaySeconds: 2
periodSeconds: 3
resources:
requests:
cpu: "50m"
memory: "64Mi"
limits:
cpu: "150m"
memory: "128Mi"
🛠️ Paso a Paso en Terminal
Paso 1: Desplegar la versión v1.0
kubectl apply -f $PWD/semana-02-deployments/1.ejemplos/02-rolling-update-cero-caidas.yaml
# Monitorear estado en vivo hasta que los 4 Pods estén listos
kubectl rollout status deployment/api-pedidos-rolling
Paso 2: Actualizar a v2.0 en caliente (Zero Downtime)
# Cambiar la variable VERSION en el Deployment
kubectl set env deployment/api-pedidos-rolling VERSION=v2.0
# Observar cómo Kubernetes reemplaza los Pods uno a uno sin apagar el servicio
kubectl rollout status deployment/api-pedidos-rolling
# Consultar el historial de revisiones
kubectl rollout history deployment/api-pedidos-rolling
💡 ¿Por qué no hubo caída?
Gracias amaxUnavailable: 0y alreadinessProbe, Kubernetes primero espera a que el nuevo Podv2.0responda HTTP200en:8080antes de apagar uno de los Podsv1.0.
🚨 Paso 3: Botón de Pánico (Rollback en 3 Segundos)
Simulemos un despliegue roto usando una imagen que no existe:
# Provocar fallo intencional
kubectl set image deployment/api-pedidos-rolling api=python:version-fantasma-999
# Observar cómo el rollout se bloquea pero los 4 Pods viejos siguen vivos (cero caídas)
kubectl rollout status deployment/api-pedidos-rolling --timeout=15s
kubectl get pods -l app=api-pedidos
Verás que el nuevo Pod queda en ImagePullBackOff / ErrImagePull, mientras tus 4 Pods anteriores siguen sirviendo tráfico.
Ahora ejecuta el Rollback inmediato a la última revisión estable:
kubectl rollout undo deployment/api-pedidos-rolling
kubectl rollout status deployment/api-pedidos-rolling
🧹 Limpieza rápida del Lab 2
kubectl delete -f $PWD/semana-02-deployments/1.ejemplos/02-rolling-update-cero-caidas.yaml
🔄 Semana 02 • Lab 3: Estrategia Recreate y Estándar de Producción
🛡️ Laboratorio 3: Estrategia Recreate y Estándar de Producción
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-02-deployments/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎯 Objetivo del Laboratorio
- Comprender cuándo y cómo usar la estrategia
Recreate(apagado total previo). - Desplegar un estándar profesional de producción con usuario sin privilegios (
runAsNonRoot),requests/limits,livenessProbe,readinessProbeyrevisionHistoryLimit.
🧹 Parte 1: Estrategia Recreate (03-estrategia-recreate.yaml)
Ideal cuando dos versiones no pueden coexistir (por ejemplo, migraciones de base de datos o volúmenes exclusivos ReadWriteOnce). En KubeCafé equivale a cerrar temporalmente el salón para cambiar toda la tubería.
Ubicación: 📂 semana-02-deployments/1.ejemplos/03-estrategia-recreate.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: batch-procesador-recreate
labels:
app: batch-procesador
spec:
replicas: 2
strategy:
type: Recreate # Apaga la versión anterior al 100% antes de encender la nueva
selector:
matchLabels:
app: batch-procesador
template:
metadata:
labels:
app: batch-procesador
version: "v1.0"
spec:
containers:
- name: worker
image: busybox:latest
command: ["sh", "-c", "echo 'Procesando pedidos v1.0...' && sleep 3600"]
resources:
requests:
cpu: "30m"
memory: "32Mi"
limits:
cpu: "100m"
memory: "64Mi"
Pruébalo en vivo:
kubectl apply -f $PWD/semana-02-deployments/1.ejemplos/03-estrategia-recreate.yaml
kubectl get pods -l app=batch-procesador
# Actualiza la imagen y observa cómo terminan primero las 2 réplicas antes de nacer las nuevas
kubectl set image deployment/batch-procesador-recreate worker=busybox:1.36
kubectl get pods -l app=batch-procesador -w
🛡️ Parte 2: Estándar de Producción (04-deployment-con-recursos-y-probes.yaml)
Este manifiesto (portal-clientes-prod) combina seguridad rootless (UID 10001), límites de CPU/RAM, variables de entorno y sondas HTTP (livenessProbe y readinessProbe).
Ubicación: 📂 semana-02-deployments/1.ejemplos/04-deployment-con-recursos-y-probes.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: portal-clientes-prod
labels:
app: portal-clientes
tier: frontend
version: "v1.0"
spec:
replicas: 3
revisionHistoryLimit: 10
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
selector:
matchLabels:
app: portal-clientes
tier: frontend
template:
metadata:
labels:
app: portal-clientes
tier: frontend
version: "v1.0"
spec:
securityContext:
runAsNonRoot: true
runAsUser: 10001
runAsGroup: 10001
containers:
- name: web
image: nginxinc/nginx-unprivileged:alpine
ports:
- containerPort: 8080
name: http
env:
- name: ENTORNO
value: "produccion"
- name: SUCURSAL
value: "KubeCafe-Medellin-Poblado"
resources:
requests:
cpu: "50m"
memory: "64Mi"
limits:
cpu: "250m"
memory: "128Mi"
livenessProbe:
httpGet:
path: /
port: 8080
initialDelaySeconds: 5
periodSeconds: 10
timeoutSeconds: 2
failureThreshold: 3
readinessProbe:
httpGet:
path: /
port: 8080
initialDelaySeconds: 3
periodSeconds: 5
timeoutSeconds: 2
successThreshold: 1
failureThreshold: 2
Despliega y verifica seguridad + tráfico:
kubectl apply -f $PWD/semana-02-deployments/1.ejemplos/04-deployment-con-recursos-y-probes.yaml
kubectl get pods -l app=portal-clientes
# Comprobar que el contenedor NO corre como root (uid=10001)
kubectl exec deployment/portal-clientes-prod -- id
# Abrir túnel local hacia el puerto 8080 del portal
kubectl port-forward deployment/portal-clientes-prod 8080:8080
Abre http://localhost:8080 en tu navegador (o usa curl http://localhost:8080) para confirmar que Nginx unprivileged responde correctamente.
🧹 Limpieza rápida del Lab 3
kubectl delete -f $PWD/semana-02-deployments/1.ejemplos/03-estrategia-recreate.yaml
kubectl delete -f $PWD/semana-02-deployments/1.ejemplos/04-deployment-con-recursos-y-probes.yaml
🔄 Semana 02 • Lab 4: Barista IA — Microservicio de Inferencia Escalable
🤖 Laboratorio 4: Barista IA — Inferencia Escalable
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-02-deployments/1.ejemplos
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎯 Objetivo del Laboratorio
Desplegar un microservicio de recomendación de café con IA (barista-ia) que devuelve respuestas JSON con latencia e identificador del Pod que atendió la petición, probarlo mediante kubectl port-forward y escalarlo horizontalmente.
📄 Manifiesto: 05-deployment-ia-inferencia.yaml
Ubicación en el repositorio:
📂 semana-02-deployments/1.ejemplos/05-deployment-ia-inferencia.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
name: barista-ia
labels:
app: barista-ia
servicio: inferencia
spec:
replicas: 2
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
selector:
matchLabels:
app: barista-ia
template:
metadata:
labels:
app: barista-ia
servicio: inferencia
version: "v1.0"
spec:
containers:
- name: api-ia
image: python:3.12-alpine
command: ["sh", "-c"]
args:
- |
python -c '
import http.server, socketserver, json, time, os, random
RECOMMENDATIONS = [
"Te recomiendo un Espresso doble con granos de origen Huila (tueste medio).",
"Para esta tarde va perfecto un Cold Brew con notas cítricas y panela.",
"Prueba un Cappuccino con leche texturizada a 65°C y café de Jericó.",
"Nuestra recomendación de hoy: Filtrado V60 con café Geisha de Fredonia."
]
class AIHandler(http.server.SimpleHTTPRequestHandler):
def do_GET(self):
self.send_response(200)
self.send_header("Content-type", "application/json; charset=utf-8")
self.end_headers()
response = {
"modelo": "KubeCafe-Barista-AI-v1",
"pod": os.environ.get("HOSTNAME", "desconocido"),
"recomendacion": random.choice(RECOMMENDATIONS),
"latencia_inferencia_ms": round(random.uniform(12.5, 35.8), 2),
"timestamp": time.time()
}
self.wfile.write(json.dumps(response, ensure_ascii=False).encode("utf-8") + b"\n")
with socketserver.TCPServer(("", 8080), AIHandler) as httpd:
print("Barista IA escuchando en el puerto 8080...")
httpd.serve_forever()
'
ports:
- containerPort: 8080
name: http-ia
resources:
requests:
cpu: "60m"
memory: "64Mi"
limits:
cpu: "250m"
memory: "128Mi"
readinessProbe:
httpGet:
path: /
port: 8080
initialDelaySeconds: 2
periodSeconds: 4
🛠️ Paso a Paso en Terminal
Paso 1: Desplegar el Barista IA
kubectl apply -f $PWD/semana-02-deployments/1.ejemplos/05-deployment-ia-inferencia.yaml
kubectl rollout status deployment/barista-ia
Paso 2: Abrir túnel y probar recomendaciones JSON
# En una terminal abre el port-forward
kubectl port-forward deployment/barista-ia 8080:8080
En otra terminal (o en tu navegador):
curl http://localhost:8080/
Respuesta esperada:
{
"modelo": "KubeCafe-Barista-AI-v1",
"pod": "barista-ia-5f8cb47d9f-x9j2",
"recomendacion": "Te recomiendo un Espresso doble con granos de origen Huila (tueste medio).",
"latencia_inferencia_ms": 18.4,
"timestamp": 1793836800.0
}
Paso 3: Escalar horizontalmente para alta demanda
kubectl scale deployment barista-ia --replicas=5
kubectl get pods -l app=barista-ia
🧹 Limpieza de todos los laboratorios de la Semana 02
kubectl delete -f $PWD/semana-02-deployments/1.ejemplos/
🔄 Semana 02 • Retos: Los 4 Retos Rotos de Deployments (+40 XP)
💥 Los 4 Retos Rotos de la Semana 02
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio del Taller: Fundamentos-Kubernetes / semana-02-deployments/2.reto-roto
- Guía de Contribución: CONTRIBUTING.md
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
En este módulo te enfrentarás a 4 incidentes reales de Deployments en Kubernetes. Cada archivo contiene fallos a propósito para que entrenes tus habilidades de diagnóstico y acumules +40 XP en el ranking oficial.
| # | Archivo del Reto | Nivel | Error / Síntoma Principal | XP |
|---|---|---|---|---|
| 01 | 01-deployment-selector-roto.yaml | 🟢 Principiante | matchLabels no coincide con template.metadata.labels. | +10 XP |
| 02 | 02-deployment-imagen-caida-rollback.yaml | 🟡 Intermedio | Imagen inexistente que causa ImagePullBackOff y bloquea el rollout (0/3 READY). | +10 XP |
| 03 | 03-deployment-estrategia-invalida.yaml | 🟡 Intermedio | Typo en el valor de la estrategia y parámetros fuera del bloque rollingUpdate. | +10 XP |
| 04 | 04-deployment-yaml-identacion.yaml | 🔴 Ninja | apiVersion obsoleto (v1) e indentación rota en el bloque template.spec. | +10 XP |
🧪 Comandos para probar y diagnosticar los 4 Retos Rotos
# Reto 01: Selector Roto
kubectl apply -f $PWD/semana-02-deployments/2.reto-roto/01-deployment-selector-roto.yaml
# Reto 02: Imagen Caída / ImagePullBackOff
kubectl apply -f $PWD/semana-02-deployments/2.reto-roto/02-deployment-imagen-caida-rollback.yaml
kubectl get deployments,replicasets,pods
kubectl describe deployment <nombre-del-deployment>
# Reto 03: Estrategia Inválida
kubectl apply -f $PWD/semana-02-deployments/2.reto-roto/03-deployment-estrategia-invalida.yaml
# Reto 04: Error de Indentación YAML y apiVersion
kubectl apply -f $PWD/semana-02-deployments/2.reto-roto/04-deployment-yaml-identacion.yaml
Herramientas clave de diagnóstico:
kubectl get deployments,replicasets,podskubectl describe deployment <nombre>(revisa losEventsyConditions)kubectl rollout status deployment <nombre>kubectl explain deployment.spec.strategy --recursive
🏆 ¿Cómo entregar tus soluciones y ganar +40 XP?
- Copia los 4 archivos a tu carpeta personal dentro de tu fork del repositorio:
mkdir -p aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-02 cp $PWD/semana-02-deployments/2.reto-roto/*.yaml aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-02/ - Corrige cada archivo dentro de
aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-02/manteniendo los nombres exactos y agregando comentarios#explicando cuál era el error y cómo lo solucionaste. - Valida que todos apliquen limpio en tu clúster local antes de subirlos:
kubectl apply -f aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-02/ kubectl get deployments - Envía tu Pull Request a la rama
mainde Fundamentos-Kubernetes.
Al aprobarse, el sistema evaluará tus manifiestos, sumará +40 XP enASISTENTES.mdy actualizará automáticamente tu Portafolio Profesional y tu Tarjeta PNG para LinkedIn.
🌐 Semana 03 • Conceptos: Services, EndpointSlices, CoreDNS y Cilium Gateway API
🌐 Semana 03: Conectando Todo — Services, CoreDNS y Cilium Gateway API
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio Oficial: Fundamentos-Kubernetes en GitHub
- Panel Interactivo 360°: Abrir en el Navegador
🎯 Objetivo de la Semana 03
En la Semana 02 vimos cómo un Deployment crea y reemplaza Pods automáticamente (Self-Healing y Rolling Updates). Pero eso trae un problema: cada Pod nuevo nace con una IP diferente.
En esta semana aprenderás cómo darles conectividad estable a tus aplicaciones:
- Services (
ClusterIPyNodePort): IP virtual y puerto estables frente a Pods efímeros. - EndpointSlices: La lista dinámica de IPs de Pods sanos detrás de un Service.
- CoreDNS: Cómo los Pods se encuentran por nombre (
cocina-svc) sin memorizar IPs. - Cilium Gateway API (
Gateway+HTTPRoute): El estándar moderno de enrutamiento HTTP/HTTPS que reemplaza al antiguoIngress.
☕ Analogía en KubeCafé
| Concepto Kubernetes | Analogía en KubeCafé | Función |
|---|---|---|
| Pod (IP efímera) | Mesa de Barismo | Cambia de ubicación/IP si un barista se reemplaza. |
Service (ClusterIP) | Mesero Interno | Punto fijo interno: siempre responde en la misma IP virtual. |
Service (NodePort) | Ventanilla en la Calle (:30080) | Expone un puerto fijo en todos los Worker Nodes (30000–32767). |
| EndpointSlices | Libreta del Mesero | Lista actualizada de qué baristas están sanos (Ready) y atendiendo. |
| CoreDNS | Directorio Telefónico | Traduce cocina-svc a la IP del Service automáticamente. |
| Gateway (Cilium) | Puerta Principal | Único punto de entrada HTTP/HTTPS al clúster. |
| HTTPRoute | Recepcionista | Lee la ruta (/cocina, /menu) y envía al Service correcto. |
📚 Documentación Oficial de Referencia
🌐 Semana 03 • Lab 1: Service ClusterIP Interno y EndpointSlices
🤵 Laboratorio 1: Service ClusterIP Interno y EndpointSlices
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
📦 Paso 0: Prepara el repositorio
# 1. Clonar el repositorio oficial del workshop
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
# 2. Entrar a la raíz del repositorio
cd Fundamentos-Kubernetes
🚀 Paso 1: Despliega la cocina y su Service interno
kubectl apply -f semana-03-services-gateway/1.ejemplos/01-service-clusterip-interno.yaml
🔍 Paso 2: Verifica el Service, sus Endpoints y EndpointSlices
kubectl get svc cocina-svc
kubectl get endpoints cocina-svc
kubectl get endpointslices -l kubernetes.io/service-name=cocina-svc
kubectl get pods -l app=kubecafe-cocina -o wide
💡 Las IPs en
EndpointsyEndpointSlicescoinciden con las de los 2 Pods. Si borras un Pod, Kubernetes actualiza la lista automáticamente sin cambiar la IP decocina-svc.
🌐 Semana 03 • Lab 2: Service NodePort Externo (:30080)
🔌 Laboratorio 2: Service NodePort Externo (:30080)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
📦 Paso 0: Asegúrate de estar en la raíz del repositorio
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
🚀 Paso 1: Despliega el menú web y el Service NodePort
kubectl apply -f semana-03-services-gateway/1.ejemplos/02-service-nodeport-externo.yaml
kubectl get svc menu-nodeport-svc
🔍 Paso 2: Prueba desde cada Nodo con curl
# 1. Ver las IPs internas de todos los nodos (control-plane y workers)
kubectl get nodes -o wide
# 2. Probar todos los nodos automáticamente en el puerto 30080:
for ip in $(kubectl get nodes -o jsonpath='{.items[*].status.addresses[?(@.type=="InternalIP")].address}'); do
echo "Probando nodo $ip:30080..."
curl -s -o /dev/null -w "HTTP %{http_code}\n" http://$ip:30080
done
(En Kind/Docker Desktop en macOS/Windows: kubectl port-forward svc/menu-nodeport-svc 8081:80 y abre http://localhost:8081).
🌐 Semana 03 • Lab 3: Descubrimiento DNS con CoreDNS (FQDNs)
📡 Laboratorio 3: Descubrimiento DNS con CoreDNS (Cross-Namespace)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
📦 Paso 0: Asegúrate de estar en la raíz del repositorio
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
🚀 Paso 1: Despliega el Pod cliente en otro Namespace (kubecafe-salon)
kubectl apply -f semana-03-services-gateway/1.ejemplos/03-dns-interno-coredns.yaml
kubectl wait --for=condition=Ready pod/mesero-tester -n kubecafe-salon --timeout=60s
🔍 Paso 2: Prueba la resolución DNS y los FQDNs
# 0. Inspecciona la configuración DNS inyectada por CoreDNS:
kubectl exec -n kubecafe-salon mesero-tester -- cat /etc/resolv.conf
# 1. Nombre corto falla porque está en otro namespace:
kubectl exec -n kubecafe-salon mesero-tester -- nslookup cocina-svc || echo "Falla sin namespace"
# 2. Con <service>.<namespace>:
kubectl exec -n kubecafe-salon mesero-tester -- curl -i http://cocina-svc.default
# 3. Con <service>.<namespace>.svc:
kubectl exec -n kubecafe-salon mesero-tester -- curl -i http://cocina-svc.default.svc
# 4. Con el FQDN completo:
kubectl exec -n kubecafe-salon mesero-tester -- curl -i http://cocina-svc.default.svc.cluster.local
🌐 Semana 03 • Lab 4: Modo Imperativo Paso a Paso
⚡ Laboratorio 4: Modo Imperativo Paso a Paso (Sin escribir YAML)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Practica crear Services y probar FQDNs usando solo comandos imperativos:
# 1. Crear Deployment
kubectl create deployment cocina-imp --image=nginx:alpine --replicas=2 --port=80
# 2. Exponer como ClusterIP y NodePort
kubectl expose deployment cocina-imp --name=cocina-imp-svc --port=80 --target-port=80 --type=ClusterIP
kubectl expose deployment cocina-imp --name=cocina-imp-nodeport --port=80 --target-port=80 --type=NodePort
kubectl get svc cocina-imp-svc cocina-imp-nodeport
# 3. Probar FQDN desde otro Namespace con un Pod temporal
kubectl create namespace salon-imp
kubectl run tester-imp -n salon-imp --image=curlimages/curl:8.10.1 --rm -it --restart=Never -- \
sh -c "curl -s -o /dev/null -w '%{http_code}\n' http://cocina-imp-svc.default.svc.cluster.local"
# 4. Limpiar
kubectl delete svc cocina-imp-svc cocina-imp-nodeport --ignore-not-found
kubectl delete deployment cocina-imp --ignore-not-found
kubectl delete namespace salon-imp --ignore-not-found
🌐 Semana 03 • Lab 5: Integrador Frontend (NodePort) ➔ Backend (ClusterIP)
🔗 Laboratorio 5 (Integrador): Frontend (NodePort) ➔ Backend (ClusterIP + FQDN)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
📦 Paso 0: Asegúrate de estar en la raíz del repositorio
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
🚀 Paso 1: Aplica el manifiesto integrador
kubectl apply -f semana-03-services-gateway/1.ejemplos/05-frontend-nodeport-backend-clusterip.yaml
kubectl get svc api-backend-svc web-frontend-svc
kubectl get endpointslices -l 'kubernetes.io/service-name in (api-backend-svc, web-frontend-svc)'
🔍 Paso 2: Prueba el balanceo entre las 3 réplicas del Backend
NODE_IP=$(kubectl get nodes -o jsonpath='{.items[0].status.addresses[?(@.type=="InternalIP")].address}')
for i in {1..6}; do
curl -s http://$NODE_IP:30090/api
done
🌐 Semana 03 • Lab 6: Canary Deployment con solo Service (75% / 25%)
🐤 Laboratorio 6: Canary Deployment con solo Service (75% v1 / 25% v2)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
📦 Paso 0: Asegúrate de estar en la raíz del repositorio
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
🚀 Paso 1: Aplica ambos Deployments y el Service compartido
kubectl apply -f semana-03-services-gateway/1.ejemplos/06-canary-solo-service.yaml
kubectl get pods -l app=barista --show-labels
kubectl get endpointslices -l kubernetes.io/service-name=barista-canary-svc
🔍 Paso 2: Prueba el reparto de tráfico
kubectl run canary-tester --image=curlimages/curl:8.10.1 --rm -it --restart=Never -- \
sh -c 'for i in $(seq 1 12); do curl -s http://barista-canary-svc; done'
🌐 Semana 03 • Lab 7: Service LoadBalancer con Cilium (IPPool + L2)
⚖️ Laboratorio 7: Service LoadBalancer con Cilium (IPPool + L2 Announcements)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
En un clúster propio o en iximiuz Kubernetes Cluster Playground (red 172.16.0.0/24 sobre eth0), un Service de tipo LoadBalancer queda en <pending> a menos que un controlador asigne IPs. Cilium asigna IPs de un rango y las anuncia por ARP en la red local.
🗺️ Diagrama de Componentes
🧩 ¿Qué hace cada recurso?
CiliumLoadBalancerIPPool(10a): Define la "caja de IPs disponibles" (172.16.0.200a172.16.0.240).CiliumL2AnnouncementPolicy(10a): Le dice a Cilium en qué interfaz (eth0) debe anunciar esas IPs por ARP ("yo tengo esta IP").Deployment(10b): Crea 2 Pods con una página web KubeCafé UTF-8 que muestra qué Pod responde ($HOSTNAME).Service LoadBalancer(10b): Toma unaEXTERNAL-IPdel Pool y reparte el tráfico entre los 2 Pods (allocateLoadBalancerNodePorts: falseevita abrir unNodePortextra).
Paso 1: Verifica y habilita L2 Announcements en Cilium
cilium config view | grep -E "enable-l2-announcements|l2-pod-announcements"
helm repo add cilium https://helm.cilium.io/ && helm repo update
helm upgrade cilium cilium/cilium --namespace kube-system --reuse-values \
--set l2announcements.enabled=true --set externalIPs.enabled=true
kubectl -n kube-system rollout restart deployment/cilium-operator daemonset/cilium
cilium status --wait
Paso 2: Aplica primero la configuración de Cilium (10a) y luego la App (10b)
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
kubectl apply -f semana-03-services-gateway/1.ejemplos/10a-cilium-ippool-l2.yaml
kubectl apply -f semana-03-services-gateway/1.ejemplos/10b-service-loadbalancer-app.yaml
kubectl get ciliumloadbalancerippool,ciliuml2announcementpolicy
kubectl get svc kubecafe-lb-svc
Paso 3: Prueba en terminal y en navegador externo (Contenedor Firefox :3000)
LB_IP=$(kubectl get svc kubecafe-lb-svc -o jsonpath='{.status.loadBalancer.ingress[0].ip}')
echo "IP del LoadBalancer: $LB_IP"
# Verificar cabeceras HTTP 200 OK:
curl -I http://$LB_IP
# Probar 6 peticiones seguidas viendo el balanceo entre Pods:
for i in $(seq 1 6); do
printf "Petición %d -> " "$i"
curl -s http://$LB_IP | grep -o "kubecafe-lb-app-[a-z0-9-]*"
done
# Navegador gráfico dentro de iximiuz:
docker run -d --name firefox -p 3000:3000 --shm-size="1gb" lscr.io/linuxserver/firefox:latest
💡 Respuesta esperada: Verás
HTTP/1.1 200 OKencurl -Iy 6 líneas alternando entre los 2 Podskubecafe-lb-app-.... En Expose HTTP(S) Ports eligedev-machine, puerto3000, haz clic en EXPOSE y abrehttp://172.16.0.200.
🌐 Semana 03 • Lab 8: Cilium Gateway API (Gateway y HTTPRoute)
🏛️ Laboratorio 8: Enrutamiento HTTP Moderno con Gateway API (Cilium)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Este laboratorio utiliza Cilium (el CNI del clúster) como controlador nativo de Kubernetes Gateway API (gatewayClassName: cilium), separando la puerta de entrada (Gateway) de las reglas de enrutamiento (HTTPRoute).
🗺️ Diagrama Simplificado de Componentes
📦 Paso 0: Asegúrate de estar en la raíz del repositorio
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
🛠️ Paso 1: Instalar CRDs de Gateway API (v1.6.3) y habilitar Cilium Gateway API
- Instala los 7 CRDs requeridos de Kubernetes Gateway API v1.6.3 (
--server-side) y los 3 opcionales:
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_gatewayclasses.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_gateways.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_httproutes.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_referencegrants.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_grpcroutes.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_backendtlspolicies.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_tlsroutes.yaml
# CRDs opcionales (ListenerSet, TCPRoute y UDPRoute):
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_listenersets.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_tcproutes.yaml
kubectl apply --server-side -f https://raw.githubusercontent.com/kubernetes-sigs/gateway-api/v1.6.3/config/crd/standard/gateway.networking.k8s.io_udproutes.yaml
- Habilita
kubeProxyReplacement=trueygatewayAPI.enabled=trueen Cilium y verifica que todo quedeOK:
helm repo add cilium https://helm.cilium.io/
helm repo update
helm upgrade cilium cilium/cilium \
--namespace kube-system \
--reuse-values \
--set kubeProxyReplacement=true \
--set gatewayAPI.enabled=true
kubectl -n kube-system rollout restart deployment/cilium-operator
kubectl -n kube-system rollout restart ds/cilium
cilium status --wait
kubectl get gatewayclass cilium
💡 Resultado esperado:
ciliumdebe aparecer conACCEPTED: True.
🚀 Paso 2: Asegura los Services base (Lab 1 y Lab 2) y aplica el Gateway + HTTPRoute
kubectl apply -f semana-03-services-gateway/1.ejemplos/01-service-clusterip-interno.yaml
kubectl apply -f semana-03-services-gateway/1.ejemplos/02-service-nodeport-externo.yaml
kubectl apply -f semana-03-services-gateway/1.ejemplos/04-gateway-api-httproute.yaml
kubectl get deploy,svc,gateway,httproute
🔍 Paso 3: Probar las rutas /cocina y /menu
GW_IP=$(kubectl get gateway kubecafe-gateway -o jsonpath='{.status.addresses[0].value}')
echo "Gateway IP: $GW_IP"
curl -I http://$GW_IP/cocina
curl -I http://$GW_IP/menu
💡 Respuesta esperada: Ambos devuelven
HTTP/1.1 200 OK.
🖥️ Visualizar en navegador externo (Contenedor Firefox :3000)
Si aún no tienes corriendo el contenedor Firefox en dev-machine:
docker run -d --name firefox -p 3000:3000 --shm-size="1gb" lscr.io/linuxserver/firefox:latest
Abre Expose HTTP(S) Ports en iximiuz (dev-machine, puerto 3000), haz clic en EXPOSE y entra a:
http://<GW_IP>/cocinahttp://<GW_IP>/menu
🧭 Paso 4: Más ejemplos de HTTPRoute (Hostnames, Headers y Canary por Peso)
- Enrutamiento por dominio (
hostnames):
kubectl apply -f semana-03-services-gateway/1.ejemplos/04b-httproute-por-dominio.yaml
curl -s -H "Host: cocina.kubecafe.local" http://$GW_IP/ | grep -o "Cocina KubeCafé\|kubecafe-cocina-[a-z0-9-]*"
💡 Respuesta esperada: Verás
Cocina KubeCaféy el Podkubecafe-cocina-....
- Enrutamiento por
headers(X-Env: beta):
kubectl apply -f semana-03-services-gateway/1.ejemplos/04c-httproute-por-header.yaml
curl -s http://$GW_IP/beta | grep -o "Cocina KubeCafé\|Menú KubeCafé"
curl -s -H "X-Env: beta" http://$GW_IP/beta | grep -o "Cocina KubeCafé\|Menú KubeCafé"
💡 Respuesta esperada: Sin header devuelve
Cocina KubeCafé; con-H "X-Env: beta"devuelveMenú KubeCafé.
- División de tráfico por pesos (
weight: 80/weight: 20):
kubectl apply -f semana-03-services-gateway/1.ejemplos/04d-httproute-canary-peso.yaml
for i in $(seq 1 10); do
printf "Petición %2d -> " "$i"
curl -s http://$GW_IP/peso | grep -o "Cocina KubeCafé\|Menú KubeCafé"
done
💡 Respuesta esperada: ~8 respuestas
Cocina KubeCaféy ~2 respuestasMenú KubeCafé.
🌐 Semana 03 • Lab 9: Canary Deployment con Gateway API (80% / 20%)
🚦 Laboratorio 9: Canary con Gateway API (80% / 20%) + Monitor Visual
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
A diferencia del Laboratorio 6 (donde el porcentaje dependía del número de Pods detrás de un mismo Service), con Gateway API controlas el porcentaje exacto (weight: 80 / weight: 20) en el HTTPRoute sin importar cuántas réplicas tenga cada Deployment.
🗺️ Diagrama de Componentes
Paso 1: Aplica el manifiesto y prueba por CLI
cd Fundamentos-Kubernetes
kubectl apply -f semana-03-services-gateway/1.ejemplos/07-gateway-canary-deployment.yaml
kubectl get httproute menu-canary-route
GW_IP=$(kubectl get gateway kubecafe-gateway -o jsonpath='{.status.addresses[0].value}')
echo "Gateway IP: $GW_IP"
for i in $(seq 1 10); do
curl -s http://$GW_IP/canary
done
💡 Observa: Alrededor de 8 respuestas dirán
Menu v1.0 (Estable - 80%)y 2 diránMenu v2.0 (Canary - 20%). Para pasar el 100% del tráfico av2, solo cambiaweight: 0enmenu-v1-svcyweight: 100enmenu-v2-svc.
Paso 2: Visualizar en navegador externo (Contenedor Firefox :3000)
Si aún no tienes corriendo el contenedor Firefox en dev-machine:
docker run -d --name firefox -p 3000:3000 --shm-size="1gb" lscr.io/linuxserver/firefox:latest
Abre Expose HTTP(S) Ports en iximiuz (dev-machine, puerto 3000), haz clic en EXPOSE y entra a:
http://<GW_IP>/canary-ui
🌐 Semana 03 • Lab 10: AI Gateway Multi-Modelo con Ollama
🤖 Laboratorio 10: AI Gateway con Ollama (/ia/rapido, /ia/avanzado, /ia/auto)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
En este laboratorio montas un AI Gateway en Kubernetes: un único punto de entrada (Gateway + HTTPRoute) donde un mismo Frontend web (ia-frontend-svc) consume dos backends de IA distintos en el puerto estándar de Ollama (:11434).
🗺️ Diagrama de Componentes
💡 ¿Por qué usar un AI Gateway? Te permite cambiar de modelo, hacer A/B testing con
weight, o enrutar por header sin modificar el código del Frontend.
Paso 1: Aplica el Frontend, los 2 Modelos y el HTTPRoute
cd Fundamentos-Kubernetes
kubectl apply -f semana-03-services-gateway/1.ejemplos/08-gateway-ia-ollama-modelos.yaml
kubectl get svc ia-frontend-svc ollama-llama-svc ollama-gemma-svc
kubectl get httproute kubecafe-ia-route
Paso 2: Prueba ambos modelos desde terminal
GW_IP=$(kubectl get gateway kubecafe-gateway -o jsonpath='{.status.addresses[0].value}')
echo "Gateway IP: $GW_IP"
curl -s http://$GW_IP/ia/rapido
curl -s http://$GW_IP/ia/avanzado
curl -s http://$GW_IP/ia/auto
Paso 3: Visualizar en navegador externo (Contenedor Firefox :3000)
Si aún no tienes corriendo el contenedor Firefox en dev-machine:
docker run -d --name firefox -p 3000:3000 --shm-size="1gb" lscr.io/linuxserver/firefox:latest
Abre Expose HTTP(S) Ports en iximiuz (dev-machine, puerto 3000), haz clic en EXPOSE y entra a:
http://<GW_IP>/
(Verás los botones del selector de modelos para probar /ia/rapido, /ia/avanzado y /ia/auto directamente desde la web).
🌐 Semana 03 • Bonus: Gateway API Inference Extension (CPU) + Chat Web
🌟 Bonus Lab: Gateway API Inference Extension (CPU) + Chat Web (/chat)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Gateway API Inference Extension (InferencePool + InferenceModel) es la extensión oficial de Kubernetes para servir LLMs. Todo este laboratorio corre 100% en CPU con el modelo ligero qwen2.5:0.5b (~390 MB) y expone el endpoint OpenAI-compatible (/v1/chat/completions) más una interfaz web de chat (/chat).
📚 Referencias Oficiales:
🗺️ Diagrama de Componentes
- Sin errores de CORS: Tanto
/chatcomo/v1/chat/completionsentran por el mismokubecafe-gateway. - CRDs (
09a) +Service(09): Los CRDs declaran elInferencePoolyInferenceModel, mientras elServicekubecafe-llm-poolconecta la red de Cilium hacia los Pods de Ollama.
Paso 1: Instala los CRDs locales y despliega Ollama + InferencePool + HTTPRoute
cd Fundamentos-Kubernetes
# 1. Instalar los CRDs locales (100% offline, sin errores 404):
kubectl apply -f semana-03-services-gateway/1.ejemplos/09a-crds-inference-extension.yaml
kubectl get crd | grep inference
# 2. Desplegar Ollama CPU Pool, InferencePool, InferenceModel, Service y HTTPRoute:
kubectl apply -f semana-03-services-gateway/1.ejemplos/09-bonus-gateway-inference-extension.yaml
kubectl get inferencepool,inferencemodel,httproute
kubectl get svc kubecafe-llm-pool
Paso 2: Descarga qwen2.5:0.5b en los Pods y prueba /v1/chat/completions
# 1. Esperar a que los Pods estén Ready:
kubectl wait --for=condition=ready pod -l app=ollama-cpu --timeout=90s
# 2. Descargar el modelo en ambos Pods:
PODS=$(kubectl get pods -l app=ollama-cpu -o jsonpath='{.items[*].metadata.name}')
for pod in $PODS; do
echo "Descargando modelo qwen2.5:0.5b en $pod..."
kubectl exec $pod -- ollama pull qwen2.5:0.5b
done
# 3. Enviar petición OpenAI-compatible (usa -s cuando uses | jq):
GW_IP=$(kubectl get gateway kubecafe-gateway -o jsonpath='{.status.addresses[0].value}')
curl -s http://$GW_IP/v1/chat/completions \
-H "Content-Type: application/json" \
-d '{"model":"qwen2.5:0.5b","messages":[{"role":"user","content":"Explica Kubernetes en 1 frase"}]}' | jq
Paso 3: Despliega el Frontend Web (/chat) conectado al Gateway
kubectl apply -f semana-03-services-gateway/1.ejemplos/09b-frontend-inference-chat.yaml
kubectl get httproute kubecafe-chat-ui-route
echo "Gateway IP: $GW_IP"
Paso 4: Visualizar en navegador externo (Contenedor Firefox :3000)
Si aún no tienes corriendo el contenedor Firefox en dev-machine:
docker run -d --name firefox -p 3000:3000 --shm-size="1gb" lscr.io/linuxserver/firefox:latest
Abre Expose HTTP(S) Ports en iximiuz (dev-machine, puerto 3000), haz clic en EXPOSE y entra a:
http://<GW_IP>/chat
(Chatea en vivo con qwen2.5:0.5b corriendo en CPU a través de Cilium Gateway API).
🌐 Semana 03 • Retos: Los 4 Retos Rotos de Redes y Gateway API (+40 XP)
💥 Los 4 Retos Rotos de la Semana 03 (+40 XP)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Cada archivo en semana-03-services-gateway/2.reto-roto/ tiene un fallo real de producción. Diagnostícalos, repáralos y sube tus soluciones a aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-03/.
01-service-selector-roto.yaml: El Service tiene0EndpointSlices (spec.selectorvslabels).02-service-targetport-incorrecto.yaml: Connection refused (targetPortvscontainerPort).03-nodeport-fuera-de-rango.yaml:nodePortfuera del rango30000–32767.04-httproute-parentref-roto.yaml:parentRefsapunta a unGatewayinexistente.
📔 ¡Suma +10 XP extra con tu Bitácora Semanal!
Registra tu aprendizaje en el Formulario de Bitácora Semanal.
💾 Semana 04 • Conceptos: ConfigMaps, Secrets y Volúmenes (PV/PVC)
💾 Semana 04: Conceptos — Configuración y Datos Persistentes
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
En KubeCafé, la receta y los precios del menú (ConfigMap) no vienen impresos dentro de la cafetera; las llaves de la caja fuerte (Secret) se guardan aparte, y las ventas del día se almacenan en una bodega externa (PersistentVolume) para sobrevivir aunque se reinicien los Pods.
🗺️ Diagrama de Componentes
📦 Paso 0: Clonar / Actualizar el Repositorio
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git 2>/dev/null || true
cd Fundamentos-Kubernetes
git pull origin main
💾 Semana 04 • Lab 1 y 2: ConfigMaps (Variables y Archivos)
🧂 Labs 1 y 2: ConfigMaps como Variables de Entorno y Archivos
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
🗺️ Diagrama de Componentes (Lab 2 — Nginx con ConfigMap)
Lab 1: ConfigMap como Variables de Entorno (envFrom)
cd Fundamentos-Kubernetes
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/01-configmap-variables-entorno.yaml
kubectl wait --for=condition=ready pod/barista-config-env --timeout=60s
kubectl logs barista-config-env
💡 Respuesta esperada:
=== Configuración de KubeCafé Medellín === Moneda: COP | Precio Tinto: 3500 | Debug: false
Lab 2: ConfigMap montado como Archivo HTML en Nginx
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/02-configmap-volumen-archivo.yaml
kubectl wait --for=condition=ready pod -l app=menu-config-web --timeout=60s
kubectl port-forward svc/menu-config-svc 8084:80 >/tmp/pf-8084.log 2>&1 &
PF_PID=$!
sleep 2
curl -s http://localhost:8084 | grep -E "h1|li"
kill $PF_PID
💡 Respuesta esperada: Verás
☕ Menú KubeCafé — Cargado desde ConfigMapy los precios del menú sin reconstruir la imagen.
💾 Semana 04 • Lab 3: Secrets (Credenciales Sensibles)
🔐 Lab 3: Secrets para Credenciales Sensibles (Opaque)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
🗺️ Diagrama de Componentes
Paso a paso y Respuesta Esperada
cd Fundamentos-Kubernetes
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/03-secret-credenciales.yaml
kubectl wait --for=condition=ready pod/caja-fuerte-pod --timeout=60s
# 1. Ver el Secret almacenado en Base64:
kubectl get secret kubecafe-receta-secreta -o yaml
# 2. Ver los logs del Pod (Kubernetes decodifica automáticamente el Secret):
kubectl logs caja-fuerte-pod
💡 Respuesta esperada en
kubectl logs:Usuario DB: barista_admin Archivo secreto montado en /etc/kubecafe/API_KEY: kc-live-987654321
💾 Semana 04 • Lab 4: Volúmenes Efímeros (emptyDir) vs Nodo (hostPath)
⏳ Lab 4: emptyDir (Efímero) vs hostPath (Nodo)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
🗺️ Diagrama de Componentes
Paso a paso y Respuesta Esperada
cd Fundamentos-Kubernetes
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/04-volumen-emptydir-vs-hostpath.yaml
kubectl wait --for=condition=ready pod/pod-almacenamiento-local --timeout=60s
kubectl exec pod-almacenamiento-local -- sh -c "cat /tmp-bandeja/pedidos.log && echo '---' && cat /nodo-estante/historial.log"
# Borra el Pod y recréalo para comparar:
kubectl delete pod pod-almacenamiento-local
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/04-volumen-emptydir-vs-hostpath.yaml
kubectl wait --for=condition=ready pod/pod-almacenamiento-local --timeout=60s
kubectl exec pod-almacenamiento-local -- sh -c "cat /tmp-bandeja/pedidos.log && echo '---' && cat /nodo-estante/historial.log"
💡 Respuesta esperada:
/tmp-bandeja/pedidos.log(emptyDir) reinicia con 1 línea nueva, mientras que/nodo-estante/historial.log(hostPath) conserva 2 líneas.
💾 Semana 04 • Lab 5 y 6: PV, PVC y StorageClass Dinámico
📦 Labs 5 y 6: PV + PVC Manual y StorageClass Dinámico
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
🗺️ Diagrama de Componentes (Lab 6 — Persistencia ante Caídas)
Lab 5: PV + PVC Manual (Bound)
cd Fundamentos-Kubernetes
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/05-pv-pvc-almacenamiento-persistente.yaml
kubectl get pv,pvc
kubectl wait --for=condition=ready pod/inventario-bodega-pod --timeout=60s
kubectl logs inventario-bodega-pod
💡 Respuesta esperada: Tanto el
PVcomo elPVCmostrarán estadoBound.
Lab 6: StorageClass Dinámico + Prueba de Persistencia
kubectl get storageclass
kubectl apply -f semana-04-configuracion-almacenamiento/1.ejemplos/06-storageclass-dinamico-stateful.yaml
kubectl wait --for=condition=available deployment/caja-persistente --timeout=90s
kubectl get pvc caja-diaria-pvc
# Simula una caída borrando el Pod y comprueba que los datos sobreviven:
kubectl delete pod -l app=caja-persistente
kubectl wait --for=condition=ready pod -l app=caja-persistente --timeout=60s
kubectl logs deployment/caja-persistente
💡 Respuesta esperada: Verás 2 líneas en
ventas.logcon el nombre del Pod anterior y el Pod nuevo.
💾 Semana 04 • Retos: Los 5 Retos Rotos de Configuración y Storage (+50 XP)
💥 Retos Rotos de la Semana 04 (+50 XP)
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Reproduce, diagnostica (kubectl describe, kubectl get pv,pvc,cm,secrets) y repara los 5 manifiestos rotos en semana-04-configuracion-almacenamiento/2.reto-roto/:
| # | Archivo | Síntoma |
|---|---|---|
| 01 | 01-configmap-clave-inexistente.yaml | CreateContainerConfigError |
| 02 | 02-secret-base64-roto.yaml | CreateContainerConfigError (secretKeyRef) |
| 03 | 03-pvc-pendiente-storageclass.yaml | PVC atascado en Pending |
| 04 | 04-volumen-mountpath-roto.yaml | volumeMounts.name != volumes.name |
| 05 | 05-configmap-volumen-roto.yaml | ContainerCreating (MountVolume.SetUp failed) |
Entrega en GitHub (+50 XP)
mkdir -p aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-04
cp semana-04-configuracion-almacenamiento/2.reto-roto/*.yaml aportes-comunidad/soluciones-retos/<tu-usuario-github>/semana-04/
Repara los 5 archivos dentro de tu carpeta personal y envía tu Pull Request siguiendo el Manual de la Comunidad.
🛡️ Semana 05 • Operación y Seguridad: Sondas, Límites y Permisos RBAC
🛡️ Módulo 05: Salud, Límites y Seguridad Básica
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio Oficial: Fundamentos-Kubernetes en GitHub
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
🎯 ¿Qué vas a dominar en esta unidad?
- Configuración de sondas de salud:
LivenessProbe,ReadinessProbeyStartupProbe. - Asignación de
requestsylimitsde CPU y Memoria (prevención deOOMKilled). - Aislamiento lógico multi-tenant con Namespaces.
- Principios de menor privilegio con RBAC:
ServiceAccount,RoleyRoleBinding.
🚀 Preparación del Entorno: Clonar el Repositorio
Para ejecutar las prácticas de este módulo con total seguridad, evitar errores de contexto (context not found) o rutas relativas incorrectas, clona el repositorio oficial en tu terminal y sitúate en la raíz del proyecto:
# 1. Clonar el repositorio oficial del workshop
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
# 2. Entrar a la raíz del repositorio
cd Fundamentos-Kubernetes
!IMPORTANT 📁 Regla de Oro: Rutas Absolutas con
$PWD:
A lo largo de toda esta unidad, todos los comandos utilizan la variable de entorno$PWD(ej.$PWD/semana-05-operacion-seguridad/...) para construir la ruta absoluta exacta en tu sistema o en la terminal web de iximiuz Labs.
Esto garantiza que puedes ejecutar cualquier comando desde la raíz del repositorio sin necesidad de cambiar de carpeta (cd) entre laboratorios, eliminando por completo los errores de archivos no encontrados.
📄 Ejemplo Práctico: Sondas de Salud y Límites de Recursos
apiVersion: v1
kind: Pod
metadata:
name: app-resiliente
spec:
containers:
- name: web
image: nginx:alpine
resources:
requests:
memory: "64Mi"
cpu: "100m"
limits:
memory: "128Mi"
cpu: "250m"
livenessProbe:
httpGet:
path: /
port: 80
initialDelaySeconds: 5
periodSeconds: 10
readinessProbe:
httpGet:
path: /
port: 80
initialDelaySeconds: 2
periodSeconds: 5
💥 Reto Roto de la Semana
Revisa el reto semanal en el repositorio oficial:
🔗 Fundamentos-Kubernetes en GitHub
🚀 Semana 06 • Helm: Empaquetado de Aplicaciones y Proyecto Final de 3 Capas
🚀 Módulo 06: Empaquetado con Helm y Proyecto Final
🎯 Práctica Interactiva en iximiuz Labs (Marca tu progreso automáticamente)
Completa este reto oficial en iximiuz Labs para validar tus conocimientos y marcar esta sección en verde:
Workshop De Cero a Capitán en Kubernetes — Cloud Native Medellín 🏔️☕
- Repositorio Oficial: Fundamentos-Kubernetes en GitHub
- Comunidad: Cloud Native Medellín (CNCF Chapter)
🎮 Simulador Visual Interactivo KubeCafé:
Mira en tiempo real cómo viajan las órdenes, cómo operan los Pods, la autorreparación y los Deployments en el navegador:
👉 Abrir Simulador Interactivo de Kubernetes (KubeCafé)
🎯 ¿Qué vas a dominar en esta unidad?
- Por qué Helm es el estándar de la industria para empaquetar aplicaciones en Kubernetes.
- La estructura de un Helm Chart:
Chart.yaml,values.yamlytemplates/. - Gestión de plantillas Go (
{{ .Values.xyz }}). - Despliegue, actualización y desinstalación con la CLI de Helm.
- Proyecto Final: Despliegue de una aplicación moderna completa (Frontend, Backend y Base de datos con almacenamiento persistente).
- ¡Graduación oficial y obtención del rango de Capitán K8s en la tripulación! ⚓
🚀 Preparación del Entorno: Clonar el Repositorio
Para ejecutar las prácticas de este módulo con total seguridad, evitar errores de contexto (context not found) o rutas relativas incorrectas, clona el repositorio oficial en tu terminal y sitúate en la raíz del proyecto:
# 1. Clonar el repositorio oficial del workshop
git clone https://github.com/edwinbermudez91/Fundamentos-Kubernetes.git
# 2. Entrar a la raíz del repositorio
cd Fundamentos-Kubernetes
!IMPORTANT 📁 Regla de Oro: Rutas Absolutas con
$PWD:
A lo largo de toda esta unidad, todos los comandos utilizan la variable de entorno$PWD(ej.$PWD/semana-06-proyecto-final/...) para construir la ruta absoluta exacta en tu sistema o en la terminal web de iximiuz Labs.
Esto garantiza que puedes ejecutar cualquier comando desde la raíz del repositorio sin necesidad de cambiar de carpeta (cd) entre laboratorios, eliminando por completo los errores de archivos no encontrados.
🛠️ Comandos Esenciales de Helm
# Crear la estructura de un Chart nuevo
helm create mi-app-chart
# Validar la sintaxis del Chart
helm lint mi-app-chart
# Simular el renderizado de los manifiestos sin aplicarlos
helm template mi-app-chart
# Instalar el Chart en el clúster
helm install mi-app-release ./mi-app-chart
# Actualizar con nuevos valores
helm upgrade mi-app-release ./mi-app-chart -f custom-values.yaml
# Revertir a una revisión previa si hubo fallos
helm rollback mi-app-release 1
⚓ Graduación: Capitán K8s
Completa el proyecto final, sube tu solución a aportes-comunidad/ en tu fork y abre tu Pull Request al repositorio oficial:
🔗 https://github.com/edwinbermudez91/Fundamentos-Kubernetes
¡Felicitaciones por llegar al final de la travesía con Cloud Native Medellín! 🏔️☕