¿Cómo puedo configurar AWS Load Balancer Controller en un clúster de Amazon EKS para Fargate?

Solución

Nota: Si se muestran errores al ejecutar comandos de la Interfaz de la línea de comandos de AWS (AWS CLI), consulta Solución de problemas de AWS CLI. Además, asegúrate de utilizar la versión más reciente de la AWS CLI.

Puedes configurar AWS Load Balancer Controller aunque no se haya desplegado ningún controlador de entrada para el equilibrador de carga de aplicación.

Requisitos previos:

• Desinstala el controlador de entrada para Kubernetes del ALB de AWS existente. AWS Load Balancer Controller reemplaza su funcionalidad.
• Utiliza la versión 0.109.0 o posterior de eksctl. Para obtener más información, consulta Installation (Instalación) en el sitio web de eksctl.
• Instala Helm en la estación de trabajo.

Creación de un clúster de Amazon EKS, una política de cuentas de AWS de servicio y políticas de control de acceso basado en roles

Sigue estos pasos:

1. Para usar eksctl con el fin de crear un clúster de Amazon EKS, ejecuta el comando siguiente:

   eksctl create cluster \
     --name YOUR_CLUSTER_NAME \
     --version 1.28 \
     --fargate

   Nota: Sustituye YOUR_CLUSTER_NAME por el nombre de tu clúster. No es necesario crear un rol de ejecución de pod de Fargate para los clústeres que solo usan pods de Fargate (--fargate).

2. Para permitir que el clúster use AWS Identity and Access Management (IAM) para las cuentas de servicio, ejecuta el siguiente comando:

   eksctl utils associate-iam-oidc-provider \
     --cluster YOUR_CLUSTER_NAME \
     --approve

   Nota: Sustituye YOUR_CLUSTER_NAME por el nombre de tu clúster. kubelet y kube-proxy usan FargateExecutionRole para ejecutar el pod de Fargate. Sin embargo, FargateExecutionRole no es el rol de IAM del pod de Fargate. En el caso de los pods de Fargate, debes usar el rol de IAM para la cuenta de servicio.

3. Para descargar una política de IAM que permita que AWS Load Balancer Controller realice llamadas a las API de AWS en tu nombre, ejecuta el siguiente comando:

4.  curl -o iam_policy.json https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.11.0/docs/install/iam_policy.json

5. Para crear una política de IAM con la política descargada, ejecuta el siguiente comando create-policy de la AWS CLI:

   aws iam create-policy \
     --policy-name AWSLoadBalancerControllerIAMPolicy \
     --policy-document file://iam_policy.json

6. Para crear una cuenta de servicio para AWS Load Balancer Controller, ejecuta el siguiente comando:

   eksctl create iamserviceaccount \
     --cluster=YOUR_CLUSTER_NAME \
     --namespace=kube-system \
     --name=aws-load-balancer-controller \
     --attach-policy-arn=arn:aws:iam::AWS_ACCOUNT_ID:policy/AWSLoadBalancerControllerIAMPolicy \
     --override-existing-serviceaccounts \
     --approve

   Nota: Sustituye YOUR_CLUSTER_NAME por el nombre del clúster y AWS_ACCOUNT_ID por el ID de tu cuenta. El comando anterior crea una cuenta de servicio denominada aws-load-balancer-controller en el espacio de nombres kube-system.

7. Para comprobar que se ha creado el nuevo rol de servicio, ejecuta uno de los siguientes comandos:

   eksctl get iamserviceaccount \
     --cluster=YOUR_CLUSTER_NAME \
     --name=aws-load-balancer-controller \
     --namespace=kube-system

   Nota: Sustituye YOUR_CLUSTER_NAME por el nombre de tu clúster.
   Alternativa:

   kubectl get serviceaccount aws-load-balancer-controller \
     --namespace kube-system \
     -o yaml

Instalación de AWS Load Balancer Controller con Helm

Sigue estos pasos:

1. Para añadir el gráfico de Amazon EKS a Helm, ejecuta el siguiente comando:

   helm repo add eks https://aws.github.io/eks-charts

2. Para actualizar el repositorio y obtener el gráfico más reciente, ejecuta el siguiente comando:

   helm repo update eks

3. Para instalar el gráfico de Helm, ejecuta el siguiente comando:

   helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
     --set clusterName=YOUR_CLUSTER_NAME \
     --set serviceAccount.create=false \
     --set region=YOUR_REGION_CODE \
     --set vpcId=EKS_CLUSTER_VPC_ID \
     --set serviceAccount.name=aws-load-balancer-controller \
     --version 1.11.0 \
     -n kube-system

   Nota: Sustituye YOUR_CLUSTER_NAME por el nombre del clúster y YOUR_REGION_CODE por la región de AWS del clúster. Además, sustituye EKS_CLUSTER_VPC_ID por el ID de la nube virtual privada (VPC) del clúster.

4. Para comprobar que el controlador se haya instalado correctamente, ejecuta el siguiente comando:

   kubectl get deployment -n kube-system aws-load-balancer-controller

   Resultado de ejemplo:

   NAME                           READY   UP-TO-DATE   AVAILABLE   AGE
   aws-load-balancer-controller   2/2     2            2           84s

Prueba de AWS Load Balancer Controller

Para probar la implementación, utiliza AWS Load Balancer Controller para crear uno de los siguientes recursos:

• Un equilibrador de carga de aplicación para la entrada.
• Un equilibrador de carga de red donde, en Servicio, el valor de Tipo sea LoadBalancer.

