!Este post esta bajo revision, capaz no anda nada.

Ingress conectar nuestros servicios al exterior

Ingress en Kubernetes es un recurso que permite administrar el acceso externo a los servicios dentro de un clúster. Básicamente, Ingress actúa como un controlador de entrada (como un balanceador de carga inteligente) que dirige las solicitudes externas a los servicios correspondientes en función de las reglas definidas. Ingress se usa principalmente para controlar el acceso HTTP y HTTPS.

¿Para qué sirve Ingress?

  1. Enrutamiento HTTP/HTTPS: Ingress te permite definir reglas de enrutamiento que dirigen el tráfico HTTP y HTTPS a servicios específicos en el clúster de Kubernetes. Por ejemplo, puedes hacer que las solicitudes a www.example.com/api se envíen a un servicio de API específico y que las solicitudes a www.example.com/app vayan a otro servicio de frontend.

  2. Balanceo de Carga: Aunque Kubernetes ya tiene balanceo de carga a nivel de servicio con Service tipo LoadBalancer, Ingress permite un control de tráfico más sofisticado, como redirigir tráfico basado en rutas o encabezados. Así puedes tener múltiples servicios detrás de un único punto de entrada y aplicar políticas de balanceo.

  3. TLS/SSL (HTTPS): Ingress permite la configuración de TLS para asegurar la comunicación. Puedes agregar certificados SSL y configurar el tráfico HTTPS para aplicaciones en el clúster, protegiendo así la transferencia de datos.

  4. Nombre de Dominio y Reglas de Host: Con Ingress, puedes enrutar tráfico basado en el nombre de dominio. Esto permite a un clúster Kubernetes manejar múltiples aplicaciones o servicios en diferentes dominios o subdominios (como app.example.com y api.example.com) desde un único punto de entrada.

  5. Redirección y Reescritura de URL: Ingress permite definir reglas avanzadas para reescribir URLs o redirigirlas. Esto es útil para personalizar la estructura de URLs y simplificar el acceso a los servicios sin exponer los detalles internos de la estructura del clúster.

Componentes de Ingress

Para usar Ingress, necesitas entender algunos de sus componentes clave:

  1. Ingress Resource (Recurso Ingress): Este es un objeto de Kubernetes que define las reglas de enrutamiento. Aquí configuras qué dominio o ruta deben dirigirse a qué servicio. Es un archivo YAML que contiene las reglas y se define usando la API de Kubernetes.

    Ejemplo de un recurso Ingress:

    apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
spec:
  rules:
    - host: app.example.com
      http:
        paths:
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api-service
                port:
                  number: 80
          - path: /app
            pathType: Prefix
            backend:
              service:
                name: frontend-service
                port:
                  number: 80

  2. Ingress Controller: El recurso Ingress no funciona por sí solo; necesita un Ingress Controller. Este es un componente que lee los recursos Ingress y configura el enrutamiento de acuerdo a las reglas. Hay varios Ingress Controllers disponibles, como NGINX Ingress Controller, Traefik, y HAProxy. Elige uno e instálalo en tu clúster para que Ingress funcione.

    • El Ingress Controller observa los recursos Ingress y configura el tráfico en tiempo real según las reglas definidas.

¿Cómo funciona Ingress en Kubernetes?

  1. Configuras un Ingress Controller en tu clúster.
  2. Creas recursos Ingress con reglas de enrutamiento.
  3. El Ingress Controller lee las reglas del recurso Ingress y configura el tráfico según corresponda.
  4. Cuando una solicitud llega al clúster, el Ingress Controller la redirige al servicio o pod correspondiente basándose en las reglas de enrutamiento definidas en el recurso Ingress.

Ejemplo práctico

Si tienes dos servicios en Kubernetes, un backend de API y un frontend, puedes usar Ingress para enrutar solicitudes entrantes a esos servicios basándose en la URL. Por ejemplo:

  • app.example.com/api redirige al servicio api-service.
  • app.example.com/app redirige al servicio frontend-service.

Esto permite a los usuarios acceder a ambos servicios usando un único punto de entrada, lo que simplifica la configuración y el acceso.

Ventajas de Ingress en Kubernetes

  • Consolidación de puntos de acceso: Puedes manejar múltiples servicios a través de una sola IP o dominio.
  • Mayor flexibilidad y control sobre el tráfico: Con Ingress, puedes implementar políticas avanzadas de enrutamiento y seguridad.
  • Mejor escalabilidad: Permite manejar varias aplicaciones o microservicios dentro de un solo clúster, optimizando recursos y simplificando la configuración.

Conclusión

Ingress es una solución poderosa en Kubernetes para manejar el tráfico HTTP/HTTPS, proporcionando un control granular sobre cómo las solicitudes externas llegan a los servicios internos. Configurarlo correctamente, junto con un Ingress Controller, te permite simplificar el acceso a tus aplicaciones y mejorar la flexibilidad del enrutamiento de tráfico en tu clúster de Kubernetes.

Ejercicio

Activar el controlador Ingress Nginx en kubeadm

En el cluster que estamos siguiendo este curso hacemos lo que dice kubernetes para baremeteal que es lo siguiente:

kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/controller-v1.12.0-beta.0/deploy/static/provider/baremetal/deploy.yaml

