Qué es el Controlador Ingress y cómo desplegar el Controlador Ingress de Nginx en el Cluster Kubernetes en AWS usando Helm

Antes de proceder a la instalación del Controlador de Ingress de Nginx, veamos brevemente qué es el Ingress y el Controlador de Ingress. Este artículo se centra en la configuración, se supone que estás familiarizado con todos los requisitos previos para configurar el Controlador Ingress de Nginx en el Clúster Kubernetes.

Kubernetes Ingress

Es un objeto de Kubernetes que gestiona el acceso externo a los servicios del clúster de Kubernetes. Expone rutas HTTP y HTTPS desde fuera del clúster de Kubernetes a los servicios del clúster de Kubernetes.

Controlador Ingress

Para utilizar Ingress, debes tener el Controlador Ingress en el clúster Kubernetes. No viene como parte del clúster de Kubernetes como otros controladores del clúster, no se inicia automáticamente en el clúster. Podemos desplegar cualquier número de controladores de ingreso en el clúster de Kubernetes. Para ello, debemos anotar cada ingress con el ingress.class apropiado. Hay muchos tipos diferentes de controladores de entrada disponibles. El controlador de entrada es un equilibrador de carga para entornos Kubernetes. Se utiliza como solución de gestión de tráfico para entornos Kubernetes.

En este artículo, veremos la instalación del Controlador de Ingress de Nginx usando Helm en el Cluster de Kubernetes configurado usando Kops. Para conocer en detalle el Controlador de Ingress de Nginx, visita la documentación oficial aquí.

Requisitos previos

1. Cuenta de AWS ( Crear si no tienes una).
2. Kops 1.18.2 instalado en tu máquina(Haz clic aquípara aprender a crear un clúster de Kubernetes utilizando Kops y saber más sobre él).
3. Helm v3.5.3 (Haz clic aquí para aprender a instalar Helm en un servidor Ubuntu)
4. S3 Bucket ( Haz clic aquí para aprender a crear un S3 Bucket en AWS).
5. Nombre de dominio (Haz clic aquípara aprender a registrar un dominio en AWS).
6. Rol IAM con permisos de administrador (Haz clic aquí para aprender a crear un rol IAM en AWS).

¿Qué vamos a hacer?

1. Crear un clúster de Kubernetes con Kops
2. Configurar el controlador de entrada de Nginx utilizando Helm
3. Crea un Recordset en Route53 que apunte al LoadBalancer creado por el Nginx Ingress Controller
4. Crea archivos de definición de objetos para una aplicación de ejemplo
5. Despliega una aplicación de ejemplo
6. Despliega un objeto Ingress

Crear un clúster Kubernetes con Kops

Antes de proceder a la creación del clúster, exporta tus claves secretas y de acceso de usuario de AWS IAM mediante los siguientes comandos.

export AWS_ACCESS_KEY_ID=<your-aws-access-key-here> #Export AWS Access Key

export AWS_SECRET_ACCESS_KEY=<your-aws-secret-key-here> ##Export AWS Secret Key export

Now, export the KOPS_STATE_STORE variable with value as S3 bucket name on your terminal.

KOPS_STATE_STORE=s3://<s3-bucket-name>

Si es la primera vez que creas un clúster con Kops y utilizas el cubo S3 especificado anteriormente para almacenar la configuración del clúster, no deberías ver ningún clúster cuando intentes obtenerlo con el siguiente comando.

kops get clusters

Visita la documentación especificada en los prerrequisitos para entender Kops en detalle. Aquí, para crear un clúster Kubernetes ejecuta el siguiente comando sustituyendo los valores. No entraré en detalles aquí.

kops create cluster --name <subdomain.domain.com> --state s3://<s3-bucket> --cloud aws --master-size t2.small --master-count 1 --master-zones us-east-1a --node-size t2.small --node-count 2 --zones us-east-1a,us-east-1b,us-east-1c

