# Salud, recursos y autoscaling

Lab de K8s 08 · Laboratorios de Kubernetes · Sistemas Operativos
Page: https://alfonsocampodonico.com/classes/operating-systems/kubernetes-08-health-resources?lang=es
Code: https://github.com/AlfonsoCampodonico/k8s-labs/tree/main/labs/08-health-resources (`gh repo clone AlfonsoCampodonico/k8s-labs`)

> Tres conceptos distintos que los estudiantes suelen mezclar: las probes le dicen al kubelet si un contenedor está vivo, listo o arrancando; los resources le dicen al scheduler y al kernel cuánta CPU y memoria espera un contenedor; y el HorizontalPodAutoscaler ajusta la cantidad de réplicas a partir de métricas observadas.

> **Tiempo estimado:** 4 horas.
> **Requisitos previos:** labs 02 y 03.

Tres conceptos distintos que los estudiantes suelen mezclar: las **probes** le
dicen al kubelet si un contenedor está vivo, listo o arrancando; los **resources**
le dicen al scheduler y al kernel cuánta CPU y memoria espera un contenedor;
y el **HorizontalPodAutoscaler** ajusta la cantidad de réplicas a partir de
métricas observadas. Cada uno resuelve un problema distinto.

## Objetivos de aprendizaje

1. Elegir la probe correcta para cada caso — `livenessProbe`, `readinessProbe`,
   `startupProbe` — y evitar el error clásico de configuración de usar
   liveness para detectar arranques lentos.
2. Explicar la relación entre `resources.requests` (scheduling),
   `resources.limits` (cumplimiento de límites) y las clases de QoS (orden de desalojo).
3. Instalar `metrics-server` en kind y leer las métricas del clúster.
4. Configurar un HorizontalPodAutoscaler y observar cómo escala bajo
   carga sintética.

## Contexto

### Probes

| Probe | Propósito | Si falla |
|-------|---------|-----------|
| startupProbe | "¿La app terminó de arrancar?" | Sigue probando; liveness y readiness se saltean durante el arranque |
| readinessProbe | "¿La app puede atender requests *ahora mismo*?" | Saca al pod de los endpoints del Service |
| livenessProbe | "¿La app está sana? (o sea, ¿tengo que reiniciarla?)" | Reinicia el contenedor |

Error común: una liveness probe con un delay inicial corto en una app
que tarda 60 segundos en arrancar. El kubelet mata al contenedor en pleno arranque.
Usá una startupProbe en su lugar.

### Clases de QoS

Se derivan automáticamente de los requests/limits de cada contenedor del pod:

| Clase | Condición |
|-------|-----------|
| `Guaranteed` | Todos los contenedores tienen requests == limits tanto para CPU como para memoria |
| `Burstable`  | Al menos un contenedor tiene requests o limits, pero no es Guaranteed |
| `BestEffort` | Ningún request ni limit en ningún lado |

Bajo presión de memoria, el kubelet ordena los pods según si el uso supera los requests,
después por prioridad y después por uso relativo al request — por eso los BestEffort
(requests = 0) suelen caer primero y los Guaranteed últimos.

### HPA

```yaml
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
spec:
  scaleTargetRef: { kind: Deployment, name: web, apiVersion: apps/v1 }
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target: { type: Utilization, averageUtilization: 50 }
```

El controlador del HPA lee las métricas de los pods a través de `metrics.k8s.io` (que sirve
metrics-server), calcula la cantidad deseada de réplicas y la escribe en el
`spec.replicas` del Deployment. El loop corre cada 15 segundos.

## Recorrido guiado

### 1. Instalá metrics-server (compatible con kind)

```bash
kubectl apply -f manifests/metrics-server.yaml
kubectl -n kube-system rollout status deployment/metrics-server --timeout=120s
kubectl top nodes
kubectl top pods -A
```

### 2. Probes

```bash
kubectl apply -f manifests/probes-demo.yaml
kubectl get pod slow-start -w
# la startup probe mantiene a raya a la liveness durante los primeros ~20 segundos
```

### 3. Prueba de carga del HPA

```bash
kubectl apply -f manifests/web-hpa.yaml
kubectl run -it --rm loader --image=busybox:1.36 -- sh
# adentro:
while true; do wget -qO- http://web/; done
```

En otra terminal:

```bash
kubectl get hpa web -w
```

## Desafíos

### C1. Un trío de probes

En `lab-08`, un Deployment `api` que corra `ghcr.io/stefanprodan/podinfo:6.7.1`
con:

- `startupProbe` en `/healthz`, `failureThreshold: 30`, `periodSeconds: 2`
- `readinessProbe` en `/readyz`, `periodSeconds: 5`
- `livenessProbe` en `/healthz`, `periodSeconds: 10`,
  `failureThreshold: 3`
- resources: `requests.cpu=50m`, `requests.memory=64Mi`,
  `limits.cpu=200m`, `limits.memory=128Mi`
- 2 réplicas al principio

### C2. Clases de QoS

Creá tres pods `besteffort`, `burstable`, `guaranteed` en `lab-08`
cuya configuración de resources en el contenedor ubique a cada pod en la
clase de QoS correspondiente. El verificador inspecciona `.status.qosClass` directamente.

### C3. Un Deployment con autoscaling

Creá un HPA llamado `api` en `lab-08` que apunte al Deployment `api`:

- `minReplicas: 2`
- `maxReplicas: 6`
- utilización promedio de CPU del 50%

## Verificación

```bash
make verify LAB=08
```

## Lecturas recomendadas

- [Probes en Kubernetes](https://kubernetes.io/docs/tasks/configure-pod-container/configure-liveness-readiness-startup-probes/).
- [Recorrido por el HPA](https://kubernetes.io/docs/tasks/run-application/horizontal-pod-autoscale-walkthrough/).
- [Desalojo por presión en el nodo](https://kubernetes.io/docs/concepts/scheduling-eviction/node-pressure-eviction/).


## Correrlo

Con Docker, kind y kubectl instalados, corré los targets de `make` desde la
raíz del repositorio; para los comandos del recorrido, que usan rutas
relativas al lab, primero `cd labs/08-health-resources`:

```sh
./bin/preflight.sh
make cluster
make lab LAB=08
make verify LAB=08
```
