# Pods y contenedores

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

> El Pod es el átomo del scheduling en Kubernetes. Todos los demás recursos de workload (Deployment, StatefulSet, Job, DaemonSet, …) terminan generando Pods. Si entendés los pods a fondo, el resto de Kubernetes se vuelve mucho más fácil.

> **Tiempo estimado:** 3 horas.
> **Requisitos previos:** lab 00.

El Pod es el átomo del scheduling en Kubernetes. Todos los demás recursos
de workload (Deployment, StatefulSet, Job, DaemonSet, …) terminan
generando Pods. Si entendés los pods a fondo, el resto de Kubernetes se
vuelve mucho más fácil.

## Objetivos de aprendizaje

1. Describir el ciclo de vida de un pod: `Pending → Running → (Succeeded|Failed)`
   y los estados intermedios de los contenedores.
2. Usar `kubectl logs`, `kubectl exec` y `kubectl debug` para inspeccionar
   un pod en ejecución.
3. Escribir un manifiesto de pod a mano, con resource requests, labels
   y annotations.
4. Implementar los patrones multicontenedor **sidecar** e
   **init-container**.
5. Entender *por qué* un mismo pod comparte un network namespace y los
   volúmenes, y qué implica eso para la seguridad.

## Contexto

### Anatomía

Un pod es un grupo de uno o más contenedores que comparten:

- Un network namespace (misma IP, mismo loopback, mismo espacio de puertos).
- Uno o más volúmenes.
- Un ciclo de vida — el pod se schedulea, y se termina, como una unidad.

Los contenedores dentro de un pod se pueden alcanzar entre sí por
`localhost`, cosa que muchas veces se confunde con una feature. Tomalo
como una vía de escape para procesos auxiliares muy acoplados, no como un
reemplazo de un service mesh.

### Init containers

Los `spec.initContainers` corren hasta completarse, en orden, *antes* de
que arranquen los contenedores principales. Comparten los volúmenes y el
network namespace del pod, pero corren antes de que exista cualquier
contenedor de la app. Casos de uso típicos:

- Esperar a que una dependencia esté accesible.
- Poblar un volumen compartido con assets, datos semilla o un bundle TLS.
- Correr migraciones de esquema antes de que arranque la app.

Si un init container falla, el kubelet lo reinicia según la
`restartPolicy` del pod y los contenedores principales nunca arrancan.

### Sidecars

Un sidecar es un contenedor de larga duración que complementa al
principal — envío de logs, proxy de service mesh, recargador de
configuración. Desde la 1.29 (activado por defecto; GA en la 1.33), los
sidecars tienen una representación de
primera clase (`initContainers[].restartPolicy: Always`) que arregla el
viejo bug de ciclo de vida en el que el contenedor principal terminaba
antes de que el sidecar terminara de vaciarse.

### Contenedores efímeros de debug

`kubectl debug pod/foo --image=busybox --target=foo` inyecta un
contenedor de vida corta en un pod que está corriendo, compartiendo sus
namespaces, así podés correr `ps`, `ss`, `nslookup` contra la app sin
reconstruir su imagen. Es una feature imprescindible para debuggear
imágenes distroless.

## Recorrido guiado

Los archivos que se mencionan abajo están en `manifests/`.

### 1. Un pod desde YAML

```bash
kubectl apply -f manifests/01-hello-pod.yaml
kubectl get pod hello -o wide
kubectl describe pod hello
```

Leé los `Events` al final de la salida de `describe`. Vas a ver:

1. `Scheduled` — el scheduler eligió un nodo.
2. `Pulled` — el kubelet bajó la imagen (o la reutilizó).
3. `Created` — containerd creó el contenedor.
4. `Started` — el contenedor está corriendo.

Estas son las etapas que vas a estar debuggeando el resto de tu carrera.

### 2. Observar el ciclo de vida

Provocá un crash y mirá el backoff de reinicios:

```bash
kubectl apply -f manifests/02-crash-pod.yaml
kubectl get pod crasher -w
```

Deberías ver aparecer `CrashLoopBackOff` después de unos cuantos
reinicios. El kubelet aplica un backoff exponencial con tope en 5
minutos — es a propósito; evita que una app rota se coma tu nodo.

### 3. Multicontenedor: sidecar

Aplicá `manifests/03-sidecar.yaml`. Tiene un productor que escribe
timestamps en `/data/app.log` y un sidecar que corre `tail -F` sobre el
mismo volumen. Inspeccioná la salida de cada contenedor por separado:

```bash
kubectl logs writer -c producer
kubectl logs writer -c tailer
```

### 4. Init containers

`manifests/04-init-wait.yaml` corre un init container que le hace `nslookup`
al nombre de un Service del clúster y solo termina cuando lo resuelve. Aplicalo
*antes* de crear el Service del que depende, y mirá cómo se queda
bloqueado:

```bash
kubectl apply -f manifests/04-init-wait.yaml
kubectl get pod waiter
# STATUS es Init:0/1

kubectl apply -f manifests/04-init-service.yaml
kubectl get pod waiter
# STATUS pasa a Running unos segundos después
```

### 5. Debuggear un pod sin shell

Aplicá `manifests/05-distroless.yaml` — usa
`registry.k8s.io/pause:3.9`, que no tiene shell. `kubectl exec`
falla. Usá `kubectl debug` en su lugar:

```bash
kubectl debug -it pod/quiet --image=busybox:1.36 --target=quiet -- sh
# dentro del contenedor de debug:
ps -ef
nslookup kubernetes.default.svc.cluster.local
```

## Desafíos

### C1. Un pod bien etiquetado

Creá un pod llamado `citizen` en el namespace `lab-01` con:

- imagen `ghcr.io/stefanprodan/podinfo:6.7.0`
- labels `app=citizen`, `tier=frontend`, `lab=01`
- annotation `owner=<your name>`
- resource requests `cpu=50m`, `memory=32Mi`, limits `cpu=200m`,
  `memory=128Mi`
- una readiness probe que haga HTTP GET a `/readyz` en el puerto 9898

### C2. Init container

Agregale a `citizen` un init container llamado `wait-dns` que corra
`busybox:1.36` y haga `nslookup kubernetes.default.svc.cluster.local` en
un loop hasta que funcione (el `nslookup` de busybox no aplica los
dominios de búsqueda, así que usá el nombre completo). No tiene que quedarse durmiendo para siempre — usá una
cantidad acotada de reintentos.

### C3. Sidecar que envía logs

Agregale a `citizen` un contenedor sidecar llamado `logger` (imagen
`busybox:1.36`) que siga el contenido de `/var/log/app/access.log`,
compartido desde el contenedor principal mediante un `emptyDir`. El
contenedor principal en realidad no escribe en ese archivo — no pasa
nada; el sidecar solo tiene que estar corriendo. Hacé que `logger` sea
un contenedor normal (el verificador lo busca en `spec.containers`).

### C4. Un pod que falla, a propósito

Creá un segundo pod `failer` que termine con código 137 después de 5
segundos (`sh -c 'sleep 5; exit 137'`) con `restartPolicy: OnFailure`. El
verificador chequea la restart policy y avisa si el kubelet todavía no
lo reinició.

## Verificación

```bash
make verify LAB=01
```

## Para seguir leyendo

- Documentación de Kubernetes: [*Pod lifecycle*](https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle/).
- Burns & Oppenheimer, [*Design patterns for container-based distributed systems*](https://static.googleusercontent.com/media/research.google.com/en//pubs/archive/45406.pdf).
- KEP-753: [Sidecar Containers](https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/753-sidecar-containers).


## 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/01-pods`:

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