Training program
StartedOct 22, 2026
EndsDec 4, 2026

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 🏔️☕


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

  1. Comprender a fondo qué es un contenedor y cómo el kernel de Linux (namespaces y cgroups) aísla procesos sin duplicar sistemas operativos.
  2. Escribir Dockerfiles siguiendo las mejores prácticas de la industria (imágenes ligeras, multi-stage builds, usuarios sin privilegios root).
  3. Dominar la arquitectura interna de Kubernetes: Control Plane (kube-apiserver, etcd, kube-scheduler, kube-controller-manager) y Worker Nodes (kubelet, kube-proxy, container runtime).
  4. Diseñar, desplegar y depurar manifiestos declarativos en YAML para Pods, Deployments, Services, ConfigMaps, Secrets y Volúmenes.
  5. Gestionar el ciclo de vida de aplicaciones en producción: despliegues continuos sin caídas (Rolling Updates), autorreparación (Self-healing) y reversiones (Rollbacks).
  6. Configurar enrutamiento avanzado con Services (ClusterIP, NodePort) e Ingress.
  7. Operar con resiliencia y seguridad: sondas de salud (liveness/readiness), límites de consumo de CPU/RAM para evitar OOMKilled, y control de acceso basado en roles (RBAC).
  8. 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) y Cgroups (límites de CPU y memoria).
    • Anatomía del Dockerfile: FROM, WORKDIR, COPY, RUN, EXPOSE, ENV, CMD vs ENTRYPOINT.
    • Buenas prácticas de seguridad y optimización: imágenes Alpine, usuario no-root (USER), COPY --chown, dockerignore y 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).
  • 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), variables ENV, .dockerignore y 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 push y escaneo con Trivy en el portal.
    • 06-ia-local-ollama: Inferencia de LLM (Qwen2.5) en CPU con límites de memoria y cores, Modelfile para asistente DevOps y API REST en 127.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 como root (Seguridad).
    • Reto 04: Fuga de contraseñas y secretos por ausencia de .dockerignore.
    • Reto 05: Conexión rechazada por enlazar a 127.0.0.1 y 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 con etcd).
      • 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: containerd o CRI-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 --recursive y exportación.
  • Laboratorios Prácticos (Subsecciones):
    • Lab 0: Preparación del entorno con Kind, kubectl, alias k con autocompletado, kubectx/kubens, k9s, stern y consola visual Headlamp.
    • Lab 1: Despliegue de un Pod básico Nginx y túnel de acceso seguro con kubectl port-forward.
    • Lab 2: Pod multi-contenedor con patrón Sidecar comunicándose por volumen compartido emptyDir.
    • Lab 3: Dosificador de recursos (requests/limits de CPU y RAM) y variables dinámicas con Downward API (spec.nodeName, status.podIP).
    • Lab 4: Tareas bloqueantes previas con initContainers y sondas de salud (readinessProbe y livenessProbe).
    • Lab 5: Inferencia de Inteligencia Artificial local en CPU con Ollama (smollm2:135m), volumen de modelos emptyDir y 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 estado Pending infinito 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 garantizar N réplicas activas (Desired State).
    • Estrategias de actualización:
      • RollingUpdate: Relevo progresivo de Pods taza por taza con maxSurge y maxUnavailable.
      • 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 undo ante versiones fallidas (ImagePullBackOff o errores críticos).
    • Estándar de producción: Usuario no privilegiado (securityContext.runAsNonRoot), límites de recursos y sondas livenessProbe / readinessProbe.
  • Laboratorios Prácticos (5 Laboratorios Oficiales):
    • 01-primer-deployment-replicas.yaml: Despliegue de cafecito-app con 3 réplicas balanceadas y prueba de autorreparación borrando Pods en vivo.
    • 02-rolling-update-cero-caidas.yaml: Despliegue de api-pedidos-rolling con maxSurge: 1, maxUnavailable: 0, readinessProbe y actualización en caliente con VERSION=v2.0.
    • 03-estrategia-recreate.yaml: Procesador batch (batch-procesador-recreate) con estrategia Recreate para 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 y revisionHistoryLimit.
    • 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 entre matchLabels y template.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 en RollingUpdate e indentación de parámetros maxSurge.
    • Reto 04: 04-deployment-yaml-identacion.yaml — apiVersion obsoleto (v1) e indentación rota en el bloque template.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.
  • Reto Roto 03:
    • Resolver un Service que no envía tráfico a sus Pods debido a un error en targetPort y selector de etiquetas (labels).

