# Services e Ingress

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

> La IP de un Pod es efímera y se rearma cada vez que se reschedulea. Un Service da una IP virtual y un nombre DNS estables para un conjunto de pods elegidos por labels. Un Ingress enruta el tráfico HTTP(S) externo hacia esos Services.

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

La IP de un Pod es efímera y se rearma cada vez que se reschedulea. Un
**Service** da una IP virtual y un nombre DNS estables para un conjunto
de pods elegidos por labels. Un **Ingress** enruta el tráfico HTTP(S)
externo hacia esos Services. En este lab armás las dos cosas.

## Objetivos de aprendizaje

1. Razonar sobre los cuatro tipos de Service — ClusterIP, NodePort,
   LoadBalancer, ExternalName — y elegir el adecuado para cada escenario.
2. Usar Services headless (`clusterIP: None`) para descubrir pods
   directamente.
3. Instalar un Ingress controller (NGINX) en kind y exponer un servicio
   HTTP en `localhost:8080`.
4. Configurar ruteo por host y por path, incluida una regla de rewrite.
5. Debuggear Services rotos inspeccionando `Endpoints` y `EndpointSlice`.

## Contexto

### Cómo funciona realmente un Service

El `kube-proxy` de cada nodo observa la API buscando Services y
EndpointSlices. Cuando se crea un Service, programa reglas de iptables
(o IPVS) para que el tráfico dirigido a la ClusterIP del Service se
haga DNAT hacia alguna de las IPs de los pods que lo respaldan, elegida
al azar (en modo iptables). No hay ningún proceso proxy
en el camino de los datos — solamente reglas de netfilter en el kernel.

### Tipos de Service

| Tipo | Alcanzable desde | Usalo cuando |
|------|---------------|----------|
| `ClusterIP` (por defecto) | Dentro del clúster | Tráfico pod a pod |
| `NodePort` | Clúster + `NodeIP:30000-32767` | Desarrollo/pruebas rápidas, ingress on-prem como último recurso |
| `LoadBalancer` | Clúster + LB del cloud | Ingress de producción en un cloud |
| `ExternalName` | CNAME de DNS | Apuntar un nombre DNS del clúster a un host externo |

En `kind` no hay LB del cloud; los Services `LoadBalancer` se quedan en
`<pending>` para siempre salvo que instales [MetalLB](https://metallb.universe.tf)
(lo hacemos en el desafío C4).

### Services headless

Poner `spec.clusterIP: None` hace que no se asigne IP virtual y que
kube-proxy ignore el Service.
El DNS devuelve directamente las IPs de los pods (un registro A por
endpoint). Así es como los StatefulSets exponen DNS por pod
(`pod-0.web.default.svc.cluster.local`).

### Ingress

La API de Ingress es una spec liviana; el ruteo HTTP en sí lo implementa
un ingress controller (NGINX, Traefik, HAProxy, Istio, …). En esta
materia usamos [ingress-nginx](https://kubernetes.github.io/ingress-nginx/), el
controller basado en NGINX de la comunidad de Kubernetes (no el producto
de NGINX/F5), porque kind tiene un deployment hecho a medida para él.

## Recorrido guiado

### 1. ClusterIP + DNS

```bash
kubectl apply -f manifests/echo.yaml              # Deployment + svc ClusterIP
kubectl get svc,endpointslices -l app=echo
kubectl run shell --rm -it --image=busybox:1.36 -- sh
# dentro del pod:
nslookup echo.default.svc.cluster.local
wget -qO- echo.default/      # la ClusterIP funciona por nombre
```

### 2. NodePort

```bash
kubectl apply -f manifests/echo-nodeport.yaml
kubectl get svc echo-np
# kind no publica los NodePorts en tu máquina; probalo desde adentro del nodo:
docker exec k8s-labs-control-plane curl -s localhost:30080
```

### 3. Instalá NGINX Ingress

```bash
kubectl apply -f https://kind.sigs.k8s.io/examples/ingress/deploy-ingress-nginx.yaml
kubectl -n ingress-nginx wait --for=condition=Ready pod -l app.kubernetes.io/component=controller --timeout=180s
# el manifiesto de kind ya no fija el controller al nodo del control plane;
# en nuestro clúster de 3 nodos fijalo para que le lleguen los puertos 80/443
kubectl -n ingress-nginx patch deploy ingress-nginx-controller -p '{"spec":{"template":{"spec":{"nodeSelector":{"ingress-ready":"true"}}}}}'
kubectl -n ingress-nginx rollout status deploy/ingress-nginx-controller --timeout=180s
```

La configuración de kind mapeó los puertos 80/443 del nodo del control
plane a los puertos 8080/8443 del host, así que una vez que el controller
está arriba podés abrir `http://localhost:8080` en el navegador.

### 4. Un Ingress

```bash
kubectl apply -f manifests/echo-ingress.yaml
curl -H 'Host: echo.k8s-labs.test' http://localhost:8080/
```

## Desafíos

### C1. Service para un deployment de dos tracks

Usá los Deployments `web` y `web-canary` del lab 02. En el namespace
`lab-03`, creá:

- un Service ClusterIP `web` que seleccione los dos tracks (pods stable y
  canary en el pool de endpoints) en el puerto 80 → puerto 9898 del pod
- un Service *headless* `web-stable` que seleccione solo `track=stable`
- un Service headless `web-canary` que seleccione solo `track=canary`

Un Service solo selecciona pods de su propio namespace, así que primero
volvé a deployar los dos Deployments en `lab-03` (adaptá los manifiestos
de `solutions/`).

### C2. Ingress con ruteo por host y path

Creá un Ingress llamado `web-ingress` en `lab-03` que:

- atienda el host `web.k8s-labs.test`
- enrute `/` al Service `web` en el puerto 80
- enrute `/canary` al Service `web-canary` en el puerto 80, reescribiendo
  el path a `/`
- use `ingressClassName: nginx`

Verificalo con:

```bash
curl -H 'Host: web.k8s-labs.test' http://localhost:8080/
curl -H 'Host: web.k8s-labs.test' http://localhost:8080/canary
```

### C3. Un Service roto para arreglar

Aplicá `manifests/broken-service.yaml`. Su lista de endpoints está vacía
porque un label selector tiene un typo. Arreglalo *sin* borrar y volver a
crear el Service. El verificador chequea que el Service tenga al menos un
endpoint.

### C4 (opcional). LoadBalancer con MetalLB

Instalá MetalLB en modo L2, configuralo para que reparta direcciones de
la red de Docker de kind, después cambiá el Service `web` a
`type: LoadBalancer` y pegale desde el host. Es un desafío extra.

## Verificación

```bash
make verify LAB=03
```

## Para seguir leyendo

- Tim Hockin, [*Kubernetes Services: Deep Dive*](https://www.youtube.com/watch?v=NFApeJRXos4).
- [Referencia de la API de EndpointSlice](https://kubernetes.io/docs/concepts/services-networking/endpoint-slices/).
- Ingress-NGINX: [annotations para ruteo canary](https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary).


## 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/03-services-ingress`:

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