Minikube: Gestión de Ingress

En Kubernetes, Ingress es un recurso que administra el acceso externo a los servicios dentro de un clúster, típicamente HTTP y HTTPS. Ingress dirige el tráfico web a los diferentes servicios según las reglas que se han definido.

A diferencia de otros métodos para exponer servicios (como NodePort o LoadBalancer), Ingress proporciona:

• Enrutamiento basado en URL: Dirige /foo a un servicio y /bar a otro

• Consolidación de puntos de entrada: Un solo punto de entrada para múltiples servicios

• Terminación TLS/SSL: Gestiona certificados y cifrado

• Balanceo de carga: Distribuye el tráfico eficientemente

Arquitectura de Ingress

Para entender Ingress correctamente, necesitamos conocer sus componentes principales:

1. Recurso Ingress: La definición de reglas (un archivo YAML donde se especifica cómo debe enrutarse el tráfico)

2. Controlador Ingress: El componente que implementa estas reglas (en Minikube, es Nginx por defecto)

3. Servicios backend: Los servicios de Kubernetes a los que Ingress dirige el tráfico

Funciona así:

Internet → Controlador Ingress → Servicios → Pods

Cuando habilita el complemento Ingress en Minikube, está instalando un Controlador Ingress (Nginx) que observa continuamente los recursos Ingress y configura las reglas de enrutamiento según corresponda.

Prerrequisitos

Antes de comenzar, asegúrate de tener:

• Minikube instalado y funcionando

• kubectl configurado correctamente

• Acceso a Internet para descargar las imágenes necesarias

Paso 1: Habilitando el complemento Ingress en Minikube

El primer paso es activar el complemento Ingress en Minikube, que instalará el controlador Nginx Ingress:

# Si su cluster de minikube esta encendido, apaguelo.
minikube stop

# Identifique la dirección IP de la máquina
ip addr show

# Inicia Minikube especificando la interfaz del host
minikube start --vm-driver=none --apiserver-ips=$(hostname -I | awk '{print $1}')

# Este paso puede tomar varios minutos
minikube addons enable ingress

Este comando realiza varias acciones importantes:

• Despliega el controlador Ingress Nginx en el namespace ingress-nginx

• Configura los componentes necesarios como ServiceAccount, ConfigMaps, etc.

• Prepara tu clúster para manejar recursos Ingress

Para verificar que el controlador se ha instalado correctamente:

minikube kubectl -- get pods -n ingress-nginx

Debería ver los pods del controlador Ingress ejecutándose. Es crucial esperar hasta que estén en estado Running antes de continuar.

Paso 2: Entendiendo la configuración de ejemplo

Vamos a utilizar el siguiente archivo de ejemplo o referencia, no es necesario que lo descargue o lo genere.

https://storage.googleapis.com/minikube-site-examples/ingress-example.yaml

Ahora vamos a analizar paso a paso el archivo YAML de ejemplo. Este archivo crea una infraestructura completa para demostrar Ingress:

Componente 1: Los Pods

kind: Pod
apiVersion: v1
metadata:
  name: foo-app
  labels:
    app: foo
spec:
  containers:
    - name: foo-app
      image: 'kicbase/echo-server:1.0'
---
kind: Pod
apiVersion: v1
metadata:
  name: bar-app
  labels:
    app: bar
spec:
  containers:
    - name: bar-app
      image: 'kicbase/echo-server:1.0'

Aquí definimos dos pods independientes:

• foo-app: Un servidor de eco etiquetado con app: foo

• bar-app: Otro servidor de eco etiquetado con app: bar

Estos pods ejecutan la misma imagen (kicbase/echo-server:1.0), que simplemente devuelve información sobre la solicitud recibida. La diferencia clave está en sus etiquetas, que usaremos para seleccionarlos desde sus respectivos servicios.

Componente 2: Los Servicios

kind: Service
apiVersion: v1
metadata:
  name: foo-service
spec:
  selector:
    app: foo
  ports:
    - port: 8080
---
kind: Service
apiVersion: v1
metadata:
  name: bar-service
spec:
  selector:
    app: bar
  ports:
    - port: 8080

Para cada pod, creamos un servicio correspondiente:

• foo-service: Selecciona el pod con etiqueta app: foo

• bar-service: Selecciona el pod con etiqueta app: bar

Cada servicio expone el puerto 8080 de su pod respectivo. Nótese que estos son servicios tipo ClusterIP (el predeterminado), lo que significa que no son accesibles directamente desde fuera del clúster. Es aquí donde Ingress entra en juego.

Componente 3: El Recurso Ingress

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
spec:
  rules:
    - http:
        paths:
          - pathType: Prefix
            path: /foo
            backend:
              service:
                name: foo-service
                port:
                  number: 8080
          - pathType: Prefix
            path: /bar
            backend:
              service:
                name: bar-service
                port:
                  number: 8080

Esta es la pieza central de nuestra configuración. El recurso Ingress define las reglas de enrutamiento:

• Cuando una solicitud llega a la ruta /foo, se redirige al foo-service en el puerto 8080

• Cuando una solicitud llega a la ruta /bar, se redirige al bar-service en el puerto 8080

El pathType: Prefix indica que cualquier URL que comience con el prefijo especificado (/foo o /bar) coincidirá con la regla. Por ejemplo, /foo/extra también se enrutaría a foo-service.

Paso 3: Aplicando la Configuración

Ahora que entendemos cada componente, vamos a aplicar la configuración a nuestro clúster:

minikube kubectl -- apply -f https://storage.googleapis.com/minikube-site-examples/ingress-example.yaml

