**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.
# Acheminez le trafic Internet avec le AWS Load Balancer Controller
**Astuce**
[Inscrivez-vous](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) aux prochains ateliers Amazon EKS.
Le AWS Load Balancer Controller gère les AWS Elastic Load Balancers pour un cluster Kubernetes. Vous pouvez utiliser le contrôleur pour exposer les applications de votre cluster à Internet. Le contrôleur fournit des équilibreurs de AWS charge qui pointent vers les ressources de service ou d'entrée du cluster. En d’autres termes, le contrôleur crée une adresse IP ou un nom DNS unique qui achemine le trafic vers plusieurs pods dans votre cluster.
![\[Diagramme d’architecture. Illustration du trafic provenant des utilisateurs Internet vers un équilibreur de charge Amazon Load Balancer. L’équilibreur de charge Amazon Load Balancer distribue le trafic aux pods du cluster.\]](http://docs.aws.amazon.com/fr_fr/eks/latest/userguide/images/lbc-overview.png)
Le contrôleur surveille les ressources Service ou Ingress Kubernetes. En réponse, il crée les ressources AWS Elastic Load Balancing appropriées. Vous pouvez configurer le comportement spécifique des équilibreurs de charge en ajoutant des annotations aux ressources Kubernetes. Par exemple, vous pouvez associer des groupes AWS de sécurité aux équilibreurs de charge à l'aide d'annotations.
Le contrôleur fournit les ressources suivantes :
**Kubernetes `Ingress`**
Le LBC crée un équilibreur de charge [AWS Application Load Balancer (ALB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html) lorsque vous créez une ressource `Ingress` Kubernetes. [Consultez la liste des annotations applicables à une ressource Ingress.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/)
**Service Kubernetes de type `LoadBalancer`**
Le LBC crée un équilibreur de charge [AWS Network Load Balancer (NLB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html) lorsque vous créez un service Kubernetes de type `LoadBalancer`. [Consultez la liste des annotations applicables à une ressource Service.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/)
Historiquement, l’équilibreur de charge Network Load Balancer Kubernetes était utilisé pour des cibles de type *instance*, tandis que le LBC était utilisé pour des cibles de type *IP*. Avec la version AWS Load Balancer Controller `2.3.0` ou ultérieure, vous pouvez créer en NLBs utilisant l'un ou l'autre type de cible. Pour plus d'informations sur les types de cibles NLB, consultez [Type de cible](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-type) dans le guide de l'utilisateur de Network Load Balancer.
Le contrôleur est un [projet open source](https://github.com/kubernetes-sigs/aws-load-balancer-controller) géré sur GitHub.
Avant de déployer le contrôleur, nous vous recommandons de consulter les prérequis et points à considérer dans [Routage du trafic des applications et du trafic HTTP à l’aide des équilibreurs de charge d’applications Application Load Balancer](alb-ingress.md) et [Acheminer le trafic TCP et UDP avec des Network Load Balancers](network-load-balancing.md). Dans ces rubriques, vous allez déployer un exemple d'application qui inclut un équilibreur de AWS charge.
**API Kubernetes `Gateway`**
Avec la version AWS Load Balancer Controller `2.14.0` ou ultérieure, le LBC crée un [Application AWS Load Balancer (ALB](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)) lorsque vous créez un Kubernetes. `Gateway` Kubernetes Gateway normalise davantage la configuration qu'Ingress, qui nécessitait des annotations personnalisées pour de nombreuses options courantes. [Passez en revue la configuration que vous pouvez appliquer à une ressource de passerelle.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/gateway/gateway/) Pour plus d'informations sur l'`Gateway`API, consultez la section [API Gateway](https://kubernetes.io/docs/concepts/services-networking/gateway/) dans la documentation de Kubernetes.
## Installation du contrôleur
Vous pouvez utiliser l'une des procédures suivantes pour installer le AWS Load Balancer Controller :
+ Si vous utilisez Amazon EKS pour la première fois, nous vous recommandons d'utiliser Helm pour l'installation, car cela simplifie l'installation du AWS Load Balancer Controller. Pour de plus amples informations, veuillez consulter [Installez le contrôleur AWS Load Balancer avec Helm](lbc-helm.md).
+ Pour les configurations avancées, telles que les clusters avec un accès réseau restreint aux registres de conteneurs publics, utilisez les manifestes Kubernetes. Pour de plus amples informations, veuillez consulter [Installer le AWS Load Balancer Controller avec des manifestes](lbc-manifest.md).
## Migration à partir des versions obsolètes du contrôleur
+ Si vous avez installé des versions obsolètes du AWS Load Balancer Controller, consultez. [Migrer des applications depuis le ALB Ingress Controller](lbc-remove.md)
+ Les versions rendues obsolètes ne peuvent pas être mises à niveau. Ils doivent être supprimés et une version actuelle du AWS Load Balancer Controller doit être installée.
+ Les versions obsolètes incluent :
+ AWS Contrôleur d'entrée ALB pour Kubernetes (« Ingress Controller »), prédécesseur du Load Balancer Controller. AWS
+ N'importe quelle `0.1.x ` version du AWS Load Balancer Controller
## Ancien fournisseur de cloud
Kubernetes inclut un ancien fournisseur de cloud pour AWS. L'ancien fournisseur de cloud est capable de fournir des équilibreurs de AWS charge, comme le AWS Load Balancer Controller. L’ancien fournisseur de cloud crée des équilibreurs de charge Classic Load Balancer. Si vous n'installez pas le AWS Load Balancer Controller, Kubernetes utilisera par défaut l'ancien fournisseur de cloud. Vous devez installer le AWS Load Balancer Controller et éviter d'utiliser l'ancien fournisseur de cloud.
**Important**
Dans les versions 2.5 et ultérieures, le AWS Load Balancer Controller devient le contrôleur par défaut pour les ressources de *service* Kubernetes avec le Network Load Balancer (NLB) `type: LoadBalancer` et crée un AWS Network Load Balancer (NLB) pour chaque service. Pour ce faire, il génère un webhook de mutation pour les services, qui définit le champ `spec.loadBalancerClass` sur `service.k8s.aws/nlb` pour les nouveaux services d'équilibreur `type: LoadBalancer`. Vous pouvez désactiver cette fonctionnalité et revenir à l'utilisation de l'[ancien fournisseur de cloud](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/#legacy-cloud-provider) en tant que contrôleur par défaut, en définissant la valeur `enableServiceMutatorWebhook` des charts de Helm sur `false`. À moins que vous ne désactiviez cette fonctionnalité, le cluster ne générera pas de nouveaux équilibreurs de charge Classic Load Balancer pour vos services. Les équilibreurs de charge Classic Load Balancer existants continueront de fonctionner.
# Installez le contrôleur AWS Load Balancer avec Helm
**Astuce**
[Inscrivez-vous](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) aux prochains ateliers Amazon EKS.
**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 AWS Load Balancer Controller à l'aide de Helm, un gestionnaire de packages pour Kubernetes, et. `eksctl` Le contrôleur est installé avec les options par défaut. Pour plus d'informations sur le contrôleur, notamment sur sa configuration à l'aide d'annotations, consultez la documentation du [contrôleur AWS Load Balancer](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) sur. GitHub
Dans les étapes suivantes, remplacez les valeurs d’exemple par vos propres valeurs.
## Conditions préalables
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
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 le contrôleur d’équilibreur de charge](#lbc-helm-install) 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 : créer un rôle IAM à l’aide d’`eksctl`
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.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy.json
```
+ Si vous êtes une AWS partition non standard, telle qu'une région gouvernementale ou chinoise, [consultez les politiques GitHub](https://github.com/kubernetes-sigs/aws-load-balancer-controller/tree/main/docs/install) et téléchargez la politique appropriée pour votre région.
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**.
1. Remplacez les valeurs pour le nom du cluster, le code régional et l’ID du compte.
```
eksctl create iamserviceaccount \
--cluster= \
--namespace=kube-system \
--name=aws-load-balancer-controller \
--attach-policy-arn=arn:aws: iam:::policy/AWSLoadBalancerControllerIAMPolicy \
--override-existing-serviceaccounts \
--region \
--approve
```
## Étape 2 : Installation du AWS Load Balancer Controller
1. Ajoutez le référentiel de `eks-charts` diagrammes Helm. AWS maintient [ce dépôt](https://github.com/aws/eks-charts) activé GitHub.
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Mettez à jour votre référentiel local pour vous assurer que vous disposez des graphiques les plus récents.
```
helm repo update eks
```
1. Installez le AWS Load Balancer Controller.
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 les indicateurs suivants `helm` à la commande suivante :
+ `--set region=region-code `
+ `--set vpcId=vpc-xxxxxxxx `
Remplacez *my-cluster* par le nom de votre cluster. Dans la commande suivante, `aws-load-balancer-controller` est le compte de service Kubernetes que vous avez créé à l'étape précédente.
Pour plus d'informations sur la configuration du graphique de barre, consultez [values.yaml](https://github.com/aws/eks-charts/blob/master/stable/aws-load-balancer-controller/values.yaml) on. GitHub
```
helm install aws-load-balancer-controller eks/aws-load-balancer-controller \
-n kube-system \
--set clusterName=my-cluster \
--set serviceAccount.create=false \
--set serviceAccount.name=aws-load-balancer-controller \
--version 1.14.0
```
**Important**
Le graphique déployé ne reçoit pas automatiquement les mises à jour de sécurité. Vous devez effectuer manuellement une mise à niveau vers un graphique plus récent lorsqu'il sera disponible. Lors de la mise *install* à niveau, `upgrade` passez à la commande précédente.
La `helm install` commande installe automatiquement les définitions de ressources personnalisées (CRDs) pour le contrôleur. Ce n’est pas le cas de la commande `helm upgrade`. Si vous utilisez, `helm upgrade,` vous devez installer manuellement le CRDs. Exécutez la commande suivante pour installer CRDs :
```
wget https://raw.githubusercontent.com/aws/eks-charts/master/stable/aws-load-balancer-controller/crds/crds.yaml
kubectl apply -f crds.yaml
```
## Étape 3 : vérifier que le contrôleur est installé
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).
# Installer le AWS Load Balancer Controller avec des manifestes
**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
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
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
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 <
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
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é
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).
# Migrer des applications depuis le ALB Ingress Controller
Cette rubrique décrit comment Migration à partir de versions de contrôleur rendues obsolètes. Plus précisément, il décrit comment supprimer les versions obsolètes du AWS Load Balancer Controller.
+ Les versions rendues obsolètes ne peuvent pas être mises à niveau. Vous devez d’abord les supprimer, puis installer une version actuelle.
+ Les versions obsolètes incluent :
+ AWS Contrôleur d'entrée ALB pour Kubernetes (« Ingress Controller »), prédécesseur du Load Balancer Controller. AWS
+ N'importe quelle `0.1.x ` version du AWS Load Balancer Controller
## Supprimer la version obsolète du contrôleur
**Note**
Vous avez peut-être installé la version obsolète à l’aide de Helm ou manuellement avec les manifestes Kubernetes. Terminez la procédure à l'aide de l'outil avec lequel vous l'avez installé à l'origine.
1. Si vous avez installé les Charts de Helm `incubator/aws-alb-ingress-controller`, désinstallez-les.
```
helm delete aws-alb-ingress-controller -n kube-system
```
1. Si la version `0.1.x ` du graphique `eks-charts/aws-load-balancer-controller` est installée, désinstallez-la. La mise à niveau depuis `0.1.x ` vers la version `1.0.0` ne fonctionne pas en raison d’une incompatibilité avec la version de l’API du webhook.
```
helm delete aws-load-balancer-controller -n kube-system
```
1. Vérifiez si le contrôleur est actuellement installé.
```
kubectl get deployment -n kube-system alb-ingress-controller
```
Il s’agit de la sortie si le contrôleur n’est pas installé.
```
Error from server (NotFound): deployments.apps "alb-ingress-controller" not found
```
Il s'agit de la sortie si le contrôleur est installé.
```
NAME READY UP-TO-DATE AVAILABLE AGE
alb-ingress-controller 1/1 1 1 122d
```
1. Saisissez les commandes suivantes pour supprimer le contrôleur.
```
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/aws-alb-ingress-controller/v1.1.8/docs/examples/alb-ingress-controller.yaml
kubectl delete -f https://raw.githubusercontent.com/kubernetes-sigs/aws-alb-ingress-controller/v1.1.8/docs/examples/rbac-role.yaml
```
## Migrer vers AWS Load Balancer Controller
Pour migrer de l'ALB Ingress Controller pour Kubernetes vers le Load Balancer Controller, vous AWS devez :
1. Retirez le contrôleur d’entrée ALB (voir ci-dessus).
1. [Installez le AWS Load Balancer Controller.](aws-load-balancer-controller.md#lbc-overview)
1. Ajoutez une politique supplémentaire au rôle IAM utilisé par le AWS Load Balancer Controller. Cette politique permet au LBC de gérer les ressources créées par le contrôleur d’entrée ALB pour Kubernetes.
1. Téléchargez la politique IAM. Cette politique permet au AWS Load Balancer Controller de gérer les ressources créées par le contrôleur ALB Ingress pour Kubernetes. Vous pouvez également [afficher la politique](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/main/docs/install/iam_policy_v1_to_v2_additional.json).
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy_v1_to_v2_additional.json
```
1. Si votre cluster se trouve dans les AWS régions AWS GovCloud (USA Est) ou AWS GovCloud (USA Ouest), remplacez-le par` arn:aws: `. `arn:aws-us-gov:`
```
sed -i.bak -e 's|arn:aws:|arn:aws-us-gov:|' iam_policy_v1_to_v2_additional.json
```
1. Créez la politique IAM et notez l'ARN renvoyé.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerAdditionalIAMPolicy \
--policy-document file://iam_policy_v1_to_v2_additional.json
```
1. Attachez la politique IAM au rôle IAM utilisé par le AWS Load Balancer Controller. Remplacez *your-role-name* par le nom du rôle, tel que`AmazonEKSLoadBalancerControllerRole`.
Si vous avez créé le rôle en utilisant`eksctl`, pour trouver le nom du rôle créé, ouvrez la [AWS CloudFormation console](https://console.aws.amazon.com/cloudformation) et sélectionnez la pile **eksctl- *my-cluster* - addon-iamserviceaccount-kube-system - aws-load-balancer-controller**. Sélectionnez l'onglet **Resources** (Ressources). Le nom du rôle se trouve dans la colonne **ID Physique**.
```
aws iam attach-role-policy \
--role-name your-role-name \
--policy-arn arn:aws: iam::111122223333:policy/AWSLoadBalancerControllerAdditionalIAMPolicy
```