# Deployments y ReplicaSets

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

> Los pods se mueren. Los nodos se mueren. Los que operan con kubectl se equivocan y borran cosas. Si querés workloads que sobrevivan a todo eso, necesitás un controller que reconcilie por vos.

> **Tiempo estimado:** 4 horas.
> **Requisitos previos:** lab 01.

Los pods se mueren. Los nodos se mueren. Los que operan con `kubectl` se
equivocan y borran cosas. Si querés workloads que sobrevivan a todo eso,
necesitás un controller que reconcilie por vos. En Kubernetes, el
principal para workloads stateless es el **Deployment**, que administra
**ReplicaSets**, que a su vez administran **Pods**.

## Objetivos de aprendizaje

1. Explicar la relación Deployment → ReplicaSet → Pod y por qué existen
   dos niveles de indirección.
2. Hacer un rolling update con un `maxSurge` / `maxUnavailable` específico
   y razonar sobre cómo se comporta.
3. Hacer rollback de un deployment fallido con `kubectl rollout undo`.
4. Usar `kubectl rollout` para pausar, reanudar y seguir un rollout.
5. Implementar un patrón blue/green o canary sobre Deployments.

## Contexto

### ¿Por qué dos capas?

Un ReplicaSet mantiene exactamente un template de réplica. Cuando cambiás
el template (por ejemplo, subís el tag de la imagen), el ReplicaSet no
tiene noción de "viejo" y "nuevo": los pods existentes siguen con el
template viejo y solo los pods que se creen después usan el nuevo. No hay
ningún reemplazo controlado.

Un Deployment resuelve esto creando *varios* ReplicaSets — uno por cada
versión del template del pod — y pasando réplicas del RS viejo al nuevo
a lo largo del tiempo. La cantidad de objetos RS que Kubernetes conserva
la controla `spec.revisionHistoryLimit` (por defecto 10), y es lo que lee
`kubectl rollout history`.

### Parámetros del rolling update

```yaml
spec:
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 25%           # pods extra por encima de replicas durante el rollout
      maxUnavailable: 25%     # pods que pueden estar Not Ready durante el rollout
```

Con `maxUnavailable: 0` tenés cero downtime, a costa de necesitar margen
para al menos un pod extra. Con `maxSurge: 0` obligás a reemplazar los
pods de a uno dentro de la capacidad existente.

### Recreate

`strategy.type: Recreate` mata primero todos los pods y después crea el
conjunto nuevo. Sirve para workloads que no pueden correr dos versiones
en paralelo (por ejemplo, un singleton que escribe en un archivo local).

### Rollbacks

Cada apply que cambia el template del pod crea una nueva revisión.
`kubectl rollout undo deployment/web` pasa la cantidad de réplicas del RS
actual de vuelta al anterior. Esto *no* revierte tu manifiesto —
igual tenés que arreglar el YAML antes del próximo apply.

## Recorrido guiado

### 1. Primer rollout

```bash
kubectl apply -f manifests/deploy-v1.yaml
kubectl rollout status deployment/podinfo
kubectl get rs -l app=podinfo
kubectl get pods -l app=podinfo -o wide
```

Fijate que tenés un solo ReplicaSet. Mirá su nombre — contiene un hash
del template del pod.

### 2. Rolling update

```bash
kubectl apply -f manifests/deploy-v2.yaml
kubectl rollout status deployment/podinfo
kubectl get rs -l app=podinfo            # ahora hay dos RS
kubectl rollout history deployment/podinfo
```

### 3. Un rollout fallido + rollback

```bash
kubectl apply -f manifests/deploy-bad.yaml
kubectl rollout status deployment/podinfo --timeout=30s   # se vence el timeout
kubectl get pods -l app=podinfo                            # trabados en ImagePullBackOff

kubectl rollout undo deployment/podinfo
kubectl rollout status deployment/podinfo
```

### 4. Pausar y reanudar

Pausar te deja apilar varios cambios y aplicarlos en un solo rollout,
que es como los operadores a escala de flota hacen rollouts graduales:

```bash
kubectl rollout pause deployment/podinfo
kubectl set image deployment/podinfo app=ghcr.io/stefanprodan/podinfo:6.8.0
kubectl set env deployment/podinfo LAB=02
kubectl rollout resume deployment/podinfo
```

## Desafíos

### C1. Un Deployment bien configurado

En el namespace `lab-02`, creá un Deployment llamado `web` con:

- 4 réplicas de `ghcr.io/stefanprodan/podinfo:6.7.0`
- labels `app=web`, `lab=02`, `track=stable` en el template del pod, y
  selector `app=web`, `track=stable`
- `strategy.type=RollingUpdate`, `maxSurge=1`, `maxUnavailable=0`
- resource requests `cpu=25m`, `memory=32Mi`
- readiness probe en `/readyz`:9898
- `revisionHistoryLimit: 5`

### C2. Rolling update, observado

Actualizá `web` a `ghcr.io/stefanprodan/podinfo:6.7.1`. El verificador
chequea que la imagen se haya actualizado y avisa si hay menos de dos
ReplicaSets registrados (uno viejo y uno nuevo).

### C3. Canary con un segundo Deployment

Creá un segundo Deployment llamado `web-canary` en el mismo namespace,
idéntico byte a byte a `web` salvo por:

- 1 réplica
- imagen `ghcr.io/stefanprodan/podinfo:6.8.0`
- los labels del pod y el selector usan `track=canary` (mientras que
  `web` tiene `track=stable`)

En el lab 03 un único Service va a seleccionar los dos Deployments; por
ahora alcanza con que los dos estén corriendo.

## Verificación

```bash
make verify LAB=02
```

## Para seguir leyendo

- Documentación de Kubernetes: [*Deployments*](https://kubernetes.io/docs/concepts/workloads/controllers/deployment/).
- Google SRE, [*Canarying releases*](https://sre.google/workbook/canarying-releases/).
- Marc Brooker, [*Software Deployment, Speed, and Safety*](https://brooker.co.za/blog/2022/01/31/deployments.html).


## 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/02-deployments`:

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