Puedes ver algunos comandos en la sugerencia.

Ahora, si intentas obtener la configuración del clúster, verás el nombre del clúster en la salida junto con Cloud y Zones.

Hasta este momento, el cluster no ha sido creado, ejecuta el siguiente comando para actualizar la configuración del Cluster.

kops update cluster --name kops.devopslee.com

Todavía tendrás que ejecutar el comando anterior con –yes como opción para que se creen los recursos del cluster.

kops update cluster --name kops.devopslee.com --yes

Valida si el clúster está listo o no.

kops validate cluster --wait 10m

Tienes que esperar un tiempo hasta que el clúster esté sano.

kops validate cluster --wait 10m

Una vez que el clúster esté sano, puedes comprobar los pods por defecto en todos los espacios de nombres utilizando el siguiente comando.

kubectl get pods -A

Configurar el controlador de entrada de Nginx con Helm

Una vez que el clúster de Kubernetes esté listo y sano, puedes proceder a instalar el controlador de entrada de Nginx utilizando Helm.

Antes de proceder, comprueba que tienes Helm v3.5.3.

Nota: He utilizado el binario de Helm presente en mi ubicación actual, de ahí que puedas ver ./helm en las capturas de pantalla.

helm version

Añade el repo e instala la tabla Helm del controlador de entrada Nginx utilizando los siguientes comandos. Para entender Helm, consulta la documentación mencionada en la sección de requisitos previos.

helm repo add ingress-nginx https://kubernetes.github.io/ingress-nginx

helm repo update

helm install nginx-ingress ingress-nginx/ingress-nginx --set controller.publishService.enabled=true

En la captura de pantalla anterior, puedes ver que se ha instalado el gráfico Helm.

Puedes comprobar los recursos que se han creado como parte del controlador de entrada.

kubectl get pods

kubectl get deployment

kubectl get service

En la captura de pantalla anterior, puedes ver que también se ha creado el Servicio «nginx-ingress-ingress-nginx-controller» de tipo LoadBalancer. Esto significa que se ha creado un LoadBalancer en la cuenta de AWS.

Crea un Recordset en Route53 que apunte al LoadBalancer creado por el Nginx Ingress Controller

Ve a tu cuenta de AWS en la región donde creaste tu clúster de Kubernetes. Comprueba el LoadBalancer y copia su nombre DNS.

Ahora, ve a Route53 y crea un único Registro A en la Zona Alojada.

Una vez creado un registro válido, el registro que hemos creado se utilizará para enrutar el tráfico hacia el Clúster Kubernetes a través del Controlador de Entrada Nginx que hemos creado. En este caso, kops.devopslee.com enrutará el tráfico a los servicios del clúster Kubernetes a través del controlador de entrada Nginx.

Crear archivos de definición de objetos para una aplicación de ejemplo

Ahora, vamos a crear archivos de definición de objetos para desplegar una aplicación de ejemplo. Desplegaremos 3 aplicaciones utilizando 3 Despliegues y 3 Servicios respectivos para los despliegues. A continuación, crearemos un recurso Ingress con enrutamiento basado en la ruta para dirigir el tráfico a nuestras aplicaciones utilizando kops.devopslee.com en función de la ruta.

Crea 1-nginx-main-app.yaml para la aplicación 1.

Enlace Github: Haz clic aquípara copiar el archivo de mi repo de Github.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-main
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-main
  template:
    metadata:
      labels:
        run: nginx-main
    spec:
      containers:
      - image: nginx
        name: nginx


---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-main
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-main

Crea 2-nginx-green-app.yaml para la aplicación 2.

Enlace Github: Haz clic aquípara copiar el archivo de mi repositorio de Github.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-green
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-green
  template:
    metadata:
      labels:
        run: nginx-green
    spec:
      volumes:
      - name: webdata
        emptyDir: {}
      initContainers:
      - name: web-content
        image: busybox
        volumeMounts:
        - name: webdata
          mountPath: "/webdata"
        command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=green>GREEN</font></h1>" > /webdata/index.html']
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: webdata
          mountPath: "/usr/share/nginx/html"


