# Almacenamiento

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

> La mayoría de las aplicaciones interesantes necesitan almacenamiento que sobreviva a un pod.

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

La mayoría de las aplicaciones interesantes necesitan almacenamiento que
sobreviva a un pod. En este lab aprendés la abstracción de tres niveles
que usa Kubernetes: **Volume** (lo que ve un pod), **PersistentVolume**
(un recurso de todo el clúster) y **StorageClass** (un template para
aprovisionar PVs dinámicamente).

## Objetivos de aprendizaje

1. Distinguir los tipos de volumen con alcance de pod (`emptyDir`,
   `hostPath`, `projected`) de los que reclaman un PersistentVolume, que
   tiene alcance de clúster (`persistentVolumeClaim`).
2. Bindear a mano un PVC a un PV aprovisionado de antemano.
3. Usar la StorageClass por defecto de kind (`standard` / `rancher.io/local-path`)
   para aprovisionamiento dinámico.
4. Razonar sobre `accessModes` (RWO vs. ROX vs. RWX) y
   `reclaimPolicy` (Delete, Retain).
5. Comprobar que los reinicios del pod conservan los datos; borrar el PVC,
   no.

## Contexto

### Qué hace el provisioner "local-path" en kind

kind viene con el `local-path-provisioner` de Rancher, que crea
PersistentVolumes respaldados por directorios `hostPath` en el nodo. Cada
PV es RWO y queda atado a un único nodo. Para los labs está bien; para
producción es una pésima elección (sin replicación, sin resize, sin
snapshots), pero es un reemplazo realista de un driver CSI.

### Ciclo de vida del binding

```
PVC created → controller finds matching PV (or provisions one)
            → bind (PVC.spec.volumeName = PV, PV.spec.claimRef = PVC)
            → pod scheduled onto a node that can mount the volume
```

Con una StorageClass dinámica, el paso 1 dispara el provisioner, que crea
un PV nuevo. Con un PV aprovisionado de antemano, el PV lo creás vos y el
scheduler igual tiene que respetar su `nodeAffinity`.

### accessModes

| Modo | Significado |
|------|---------|
| `ReadWriteOnce` (RWO) | Un *nodo* a la vez (varios pods en el mismo nodo están bien; desde la 1.22 existe `ReadWriteOncePod` para una semántica más estricta) |
| `ReadOnlyMany` (ROX)  | Muchos nodos, solo lectura |
| `ReadWriteMany` (RWX) | Muchos nodos, lectura y escritura — necesita un driver tipo NFS/CephFS |
| `ReadWriteOncePod` (RWOP) | Exactamente un pod |

## Recorrido guiado

### 1. StorageClass por defecto

```bash
kubectl get storageclass
# NAME (default)   PROVISIONER             RECLAIMPOLICY  ...
# standard         rancher.io/local-path   Delete
```

### 2. PVC dinámico

```bash
kubectl apply -f manifests/pvc-dynamic.yaml
kubectl get pvc
# Pending al principio — el binding es lazy hasta que un pod lo monta
kubectl apply -f manifests/writer-dynamic.yaml
kubectl get pvc
# Ahora Bound
kubectl exec deploy/writer -- sh -c 'cat /data/log.txt'
```

Borrá el Deployment y volvé a crearlo; los datos sobreviven:

```bash
kubectl delete deploy writer
kubectl apply -f manifests/writer-dynamic.yaml
kubectl exec deploy/writer -- sh -c 'cat /data/log.txt'
```

Borrá el PVC y los datos desaparecen (reclaimPolicy `Delete`):

```bash
kubectl delete deploy writer   # un PVC en uso se conserva hasta que ningún pod lo monte
kubectl delete pvc data
```

### 3. PV aprovisionado de antemano

```bash
kubectl apply -f manifests/pv-static.yaml
kubectl apply -f manifests/pvc-static.yaml
kubectl apply -f manifests/writer-static.yaml
```

Fijate cómo `pv-static.yaml` declara una `nodeAffinity` — el PV solo se
puede usar desde un nodo, así que el scheduler tiene que poner el pod ahí.

## Desafíos

### C1. podinfo persistente

En `lab-05`, deployá `ghcr.io/stefanprodan/podinfo:6.7.1` con un PVC
llamado `podinfo-data` (1Gi, RWO, StorageClass por defecto) montado en
`/data`. El pod tiene que seguir Ready.

### C2. Sobrevivir a un reinicio del pod

Entrá al pod con exec y hacé `echo hello > /data/hello.txt`. Borrá el pod
y dejá que el Deployment lo vuelva a crear. El archivo tiene que seguir
existiendo.

### C3. Un PV estático que no podés aprovisionar dinámicamente

Creá un PV llamado `archive` con `capacity=500Mi`, `hostPath: /var/local/archive`,
`storageClassName: ""` (vacío — no dinámico), `accessModes: [ReadOnlyMany]`,
`persistentVolumeReclaimPolicy: Retain`. Después, un PVC llamado `archive` en `lab-05` que
se bindee a él. El verificador confirma que el PVC esté `Bound` y que
referencie ese PV en particular.

Si te trabás, hay una solución de referencia en `solutions/`.

## Verificación

```bash
make verify LAB=05
```

## Para seguir leyendo

- [Kubernetes Storage Concepts](https://kubernetes.io/docs/concepts/storage/).
- [Spec de CSI](https://github.com/container-storage-interface/spec).
- El [local-path-provisioner](https://github.com/rancher/local-path-provisioner) de Rancher.


## 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/05-storage`:

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