# Proyecto integrador

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

> Diseñá, desplegá y operá una aplicación multicapa no trivial en el clúster de kind.

> **Tiempo estimado:** 8 horas.
> **Requisitos previos:** todos los labs anteriores.

Diseñá, desplegá y operá una aplicación multicapa no trivial en
el clúster de kind. El proyecto integrador se corrige a mano según la rúbrica
de [`GRADING.md`](https://github.com/AlfonsoCampodonico/k8s-labs/blob/main/GRADING.md); hay un verificador automático básico
que sirve como control de cordura, pero no alcanza para la nota completa.

## La aplicación

Vas a desplegar un servicio de notas de tres capas llamado **scribe**:

```
+-----------+        +------------+        +------------+
|  browser  |  HTTP  |  frontend  |  HTTP  |  backend   |
+-----------+ -----> | (nginx)    | -----> | (podinfo   |
      ^              +------------+        |  serving   |
      |                                    |  JSON)     |
      |                                    +-----+------+
      |                                          |
      |                                          v
      |                                    +------------+
      |                                    |  postgres  |
      |                                    |  (single   |
      |                                    |  replica)  |
      +------------------------------------+------------+
```

Podés reemplazar `podinfo` por cualquier servicio HTTP que elijas y
`postgres` por cualquier carga de trabajo con estado (Redis, MySQL), siempre que sea
software real con una semántica de datos real.

## Requisitos

Tu entrega tiene que incluir todo lo siguiente.

### Arquitectura (entregable: `ARCHITECTURE.md`)

- Un diagrama del sistema.
- Un párrafo por componente: responsabilidad, modo de falla y cómo se
  recupera al reiniciarse.
- Una nota sobre cómo escalarías horizontalmente cada capa.

### Requisitos de plataforma (el verificador controla una parte)

Todo en el namespace `lab-12`:

1. Tres Deployments u objetos de carga de trabajo: `frontend`, `backend`,
   `postgres` (un StatefulSet con un Service headless y un PVC). Poneles a
   los pods de `frontend` y `backend` los labels `app=frontend` /
   `app=backend`; el verificador los busca por ese label.
2. Services: `frontend` (ClusterIP), `backend` (ClusterIP), `postgres`
   (headless).
3. Un Ingress que rutee el host `scribe.k8s-labs.test` a `frontend`.
4. Un Secret `postgres-credentials` con las claves `username`, `password`,
   `database` — consumido por `postgres` y `backend`.
5. Un ConfigMap usado por al menos una carga de trabajo (por ejemplo, `backend-config`
   con feature flags).
6. Requests y limits de recursos en todos los contenedores.
7. `readinessProbe` en `frontend` y `backend`.
8. Un HorizontalPodAutoscaler que apunte a `backend` (mín. 2, máx. 6, según
   la utilización de CPU).
9. Cuatro NetworkPolicies:
   - `default-deny-ingress` que seleccione todos los pods.
   - `allow-frontend-to-backend` que abra TCP hacia `backend` desde
     `frontend`.
   - `allow-ingress-to-frontend` que abra TCP hacia `frontend` desde el
     namespace `ingress-nginx`.
   - `allow-backend-to-postgres` que abra TCP hacia `postgres` solo desde
     `backend` (obligatoria — sin ella el backend no llega a la base).
10. Label de Pod Security Admission en el namespace con nivel de al menos
    `baseline`.
11. Un Helm chart `charts/scribe/` que renderice toda la aplicación.
    `helm install scribe ./charts/scribe -n lab-12` tiene que producir el
    estado descripto arriba partiendo de un clúster limpio.

### Demo operativa (entregable: grabación de pantalla de 10 minutos)

Mostrale al corrector:

1. Un `helm install` limpio de tu chart.
2. El Ingress funcionando con `curl -H 'Host: scribe.k8s-labs.test' http://localhost:8080/`.
3. Un escenario de falla y cómo lo debuggeás (matá un pod de postgres y mostrá
   que la app se recupera; o rompé una probe y mostrá cómo falla el rollout;
   o pasate de un límite de memoria y observá el OOMKill).
4. Un rolling update de `backend` a un nuevo tag de imagen sin downtime
   (usá un cambio de versión de `podinfo` o algo equivalente).

### Entrega

Comprimí en un zip o pusheá una carpeta con:

```
scribe/
├── ARCHITECTURE.md
├── charts/
│   └── scribe/
│       ├── Chart.yaml
│       ├── values.yaml
│       └── templates/
├── manifests/          # opcional — si también querés una versión sin Helm
└── recording.mp4
```

Dejala en `labs/12-capstone/submission/` para el corrector.

## Verificación (control de cordura)

```bash
make verify LAB=12
```

Esto chequea que los recursos requeridos existan y estén Ready. Por sí
solo no otorga puntos — mirá `GRADING.md`.

## Lecturas recomendadas

- [Benchmarks de microservicios del mundo real](https://github.com/GoogleCloudPlatform/microservices-demo) para inspirarte.
- Bilgin Ibryam, *Kubernetes Patterns*, 2.ª ed.
- Cindy Sridharan, [*Distributed systems observability*](https://www.oreilly.com/library/view/distributed-systems-observability/9781492033431/) — te va a servir para la demo operativa.


## Correrlo

Con Docker, kind y kubectl instalados, desde la raíz del repositorio:

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