---
---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-green
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-green          

Crea 3-nginx-blue-app.yaml para la aplicación 3

Enlace Github: Haz clic aquípara copiar el archivo de mi repo de Github.

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: nginx
  name: nginx-deploy-blue
spec:
  replicas: 1
  selector:
    matchLabels:
      run: nginx-blue
  template:
    metadata:
      labels:
        run: nginx-blue
    spec:
      volumes:
      - name: webdata
        emptyDir: {}
      initContainers:
      - name: web-content
        image: busybox
        volumeMounts:
        - name: webdata
          mountPath: "/webdata"
        command: ["/bin/sh", "-c", 'echo "<h1>I am <font color=blue>BLUE</font></h1>" > /webdata/index.html']
      containers:
      - image: nginx
        name: nginx
        volumeMounts:
        - name: webdata
          mountPath: "/usr/share/nginx/html"


---
apiVersion: v1
kind: Service
metadata:
  name: nginx-deploy-blue
spec:
  type: ClusterIP
  ports:
  - port: 80
    targetPort: 80
  selector:
    run: nginx-blue

Crea 4-ingress.yaml para crear reglas Ingress basadas en la ruta.

Enlace Github: Haz clic aquípara copiar el archivo de mi repo de Github.

apiVersion: extensions/v1beta1
kind: Ingress
metadata:
  annotations:
    nginx.ingress.kubernetes.io/rewrite-target: /
  name: ingress-resource
spec:
  rules:
  - host: kops.devopslee.com
    http:
      paths:
      - path: /
        backend:
          serviceName: nginx-deploy-main
          servicePort: 80
      - path: /blue
        backend:
          serviceName: nginx-deploy-blue
          servicePort: 80
      - path: /green
        backend:
          serviceName: nginx-deploy-green
          servicePort: 80

Puedes encontrar todos estos archivos en mi repo de Github aquí.

Desplegar aplicaciones de ejemplo

Vamos a desplegar las aplicaciones de ejemplo una por una y a comprobar su estado.

kubectl apply -f 1-nginx-main-app.yaml

kubectl apply -f 2-nginx-green-app.yaml

kubectl apply -f 3-nginx-blue-app.yaml

kubectl get deployments

kubectl get pods

kubectl get service

Desplegar un objeto de entrada

Ahora, es el momento de crear un recurso Ingress de enrutamiento basado en la ruta. Al mismo tiempo, comprueba los registros del Pod Nginx.

kubectl logs nginx-ingress-ingress-nginx-controller-5c97c6b4d5-btvpl -f

kubectl apply -f 4-ingress.yaml

En cuanto se crea el recurso Ingress, puedes ver que el Nginx ha cargado su configuración.

Y ahora, 3 aplicaciones diferentes están listas para ser accedidas utilizando el mismo Nombre de Host, es decir, kops.devopslee.com, en diferentes rutas.

Las URLs de las aplicaciones, el nombre del Hostname aquí será diferente para ti.

Se puede acceder a nginx-deploy-main en kops.devopslee.com

se puede acceder a nginx-deploy-green en kops.devopslee.com/green y

nginx-deploy-azul se puede acceder en kops.devopslee.com/blue

Puedes ver que se puede acceder a 3 aplicaciones diferentes utilizando el mismo nombre de host basado en la ruta.

Conclusión

En este artículo, hemos visto los pasos para crear un clúster Kubernetes utilizando Kops. Este artículo se ha centrado principalmente en la configuración del controlador Nginx Ingress utilizando Helm y en la creación de un enrutamiento basado en la ruta utilizando el recurso Ingress. Hemos desplegado 3 aplicaciones de ejemplo diferentes y hemos probado a acceder a ellas utilizando el mismo nombre de host y diferentes rutas.