

 **Ayude a mejorar esta página** 

Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página.

# Instalación del Controlador del equilibrador de carga de AWS con manifiestos
<a name="lbc-manifest"></a>

**sugerencia**  
Con el modo automático de Amazon EKS, no necesita instalar ni actualizar complementos de red. El modo automático ofrece capacidades para la conexión en red de pods y el equilibrio de carga.  
Para obtener más información, consulte [Automatización de la infraestructura de clústeres con el modo automático de EKS](automode.md).

En este tema, se describe cómo instalar el controlador mediante la descarga y la aplicación de los manifiestos de Kubernetes. Puede ver la [documentación](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/) completa para el controlador en GitHub.

En los siguientes pasos, reemplace los valores de ejemplo por sus propios valores.

## Requisitos previos
<a name="lbc-manifest-prereqs"></a>

Antes de comenzar este tutorial, debe completar los siguientes pasos:
+ Cree un clúster de Amazon EKS. Para crear uno, consulte [Introducción a Amazon EKS](getting-started.md).
+ Instale [Helm](https://helm.sh/docs/helm/helm_install/) en el equipo local.
+ Asegúrese de que sus complementos CNI de Amazon VPC para Kubernetes, `kube-proxy` y CoreDNS tengan las versiones mínimas enumeradas en [Service account tokens](service-accounts.md#boundserviceaccounttoken-validated-add-on-versions).
+ Conozca los conceptos de AWS Elastic Load Balancing. Para obtener más información, consulte la [Guía del usuario de Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
+ Obtenga información sobre los recursos del [servicio](https://kubernetes.io/docs/concepts/services-networking/service/) y de [entrada](https://kubernetes.io/docs/concepts/services-networking/ingress/) de Kubernetes.

### Consideraciones
<a name="lbc-manifest-considerations"></a>

Antes de seguir con los pasos de configuración de esta página, tenga en cuenta lo siguiente:
+ La política y el rol (`AmazonEKSLoadBalancerControllerRole`) de IAM se pueden reutilizar en varios clústeres de EKS de la misma cuenta de AWS.
+ Si instalará el controlador en el mismo clúster en el que se creó originalmente el rol (`AmazonEKSLoadBalancerControllerRole`), vaya al [Paso 2: Instalación de cert-manager](#lbc-cert) después de comprobar que el rol existe.
+ Si utiliza roles de IAM para cuentas de servicio (IRSA), estos deben configurarse para cada clúster y el ARN del proveedor de OpenID Connect (OIDC) de la política de confianza del rol es específico de cada clúster de EKS. Además, si instalará el controlador en un clúster nuevo con un `AmazonEKSLoadBalancerControllerRole` existente, actualice la política de confianza del rol para incluir el proveedor de OIDC del nuevo clúster y cree una nueva cuenta de servicio con la anotación de rol adecuada. Para determinar si ya tiene un proveedor de OIDC o para crear uno, consulte [Crear un proveedor de OIDC de IAM para su clúster](enable-iam-roles-for-service-accounts.md).

## Paso 1: configurar IAM
<a name="lbc-iam"></a>

Los siguientes pasos corresponden a la **versión 2.14.1** del controlador del equilibrador de carga de AWS. Para obtener más información sobre todas las versiones, consulte la [página de versiones del Controlador del equilibrador de carga de AWS](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/) en GitHub.

1. Descargue una política de IAM para el Controlador del equilibrador de carga de AWS que le permita realizar llamadas a las API de AWS en su nombre.  
**Example**  

------
#### [  AWS  ]

   ```
   curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy.json
   ```

------
#### [  AWS GovCloud (US) ]

   ```
   curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy_us-gov.json
   ```

   ```
   mv iam_policy_us-gov.json iam_policy.json
   ```

------

1. Cree una política de IAM con la política descargada en el paso anterior.

   ```
   aws iam create-policy \
       --policy-name AWSLoadBalancerControllerIAMPolicy \
       --policy-document file://iam_policy.json
   ```
**nota**  
Si ve la política en la Consola de administración de AWS, la consola muestra advertencias para el servicio **ELB**, pero no para el servicio **ELB v2**. Esto ocurre porque algunas de las acciones de la política existen para **ELB v2**, pero no para **ELB**. Puede obviar estas advertencias para **ELB**.

**Example**  

1. Reemplace *my-cluster* por el nombre de su clúster y *111122223333* con el ID de su cuenta y luego ejecute el comando.

   ```
   eksctl create iamserviceaccount \
     --cluster=my-cluster \
     --namespace=kube-system \
     --name=aws-load-balancer-controller \
     --role-name AmazonEKSLoadBalancerControllerRole \
     --attach-policy-arn=arn:aws:iam::111122223333:policy/AWSLoadBalancerControllerIAMPolicy \
     --approve
   ```

1. Recupere el ID del proveedor de OIDC de su clúster y almacénelo en una variable.

   ```
   oidc_id=$(aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
   ```

1. Determine si ya hay un proveedor de OIDC de IAM con el ID de su clúster en su cuenta. Debe tener configurado OIDC tanto para el clúster como para IAM.

   ```
   aws iam list-open-id-connect-providers | grep $oidc_id | cut -d "/" -f4
   ```

   Si no se devuelve ninguna salida, debe contar con un proveedor de OIDC de IAM para su clúster. Si no se devuelve ninguna salida, debe crear un proveedor de OIDC de IAM para el clúster. Para obtener más información, consulte [Crear un proveedor de OIDC de IAM para su clúster](enable-iam-roles-for-service-accounts.md).

1. Copie los siguientes contenidos en su dispositivo. Reemplace *111122223333* por el ID de su cuenta. Reemplace *region-code* por la región de AWS en la que se encuentra el clúster. Reemplace *EXAMPLED539D4633E53DE1B71EXAMPLE* con la salida que obtuvo en el paso anterior.

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Principal": {
                   "Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
               },
               "Action": "sts:AssumeRoleWithWebIdentity",
               "Condition": {
                   "StringEquals": {
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
                       "oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:aws-load-balancer-controller"
                   }
               }
           }
       ]
   }
   ```

1. Creación del rol de IAM.

   ```
   aws iam create-role \
     --role-name AmazonEKSLoadBalancerControllerRole \
     --assume-role-policy-document file://"load-balancer-role-trust-policy.json"
   ```

1. Adjunte la política de IAM administrada por Amazon EKS requerida al rol de IAM. Reemplace *111122223333* por el ID de su cuenta.

   ```
   aws iam attach-role-policy \
     --policy-arn arn:aws:iam::111122223333:policy/AWSLoadBalancerControllerIAMPolicy \
     --role-name AmazonEKSLoadBalancerControllerRole
   ```

1. Copie los siguientes contenidos en su dispositivo. Reemplace *111122223333* por el ID de su cuenta. Después de reemplazar el texto, ejecute el comando modificado para crear el archivo `aws-load-balancer-controller-service-account.yaml`.

   ```
   cat >aws-load-balancer-controller-service-account.yaml <<EOF
   apiVersion: v1
   kind: ServiceAccount
   metadata:
     labels:
       app.kubernetes.io/component: controller
       app.kubernetes.io/name: aws-load-balancer-controller
     name: aws-load-balancer-controller
     namespace: kube-system
     annotations:
       eks.amazonaws.com/role-arn: arn:aws:iam::111122223333:role/AmazonEKSLoadBalancerControllerRole
   EOF
   ```

1. Cree la cuenta de servicio de Kubernetes en el clúster. La cuenta de servicio de Kubernetes denominada `aws-load-balancer-controller` está anotada con el rol de IAM que creó con el nombre *AmazonEKSLoadBalancerControllerRole*.

   ```
   kubectl apply -f aws-load-balancer-controller-service-account.yaml
   ```

## Paso 2: instalar el `cert-manager`
<a name="lbc-cert"></a>

Instale el `cert-manager` con uno de los siguientes métodos para ingresar la configuración del certificado en los webhooks. Para obtener más información, consulte [Cómo empezar](https://cert-manager.io/docs/installation/#getting-started) en la *documentación de cert-manager*.

Se recomienda utilizar el registro del contenedor `quay.io` para realizar la instalación de `cert-manager`. Si los nodos no tienen acceso al registro contenedor de `quay.io`, instale `cert-manager` mediante Amazon ECR (consulte a continuación).

**Example**  

1. Si los nodos tienen acceso al registro de contenedores de `quay.io`, instale el `cert-manager` para ingresar la configuración del certificado en los webhooks.

   ```
   kubectl apply \
       --validate=false \
       -f https://github.com/jetstack/cert-manager/releases/download/v1.13.5/cert-manager.yaml
   ```

1. Instale el `cert-manager` con uno de los siguientes métodos para ingresar la configuración del certificado en los webhooks. Para obtener más información, consulte [Cómo empezar](https://cert-manager.io/docs/installation/#getting-started) en la *documentación de cert-manager*.

1. Descargue el manifiesto.

   ```
   curl -Lo cert-manager.yaml https://github.com/jetstack/cert-manager/releases/download/v1.13.5/cert-manager.yaml
   ```

1. Extraiga las siguientes imágenes y envíelas un repositorio al que tengan acceso sus nodos. Para obtener más información sobre cómo extraer, etiquetar y enviar las imágenes en su propio repositorio, consulte [Copiar una imagen de contenedor de un repositorio en otro repositorio](copy-image-to-repository.md).

   ```
   quay.io/jetstack/cert-manager-cainjector:v1.13.5
   quay.io/jetstack/cert-manager-controller:v1.13.5
   quay.io/jetstack/cert-manager-webhook:v1.13.5
   ```

1. Reemplace `quay.io` en el manifiesto de las tres imágenes por su propio nombre de registro. El siguiente comando supone que el nombre del repositorio privado es el mismo que el repositorio de origen. Sustituya *111122223333.dkr.ecr.region-code.amazonaws.com* por el registro privado.

   ```
   sed -i.bak -e 's|quay.io|111122223333.dkr.ecr.region-code.amazonaws.com|' ./cert-manager.yaml
   ```

1. Aplique el manifiesto.

   ```
   kubectl apply \
       --validate=false \
       -f ./cert-manager.yaml
   ```

## Paso 3: instalación del Controlador del equilibrador de carga de AWS
<a name="lbc-install"></a>

1. Descargue la especificación del controlador. Para obtener más información sobre el controlador, consulte la [documentación](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) en GitHub.

   ```
   curl -Lo v2_14_1_full.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.14.1/v2_14_1_full.yaml
   ```

1. Lleve a cabo las siguientes modificaciones en el archivo.

   1. Si ha descargado el archivo `v2_14_1_full.yaml`, ejecute el siguiente comando para eliminar la sección `ServiceAccount` del manifiesto. Si no elimina esta sección, se sobrescribirá la anotación obligatoria que hizo en la cuenta de servicio en un paso anterior. Al eliminar esta sección también conserva la cuenta de servicio que creó en un paso anterior si elimina el controlador.

      ```
      sed -i.bak -e '764,772d' ./v2_14_1_full.yaml
      ```

      Si ha descargado una versión de archivo diferente, abra el archivo en un editor y elimine las siguientes líneas.

      ```
      apiVersion: v1
      kind: ServiceAccount
      metadata:
        labels:
          app.kubernetes.io/component: controller
          app.kubernetes.io/name: aws-load-balancer-controller
        name: aws-load-balancer-controller
        namespace: kube-system
      ---
      ```

   1. Reemplace `your-cluster-name` en la sección `Deployment` `spec` del archivo por el nombre del clúster. Para ello, reemplace *my-cluster* por el nombre del clúster.

      ```
      sed -i.bak -e 's|your-cluster-name|my-cluster|' ./v2_14_1_full.yaml
      ```

   1. Si los nodos no tienen acceso a los repositorios de imágenes de Amazon ECR de Amazon EKS, tiene que extraer la siguiente imagen y enviarla a un repositorio al que tengan acceso los nodos. Para obtener más información sobre cómo extraer, etiquetar y enviar una imagen a su propio repositorio, consulte [Copiar una imagen de contenedor de un repositorio en otro repositorio](copy-image-to-repository.md).

      ```
      public.ecr.aws/eks/aws-load-balancer-controller:v2.14.1
      ```

      Agregue el nombre del registro al manifiesto. El siguiente comando supone que el nombre del repositorio privado es el mismo que el repositorio de origen y agrega el nombre del registro privado al archivo. Sustituya *111122223333.dkr.ecr.region-code.amazonaws.com* por el registro. En esta línea se supone que ha asignado el mismo nombre al repositorio privado que al repositorio de origen. Si no es así, cambie el texto `eks/aws-load-balancer-controller` después del nombre del registro privado al nombre del repositorio.

      ```
      sed -i.bak -e 's|public.ecr.aws/eks/aws-load-balancer-controller|111122223333.dkr.ecr.region-code.amazonaws.com/eks/aws-load-balancer-controller|' ./v2_14_1_full.yaml
      ```

   1. (Necesario solo para IMDS restringido o Fargate)

      Si va a implementar el controlador en nodos de Amazon EC2 que tienen [acceso restringido al servicio de metadatos de instancias de Amazon EC2 (IMDS)](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node), o si va a realizar una implementación en Nodos híbridos de Amazon EKS o Fargate, agregue los `following parameters` bajo `- args:`.

      ```
      [...]
      spec:
            containers:
              - args:
                  - --cluster-name=your-cluster-name
                  - --ingress-class=alb
                  - --aws-vpc-id=vpc-xxxxxxxx
                  - --aws-region=region-code
      
      
      [...]
      ```

1. Aplique el archivo.

   ```
   kubectl apply -f v2_14_1_full.yaml
   ```

1. Descargue el manifiesto `IngressClass` y `IngressClassParams` a su clúster.

   ```
   curl -Lo v2.14.1_ingclass.yaml https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/download/v2.14.1/v2_14_1_ingclass.yaml
   ```

1. Aplique el manifiesto al clúster.

   ```
   kubectl apply -f v2_14_1_ingclass.yaml
   ```

## Paso 4: verificar que el controlador se encuentre instalado
<a name="lbc-verify"></a>

1. Verifique que el controlador se encuentre instalado.

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

   Un ejemplo de salida sería el siguiente.

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

   Recibe la salida anterior si ha implementado mediante Helm. Si ha implementado utilizando el manifiesto de Kubernetes, solo tiene una réplica.

1. Antes de utilizar el controlador para aprovisionar el recurso de AWS, el clúster debe cumplir requisitos específicos. Para obtener más información, consulte [Redirección de tráfico de aplicaciones y HTTP con los equilibradores de carga de aplicaciones](alb-ingress.md) y [Dirija el tráfico de TCP y UDP con equilibradores de carga de red](network-load-balancing.md).