💾 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 PVC y verificación de datos tras reiniciar los Pods.
  • Reto Roto 04:
    • Diagnóstico de un Pod con CreateContainerConfigError por un ConfigMapKeyRef inexistente y un PVC que se queda en estado Pending.

🛡️ 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, tcpSocket y exec.
    • 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.
  • Laboratorios Prácticos:
    • Configuración de sondas liveness y readiness en 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.
  • Reto Roto 05:
    • Reparar un Pod que entra en bucle continuo de reinicios porque su livenessProbe apunta a una ruta errónea.

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

  1. Navega a la carpeta semanal correspondiente en el repositorio oficial.
  2. Identifica el error aplicando el archivo en tu clúster de laboratorio.
  3. Investiga con comandos de diagnóstico: kubectl get, kubectl describe, kubectl logs.
  4. Corrige el archivo en tu rama de trabajo y agrégalo en aportes-comunidad/soluciones-retos/<tu-usuario>/.
  5. 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 🏔️☕


🎮 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?

  1. Qué es realmente un contenedor y en qué se diferencia de una Máquina Virtual pesada.
  2. Cómo el Kernel de Linux aísla procesos usando Namespaces y limita recursos con Cgroups.
  3. Cómo escribir un Dockerfile desde cero con buenas prácticas (Alpine, usuario no-root, .dockerignore, exec form).
  4. Construir redes bridge personalizadas y entender la resolución DNS interna por nombre entre contenedores.
  5. Almacenamiento efímero vs. Named Volumes (docker volume) vs. Bind Mounts (-v).
  6. Auditoría y escaneo de vulnerabilidades con Trivy (HIGH, CRITICAL).
  7. Ciclo de distribución OCI con Harbor: autenticación (docker login), etiquetado (docker tag), publicación (docker push) y descarga (docker pull).
  8. Inferencia de modelos de IA locales en CPU con Ollama, límites de recursos y consumo vía API REST.
  9. 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ónComando¿Qué hace?
Construir imagendocker 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ágenesdocker imagesMuestra las imágenes almacenadas localmente.
Correr contenedordocker 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 activosdocker psMuestra qué contenedores están corriendo actualmente.
Ver todos (incluidos caídos)docker ps -aPermite revisar contenedores detenidos o con error.
Ver logs en vivodocker logs -f mi-servidorSigue en tiempo real la salida estándar y errores de la aplicación.
Entrar a la terminaldocker exec -it mi-servidor shAbre una sesión interactiva dentro del contenedor.
Detener contenedordocker stop mi-servidorEnvía una señal limpia SIGTERM para apagarlo.
Eliminar contenedordocker rm mi-servidorBorra el contenedor detenido del disco.
Crear red bridgedocker network create mi-redCrea una red privada con resolución DNS automática por nombre.
Crear volumendocker volume create mi-volumenCrea un volumen administrado que persiste datos fuera del ciclo de vida del contenedor.
Etiquetar imagendocker tag mi-app:v1.0 mi-registro.io/equipo/mi-app:v1.0Asigna un nuevo tag con la URL del registro de destino.
Iniciar sesión en registrodocker login mi-registro.ioAutentica contra un registro OCI como Harbor o Docker Hub.
Publicar imagendocker push mi-registro.io/equipo/mi-app:v1.0Sube la imagen empaquetada al registro remoto.
Descargar imagendocker pull mi-registro.io/equipo/mi-app:v1.0Descarga la imagen remota a tu máquina o nodo.
Escanear seguridadtrivy image --severity HIGH,CRITICAL mi-app:v1.0Analiza 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:

UnidadLaboratorioDescripción
Lab 01Servidor Web Estático con NginxNginx Alpine (~25 MB), proceso en primer plano y HTML.
Lab 02API en Python con Variables de EntornoUsuario no-root (appuser), ENV, .dockerignore y UI interactiva.
Lab 03Redes en Docker y MicroserviciosRed bridge custom (red-cafetera), DNS interno y comunicación Backend-Frontend.
Lab 04Almacenamiento y VolúmenesDatos efímeros vs Named Volumes y Bind Mounts con persistencia real.
Lab 05Registro y Publicación con HarborAutenticación con Cuentas Robot, docker tag, push y auditoría Trivy.
Lab 06IA Local en Docker con OllamaInferencia de LLM (Qwen2.5) en CPU con límites cgroups y Modelfile DevOps.
Retos RotosLos 5 Retos Rotos de la Semana 00Depuració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:



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



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



🎮 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 puerto 8080 que mantiene el inventario de tintos. No necesita exponer puertos al host (-p).
  • Cliente (carrito-cliente:v1.0): Microservicio en puerto 8081 que recibe peticiones externas y consulta a greca-central:8080 utilizando 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:



🎮 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 nuestro Dockerfile sigue las mejores prácticas de seguridad ejecutándose con appuser (UID 10001), la carpeta montada del host requiere permisos de escritura (chmod 777) para permitirle al contenedor crear el archivo ventas.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:



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

Ciclo de Distribución OCI con Registro Local

📦 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 en python:3.12-alpine), verás que Docker indica Layer 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 namespace cafeteria/, 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:
    docker run --rm -v /var/run/docker.sock:/var/run/docker.sock aquasec/trivy:latest image mi-api-cnm:v1.0
    
    (O con docker scout cves mi-api-cnm:v1.0). Gracias a python: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:



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

Arquitectura 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ámetroPropósito Técnico
--memory=1400mLímite estricto de memoria RAM vía cgroups para evitar congelar el host.
--cpus=3Techo de núcleos de CPU asignados para inferencia.
-p 127.0.0.1:11434:11434Publica la API únicamente en loopback local por seguridad.
-v ollama:/root/.ollamaPersistencia 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:



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


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

RetoTipo de Falla / TemaDiagnóstico ClaveEnlace al Reto en GitHub
01Proceso 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
02Contenedor 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
03Contenedor vulnerable ejecutándose como root (Seguridad)docker run whoami responde root (UID 0), violando las directivas de seguridad.🔗 Ver Reto 03: Contenedor Root
04Fuga de contraseñas y secretos por falta de .dockerignoreCOPY . . empaqueta archivos .env privados dentro de las capas de la imagen.🔗 Ver Reto 04: Archivos Secretos
05Conexión rechazada por enlace a 127.0.0.1 y puerto desalineadoLa 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?

  1. Realiza un Fork de Fundamentos-Kubernetes.
  2. Clónalo y soluciona cada reto en tu máquina.
  3. Copia tus soluciones a aportes-comunidad/soluciones-retos/<tu-usuario>/semana-00/.
  4. 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 🏔️☕


🎮 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?

  1. Por qué Docker por sí solo no basta en producción y por qué necesitamos un Orquestador de Contenedores.
  2. La arquitectura interna de Kubernetes: Control Plane (Oficina de Gerencia) vs. Worker Nodes (Mesas de Barismo).
  3. Qué es un Pod y por qué es la unidad atómica y mínima de despliegue en Kubernetes.
  4. La diferencia crítica entre el Modo Imperativo (Interactivo) y el Modo Declarativo (Producción / GitOps).
  5. El secreto de velocidad: uso de --dry-run=client -o yaml, --help, kubectl explain --recursive y exportación a archivos.
  6. 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 Node o 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écnicoEn ☕ KubeCafé¿Cuál es su función en la cafetería y en el clúster?
