

 **Aidez à améliorer cette page** 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Pour contribuer à ce guide de l'utilisateur, cliquez sur le GitHub lien **Modifier cette page sur** qui se trouve dans le volet droit de chaque page.

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Installer le AWS Load Balancer Controller avec des manifestes
<a name="lbc-manifest"></a>

**Astuce**  
Avec le mode automatique Amazon EKS, il n’est pas nécessaire d’installer ou de mettre à niveau de modules complémentaires de mise en réseau. Le mode automatique inclut des fonctionnalités de mise en réseau des pods et d’équilibrage de charge.  
Pour de plus amples informations, veuillez consulter [Automatisation de l’infrastructure du cluster avec le mode automatique EKS](automode.md).

Cette rubrique décrit comment installer le contrôleur en téléchargeant et en appliquant des manifestes Kubernetes. Vous pouvez afficher l'intégralité de la [documentation](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/) pour le contrôleur sur GitHub.

Dans les étapes suivantes, remplacez les valeurs d’exemple par vos propres valeurs.

## Conditions préalables
<a name="lbc-manifest-prereqs"></a>

Avant de commencer ce tutoriel, vous devez suivre les étapes suivantes :
+ Créez un cluster Amazon EKS. Pour en créer un, consultez [Mise en route avec Amazon EKS](getting-started.md).
+ Installez [Helm](https://helm.sh/docs/helm/helm_install/) sur votre machine locale.
+ Assurez-vous que votre plug-in Amazon VPC CNI pour Kubernetes, `kube-proxy`, et les modules complémentaires CoreDNS sont au minimum aux versions indiquées dans les [jetons de compte de service](service-accounts.md#boundserviceaccounttoken-validated-add-on-versions).
+ Découvrez les concepts d' AWS Elastic Load Balancing. Pour plus d'informations, consultez le [Guide de l'utilisateur Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
+ Découvrez les ressources Kubernetes [Service](https://kubernetes.io/docs/concepts/services-networking/service/) et [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/).

### Considérations
<a name="lbc-manifest-considerations"></a>

Avant de procéder aux étapes de configuration décrites sur cette page, tenez compte des points suivants :
+ La politique et le rôle IAM (`AmazonEKSLoadBalancerControllerRole`) peuvent être réutilisés sur plusieurs clusters EKS du même AWS compte.
+ Si vous installez le contrôleur sur le même cluster où le rôle (`AmazonEKSLoadBalancerControllerRole`) a été créé à l’origine, passez à l’[Étape 2 : installer cert-manager](#lbc-cert) après avoir vérifié que le rôle existe.
+ Si vous utilisez les rôles IAM pour les comptes de service (IRSA), IRSA doit être configuré pour chaque cluster, et l’ARN du fournisseur OpenID Connect (OIDC) dans la politique de confiance du rôle est spécifique à chaque cluster EKS. De plus, si vous installez le contrôleur sur un nouveau cluster avec un `AmazonEKSLoadBalancerControllerRole` existant, mettez à jour la politique de confiance du rôle afin d’inclure le fournisseur OIDC du nouveau cluster et créez un nouveau compte de service avec l’annotation de rôle appropriée. Pour déterminer si vous disposez déjà d’un fournisseur OIDC ou pour en créer un, consultez [Créer un fournisseur d'identité OIDC IAM pour votre cluster](enable-iam-roles-for-service-accounts.md).

## Étape 1 : configurer IAM
<a name="lbc-iam"></a>

Les étapes suivantes font référence à la **version 2.14.1** du AWS Load Balancer Controller. Pour plus d'informations sur toutes les versions, consultez la [page de mise à jour du AWS Load Balancer Controller](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/) sur. GitHub

1. Téléchargez une politique IAM pour le AWS Load Balancer Controller qui lui permet de passer des appels en votre AWS APIs nom.  
**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. Créez une politique IAM à l'aide de la politique téléchargée à l'étape précédente.

   ```
   aws iam create-policy \
       --policy-name AWSLoadBalancerControllerIAMPolicy \
       --policy-document file://iam_policy.json
   ```
**Note**  
Si vous consultez la politique dans le AWS Management Console, la console affiche des avertissements pour le service **ELB**, mais pas pour le service **ELB v2**. Cela est dû au fait que certaines des actions de la politique sont disponibles pour **ELB v2**, mais pas pour **ELB**. Vous pouvez ignorer les avertissements relatifs au service **ELB**.

**Example**  

1. Remplacez *my-cluster* par le nom de votre cluster, *111122223333* par votre ID de compte, puis exécutez la commande.

   ```
   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. Récupérez l’ID du fournisseur OIDC de votre cluster et stockez-le dans une variable.

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

1. Déterminez si un fournisseur IAM OIDC avec l’ID de votre cluster existe déjà dans votre compte. Vous devez configurer OIDC à la fois pour le cluster et pour IAM.

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

   Si une sortie est renvoyée, cela signifie que vous disposez déjà d’un fournisseur IAM OIDC pour votre cluster. Si aucune sortie n'est renvoyée, vous devez créer un fournisseur OIDC IAM pour votre cluster. Pour de plus amples informations, veuillez consulter [Créer un fournisseur d'identité OIDC IAM pour votre cluster](enable-iam-roles-for-service-accounts.md).

1. Copiez les contenus suivants sur votre appareil. Remplacez *111122223333* par votre ID de compte. Remplacez *region-code* par la AWS région dans laquelle se trouve votre cluster. Remplacez *EXAMPLED539D4633E53DE1B71EXAMPLE* par la sortie renvoyée dans l'étape précédente.

   ```
   {
       "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. Créez le rôle IAM.

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

1. Attachez la politique IAM gérée par Amazon EKS au rôle IAM. Remplacez *111122223333* par votre ID de compte.

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

1. Copiez les contenus suivants sur votre appareil. Remplacez *111122223333* par votre ID de compte. Après avoir remplacé le texte, exécutez la commande modifiée pour créer le fichier `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. Créez le compte de service Kubernetes sur votre cluster. Le compte de service Kubernetes nommé `aws-load-balancer-controller` est annoté avec le nom du rôle IAM que vous avez créé. *AmazonEKSLoadBalancerControllerRole*

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

## Étape 2 : Installation `cert-manager`
<a name="lbc-cert"></a>

Installez `cert-manager` en utilisant l'une des méthodes suivantes pour injecter la configuration du certificat dans les webhooks. Pour plus d’informations, consultez le [guide de démarrage](https://cert-manager.io/docs/installation/#getting-started) de la *documentation cert-manager*.

Pour installer `cert-manager`, nous vous recommandons d’utiliser le registre des conteneurs `quay.io`. Si vos nœuds n’ont pas accès au registre de conteneurs `quay.io`, installez `cert-manager` à l’aide d’Amazon ECR (voir ci-dessous).

**Example**  

1. Si vos nœuds ont accès au registre de conteneurs `quay.io`, installez `cert-manager` pour injecter la configuration du certificat dans les webhooks.

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

1. Installez `cert-manager` en utilisant l'une des méthodes suivantes pour injecter la configuration du certificat dans les webhooks. Pour plus d’informations, consultez le [guide de démarrage](https://cert-manager.io/docs/installation/#getting-started) de la *documentation cert-manager*.

1. Téléchargez le manifeste.

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

1. Extrayez les images suivantes et transférez-les vers un référentiel auquel vos nœuds ont accès. Pour plus d'informations sur l'extraction, le balisage et le transfert d'images vers votre propre référentiel, consultez [Copier une image de conteneur d'un référentiel vers un autre référentiel](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. Remplacez `quay.io` dans le manifeste des trois images par votre propre nom de registre. La commande suivante suppose que le nom de votre référentiel privé est le même que celui du référentiel source. Remplacez *111122223333.dkr.ecr.region-code.amazonaws.com* par votre registre privé.

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

1. Appliquez le manifeste.

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

## Étape 3 : Installation du AWS Load Balancer Controller
<a name="lbc-install"></a>

1. Téléchargez la spécification du contrôleur. Pour plus d'informations sur le contrôleur, consultez la [documentation](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) sur 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. Effectuez les modifications suivantes dans le fichier.

   1. Si vous avez téléchargé le fichier `v2_14_1_full.yaml`, exécutez la commande suivante pour supprimer la section `ServiceAccount` du manifeste. Si vous ne supprimez pas cette section, l’annotation requise que vous avez apportée au compte de service lors d’une étape précédente sera écrasée. La suppression de cette section préserve également le compte de service que vous avez créé à une étape précédente, si vous supprimez le contrôleur.

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

      Si vous avez téléchargé une version différente du fichier, ouvrez le fichier dans un éditeur et supprimez les lignes suivantes.

      ```
      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. Remplacez `your-cluster-name` dans la section `Deployment` `spec` du fichier par le nom de votre cluster en remplaçant *my-cluster* par le nom de votre cluster.

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

   1. Si vos nœuds n’ont pas accès aux référentiels d’images Amazon EKS Amazon ECR, vous devez extraire l’image suivante et l’envoyer vers un référentiel auquel vos nœuds ont accès. Pour plus d'informations sur l'extraction, l'identification et le transfert d'une image vers votre propre référentiel, consultez [Copier une image de conteneur d'un référentiel vers un autre référentiel](copy-image-to-repository.md).

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

      Ajoutez le nom de votre registre au manifeste. La commande suivante suppose que le nom de votre référentiel privé est le même que celui du référentiel source et ajoute le nom de votre registre privé au fichier. Remplacez *111122223333.dkr.ecr.region-code.amazonaws.com* par votre registre. Cette ligne suppose que vous avez nommé votre référentiel privé de la même manière que le référentiel source. Dans le cas contraire, remplacez le texte `eks/aws-load-balancer-controller` après votre nom de registre privé par le nom de votre référentiel.

      ```
      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. (Requis uniquement pour Fargate ou Restricted IMDS)

      Si vous déployez le contrôleur sur des EC2 nœuds Amazon ayant un [accès restreint au service de métadonnées d' EC2 instance Amazon (IMDS)](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node), ou si vous déployez sur des nœuds hybrides Fargate ou Amazon EKS, ajoutez le point ci-dessous. `following parameters` `- args:`

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

1. Appliquez le fichier.

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

1. Téléchargez l'attaque de l'homme du milieu (HDM) `IngressClass` et `IngressClassParams` à votre cluster.

   ```
   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. Appliquez le manifeste à votre cluster.

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

## Étape 4 : vérifier que le contrôleur est installé
<a name="lbc-verify"></a>

1. Vérifiez que le contrôleur est installé.

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

   L'exemple qui suit illustre un résultat.

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

   Vous recevez la sortie précédente si vous avez déployé à l'aide de Helm. Si vous avez déployé à l'aide du manifeste Kubernetes, vous n'avez qu'un seul réplica.

1. Avant d'utiliser le contrôleur pour provisionner AWS des ressources, votre cluster doit répondre à des exigences spécifiques. Pour plus d'informations, consultez [Routage du trafic des applications et du trafic HTTP avec des équilibreurs de charge Application Load Balancer](alb-ingress.md) et [Acheminer le trafic TCP et UDP avec des Network Load Balancers](network-load-balancing.md).