GuíaIntermedio
Guía de Kubernetes y EKS en Producción
Le da a Andes Cargo el orquestador que le faltaba: `andes-cargo-status-api`, el componente en contenedor que `aws-serverless-and-containers-guide` construyó pero dejó "documentado, nunca ejecutado" en ECS, finalmente corre de verdad contra un clúster Kubernetes real. Esta guía usa `kind` —Kubernetes real, no un simulador— como laboratorio $0, con el backbone ejecutable más fuerte del ecosistema hasta ahora: casi todo el contenido corre sin ningún límite de plan de pago. Construye las primitivas de carga de trabajo (Pod, Deployment, Service) hasta llevarlas a nivel de producción con configuración externalizada, `liveness`/`readiness`/`startup probes` y autoscaling horizontal por métricas reales; el modelo de red del clúster con `Ingress` y `NetworkPolicy`; GitOps pull-based real con ArgoCD sobre un repositorio Git propio (Gitea, corriendo dentro del mismo clúster) que converge el estado del sistema sin que nadie ejecute un `kubectl apply` manual; admission control real con dos motores (OPA Gatekeeper y Kyverno) que rechazan un objeto antes de que llegue a existir; y escaneo de la imagen de contenedor con Trivy. Cierra con un módulo específico de EKS —node groups, Fargate profiles, IRSA/EKS Pod Identity, autoscaling de nodos con Karpenter, el AWS Load Balancer Controller— mostrado y explicado a fondo pero declarado representativo con honestidad exacta: EKS solo está disponible en el plan Ultimate de LocalStack, y ni pagando reproduce fielmente el plano de control gestionado real. El capstone corre el sistema completo de punta a punta, con un cambio que pasa el gate y uno que el admission webhook detiene.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Decidir cuándo Kubernetes le gana a ECS/Fargate y qué cuesta esa ganancia (más piezas que administrar: no es *batteries included*)
- Levantar un clúster Kubernetes real con `kind`, y llevar `andes-cargo-status-api` (heredado, sin reescribir el Dockerfile) a correr dentro de él
- Dominar las primitivas de carga de trabajo — Pod, Deployment, Service — y por qué casi nunca se crea un Pod suelto
- Externalizar configuración con ConfigMap y Secret, configurar `liveness`/`readiness`/`startup probes`, y escalar horizontalmente con un `HorizontalPodAutoscaler` que reacciona a métricas reales
- Exponer el servicio con `Ingress` (`ingress-nginx`) y protegerlo con una `NetworkPolicy` real de tipo *deny-by-default*
- Construir GitOps *pull-based* de punta a punta con ArgoCD sobre un repositorio Git real (Gitea): un cambio committeado converge solo en el clúster, sin `kubectl apply` manual
- Implementar *admission control* real con dos motores de políticas (OPA Gatekeeper y Kyverno) y escanear la imagen de contenedor con `trivy image`, rechazando un objeto antes de que exista
- Entender qué cambia cuando el clúster es EKS real: quién administra el plano de control, node groups frente a Fargate profiles, IRSA y su sucesor EKS Pod Identity, autoscaling de nodos con Karpenter, y el AWS Load Balancer Controller
Antes de empezar
Qué necesitas traer
Es para ti si...
- Backend, DevOps o Cloud engineers que completaron las guías de Servicios Core de AWS y de Serverless y Contenedores, y necesitan el orquestador de contenedores que domina la producción real
- Devs que construyeron una imagen Docker y la corrieron local, pero nunca la desplegaron con un orquestador de verdad
- Ingenieros que se preparan para roles donde Kubernetes/EKS es requisito explícito de la oferta (la evidencia de mercado lo pide en la gran mayoría de los puestos cloud)
- Equipos que ya tienen GitOps *push-based* (un pipeline de CI que corre `apply`) y quieren entender el otro polo del mismo principio: un operador *pull-based* que converge el clúster solo
Requisitos y materiales
- Guía de Servicios Core de AWS y Guía de Serverless y Contenedores en AWS completadas (o equivalente: IAM de una cuenta, la tabla `Shipments`, y `andes-cargo-status-api` construida en Docker)
- Guía de Fundamentos de Docker completada (o equivalente: Dockerfile, capas, `docker build`/`run`)
- Docker instalado y funcionando (para correr `kind`)
- Familiaridad con YAML y la línea de comandos; conocer el vocabulario de GitOps (`push` vs. `pull`) ayuda pero no es obligatorio
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Introducción a la guía: el orquestador que faltaba
- 2. Por qué Kubernetes cuando ECS ya alcanzaba
- 3. El reto de continuidad: recogiendo `andes-cargo-status-api` donde quedó
- 4. Manos a la obra: instalando `kind` y `kubectl`
- 5. Manos a la obra: tu primer clúster
- 6. Arquitectura de un clúster: control plane, nodos, y `etcd`
- 7. Manos a la obra: cargando la imagen de `andes-cargo-status-api` en el clúster
- 8. Proyecto: el clúster de Andes Cargo, listo
- 1. Introducción: de un contenedor a una carga de trabajo administrada
- 2. Qué es un Pod, y por qué casi nunca se crea uno suelto
- 3. Deployments: ReplicaSets y el bucle de control declarativo
- 4. Manos a la obra: tu primer Pod
- 5. Manos a la obra: el Deployment de `andes-cargo-status-api`
- 6. Services: `ClusterIP`, `NodePort`, y por qué un Pod no es una dirección estable
- 7. Manos a la obra: exponiendo `status-api-service`
- 8. Proyecto: `andes-cargo-status-api` con N réplicas
- 1. Introducción al módulo: lo que un Deployment solo no te da
- 2. ConfigMaps: separar configuración de imagen
- 3. Secrets: por qué una credencial nunca vive en la imagen
- 4. Manos a la obra: `ConfigMap` y `Secret` para `andes-cargo-status-api`
- 5. `liveness`, `readiness` y `startup probes`
- 6. Manos a la obra: `probes` reales sobre `status-api-service`
- 7. `HorizontalPodAutoscaler`: escalar por métricas, no por corazonada
- 8. Proyecto: `andes-cargo-status-api` bajo carga
- 1. Introducción al módulo: la capa que "no es *batteries included*"
- 2. El modelo de red de Kubernetes: cada Pod, una IP
- 3. `Ingress`: una puerta HTTP para el clúster
- 4. Manos a la obra: instalando `ingress-nginx` en `kind`
- 5. Manos a la obra: `Ingress` para `status-api-service`
- 6. `NetworkPolicy`: por defecto, todos hablan con todos — y por qué eso no dura
- 7. Manos a la obra: `NetworkPolicy` real sobre `andes-cargo`
- 8. Proyecto: `status-api-service` expuesto y protegido
- 1. Introducción al módulo: la otra mitad de GitOps
- 2. GitOps *pull-based*: un operador que hace *watch*, no un pipeline que empuja
- 3. Manos a la obra: Gitea en el clúster
- 4. Manos a la obra: instalando ArgoCD
- 5. Anatomía de una `Application` de ArgoCD
- 6. Manos a la obra: sincronizando `andes-cargo-status-api` desde Git
- 7. Estrategias de despliegue: rolling, blue/green y canary
- 8. Proyecto: un cambio en Git, reflejado solo
- 1. Introducción al módulo: el portero antes de `etcd`
- 2. Qué es un *admission controller*, y por qué corre antes de que el objeto exista
- 3. OPA Gatekeeper: `ConstraintTemplate` y `Constraint`
- 4. Manos a la obra: instalando Gatekeeper y tu primera política
- 5. Kyverno: la alternativa YAML-nativa
- 6. Manos a la obra: la misma política, en Kyverno
- 7. Manos a la obra: `trivy image` sobre `andes-cargo-status-api`
- 8. Proyecto: los guardrails de runtime de Andes Cargo
- 1. Introducción al módulo: por qué este es distinto a los seis anteriores
- 2. El plano de control gestionado: qué administra AWS, qué sigue siendo tuyo
- 3. Node groups: gestionados, autogestionados, y Fargate profiles
- 4. Autoscaling de nodos: Karpenter frente a Cluster Autoscaler
- 5. IRSA y su sucesor, EKS Pod Identity
- 6. El AWS Load Balancer Controller: el `Ingress` real de producción
- 7. Manos a la obra: el YAML de EKS, mostrado y explicado
- 8. Proyecto: el plan de migración de Andes Cargo, `kind` → EKS real
- 1. Introducción al capstone
- 2. Repaso de arquitectura: el clúster completo
- 3. Recorrido end-to-end: un cambio que cruza el gate completo
- 4. Recorrido end-to-end: un cambio que el gate detiene
- 5. Lo que esta guía dejó representativo, honestidad final
- 6. La corrección de continuidad que esta guía deja para el ecosistema
- 7. Lo que Andes Cargo todavía necesita
- 8. Proyecto final: `andes-cargo-k8s/` como entregable del capstone
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!