# ConfigMaps y Secrets

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

> Los workloads stateless igual tienen configuración: feature flags, URLs de bases de datos, bundles TLS, credenciales. Kubernetes tiene dos objetos de primera clase para eso — ConfigMaps (no sensibles) y Secrets (sensibles).

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

Los workloads stateless igual tienen configuración: feature flags, URLs
de bases de datos, bundles TLS, credenciales. Kubernetes tiene dos
objetos de primera clase para eso — **ConfigMaps** (no sensibles) y
**Secrets** (sensibles). Los dos se pueden inyectar como variables de
entorno o flags de línea de comandos, o montar como archivos. En este lab
aprendés cuándo usar cada uno.

## Objetivos de aprendizaje

1. Crear ConfigMaps y Secrets a partir de literales, archivos y
   directorios.
2. Inyectar configuración como variables de entorno o como archivos
   montados, y explicar por qué elegirías cada opción.
3. Entender la semántica de recarga de los projected volumes (¿se
   reinician los pods? ¿Cuándo?).
4. Usar ConfigMaps *inmutables* y conocer sus trade-offs.
5. Explicar por qué los Secrets en reposo están, por defecto, sin cifrar
   (`base64` es solo la codificación de la API), y qué hace falta
   realmente para tener cifrado en reposo.

## Contexto

### ConfigMap vs. Secret

Son casi el mismo objeto: un mapa de claves string a bytes arbitrarios.
Los Secrets se diferencian en que:

- No se muestran en la salida de `kubectl describe` (los valores se omiten).
- Pueden estar respaldados por un proveedor de cifrado en reposo mediante
  `EncryptionConfiguration` en el API server.
- Solo se envían a los nodos que corren un pod que los usa, y el kubelet
  los guarda en tmpfs, no en el disco del nodo.
- Hay que tratarlos como sensibles aunque por defecto etcd
  (`/registry/secrets`) los guarda sin cifrar; base64 es solo la
  codificación de la API.

### Variables de entorno vs. archivos montados

| Propiedad | Variables de entorno | Archivo montado |
|----------|----------|-----------|
| Cambia cuando se actualiza la fuente | No — se fija al arrancar el pod | Sí — en aproximadamente el período de sync del kubelet (~1 min) más la demora de la caché; nunca con montajes `subPath` |
| Visible en `/proc/<pid>/environ` | Sí (se filtra a los forks) | No |
| Límite de tamaño | 1 MB por Secret, ~1 MB por ConfigMap | Igual |
| Ideal para | Flags chicos, URLs | Bundles TLS, archivos de configuración |

Regla práctica: las credenciales, **montalas** como archivos; usá
**env** solo para valores escalares no sensibles.

### ConfigMaps inmutables

`spec.immutable: true` le dice al API server que rechace cualquier
actualización de un ConfigMap o Secret. Combinado con nombres versionados
(`app-config-v7`), esto te permite hacer rollouts atómicos de
configuración cambiando a qué ConfigMap referencia un Deployment; no hay
mutaciones in-place que el kubelet tenga que reconciliar.

## Recorrido guiado

### 1. ConfigMap desde un literal

```bash
kubectl create configmap app-config \
  --from-literal=LOG_LEVEL=info \
  --from-literal=FEATURE_X=true
kubectl describe configmap app-config
```

### 2. ConfigMap desde un archivo

```bash
cat > /tmp/app.conf <<'EOF'
log.level = info
feature.x = true
EOF
kubectl create configmap app-file --from-file=/tmp/app.conf
kubectl get configmap app-file -o yaml
```

### 3. Consumirlo como variables de entorno

```bash
kubectl apply -f manifests/consumer-env.yaml
kubectl logs deploy/consumer-env
```

El pod imprime las variables de entorno que recibió.

### 4. Consumirlo como volumen

```bash
kubectl apply -f manifests/consumer-file.yaml
kubectl exec deploy/consumer-file -- ls /etc/app
kubectl exec deploy/consumer-file -- cat /etc/app/LOG_LEVEL
```

Cambiá el ConfigMap y esperá hasta ~60 segundos:

```bash
kubectl patch configmap app-config --type=merge \
  -p '{"data":{"LOG_LEVEL":"debug"}}'
kubectl exec deploy/consumer-file -- cat /etc/app/LOG_LEVEL
# en algún momento imprime "debug"
```

El consumidor por variables de entorno nunca ve el cambio — necesitaría
reiniciar el pod.

### 5. Secrets

```bash
kubectl create secret generic db-cred \
  --from-literal=username=app \
  --from-literal=password='not-a-real-secret'
kubectl apply -f manifests/consumer-secret.yaml
```

Inspeccioná cómo queda el Secret guardado con `kubectl get secret db-cred -o yaml`
— fijate en los valores en base64. Esa es la *única* ofuscación que
tenés de fábrica.

## Desafíos

### C1. podinfo guiado por configuración

En el namespace `lab-04`, deployá dos réplicas de `podinfo` de forma que:

- `PODINFO_UI_COLOR` y `PODINFO_UI_MESSAGE` salgan de un ConfigMap
  llamado `podinfo-cfg`
- un Secret `Opaque` `podinfo-creds` con las claves `api_key` y
  `api_secret` esté montado en `/etc/podinfo/creds` (solo lectura)
- el Deployment tenga el label `app=podinfo`, y los labels del pod
  incluyan `app=podinfo`

### C2. Rollout de configuración inmutable

Creá `podinfo-cfg-v2` como un nuevo ConfigMap *inmutable* con un color
distinto. Actualizá el Deployment para que referencie `podinfo-cfg-v2`
(no `podinfo-cfg`). El rollout tiene que completarse; el verificador chequea
que `podinfo-cfg-v2` sea inmutable y que el Deployment lo referencie. **No** borres `podinfo-cfg` — el verificador chequea que
existan los dos.

### C3. Arreglá una referencia rota

Aplicá `manifests/broken-consumer.yaml`. Referencia una clave de
ConfigMap que no existe y, por lo tanto, nunca puede arrancar. Arreglalo
creando la clave faltante *sin* editar el manifiesto del Deployment ni el
template del pod del Deployment. El verificador chequea que `broken-cfg`
tenga ahora la clave `DB_URL` y que el Deployment tenga una réplica
disponible.

## Verificación

```bash
make verify LAB=04
```

## Para seguir leyendo

- Documentación de Kubernetes: [*Secrets*](https://kubernetes.io/docs/concepts/configuration/secret/), [*ConfigMaps*](https://kubernetes.io/docs/concepts/configuration/configmap/).
- [Encrypting Secret Data at Rest](https://kubernetes.io/docs/tasks/administer-cluster/encrypt-data/).
- Anatomía de un Secret que rota: mirá External Secrets Operator / Bank-Vaults.


## 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/04-config-secrets`:

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