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

Comando Kops para crear un cl√ļster K8S

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.

Entrada 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 ingreso

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 del 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 una 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 saber m√°s sobre Nginx Ingress Controller, visite la documentaci√≥n oficial aqu√≠.

requisitos previos

  1. Cuenta AWS ( Crear si no tienes uno).
  2. Kops 1.18.2 instalado en su m√°quina (Haga clic aqu√≠ para aprender a crear un cl√ļster de Kubernetes usando 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. S3 Bucket (Haga clic aquí para aprender a crear un S3 Bucket 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).

¬ŅQue haremos?

  1. Cree un cl√ļster de Kubernetes con Kops
  2. Configurar el controlador de entrada de Nginx con 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

Cree 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

Comando Kops para crear un cl√ļster K8S

Puede ver algunos comandos en la sugerencia.

Fuera del comando anterior

Ahora, esta vez, si intenta obtener la configuraci√≥n del cl√ļster, ver√° el nombre del cl√ļster en el resultado junto con la nube y las zonas.

Obtener cl√ļsteres

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

Cl√ļster de actualizaci√≥n de ejecuci√≥n en seco

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

Actualice el cl√ļster para crear recursos en la nube

Valide si el cl√ļster est√° listo o no.

kops validate cluster --wait 10m

Validar el cl√ļsterAnuncio publicitario

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

kops validate cluster --wait 10m

Validaci√≥n exitosa del cl√ļster

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

Verifique los pods predeterminados en todos los espacios de nombres

Configurar el controlador de entrada de Nginx con 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 tenga Helm v3.5.3.

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

helm version

Versión de timón

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

Configurar el controlador de entrada de Nginx

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

Objetos creados por Ingress Controller

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.

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

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

LoadBalancer creado por Ingress Controller

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

Crear un conjunto de registros

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 objetos 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. Luego crearemos un recurso de Ingress con enrutamiento basado en rutas para enrutar el tr√°fico a nuestras aplicaciones usando kops.devopslee.com seg√ļn la ruta.

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

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

Puedes 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 una aplicación de muestra

Implementar un objeto de ingreso

Ahora es el momento de crear un recurso de entrada de enrutamiento basado en ruta. 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

Cree un recurso de Ingress y verifique los registros del pod de nginx-ingress

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

Comprobar el recurso de entrada

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

Accede a las aplicaciones

Conclusión

En este art√≠culo, vimos los pasos para crear un cl√ļster de Kubernetes usando 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 diferentes rutas.

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *