# RBAC y seguridad

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

> Cada request al API server se autentica (¿quién sos?), se autoriza (¿tenés permiso?) y se admite (¿lo que querés hacer está permitido por la política del clúster?).

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

Cada request al API server se **autentica** (¿quién sos?), se
**autoriza** (¿tenés permiso?) y se **admite** (¿lo que querés hacer
está permitido por la política del clúster?). Este lab se centra en la
segunda etapa — **Role-Based Access Control** — y la complementa con
otras dos defensas de nivel producción: las **NetworkPolicies** y los
estándares de **Pod Security Admission**.

## Objetivos de aprendizaje

1. Distinguir Users, Groups y ServiceAccounts como sujetos de RBAC.
2. Escribir Roles, RoleBindings, ClusterRoles y ClusterRoleBindings
   con alcances de mínimo privilegio.
3. Usar `kubectl auth can-i` para probar decisiones de autorización.
4. Escribir NetworkPolicies de default-deny y permitir solo el tráfico que
   querés.
5. Etiquetar un namespace con `pod-security.kubernetes.io/enforce` para bloquear
   cargas de trabajo privilegiadas.

## Contexto

### Modelo de RBAC

```
Subject (user / SA / group)
   |
 (Binding)
   |
   v
Role / ClusterRole  — list of (apiGroup, resource, verb) tuples
```

Los bindings son por namespace (`RoleBinding`) o de todo el clúster
(`ClusterRoleBinding`). Los ClusterRoles se pueden reutilizar dentro de un namespace
referenciándolos desde un `RoleBinding`.

### NetworkPolicies

Una NetworkPolicy se aplica según los labels de los pods. Si *alguna* NetworkPolicy
selecciona a un pod, ese pod queda sujeto a políticas y solo puede circular el tráfico
permitido explícitamente; los pods que ninguna NetworkPolicy selecciona no tienen
restricciones. Por eso un default-deny es una única política que selecciona
todo y no permite nada.

Necesitás un CNI que implemente NetworkPolicy. El `kindnet` que trae kind
por defecto lo hace desde kind v0.24.0 (las versiones anteriores ignoran
las políticas sin avisar, y el paso "bloqueado" de abajo seguiría
funcionando). Calico y Cilium también funcionan.

### Pod Security Admission

PSA es el sucesor de PodSecurityPolicy. Etiquetás un namespace con
uno o más de:

- `pod-security.kubernetes.io/enforce=<level>`
- `pod-security.kubernetes.io/audit=<level>`
- `pod-security.kubernetes.io/warn=<level>`

con `level` en `{privileged, baseline, restricted}`. El plugin de admisión
rechaza (o audita, o advierte sobre) los pods que no cumplen ese nivel.

## Recorrido guiado

### 1. Una ServiceAccount con permiso para listar pods

```bash
kubectl apply -f manifests/viewer-role.yaml
kubectl auth can-i list pods --as=system:serviceaccount:default:viewer
# yes
kubectl auth can-i delete pods --as=system:serviceaccount:default:viewer
# no
```

### 2. Usá la SA desde adentro del clúster

```bash
kubectl apply -f manifests/viewer-pod.yaml
kubectl logs viewer-pod
# lista los pods usando el token de la SA montado en /var/run/secrets/...
```

### 3. NetworkPolicy de default-deny

```bash
kubectl create namespace policy-demo
kubectl -n policy-demo apply -f manifests/policy-demo.yaml
kubectl -n policy-demo exec deploy/a -- wget -qO- http://b --timeout=3
# funciona — todavía no hay políticas
kubectl -n policy-demo apply -f manifests/default-deny.yaml
kubectl -n policy-demo exec deploy/a -- wget -qO- http://b --timeout=3
# bloqueado
kubectl -n policy-demo apply -f manifests/allow-a-to-b.yaml
kubectl -n policy-demo exec deploy/a -- wget -qO- http://b --timeout=3
# funciona de nuevo
```

### 4. Pod Security Admission

```bash
kubectl create namespace restricted
kubectl label ns restricted pod-security.kubernetes.io/enforce=restricted
kubectl -n restricted apply -f manifests/privileged-pod.yaml
# el API server lo rechaza: "violates PodSecurity \"restricted:latest\""
```

## Desafíos

### C1. SA de lectura acotada a un namespace

En `lab-09`, creá:

- una ServiceAccount `reader`
- un Role `pod-reader` que permita `get`, `list`, `watch` sobre pods
- un RoleBinding que vincule `reader` → `pod-reader`
- verificalo con `kubectl auth can-i get pods -n lab-09 --as=system:serviceaccount:lab-09:reader`, que tiene que devolver `yes`

### C2. Default-deny + permiso explícito

En `lab-09`:

- un Deployment `frontend` (imagen `nginx:1.27-alpine`, label `app=frontend`)
- un Deployment `backend` (imagen `nginx:1.27-alpine`, label `app=backend`)
- un Service `backend` que seleccione `app=backend`
- una NetworkPolicy `default-deny-ingress` que seleccione todos los pods y
  deniegue todo el ingress
- una NetworkPolicy `allow-frontend-to-backend` que permita el ingress a los
  pods `app=backend` desde los pods `app=frontend` en el puerto 80

### C3. Aplicá PSA baseline

Etiquetá el namespace `lab-09` con
`pod-security.kubernetes.io/enforce=baseline`. Intentá crear un pod
con `privileged: true` y observá el rechazo. El verificador chequea
que el label esté puesto; el rechazo es parte del recorrido.

## Verificación

```bash
make verify LAB=09
```

## Lecturas recomendadas

- [Buenas prácticas de RBAC](https://kubernetes.io/docs/concepts/security/rbac-good-practices/).
- [Recetas de NetworkPolicy](https://github.com/ahmetb/kubernetes-network-policy-recipes).
- [Pod Security Standards](https://kubernetes.io/docs/concepts/security/pod-security-standards/).


## 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/09-rbac-security`:

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