Redes con Ingress en Kubernetes

Introducción

En este laboratorio, aprenderás cómo utilizar Ingress para enrutar el tráfico externo a los servicios que se ejecutan en un clúster de Kubernetes.

Kubernetes Ingress es una herramienta poderosa para gestionar el acceso externo a los servicios en un clúster de Kubernetes. Ingress actúa como un equilibrador de carga de capa 7, lo que te permite enrutar el tráfico a diferentes servicios según la ruta de la URL de entrada o el nombre de host.

En este laboratorio, crearemos una aplicación de muestra y la expondremos al mundo exterior utilizando Ingress. Utilizaremos nginx-ingress como controlador de Ingress, que es una solución popular y ampliamente utilizada para Kubernetes Ingress.

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

Navegar a tu directorio de trabajo:

Abre la terminal y navega hasta la carpeta de proyecto predeterminada:
```
cd /home/labex/project
```
Iniciar Minikube:

Inicia Minikube para inicializar un clúster de Kubernetes:
```
minikube start
```
- Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
- Minikube puede tardar unos minutos en iniciar dependiendo del rendimiento de tu sistema.
Verificar que Minikube esté en ejecución:

Comprueba el estado del clúster de Minikube:
```
minikube status
```
- Busca componentes como kubelet y apiserver listados como Running (En ejecución).
- Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Instalar el Controlador de Ingress de Nginx

Primero, necesitamos instalar el controlador nginx-ingress en nuestro clúster. Podemos hacer esto creando un Despliegue (Deployment) y un Servicio (Service) que serán responsables de ejecutar el controlador de Ingress.

Crea un espacio de nombres (namespace) para el controlador de Ingress:

kubectl create namespace ingress-nginx

Instala la plantilla (chart) ingress-nginx utilizando kubectl:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.7.0/deploy/static/provider/cloud/deploy.yaml

Verifica que los pods del controlador ingress-nginx estén en ejecución:

kubectl get pods -n ingress-nginx

NAME                                        READY   STATUS              RESTARTS   AGE
ingress-nginx-admission-create-zjfqx        0/1     ContainerCreating   0          2s
ingress-nginx-admission-patch-8rvzw         0/1     ContainerCreating   0          2s
ingress-nginx-controller-6bdb654777-qz8fb   0/1     ContainerCreating   0          2s

Crear una aplicación de muestra

A continuación, crearemos una aplicación de muestra que expondremos utilizando Ingress.

Crea un Despliegue (Deployment) para una aplicación de muestra:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: sample-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: sample-app
  template:
    metadata:
      labels:
        app: sample-app
    spec:
      containers:
      - name: sample-app
        image: nginx
        ports:
        - containerPort: 80

El archivo YAML se llama sample-app.yaml. Aplica el despliegue a tu clúster con el siguiente comando:

kubectl apply -f sample-app.yaml

Crea un Servicio (Service) para la aplicación de muestra:

apiVersion: v1
kind: Service
metadata:
  name: sample-app
spec:
  selector:
    app: sample-app
  ports:
  - name: http
    port: 80
    targetPort: 80

El archivo YAML se llama service-sample-app.yaml. Aplica el despliegue a tu clúster con el siguiente comando:

kubectl apply -f service-sample-app.yaml

Crear un recurso de Ingress

Ahora que tenemos configurado el controlador de Ingress y un servicio de backend en ejecución, podemos crear las reglas para el recurso de Ingress.

En este ejemplo, crearemos una regla simple para enrutar el tráfico del dominio test.local a nuestro servicio de backend:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: test-ingress
  annotations:
    kubernetes.io/ingress.class: nginx
spec:
  rules:
  - host: test.local
    http:
      paths:
      - path: /
        pathType: Prefix
        backend:
          service:
            name: sample-app
            port:
              name: http

El archivo YAML se llama ingress.yaml. Aplica el recurso de Ingress al clúster:

kubectl apply -f ingress.yaml

Probar el recurso de Ingress

Finalmente, podemos probar el recurso de Ingress para asegurarnos de que todo funcione correctamente.

Primero, determina la dirección IP del nodo:

kubectl get node -o wide

NAME       STATUS   ROLES           AGE   VERSION   INTERNAL-IP    EXTERNAL-IP   OS-IMAGE             KERNEL-VERSION      CONTAINER-RUNTIME
minikube   Ready    control-plane   93s   v1.26.1   192.168.49.2   <none>        Ubuntu 20.04.5 LTS   5.15.0-56-generic   docker://20.10.23

Este comando obtendrá la dirección del nodo de Kubernetes. La dirección IP etiquetada como INTERNAL-IP.

A continuación, agrega una entrada a tu archivo /etc/hosts para mapear el dominio test.local a la dirección IP del nodo:

echo "<IP_ADDRESS> test.local" | sudo tee -a /etc/hosts

Reemplaza <IP_ADDRESS> con la dirección IP interna del nodo. Por ejemplo:

echo "192.168.49.2 test.local" | sudo tee -a /etc/hosts

Luego, obtén el puerto de nodo (NodePort) del servicio ingress-nginx.

kubectl get services -n ingress-nginx

Este comando mostrará una lista de servicios en el espacio de nombres (namespace) ingress-nginx. Busca el servicio nginx-ingress-controller y anota su NodePort.

NAME                                 TYPE           CLUSTER-IP      EXTERNAL-IP   PORT(S)                      AGE
ingress-nginx-controller             LoadBalancer   10.104.99.158   <pending>     80:32518/TCP,443:31620/TCP   2m45s
ingress-nginx-controller-admission   ClusterIP      10.100.46.109   <none>        443/TCP                      2m45s

Finalmente, utiliza curl para realizar una solicitud HTTP al punto final (endpoint) de Ingress:

curl test.local:NodePort

Por ejemplo:

curl test.local:32518

Reemplaza <NodePort> con el NodePort del servicio nginx-ingress-controller.

Si todo está configurado correctamente, deberías ver la página de bienvenida de Nginx.

También puedes probar el Ingress utilizando un navegador web para visitar test.local:<NodePort>/nginx.

Felicidades, has configurado con éxito un recurso de Ingress en Kubernetes y lo has probado para asegurarte de que funcione correctamente.

Resumen

En este laboratorio, recorrimos el proceso de configuración y puesta en marcha de un controlador de entrada (ingress controller) de Nginx en Kubernetes. También creamos una aplicación de muestra y utilizamos Ingress para enrutar el tráfico externo a nuestro servicio de Nginx. Esto es solo el comienzo de lo que puedes hacer con la red de Kubernetes, y te animamos a explorar más.