Revisamos que todo se haya instalado bien con :

kubectl get pods -n ingress-nginx
kubectl get svc -n ingress-nginx

Configuración de MetalLB y Ingress en Kubernetes para Entornos Bare-Metal

Este tutorial te guiará para configurar MetalLB y Ingress en un entorno Kubernetes bare-metal, exponiendo dos rutas (/apache y /nginx) que apuntan a diferentes servicios.

Requisitos Previos

  • Un clúster de Kubernetes en bare-metal o virtual.
  • kubectl instalado y configurado.
  • Permisos de administrador en el clúster.

Paso 1: Instalar MetalLB

MetalLB es un balanceador de carga para Kubernetes que permite el uso de servicios LoadBalancer en entornos que no son de nube.

  1. Instala MetalLB en el namespace metallb-system:

    kubectl apply -f https://raw.githubusercontent.com/metallb/metallb/v0.14.8/config/manifests/metallb-native.yaml

  2. Configura un IPAddressPool con el rango de direcciones IP que MetalLB usará para asignar a los servicios de tipo LoadBalancer. Asegúrate de ajustar el rango de IPs según la red de tu entorno:

    apiVersion: metallb.io/v1beta1
kind: IPAddressPool
metadata:
  name: my-ip-pool
  namespace: metallb-system
spec:
  addresses:
    - 192.168.0.240-192.168.0.250  # Ajusta el rango de IPs según tu red local

---
apiVersion: metallb.io/v1beta1
kind: L2Advertisement
metadata:
  name: my-l2-advertisement
  namespace: metallb-system
spec:
  ipAddressPools:
    - my-ip-pool

  3. Aplica la configuración:

    kubectl apply -f ip-pool.yaml

Paso 2: Configurar el Servicio de Ingress como LoadBalancer

Configura el Ingress Controller para usar LoadBalancer de una vez y evitar cambios posteriores.

  1. Si aún no tienes un controlador Ingress instalado, sigue estos pasos para instalar ingress-nginx como un servicio LoadBalancer:

    kubectl apply -f https://raw.githubusercontent.com/kubernetes/ingress-nginx/main/deploy/static/provider/baremetal/deploy.yaml

  2. Cambia el tipo de servicio del controlador Ingress a LoadBalancer. Crea un archivo ingress-svc.yaml con el siguiente contenido:

    apiVersion: v1
kind: Service
metadata:
  name: ingress-nginx-controller
  namespace: ingress-nginx
spec:
  type: LoadBalancer  # Configurado como LoadBalancer desde el inicio
  selector:
    app.kubernetes.io/name: ingress-nginx
  ports:
    - port: 80
      targetPort: 80
    - port: 443
      targetPort: 443

    Aplica el archivo:

    kubectl apply -f ingress-svc.yaml

  3. Verifica que MetalLB haya asignado una IP al servicio ingress-nginx-controller:

    kubectl get svc -n ingress-nginx

    La columna EXTERNAL-IP debe mostrar una IP asignada dentro del rango que configuraste en el pool de MetalLB, como 192.168.0.240.

Paso 3: Crear Despliegues y Servicios de Apache y Nginx

  1. Crea un despliegue y servicio para Apache:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: apache
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: apache
  template:
    metadata:
      labels:
        app: apache
    spec:
      containers:
        - name: apache
          image: httpd:latest
          ports:
            - containerPort: 80

---
apiVersion: v1
kind: Service
metadata:
  name: apache
  namespace: default
spec:
  selector:
    app: apache
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

    Aplica el archivo:

    kubectl apply -f apache-deployment.yaml

  2. Crea un despliegue y servicio para Nginx:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
  namespace: default
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

---
apiVersion: v1
kind: Service
metadata:
  name: nginx
  namespace: default
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: ClusterIP

    Aplica el archivo:

    kubectl apply -f nginx-deployment.yaml

Paso 4: Configurar el Ingress con las Rutas /apache y /nginx

Crea un archivo ingress.yaml para definir las rutas de Ingress:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: example-ingress
  namespace: default
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
  labels:
    app.kubernetes.io/instance: ingress-nginx
spec:
  ingressClassName: nginx
  rules:
    - host: myapp.local
      http:
        paths:
          - path: /apache
            pathType: Prefix
            backend:
              service:
                name: apache
                port:
                  number: 80
          - path: /nginx
            pathType: Prefix
            backend:
              service:
                name: nginx
                port:
                  number: 80

Aplica la configuración de Ingress:

kubectl apply -f ingress.yaml

Paso 5: Configurar el Dominio en el Archivo /etc/hosts

Agrega el dominio myapp.local en el archivo /etc/hosts de tu máquina local para que apunte a la IP asignada por MetalLB (por ejemplo, 192.168.0.240):

192.168.0.240 myapp.local  # Usa la IP asignada por MetalLB en el rango configurado

Paso 6: Verifica el Acceso a las Rutas

Una vez configurado, prueba acceder a las rutas:

  • http://myapp.local/apache debería mostrar la página de Apache.
  • http://myapp.local/nginx debería mostrar la página de Nginx.

Conclusión

Este tutorial configura MetalLB y Ingress en Kubernetes en un entorno bare-metal, proporcionando acceso sin necesidad de modificar manualmente el tipo de servicio o redirigir puertos.