CKA · Módulo 4 K8s v1.34 Workloads & Scheduling 15%

Workloads: los controllers y su configuración

Arranca el segundo dominio. Cómo Kubernetes corre y mantiene tus aplicaciones: Deployments, DaemonSets, StatefulSets, cómo se configuran con ConfigMaps y Secrets, y cómo escalan solos con HPA.

Duración60 min
DominioWorkloads & Scheduling
Peso15%
Base paraTroubleshooting
Un Pod solo es frágil: si muere, no vuelve. Los controllers (Deployment, DaemonSet, StatefulSet) son los que mantienen tus pods vivos y en la cantidad correcta — el "estado deseado" del Módulo 1 aplicado a las cargas. Este módulo cubre qué controller usar en cada caso, cómo inyectarles configuración (ConfigMaps/Secrets), y cómo escalan automáticamente (HPA). Todo con foco imperativo, porque en el examen la velocidad manda.
4.1
Deployments y ReplicaSets
El controller estrella. Escalar, rollout, rollback.
4.2
DaemonSets y StatefulSets
Uno por nodo, o apps con estado e identidad.
4.3
ConfigMaps y Secrets
Inyectar configuración sin hornearla en la imagen.
4.4
HPA
Escalar réplicas automáticamente según carga.
4.1
El controller estrella · 20 min

Deployments y ReplicaSets

El 90% de lo que corrés en K8s es un Deployment. Dominá su ciclo de vida.
Práctica · Ciclo de vida

Crear y escalar

# Crear un deployment
k create deploy web --image=nginx --replicas=3

# Escalar
k scale deploy web --replicas=5

# Ver el deployment, sus RS y pods
k get deploy,rs,pods

Rollout: actualizar la imagen

# Cambiar la imagen (dispara un rollout)
k set image deploy/web nginx=nginx:1.27

# Ver el estado del rollout
k rollout status deploy/web

# Ver el historial de revisiones
k rollout history deploy/web

Rollback: volver atrás

# Volver a la revisión anterior
k rollout undo deploy/web

# Volver a una revisión específica
k rollout undo deploy/web --to-revision=2
El rollout es de examen puro: te piden actualizar una imagen y verificar, o "volvé a la versión anterior porque la nueva falla". Los comandos set image, rollout status/history/undo tienen que salir rápido.
Teoría · La jerarquía

Deployment → ReplicaSet → Pods

Hay tres capas y cada una tiene su rol:

  • Deployment: gestiona rollouts y rollbacks. Es con el que interactuás.
  • ReplicaSet: mantiene N réplicas vivas. Lo crea el Deployment; casi nunca lo tocás directo.
  • Pod: la unidad que corre los containers.

Por qué un RS por revisión

Cada vez que cambiás la imagen, el Deployment crea un ReplicaSet nuevo y va moviendo pods del viejo al nuevo (rolling update). El RS viejo queda con 0 réplicas — por eso el rollback es rápido: solo reactiva el RS anterior.

Cuando hacés rollback, K8s no "reconstruye" nada: simplemente escala el ReplicaSet viejo de vuelta a N y el nuevo a 0. Por eso es casi instantáneo.

Rolling update vs recreate

Por defecto el Deployment usa RollingUpdate (reemplaza pods de a poco, sin downtime). La otra estrategia es Recreate (mata todos, después crea todos — con downtime, pero útil si no pueden coexistir versiones).

4.2
Controllers especializados · 15 min

DaemonSets y StatefulSets

Cuándo NO usar un Deployment.
Práctica · Reconocerlos

DaemonSet — uno por nodo

# No hay 'create daemonset' imperativo.
# Truco: generar un deployment y editar el kind
k create deploy logger --image=fluentd $do > ds.yaml
# editar: kind: Deployment → DaemonSet
# quitar: replicas y strategy

# Verlos (ya tenés varios en tu cluster)
k get daemonsets -A
# calico-node y kube-proxy son DaemonSets

StatefulSet — identidad estable

# Ver los StatefulSets
k get statefulsets

# Los pods tienen nombre predecible:
# db-0, db-1, db-2 (no hash aleatorio)
Ya conocés DaemonSets sin saberlo: calico-node y kube-proxy corren uno por nodo. Por eso en el upgrade usabas drain --ignore-daemonsets: no se pueden mover, hay uno fijo por nodo.
Teoría · Cuál para qué

Los tres controllers de pods

ControllerPara qué
DeploymentApps sin estado. Réplicas intercambiables
DaemonSetUn pod en CADA nodo (logs, red, monitoreo)
StatefulSetApps con estado: identidad y almacenamiento estables

Qué hace especial al StatefulSet

  • Nombres estables: db-0, db-1 (no aleatorios)
  • Orden: crea/borra en secuencia (0, luego 1...)
  • Almacenamiento propio: cada pod tiene su PVC que persiste aunque el pod se recree

Ideal para bases de datos, colas, cualquier cosa donde "quién es quién" importa.

Cuándo cada uno (regla rápida)

¿Los pods son intercambiables? → Deployment. ¿Necesitás uno por nodo? → DaemonSet. ¿Cada pod es único y tiene datos propios? → StatefulSet.