Contenedor☕ Taza de café servidaLa bebida lista y ejecutándose en memoria/CPU.
Pod🍽️ Bandeja de servicioUnidad 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 barismoEstación de trabajo física o virtual con agua (RAM) y cafeteras (CPU).
Kubelet👨‍🍳 Barista de la mesaAgente en cada nodo: recibe órdenes de gerencia y vigila que las tazas no se enfríen.
Control Plane🏢 Oficina de GerenciaCoordina toda la cafetería sin preparar café directamente.
kube-apiserver🛎️ Caja / MostradorVentanilla única: todos tus comandos (kubectl) y reportes entran por aquí.
etcd📖 Libro contableBase de datos llave-valor inmutable donde se registran todas las órdenes activas y el estado de las mesas.
kube-scheduler📋 Despachador de mesasMira qué mesa de barismo tiene cafetera y agua libre para asignar la bandeja (Pod).
Controller Manager🧐 Supervisor de salónSi 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ípicosk run, k create, k expose, k edit, k delete pod Xk 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 yaml para que kubectl te 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:

🌱 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 🏔️☕


🎮 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

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.kind o choco 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) o winget 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) o winget 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) o winget 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 🏔️☕


🎮 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 decir Running.
  • 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:

  1. Scheduled: El kube-scheduler asignó el Pod a un nodo disponible.
  2. Pulling: El kubelet inició la descarga de la imagen nginx:alpine.
  3. Pulled: La imagen fue descargada con éxito.
  4. Created: El contenedor fue creado en containerd.
  5. 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 🏔️☕


🎮 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 🏔️☕


🎮 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 🏔️☕


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

  1. initContainers: Contenedores de inicialización que se ejecutan de forma secuencial y bloqueante antes de que arranque la aplicación principal.
  2. 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 🏔️☕


🎮 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 🏔️☕


🎮 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

PilarEn ☕ 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 barrastern y kubectl logs -f con formato estructurado JSON
3. Eventos y Trazabilidad📋 Libro de novedades e incidentes de gerenciakubectl 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 🏔️☕


🎮 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
0101-pod-con-errores.yamlEl barista buscó una 📦 bolsa de café con etiqueta mal escrita y puerto inválido.ImagePullBackOff / Error de puerto
0202-pod-crashloop.yamlLa ☕ taza se sirve pero se derrama al instante porque el comando falla.CrashLoopBackOff
0303-pod-pendiente-infinito.yamlLa orden del pedido pide 64 cafeteras (CPU) y ninguna 🪵 mesa tiene capacidad.Pending (Insufficient cpu)
0404-pod-yaml-molesto.yamlEl 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 PodEn ☕ 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?

  1. 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)
  2. Cada archivo resuelto que pase la validación estricta de contenido sumará +10 XP inmediatamente.
  3. Al completar los 4 retos de la Semana 01, ¡tu semana contará como 100% Completada para ascender a 🧭 Timonel o ⚓ Capitán K8s!
  4. 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 🏔️☕


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

  1. Comprender la diferencia crucial entre un Pod y un Deployment, y por qué nunca debes desplegar Pods aislados en producción.
  2. Entender el rol del ReplicaSet como el mecanismo de reconciliación que garantiza el estado deseado (Desired State vs. Actual State).
  3. Comprobar la autorreparación (Self-Healing) en vivo: eliminar Pods manualmente y ver cómo el controlador los recrea en milisegundos.
  4. Dominar las estrategias de despliegue:
    • RollingUpdate (cero tiempo de inactividad con maxSurge y maxUnavailable).
    • Recreate (todo o nada, ideal para migraciones de bases de datos o volúmenes exclusivos ReadWriteOnce).
  5. Realizar Rollbacks instantáneos con kubectl rollout undo ante versiones fallidas con ImagePullBackOff o errores fatales.
  6. Configurar recursos (Requests/Limits) y Probes (Liveness/Readiness) para proteger la estabilidad de los nodos.
  7. 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

