Qué es Ingress Controller y cómo implementar Nginx Ingress Controller en Kubernetes Cluster en AWS usando Helm

Antes de proceder con la instalación del Nginx Ingress Controller, veamos brevemente qué es Ingress e Ingress Controller. El enfoque de este artículo está en la configuración, se supone que está familiarizado con todos los requisitos previos para configurar Nginx Ingress Controller en el clúster de Kubernetes.

Ingreso de Kubernetes

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

Controlador de entrada

Para usar Ingress, debe tener el controlador de Ingress en el clúster de Kubernetes. No viene como parte del clúster de Kubernetes como otros controladores en el clúster, no se inicia automáticamente en el clúster. Podemos implementar cualquier número de controladores de entrada en el clúster de Kubernetes. Para hacerlo, debemos anotar cada ingreso con el ingreso.clase apropiado. Hay muchos tipos diferentes de controladores de entrada disponibles. Ingress Controller es un LoadBalancer para entornos de Kubernetes. Se utiliza como solución de gestión de tráfico para entornos de Kubernetes.

En este artículo, veremos la instalación del controlador de entrada de Nginx mediante Helm en el clúster de Kubernetes configurado mediante Kops. Para obtener más información sobre el controlador de entrada de Nginx, visite la documentación oficial aquí.

Requisitos previos

1. Cuenta de AWS (cree si no tiene una).
2. Kops 1.18.2 instalado en su máquina (haga clic aquí para aprender a crear un clúster de Kubernetes con Kops y obtener más información al respecto).
3. Helm v3.5.3  (Haga clic aquí para aprender a instalar Helm en Ubuntu Server)
4. Cubo de S3 (haga clic aquí para aprender a crear un cubo de S3 en AWS).
5. Nombre de dominio (haga clic aquí para aprender a registrar un dominio en AWS).
6. Rol de IAM con permisos de administrador (haga clic aquí para aprender a crear un rol de IAM en AWS).

¿Qué haremos?

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

Crea un clúster de Kubernetes con Kops

Antes de continuar con la creación del clúster, exporte sus claves secretas y de acceso de usuario de AWS IAM con 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 está creando un clúster por primera vez usando Kops y usando el S3 Bucket especificado anteriormente para almacenar la configuración del clúster, no debería ver ningún clúster cuando intente obtener clústeres usando el siguiente comando.

kops get clusters

Visite la documentación especificada en los requisitos previos para comprender Kops en detalle. Aquí, para crear un clúster de Kubernetes, ejecute el siguiente comando reemplazando 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, esta vez, si intenta obtener la configuración del clúster, verá el nombre del clúster en la salida junto con la nube y las zonas.

Hasta este momento, el clúster no se ha creado, ejecute el siguiente comando para actualizar la configuración del clúster.

kops update cluster --name kops.devopslee.com

Aún deberá ejecutar el comando anterior con --yes como opción para que se creen los recursos del clúster.

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

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

kops validate cluster --wait 10m

Debe esperar un tiempo mientras el clúster se vuelve saludable.

kops validate cluster --wait 10m

Una vez que el clúster esté en buen estado, puede verificar los pods predeterminados en todos los espacios de nombres con el siguiente comando.

kubectl get pods -A

Configurar el controlador de entrada de Nginx usando Helm

Una vez que el clúster de Kubernetes esté listo y en buen estado, podrá instalar Nginx Ingress Controller mediante Helm.

Antes de continuar, verifique que tiene Helm v3.5.3.

Nota:He usado el presente binario de Helm en mi ubicación actual, por lo tanto, puedes ver ./helm en las capturas de pantalla.

helm version

Agregue el repositorio e instale el gráfico Nginx Ingress Controller Helm con los siguientes comandos. Para comprender Helm, consulte 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, puede ver que se instaló el gráfico de Helm.

Puede 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, puede ver que también se ha creado el servicio "nginx-ingress-ingress-nginx-controller" de tipo LoadBalancer. Significa que se ha creado un LoadBalancer en la cuenta de AWS.

Crear un conjunto de registros en Route53 que apunte al LoadBalancer creado por Nginx Ingress Controlador

Vaya a su cuenta de AWS en la región donde creó su clúster de Kubernetes. Compruebe LoadBalancer y copie su nombre DNS.

Ahora, vaya a Route53 y cree un registro A único en HostedZone.

Una vez que creamos un registro válido, el registro que creamos se usará para enrutar el tráfico al clúster de Kubernetes a través del controlador de entrada de Nginx que creamos. En este caso, kops.devopslee.com enrutará el tráfico a los servicios en el clúster de Kubernetes a través del controlador de entrada de Nginx.

Crear archivos de definición de objeto para una aplicación de muestra

Ahora, vamos a crear archivos de definición de objetos para implementar una aplicación de muestra. Implementaremos 3 aplicaciones utilizando 3 implementaciones y 3 servicios respectivos para las implementaciones. A continuación, crearemos un recurso de Ingress con enrutamiento basado en rutas para enrutar el tráfico a nuestras aplicaciones mediante kops.devopslee.com en función de la ruta.

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

Enlace de Github:haga clic aquí para copiar el archivo de mi repositorio 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

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

Enlace de Github:haga 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          

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

Enlace de Github:haga clic aquí para copiar el archivo de mi repositorio 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

Cree 4-ingress.yaml para crear reglas de ingreso basadas en rutas.

Enlace de Github:haga clic aquí para copiar el archivo de mi repositorio 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

Puede encontrar todos estos archivos en mi repositorio de Github aquí.

Implementar aplicaciones de muestra

Implementemos aplicaciones de muestra una por una y verifiquemos 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

Implementar un objeto de ingreso

Ahora es el momento de crear un recurso de entrada de enrutamiento basado en rutas. Al mismo tiempo, verifique los registros de Nginx Pod.

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

kubectl apply -f 4-ingress.yaml

Tan pronto como se crea el recurso Ingress, puede ver que Nginx ha cargado su configuración.

Y ahora, 3 aplicaciones diferentes están listas para acceder usando el mismo nombre de host, es decir, kops.devopslee.com, en diferentes rutas.

URL para las aplicaciones, el nombre de host aquí será diferente para usted.

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

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

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

Puede ver que se puede acceder a 3 aplicaciones diferentes utilizando el mismo nombre de host según la ruta.

Conclusión

En este artículo, vimos los pasos para crear un clúster de Kubernetes con Kops. Este artículo se centró principalmente en configurar Nginx Ingress Controller mediante Helm y crear un enrutamiento basado en rutas mediante el recurso Ingress. Implementamos 3 aplicaciones de muestra diferentes e intentamos acceder a ellas usando el mismo nombre de host y rutas diferentes.