4.3
Configuración · 15 min

ConfigMaps y Secrets

Separar la configuración del código. La imagen se mantiene genérica.
Práctica · Crear e inyectar

Crear

# ConfigMap desde literales
k create configmap app-cfg \
  --from-literal=COLOR=blue \
  --from-literal=MODE=prod

# ConfigMap desde un archivo
k create configmap app-cfg --from-file=config.txt

# Secret (se guarda en base64, no cifrado por defecto)
k create secret generic db-pass \
  --from-literal=password=s3cr3t

Inyectar como variables de entorno

spec:
  containers:
  - name: app
    image: nginx
    envFrom:
    - configMapRef:
        name: app-cfg
    - secretRef:
        name: db-pass

Inyectar una sola variable

env:
- name: COLOR
  valueFrom:
    configMapKeyRef:
      name: app-cfg
      key: COLOR

Montar como archivos (volumen)

volumes:
- name: cfg
  configMap:
    name: app-cfg
# y en el container:
volumeMounts:
- name: cfg
  mountPath: /etc/config
Teoría · El porqué

Por qué separar config del código

La misma imagen (nginx) debe correr en dev, staging y prod sin recompilar. La configuración cambia por entorno; la imagen no. ConfigMaps y Secrets inyectan esa config en runtime.

ConfigMap vs Secret

ConfigMapSecret
Config no sensibleDatos sensibles
Texto planobase64 (NO cifrado)
URLs, flags, modosPasswords, tokens, certs
Un Secret NO está cifrado por defecto — solo codificado en base64, que cualquiera decodifica. La "seguridad" real viene de RBAC (quién puede leer secrets) y de encryption-at-rest configurado aparte. No asumas que base64 = seguro.

Dos formas de consumir

  • Env vars: la config aparece como variables de entorno en el container
  • Volumen: cada clave se vuelve un archivo en un directorio montado
4.4
Escalado automático · 10 min

Horizontal Pod Autoscaler

Que el cluster ajuste las réplicas solo, según la carga.
Práctica · Crear un HPA

Crear un autoscaler

# Escalar 'web' entre 2 y 10 réplicas,
# objetivo: 50% de CPU
k autoscale deploy web \
  --min=2 --max=10 --cpu-percent=50

# Ver los HPA y su estado actual
k get hpa
k describe hpa web
El HPA necesita el metrics-server instalado para leer el uso de CPU/memoria. Sin él, el HPA no sabe cuánta carga hay y muestra <unknown> en los targets. En clusters de práctica hay que instalarlo aparte.

Requisito: requests de CPU en el pod

# El HPA calcula el % sobre el 'request', así que
# el deployment DEBE tener resources.requests.cpu
resources:
  requests:
    cpu: 100m
Teoría · Cómo decide

Qué hace el HPA

Vigila una métrica (típicamente CPU) de los pods de un Deployment. Si la carga supera el objetivo, agrega réplicas; si baja, las quita. Todo dentro del rango min/max que definís.

La cuenta simplificada

Si el objetivo es 50% de CPU y los pods están al 100%, el HPA duplica las réplicas para repartir la carga a la mitad. Es proporcional: apunta a que el promedio quede en el target.

Horizontal = más pods (escala a lo ancho). No confundir con Vertical (VPA), que da más CPU/RAM a cada pod. El CKA es sobre HPA (horizontal).

Las 3 piezas necesarias

  • metrics-server instalado (para leer métricas)
  • requests de CPU en el pod (base del cálculo del %)
  • el HPA con min/max/target
Cierre del módulo

Lo que te llevás del Módulo 4

Resumen · Comandos clave

Para tu agenda

# Deployments
k create deploy NAME --image=IMG --replicas=N
k scale deploy NAME --replicas=N
k set image deploy/NAME cont=img:tag
k rollout status/history/undo deploy/NAME

# ConfigMaps / Secrets
k create configmap NAME --from-literal=K=V
k create secret generic NAME --from-literal=K=V
# consumir: envFrom (todo) o env+valueFrom (una)

# HPA
k autoscale deploy NAME --min=2 --max=10 --cpu-percent=50

# DaemonSet: no hay imperativo →
#   generar deploy con $do y cambiar kind
Teoría · Lo esencial

Las 4 ideas que no se negocian

  • Deployment → ReplicaSet → Pods. Rollout crea RS nuevo; rollback reactiva el viejo.
  • DaemonSet = uno por nodo. StatefulSet = identidad + storage estables.
  • ConfigMap (config) vs Secret (sensible, base64 ≠ cifrado). Se consumen como env o volumen.
  • HPA = más pods según carga. Necesita metrics-server + requests de CPU.
Este módulo conecta con Troubleshooting (30%): muchos pods rotos son por ConfigMaps/Secrets mal referenciados, o rollouts que fallan. Entender bien esto ahora te ahorra sufrir después.
Checkpoint Módulo 4: controllers (Deployment/DaemonSet/StatefulSet), config (ConfigMaps/Secrets), y HPA dominados. Siguiente: Módulo 5 — Scheduling (taints, affinity, resources).
Módulo 4 completado · Los workloads y su configuración · Siguiente: Scheduling avanzado