ComandoDescripción
kubectl get deploymentsLista los deployments y sus réplicas deseadas/actuales
kubectl describe deployment <nombre>Muestra eventos, estrategia, selector y réplicas
kubectl scale deployment <nombre> --replicas=5Escala 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=1Vuelve a una revisión específica
kubectl rollout restart deployment <nombre>Reinicia todos los Pods en secuencia ordenada

🌟 Buenas Prácticas para Producción

  1. Nunca uses replicas: 1 en producción: Pierdes la alta disponibilidad durante reinicios de nodos. Usa mínimo 2 o 3.
  2. Define siempre requests y limits: Evita que un Pod con fuga de memoria agote el nodo (OOMKilled a nivel de sistema).
  3. Configura readinessProbe con 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.
  4. No uses la etiqueta :latest en 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.3 o hash de commit git).
  5. Alinea siempre matchLabels con template.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 🏔️☕


🎮 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 que Actual: 2 != Desired: 3 y ordenó al kube-scheduler y kubelet crear 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 🏔️☕


🎯 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 a maxUnavailable: 0 y al readinessProbe, Kubernetes primero espera a que el nuevo Pod v2.0 responda HTTP 200 en :8080 antes de apagar uno de los Pods v1.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 🏔️☕


🎯 Objetivo del Laboratorio

  1. Comprender cuándo y cómo usar la estrategia Recreate (apagado total previo).
  2. Desplegar un estándar profesional de producción con usuario sin privilegios (runAsNonRoot), requests/limits, livenessProbe, readinessProbe y revisionHistoryLimit.

🧹 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 🏔️☕


🎯 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 🏔️☕


🎮 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 RetoNivelError / Síntoma PrincipalXP
0101-deployment-selector-roto.yaml🟢 PrincipiantematchLabels no coincide con template.metadata.labels.+10 XP
0202-deployment-imagen-caida-rollback.yaml🟡 IntermedioImagen inexistente que causa ImagePullBackOff y bloquea el rollout (0/3 READY).+10 XP
0303-deployment-estrategia-invalida.yaml🟡 IntermedioTypo en el valor de la estrategia y parámetros fuera del bloque rollingUpdate.+10 XP
0404-deployment-yaml-identacion.yaml🔴 NinjaapiVersion 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,pods
  • kubectl describe deployment <nombre> (revisa los Events y Conditions)
  • kubectl rollout status deployment <nombre>
  • kubectl explain deployment.spec.strategy --recursive

🏆 ¿Cómo entregar tus soluciones y ganar +40 XP?

  1. 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/
    
  2. 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.
  3. 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
    
  4. Envía tu Pull Request a la rama main de Fundamentos-Kubernetes.
    Al aprobarse, el sistema evaluará tus manifiestos, sumará +40 XP en ASISTENTES.md y 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 🏔️☕


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

  1. Services (ClusterIP y NodePort): IP virtual y puerto estables frente a Pods efímeros.
  2. EndpointSlices: La lista dinámica de IPs de Pods sanos detrás de un Service.
  3. CoreDNS: Cómo los Pods se encuentran por nombre (cocina-svc) sin memorizar IPs.
  4. Cilium Gateway API (Gateway + HTTPRoute): El estándar moderno de enrutamiento HTTP/HTTPS que reemplaza al antiguo Ingress.

☕ Analogía en KubeCafé

