Kubernetes Ingress

Hasta ahora tenemos dos opciones principales para acceder a nuestras aplicaciones desde el exterior:

1. Utilizando servicios del tipo NodePort: Esta opción no es muy viable para entornos de producción ya que tenemos que utilizar puertos aleatorios desde 30000-40000.
2. Utilizando servicios del tipo LoadBalancer: Esta opción sólo es válida si trabajamos en un proveedor Cloud que nos cree un balanceador de carga para cada una de las aplicaciones, en cloud público puede ser una opción muy cara.

La solución puede ser utilizar un Ingress controller que nos permite utilizar un proxy inverso (HAproxy, nginx, traefik,…) que por medio de reglas de encaminamiento que obtiene de la API de Kubernetes nos permite el acceso a nuestras aplicaciones por medio de nombres, en este caso utilizaremos la imgen de traefik (traefik:v1.7).

.

Vamos a desplegar una pod que implementa un proxy inverso (en nuestro caso, traefik:v1.7) que esperará peticiones HTTP y HTTPS.

• Por lo tanto el Ingress Controller será el nodo del cluster donde se ha instalado el pod. En nuestro caso, para realizar el despliegue vamos utilizar un recurso de Kubernetes llamado DaemontSet que asegura que el despliegue se hace en todos los nodos del cluster y que los puertos que expone los pods (80 y 443) están mapeado y son accesible en los nodos. Por lo que cada uno de los nodos del cluster va a poseer una copia del Ingress Controller.

• No es necesario que al servicio al que accede el Ingress Controller este configurado del tipo NodePort, lo recomendado es que el service este configurado de tipo ClusterIP.

Instalación de Ingress Controller con Traefik

Lo primero es crear las reglas de acceso (RBAC) necesarias (puedes ver el contenido del los ficheros yaml en la documentación):
kubectl apply -f https://raw.githubusercontent.com/containous/traefik/v1.7/examples/k8s/traefik-rbac.yaml

Como hemos comentado podemos desplegar el proxy utilizando un Deployment o un DaemonSet, hemos elegido esta última opción:

kubectl apply -f https://raw.githubusercontent.com/containous/traefik/v1.7/examples/k8s/traefik-ds.yaml

Comprobamos el despliegue:

$kubectl get ds -n kube-system

Comprobamos la creación de los pods:

$kubectl get pods -n kube-system -o wide

Como vemos se ha creado un pod en cada nodo:

La IP de acceso a uno de los nodos es la 10.0.0.11, y 10.0.0.12, por lo que podemos hacer la prueba de que el proxy inverso está funcionando:
$curl http://10.0.0.11/
404 page not found

El dashboard de traefik en los dos nodos seria:

http://10.0.0.11:8080/dashboard/
http://10.0.0.12:8080/dashboard/

Ahora podemos crear un deployment, con un service, al cual enlazaremos una entrada a traves de nuestro ingress de traefik ejemplo, deploy1.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
name: hola
labels:
app: hola
spec:
replicas: 1
selector:
matchLabels:
app: hola
template:
metadata:
labels:
app: hola
spec:
containers:
– name: nginx
image: nbrown/nginxhello:1.12.1
ports:
– containerPort: 80
—
apiVersion: v1
kind: Service
metadata:
name: hola
spec:
type: ClusterIP
ports:
– port: 80
name: http
selector:
app: hola

Desplegaremos nuestro deploymen junto a nuestro service:
$kubectl apply -f deploy1.yaml

Ahora desplegamos nuestro Ingress, ejemplo ingress.yml, y como podemos ver lo enlazamos con nuestro service hola, desplegado anteriormente:

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
name: rules
spec:
rules:
– host: hola.curso.local
http:
paths:
– path: /
backend:
serviceName: hola
servicePort: 80

Ahora damos de alta (para poder resolver la url), en el fichero hosts de Windows, para poder resolver hola.curso.local, recordar de sustituir la ip, por la ip de vuestro nodo worker:

C:\Windows\System32\drivers\etc\hosts
10.0.0.11 hola.curso.local

Desplegaremos nuestro ingress, para hacer pasar el deployment hola, a traves de nuestro ingress de traefik:

$kubectl apply -f ingress.yaml