Este comando descarga y aplica el archivo YAML completo, creando todos los recursos descritos anteriormente en un solo paso.

Para verificar que todos los recursos se han creado correctamente:

minikube kubectl -- get pods         # Debería mostrar foo-app y bar-app
minikube kubectl -- get services     # Debería mostrar foo-service y bar-service
minikube kubectl -- get ingress      # Debería mostrar example-ingress

Paso 4: Esperando la Asignación de Dirección IP

El controlador Ingress necesita tiempo para configurarse y asignar una dirección IP al recurso Ingress:

minikube kubectl -- get ingress

Inicialmente, el campo ADDRESS puede estar vacío. Espera unos minutos y vuelve a ejecutar el comando hasta que veas una dirección IP asignada:

NAME              CLASS   HOSTS   ADDRESS          PORTS   AGE
example-ingress   nginx   *       192.168.49.2     80      5m45s

Esta dirección IP es el punto de entrada único a través del cual accederás a ambos servicios.

Paso 5: Accediendo a los Servicios

Una vez que tiene la dirección IP, puede verificar que el enrutamiento funciona correctamente desde la terminal:

# Accediendo al servicio foo
curl <ip_from_above>/foo

# Accediendo al servicio bar
curl <ip_from_above>/bar

Deberías ver respuestas diferentes según la ruta que uses:

• /foo mostrará "Request served by foo-app" y más información

• /bar mostrará "Request served by bar-app" y más información

Esto confirma que el Ingress está enrutando correctamente el tráfico según la URL.

Consideraciones Especiales para Docker Desktop

Si está utilizando Minikube con Docker Desktop (un escenario común en Windows y macOS), hay un paso adicional necesario:

minikube tunnel

Este comando crea un túnel de red entre su sistema y el clúster Minikube, permitiendo que las direcciones IP asignadas por Ingress sean accesibles. En este caso, usaría 127.0.0.1 en lugar de la dirección IP mostrada por el comando kubectl get ingress.

Nota importante: El comando minikube tunnel debe ejecutarse en una terminal separada y mantenerse en ejecución mientras necesites acceder a los servicios Ingress.

Análisis Profundo del Funcionamiento

Para entender realmente lo que está sucediendo, visualicemos el flujo de una solicitud:

1. El usuario envía una solicitud a <ip_of_ingress>/foo

2. El controlador Ingress recibe la solicitud y examina la URL

3. Como la URL comienza con /foo, el controlador consulta las reglas de Ingress

4. Las reglas indican que debe reenviar a foo-service:8080

5. El servicio foo-service reenvía la solicitud al pod foo-app

6. El pod foo-app procesa la solicitud y devuelve una respuesta

7. La respuesta viaja de vuelta a través del mismo camino

Este proceso ocurre para cada solicitud que llega al Ingress.

Configuraciones Avanzadas de Ingress

El ejemplo mostrado es básico, pero Ingress puede hacer mucho más:

Enrutamiento basado en Host

Puede enrutar tráfico basado en el nombre de host:

spec:
  rules:
  - host: foo.example.com
    http:
      paths:
      - backend:
          service:
            name: foo-service
            port:
              number: 8080
  - host: bar.example.com
    http:
      paths:
      - backend:
          service:
            name: bar-service
            port:
              number: 8080

Terminación TLS

Puede configurar HTTPS añadiendo una sección TLS:

yamlspec:
  tls:
  - hosts:
    - secure.example.com
    secretName: example-tls-secret
  rules:
  - host: secure.example.com
    # ...

Anotaciones de Ingress

Para una configuración más avanzada, puedes usar anotaciones específicas del controlador:

yamlmetadata:
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
    nginx.ingress.kubernetes.io/ssl-redirect: "false"

Solución de Problemas Comunes

Si encuentra problemas con tu configuración de Ingress, estos son algunos pasos de solución:

1. Verifica el controlador Ingress:

    minikube kubectl -- get pods -n ingress-nginx
   

   Todos los pods deben estar en estado Running.

2. Examina los logs del controlador:

    minikube kubectl -- logs -n ingress-nginx -l app.kubernetes.io/name=ingress-nginx
   

3. Verifica la configuración de Ingress:

    minikube kubectl -- describe ingress example-ingress
   

   Busca la sección "Events" para ver posibles errores.

4. Prueba los servicios directamente:

    minikube kubectl -- port-forward service/foo-service 8080:8080
   

   Luego accede a localhost:8080 para verificar si el servicio funciona correctamente.

Mejores Prácticas para Ingress

1. Organización de rutas: Diseña tu estructura de rutas de manera lógica y coherente

2. Seguridad: Utiliza HTTPS siempre que sea posible

3. Monitoreado: Configura alertas para problemas con tu Ingress

4. Escalabilidad: Considera usar múltiples controladores Ingress para alta disponibilidad

5. Validación: Prueba tus configuraciones de Ingress antes de desplegarlas en producción

Ingress es una herramienta para gestionar el acceso externo a tus servicios en Kubernetes. Proporciona una capa de abstracción que permite un enrutamiento avanzado mientras optimiza recursos, especialmente en entornos de nube donde cada LoadBalancer tiene un costo asociado.

Eliminación de Recursos en Kubernetes

Para eliminar todos los recursos que fueron aprovisionados previamente, puedes utilizar el comando kubectl delete con la misma referencia al archivo YAML. Esto instruirá a Kubernetes que elimine todos los recursos definidos en ese archivo.

El comando exacto sería:

minikube kubectl -- delete -f https://storage.googleapis.com/minikube-site-examples/ingress-example.yaml