Un recurso de entrada enruta el tráfico a diferentes servicios en función de conceptos web como los URI, los nombres de host y las rutas. Se recomienda usar un recurso de entrada para compartir un equilibrador de carga con varios servicios o para controlar el enrutamiento del servicio. Usa un LoadBalancer de servicio para asignar un equilibrador de carga dedicado al servicio.

Nota: Los siguientes pasos de prueba implementan una aplicación de juego de ejemplo llamada 2048.

Creación de un equilibrador de carga de aplicación

Para crear un equilibrador de carga de aplicación para la entrada, sigue estos pasos:

1. Para crear el perfil de Fargate que sea necesario para la implementación del juego, ejecuta el siguiente comando:

   eksctl create fargateprofile \
     --cluster YOUR_CLUSTER_NAME \
     --region YOUR_REGION_CODE \
     --name your-alb-sample-app \
     --namespace game-2048

   Nota: Sustituye YOUR_CLUSTER_NAME por el nombre del clúster y YOUR_REGION_CODE por la región.

2. Para implementar la aplicación, ejecuta el siguiente comando:

   kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.11.0/docs/examples/2048/2048_full.yaml

3. Espera unos minutos. A continuación, ejecuta el siguiente comando para comprobar que AWS Load Balancer Controller haya creado un recurso de entrada:

   kubectl get ingress/ingress-2048 -n game-2048

   Resultado de ejemplo:

   NAME         CLASS HOSTS ADDRESS                                                                PORTS AGE
   ingress-2048 alb   *     k8s-game2048-ingress2-xxxxxxxxxx-yyyyyyyyyy.region.elb.amazonaws.com   80    3d4h

   Si no ves un recurso de entrada después de varios minutos, ejecuta el siguiente comando para ver los registros de AWS Load Balancer Controller:

   kubectl logs -n kube-system deployment.apps/aws-load-balancer-controller

   Consulta los registros para ver si hay mensajes de error que ayudan a diagnosticar problemas relacionados con la implementación.

4. Para ver la aplicación, abre un navegador y, a continuación, navega hasta la URL en el resultado del comando del recurso de entrada.
   Nota: Si no puedes ver la aplicación, espera unos minutos y actualiza el navegador.

Creación de un equilibrador de carga de red

Para implementar una aplicación con el servicio en modo de dirección IP del equilibrador de carga de red, sigue estos pasos:

1. Para crear un perfil de Fargate, ejecuta el siguiente comando:

   eksctl create fargateprofile --cluster your-cluster --region your-region-code --name your-alb-sample-app --namespace game-2048

   Nota: Sustituye your-cluster por el nombre del clúster y your-region-code por la región del clúster.

2. Para obtener el manifiesto para implementar el juego 2048, ejecuta el siguiente comando:

   curl -o 2048-game.yaml https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.11.0/docs/examples/2048/2048_full.yaml

3. En el manifiesto, elimina la siguiente sección de entrada:

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     namespace: game-2048
     name: ingress-2048
     annotations:
       alb.ingress.kubernetes.io/scheme: internet-facing
       alb.ingress.kubernetes.io/target-type: ip
   spec:
     ingressClassName: alb
     rules:
       - http:
           paths:
             - path: /
               pathType: Prefix
               backend:
                 service:
                   name: service-2048           
                   port:
                     number: 80

4. Modifica el objeto de servicio para usar los valores siguientes:

   apiVersion: v1
   kind: Service
   metadata:
     namespace: game-2048
     name: service-2048
     annotations:
       service.beta.kubernetes.io/aws-load-balancer-nlb-target-type: "ip"
       service.beta.kubernetes.io/aws-load-balancer-type: external
       service.beta.kubernetes.io/aws-load-balancer-scheme: internet-facing
   spec:
     ports:
       - port: 80
         targetPort: 80
         protocol: TCP
     type: LoadBalancer
     selector:
       app.kubernetes.io/name: app-2048

5. Para crear el manifiesto de implementación y el servicio, ejecuta el siguiente comando:

   kubectl apply -f 2048-game.yaml

6. Para comprobar que se haya creado el servicio y consultar el nombre DNS del equilibrador de carga de red, ejecuta el siguiente comando:

   kubectl get svc -n game-2048

   Resultado de ejemplo:

   NAME           TYPE           CLUSTER-IP       EXTERNAL-IP                                                               PORT(S)        AGE
   service-2048   LoadBalancer   10.100.114.197   k8s-game2048-service2-xxxxxxxxxx-yyyyyyyyyy.us-east-2.elb.amazonaws.com   80:xxxxx/TCP   23m

7. Espera unos minutos a que el equilibrador de carga esté activo. Para comprobar que puedes acceder a la implementación, abre un navegador web. A continuación, abre el nombre de dominio completo (FQDN) en la salida del comando en EXTERNAL-IP.

Solución de problemas de AWS Load Balancer Controller

Si tienes problemas al configurar AWS Load Balancer Controller, ejecuta los siguientes comandos:

kubectl logs -n kube-system deployment.apps/aws-load-balancer-controller
kubectl get endpoints -n game-2048
kubectl get ingress/ingress-2048 -n game-2048

Comprueba el resultado del comando logs para ver si hay mensajes de error, como problemas con las etiquetas o las subredes. Para ver los pasos de solución de errores comunes, consulta Issues (Problemas) en el sitio web de GitHub. Consulta también ¿Cómo puedo solucionar problemas al crear un equilibrador de carga con el controlador del equilibrador de carga de AWS?

El comando get endpoints muestra si has registrado correctamente los pods de implementación respaldados. Los comandos get ingress muestran si se han implementado los recursos de entrada.

Para obtener más información, consulta AWS Load Balancer Controller en el sitio web de Kubernetes.