Concepto KubernetesAnalogía en KubeCaféFunción
Pod (IP efímera)Mesa de BarismoCambia de ubicación/IP si un barista se reemplaza.
Service (ClusterIP)Mesero InternoPunto 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).
EndpointSlicesLibreta del MeseroLista actualizada de qué baristas están sanos (Ready) y atendiendo.
CoreDNSDirectorio TelefónicoTraduce cocina-svc a la IP del Service automáticamente.
Gateway (Cilium)Puerta PrincipalÚnico punto de entrada HTTP/HTTPS al clúster.
HTTPRouteRecepcionistaLee 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 Endpoints y EndpointSlices coinciden con las de los 2 Pods. Si borras un Pod, Kubernetes actualiza la lista automáticamente sin cambiar la IP de cocina-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.200 a 172.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 una EXTERNAL-IP del Pool y reparte el tráfico entre los 2 Pods (allocateLoadBalancerNodePorts: false evita abrir un NodePort extra).

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 OK en curl -I y 6 líneas alternando entre los 2 Pods kubecafe-lb-app-.... En Expose HTTP(S) Ports elige dev-machine, puerto 3000, haz clic en EXPOSE y abre http://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

  1. 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
  1. Habilita kubeProxyReplacement=true y gatewayAPI.enabled=true en Cilium y verifica que todo quede OK:
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: cilium debe aparecer con ACCEPTED: 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>/cocina
  • http://<GW_IP>/menu

🧭 Paso 4: Más ejemplos de HTTPRoute (Hostnames, Headers y Canary por Peso)

  1. 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 Pod kubecafe-cocina-....

  1. 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" devuelve Menú KubeCafé.

  1. 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 respuestas Menú 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án Menu v2.0 (Canary - 20%). Para pasar el 100% del tráfico a v2, solo cambia weight: 0 en menu-v1-svc y weight: 100 en menu-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 /chat como /v1/chat/completions entran por el mismo kubecafe-gateway.
  • CRDs (09a) + Service (09): Los CRDs declaran el InferencePool y InferenceModel, mientras el Service kubecafe-llm-pool conecta 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/.

  1. 01-service-selector-roto.yaml: El Service tiene 0 EndpointSlices (spec.selector vs labels).
  2. 02-service-targetport-incorrecto.yaml: Connection refused (targetPort vs containerPort).
  3. 03-nodeport-fuera-de-rango.yaml: nodePort fuera del rango 30000–32767.
  4. 04-httproute-parentref-roto.yaml: parentRefs apunta a un Gateway inexistente.

📔 ¡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 ConfigMap y 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 PV como el PVC mostrarán estado Bound.

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.log con 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/:

#ArchivoSíntoma
0101-configmap-clave-inexistente.yamlCreateContainerConfigError
0202-secret-base64-roto.yamlCreateContainerConfigError (secretKeyRef)
0303-pvc-pendiente-storageclass.yamlPVC atascado en Pending
0404-volumen-mountpath-roto.yamlvolumeMounts.name != volumes.name
0505-configmap-volumen-roto.yamlContainerCreating (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 🏔️☕


🎮 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?

  1. Configuración de sondas de salud: LivenessProbe, ReadinessProbe y StartupProbe.
  2. Asignación de requests y limits de CPU y Memoria (prevención de OOMKilled).
  3. Aislamiento lógico multi-tenant con Namespaces.
  4. Principios de menor privilegio con RBAC: ServiceAccount, Role y RoleBinding.

🚀 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 🏔️☕


🎮 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?

  1. Por qué Helm es el estándar de la industria para empaquetar aplicaciones en Kubernetes.
  2. La estructura de un Helm Chart: Chart.yaml, values.yaml y templates/.
  3. Gestión de plantillas Go ({{ .Values.xyz }}).
  4. Despliegue, actualización y desinstalación con la CLI de Helm.
  5. Proyecto Final: Despliegue de una aplicación moderna completa (Frontend, Backend y Base de datos con almacenamiento persistente).
  6. ¡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! 🏔️☕