# Puesta en marcha

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

> Este lab es un precalentamiento. Al terminarlo vas a tener un clúster de kind andando, un kubectl que funciona y un modelo mental básico de lo que acaba de pasar.

> **Tiempo estimado:** 1 hora.
> **Requisitos previos:** ninguno — acá es donde arrancás.

Este lab es un precalentamiento. Al terminarlo vas a tener un clúster de
kind andando, un `kubectl` que funciona y un modelo mental básico de lo que
acaba de pasar. También vas a conocer el corrector automático que vas a
usar durante el resto de la materia.

## Objetivos de aprendizaje

Después de este lab podés:

1. Instalar y verificar las herramientas que pide la materia.
2. Crear y destruir un clúster de Kubernetes multinodo en tu notebook.
3. Enumerar los componentes del control plane y explicar el rol de cada uno.
4. Cambiar de namespace y de contexto con `kubectl`.
5. Leer un recurso del clúster de tres maneras distintas (`get`,
   `describe`, `get -o yaml`).

## Contexto

### ¿Qué es Kubernetes, en realidad?

Kubernetes es un lazo de control. Vos escribís lo que querés ("tres copias
de este contenedor, siempre") y los controllers del sistema observan el
clúster todo el tiempo y actúan para achicar la diferencia entre el
*estado declarado* (lo que escribiste) y el *estado real* (lo que está
corriendo). Nada más — ni colas, ni motor de workflows — solamente cientos
de pequeños lazos que leen y escriben en un almacén de datos compartido.

Ese almacén compartido es **etcd**. El único proceso que habla con etcd
directamente es el **kube-apiserver**. Todo lo demás — controllers, el
scheduler, tu `kubectl` — habla con el API server por HTTPS. Eso convierte
al API server en lo único que de verdad no podés perder.

### ¿Qué es kind?

[`kind`](https://kind.sigs.k8s.io) empaqueta Kubernetes dentro de
contenedores de Docker. Cada "nodo" es un contenedor que corre un kubelet
real, containerd y (en los nodos del control plane) el API server, el
scheduler y el controller-manager. Visto *desde adentro* del clúster, se ve
exactamente igual que un clúster real. Las salvedades están en [`docs/kind-notes.md`](https://github.com/AlfonsoCampodonico/k8s-labs/blob/main/docs/kind-notes.md)
— pegale una leída rápida ahora.

## Recorrido guiado

### 1. Chequeo previo

```bash
./bin/preflight.sh
```

Cada línea tiene que empezar con `PASS`. Si no, instalá la herramienta que
falta y volvé a correrlo.

### 2. Creá el clúster

```bash
make cluster
```

Esto corre `kind create cluster --config clusters/kind-basic.yaml`. Mirá
ese archivo — describe un nodo de control plane y dos workers, y le pide a
kind que le ponga un label al nodo del control plane para que un Ingress
controller pueda bindearse a los puertos 80/443. Cuando termine el comando
deberías ver (la columna VERSION depende de tu versión de kind):

```text
Nodes:
NAME                       STATUS   ROLES           AGE   VERSION
k8s-labs-control-plane     Ready    control-plane   30s   v1.3x.x
k8s-labs-worker            Ready    <none>          20s   v1.3x.x
k8s-labs-worker2           Ready    <none>          20s   v1.3x.x
```

### 3. Conocé el control plane

Los componentes del control plane corren como static pods en el namespace
`kube-system`, junto a los add-ons del clúster (kindnet, kube-proxy,
coredns), que son DaemonSets y Deployments comunes:

```bash
kubectl -n kube-system get pods
```

Tomate un minuto para ubicar lo que ves:

- `etcd-k8s-labs-control-plane` — el almacén clave/valor.
- `kube-apiserver-k8s-labs-control-plane` — lo único que habla con
  etcd. Todos los demás componentes hablan con él.
- `kube-controller-manager-...` — un único binario que aloja docenas de
  controllers (Deployment, ReplicaSet, Node, Namespace, …).
- `kube-scheduler-...` — asigna los pods pendientes a nodos.
- `kindnet-...` — el plugin CNI que les da direcciones IP a los pods.
- `coredns-...` — el DNS interno del clúster.
- `kube-proxy-...` — programa iptables/ipvs en los nodos para los Services.

Corré `kubectl -n kube-system describe pod kube-apiserver-k8s-labs-control-plane`
y leé los argumentos. Todo lo importante de tu clúster — admission
plugins, feature gates, cifrado — está codificado ahí.

### 4. Namespaces y contextos

Un *contexto* es una terna (clúster, usuario, namespace) en tu kubeconfig.
Un *namespace* delimita el alcance de los recursos dentro de un clúster.

```bash
kubectl config current-context          # imprime kind-k8s-labs
kubectl get namespaces

kubectl create namespace lab-00
kubectl config set-context --current --namespace=lab-00
kubectl get all                         # vacío, ahora estás en lab-00
```

Siempre podés volver a `default` con el mismo comando.

### 5. Tu primer pod, de tres maneras

Creá un pod con el comando imperativo:

```bash
kubectl run hello --image=nginx:1.27-alpine
```

Inspeccionalo de tres maneras. Fijate qué resalta cada vista:

```bash
kubectl get pod hello                   # resumen de una línea
kubectl describe pod hello              # legible para humanos, incluye los Events
kubectl get pod hello -o yaml           # manifiesto declarativo completo
```

Cuando hayas leído el YAML, limpiá:

```bash
kubectl delete pod hello
```

## Desafíos

Completá los tres antes de correr el verificador.

### C1. Dos namespaces

Creá dos namespaces, `lab-00-alpha` y `lab-00-beta`, cada uno con el label
`lab=bootstrap`. El verificador chequea los labels, no solamente que
existan.

### C2. Un pod en cada namespace

Creá un pod de nginx llamado `sentinel` en cada uno de los dos namespaces.
Usá la imagen oficial `nginx:1.27-alpine`. Los pods tienen que llegar a la
fase `Running` y estar `Ready`.

### C3. Un hábito de kubeconfig

Configurá `lab-00-alpha` como namespace por defecto de tu contexto actual.
El verificador lee tu kubeconfig para chequearlo.

Hay una solución de referencia en [`solutions/`](https://github.com/AlfonsoCampodonico/k8s-labs/tree/main/labs/00-bootstrap/solutions/), pero no la abras
hasta haber intentado los desafíos.

## Verificación

```bash
make verify LAB=00
```

Cada línea tiene que empezar con `PASS`. Cualquier `FAIL` te explica qué
esperaba y qué encontró.

Cuando el verificador pase, volvé atrás:
`kubectl config set-context --current --namespace=default`. Los
recorridos de los labs siguientes asumen `default`.

## Para seguir leyendo

- Conceptos oficiales: [Kubernetes Components](https://kubernetes.io/docs/concepts/overview/components/).
- Brendan Burns, [*Designing Distributed Systems*, capítulo 1](https://azure.microsoft.com/en-us/resources/designing-distributed-systems/).
- [Kubernetes the Hard Way](https://github.com/kelseyhightower/kubernetes-the-hard-way) — una vez que te sientas cómodo, esta es la próxima montaña.


## Correrlo

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

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