**Contribuisci a migliorare questa pagina**
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
Per contribuire a questa guida per l'utente, scegli il GitHub link **Modifica questa pagina** nel riquadro destro di ogni pagina.
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Indirizza il traffico Internet con AWS Load Balancer Controller
**Suggerimento**
[Registrati](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) ai prossimi workshop Amazon EKS.
Il AWS Load Balancer Controller gestisce AWS Elastic Load Balancer per un cluster Kubernetes. Puoi usare il controller per esporre le app del cluster a Internet. Il controller fornisce sistemi di AWS bilanciamento del carico che puntano alle risorse Cluster Service o Ingress. In altri termini, il controller crea un unico indirizzo IP o nome DNS che punta a più pod del cluster.
![\[Diagramma architetturale. Illustrazione del traffico proveniente dagli utenti di Internet verso il bilanciatore del carico Amazon. Il bilanciatore del carico Amazon distribuisce il traffico ai pod del cluster.\]](http://docs.aws.amazon.com/it_it/eks/latest/userguide/images/lbc-overview.png)
Il controller monitora le risorse di Kubernetes Ingress o Service. In risposta, crea le risorse AWS Elastic Load Balancing appropriate. Puoi configurare il comportamento specifico dei bilanciatori del carico applicando annotazioni alle risorse Kubernetes. Ad esempio, è possibile collegare gruppi di AWS sicurezza ai sistemi di bilanciamento del carico utilizzando le annotazioni.
Il controller fornisce le risorse seguenti:
**Kubernetes `Ingress` **
L’LBC crea un [AWS Application Load Balancer (ALB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html) quando crei un `Ingress`. [Rivedi le annotazioni che puoi applicare a una risorsa Ingress.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/ingress/annotations/)
**Servizio Kubernetes di tipo `LoadBalancer`**
L’LBC crea un [AWS Network Load Balancer (NLB)](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/introduction.html) quando crei un servizio Kubernetes di tipo `LoadBalancer`. [Rivedi le annotazioni che puoi applicare a una risorsa Service.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/)
In passato, il Network Load Balancer (NLB) Kubernetes veniva utilizzato per le destinazioni *istanza*, ma per le destinazioni *IP* veniva utilizzato l’LBC. Con la versione AWS Load Balancer Controller `2.3.0` o successiva, puoi creare NLBs utilizzando entrambi i tipi di destinazione. Per ulteriori informazioni sui tipi di destinazioni dei NLB, consultare [Target type (Tipo di destinazione)](https://docs.aws.amazon.com/elasticloadbalancing/latest/network/load-balancer-target-groups.html#target-type) nella Guida per l'utente di Network Load Balancer.
Il controller è un [progetto open source](https://github.com/kubernetes-sigs/aws-load-balancer-controller) gestito su. GitHub
Prima di implementare il controller, è consigliabile esaminare i prerequisiti e le considerazioni in [Route application and HTTP traffic with Application Load Balancers](alb-ingress.md) e [Esecuzione del routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md). In questi argomenti, verrà distribuita un'app di esempio che include un sistema di AWS bilanciamento del carico.
**API Kubernetes `Gateway`**
Con la versione AWS Load Balancer Controller `2.14.0` o successiva, LBC crea un [Application Load AWS Balancer (ALB](https://docs.aws.amazon.com/elasticloadbalancing/latest/application/introduction.html)) quando crei un Kubernetes. `Gateway` Kubernetes Gateway standardizza più configurazioni rispetto a Ingress, che richiedeva annotazioni personalizzate per molte opzioni comuni. [Rivedi la configurazione che puoi applicare a una risorsa Gateway.](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/gateway/gateway/) Per ulteriori informazioni sull'`Gateway`API, consulta [Gateway API nella documentazione](https://kubernetes.io/docs/concepts/services-networking/gateway/) di Kubernetes.
## Installare il controller
È possibile utilizzare una delle seguenti procedure per installare il AWS Load Balancer Controller:
+ Se non conosci Amazon EKS, ti consigliamo di utilizzare Helm per l'installazione perché semplifica l'installazione del Load AWS Balancer Controller. Per ulteriori informazioni, consulta [Installa il AWS Load Balancer Controller con Helm](lbc-helm.md).
+ Per configurazioni avanzate, come cluster con accesso di rete limitato ai registri di container pubblici, utilizza i manifesti Kubernetes. Per ulteriori informazioni, consulta [Installa AWS Load Balancer Controller con manifesti](lbc-manifest.md).
## Migrazione dalle versioni obsolete del controller
+ Se sono installate versioni obsolete del Load AWS Balancer Controller, consulta. [Esegui la migrazione delle app da Controller di ingresso ALB obsoleto](lbc-remove.md)
+ Le versioni obsolete non possono essere aggiornate. Devono essere rimossi e deve essere installata una versione corrente del AWS Load Balancer Controller.
+ Le versioni obsolete includono:
+ AWS ALB Ingress Controller for Kubernetes («Ingress Controller»), un predecessore del Load Balancer Controller. AWS
+ Qualsiasi `0.1.x ` versione del AWS Load Balancer Controller
## Provider cloud legacy
Kubernetes include un provider cloud legacy per AWS. Il provider cloud legacy è in grado di effettuare il provisioning di sistemi di bilanciamento del AWS carico, in modo simile al Load Balancer Controller AWS . Il provider cloud legacy crea i Classic Load Balancer. Se non installi il AWS Load Balancer Controller, Kubernetes utilizzerà per impostazione predefinita il provider cloud legacy. È necessario installare il AWS Load Balancer Controller ed evitare di utilizzare il provider cloud legacy.
**Importante**
Nelle versioni 2.5 e successive, il AWS Load Balancer Controller diventa il controller predefinito per le risorse del servizio *Kubernetes e crea* un Network Load AWS Balancer (NLB) per ogni servizio. `type: LoadBalancer` Lo fa creando un webhook mutante per i servizi, che imposta il campo `spec.loadBalancerClass`a `service.k8s.aws/nlb` per nuovi servizi di`type: LoadBalancer`. È possibile disattivare questa funzione e tornare a utilizzare il [Cloud Provider obsoleto](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/guide/service/annotations/#legacy-cloud-provider) come controller predefinito, impostando il valore della tabella di comando `enableServiceMutatorWebhook` a `false`. Il cluster non eseguirà il provisioning dei nuovi Classic Load Balancer per i tuoi servizi a meno che non disattivi questa funzionalità. I sistemi Classic Load Balancer esistenti continueranno a funzionare.
# Installa il AWS Load Balancer Controller con Helm
**Suggerimento**
[Registrati](https://aws-experience.com/emea/smb/events/series/get-hands-on-with-amazon-eks?trk=4a9b4147-2490-4c63-bc9f-f8a84b122c8c&sc_channel=el) ai prossimi workshop Amazon EKS.
**Suggerimento**
Con la modalità automatica di Amazon EKS, non devi installare o aggiornare componenti aggiuntivi di rete. Auto Mode include funzionalità di pod networking e bilanciamento del carico.
Per ulteriori informazioni, consulta [Automate cluster infrastructure with EKS Auto Mode](automode.md).
Questo argomento descrive come installare il AWS Load Balancer Controller utilizzando Helm, un gestore di pacchetti per Kubernetes, e. `eksctl` Il controller viene installato con le opzioni predefinite. Per ulteriori informazioni sul controller, inclusi i dettagli sulla configurazione con annotazioni, vedere la documentazione del controller [Load AWS Balancer](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) su. GitHub
Nei passaggi seguenti, sostituisci i valori di esempio con i tuoi valori.
## Prerequisiti
Prima di iniziare questo tutorial, completa i seguenti passaggi:
+ Crea un cluster Amazon EKS. Per crearne uno, consulta [Nozioni di base su Amazon EKS](getting-started.md).
+ Installa [Helm](https://helm.sh/docs/helm/helm_install/) sul computer locale.
+ Assicurati che il plug-in CNI di Amazon VPC per Kubernetes, `kube-proxy` e i componenti aggiuntivi CoreDNS siano alle versioni minime elencate in [Service account tokens](service-accounts.md#boundserviceaccounttoken-validated-add-on-versions).
+ Scopri i concetti di AWS Elastic Load Balancing. Per ulteriori informazioni, consulta la [Guida per l’utente di Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
+ Scopri il [servizio](https://kubernetes.io/docs/concepts/services-networking/service/) Kubernetes e le risorse [in entrata](https://kubernetes.io/docs/concepts/services-networking/ingress/).
### Considerazioni
Prima di procedere con i passaggi per la configurazione descritti in questa pagina, considera quanto segue:
+ La policy e il ruolo IAM (`AmazonEKSLoadBalancerControllerRole`) possono essere riutilizzati su più cluster EKS nello stesso account. AWS
+ Se stai installando il controller sullo stesso cluster in cui il ruolo (`AmazonEKSLoadBalancerControllerRole`) è stato originariamente creato, vai a [Step 2: Install Load Balancer Controller](#lbc-helm-install) dopo aver verificato l’esistenza del ruolo.
+ Se utilizzato, IRSA (IAM Roles for Service Accounts) deve essere configurato per ogni cluster e l’ARN del provider OpenID Connect (OIDC) nella policy di attendibilità del ruolo è specifico per ogni cluster EKS. Inoltre, se stai installando il controller su un nuovo cluster con un`AmazonEKSLoadBalancerControllerRole` esistente, aggiorna la policy di attendibilità del ruolo per includere il provider OIDC del nuovo cluster e crea un nuovo account di servizio con l’annotazione di ruolo appropriata. Per determinare se disponi già di un provider OIDC o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md).
## Passaggio 1: crea un ruolo IAM utilizzando `eksctl`
I passaggi seguenti si riferiscono alla versione di rilascio del AWS Load Balancer Controller **v2.14.1**. Per ulteriori informazioni su tutte le versioni, consulta la [pagina di rilascio del AWS Load Balancer Controller](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/) su. GitHub
1. Scarica una policy IAM per il AWS Load Balancer Controller che gli consenta di effettuare chiamate per tuo AWS APIs conto.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.14.1/docs/install/iam_policy.json
```
+ Se utilizzi una AWS partizione non standard, ad esempio una regione governativa o cinese, [consulta le politiche GitHub](https://github.com/kubernetes-sigs/aws-load-balancer-controller/tree/main/docs/install) e scarica la politica appropriata per la tua regione.
1. Creare una policy IAM utilizzando le policy scaricate nel passaggio precedente.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerIAMPolicy \
--policy-document file://iam_policy.json
```
**Nota**
**Se visualizzi la politica in Console di gestione AWS, la console mostra gli avvisi per il servizio **ELB**, ma non per il servizio ELB v2.** Ciò accade perché alcune azioni nella policy esistono per **ELB v2**, ma non per **ELB**. Queste avvertenze per **ELB** possono essere ignorate.
1. Sostituisci i valori per il nome del cluster, il codice regionale e l’ID dell’account.
```
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
```
## Fase 2: Installare AWS Load Balancer Controller
1. Aggiungi l'archivio `eks-charts` cartografico Helm. AWS mantiene [questo repository attivo](https://github.com/aws/eks-charts). GitHub
```
helm repo add eks https://aws.github.io/eks-charts
```
1. Aggiornare il repository locale per assicurarsi di avere i grafici più recenti.
```
helm repo update eks
```
1. Installa il AWS Load Balancer Controller.
Se stai distribuendo il controller su EC2 nodi Amazon con [accesso limitato al servizio di metadati di Amazon EC2 Instance (IMDS)](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node) o se esegui la distribuzione su Fargate o Amazon EKS Hybrid Nodes, aggiungi i seguenti flag `helm` al comando che segue:
+ `--set region=region-code `
+ `--set vpcId=vpc-xxxxxxxx `
Sostituisci *my-cluster* con il nome del cluster. Nel comando seguente, `aws-load-balancer-controller` indica l’account del servizio Kubernetes creato in una fase precedente.
[Per ulteriori informazioni sulla configurazione del grafico helm, consulta values.yaml su.](https://github.com/aws/eks-charts/blob/master/stable/aws-load-balancer-controller/values.yaml) 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
```
**Importante**
Il grafico implementato non riceve automaticamente gli aggiornamenti di sicurezza. È necessario eseguire manualmente l’aggiornamento a un grafico più recente quando diventa disponibile. Durante l'aggiornamento, passate al comando precedente. *install* `upgrade`
Il `helm install` comando installa automaticamente le definizioni di risorse personalizzate (CRDs) per il controller. Il comando `helm upgrade` non lo fa. Se si utilizza, `helm upgrade,` è necessario installare manualmente il CRDs. Esegui il comando seguente per installare CRDs:
```
wget https://raw.githubusercontent.com/aws/eks-charts/master/stable/aws-load-balancer-controller/crds/crds.yaml
kubectl apply -f crds.yaml
```
## Passaggio 3: verifica che il controller sia installato
1. Verificare che il controller sia installato.
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
Di seguito viene riportato un output di esempio:
```
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 84s
```
Riceverai l’output precedente se hai eseguito l’implementazione con Helm. Se hai eseguito l’implementazione utilizzando il manifesto Kubernetes, hai una sola replica.
1. Prima di utilizzare il controller per il provisioning AWS delle risorse, il cluster deve soddisfare requisiti specifici. Per ulteriori informazioni, consultare [Instradare il traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md) e [Esecuzione del routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md).
# Installa AWS Load Balancer Controller con manifesti
**Suggerimento**
Con la modalità automatica di Amazon EKS, non è necessario installare o aggiornare componenti aggiuntivi di rete. Auto Mode include funzionalità di pod networking e bilanciamento del carico.
Per ulteriori informazioni, consulta [Automate cluster infrastructure with EKS Auto Mode](automode.md).
Questo argomento descrive come installare il controller scaricando e applicando i manifesti di Kubernetes. É possibile visualizzare l'intera [documentazione](https://kubernetes-sigs.github.io/aws-load-balancer-controller/latest/) per il controller su GitHub.
Nei passaggi seguenti, sostituisci i valori di esempio con i tuoi valori.
## Prerequisiti
Prima di iniziare questo tutorial, completa i seguenti passaggi:
+ Crea un cluster Amazon EKS. Per crearne uno, consulta [Nozioni di base su Amazon EKS](getting-started.md).
+ Installa [Helm](https://helm.sh/docs/helm/helm_install/) sul computer locale.
+ Assicurati che il plug-in CNI di Amazon VPC per Kubernetes, `kube-proxy` e i componenti aggiuntivi CoreDNS siano alle versioni minime elencate in [Service account tokens](service-accounts.md#boundserviceaccounttoken-validated-add-on-versions).
+ Scopri i concetti di AWS Elastic Load Balancing. Per ulteriori informazioni, consulta la [Guida per l’utente di Elastic Load Balancing](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/).
+ Scopri il [servizio](https://kubernetes.io/docs/concepts/services-networking/service/) Kubernetes e le risorse [in entrata](https://kubernetes.io/docs/concepts/services-networking/ingress/).
### Considerazioni
Prima di procedere con i passaggi per la configurazione descritti in questa pagina, considera quanto segue:
+ La policy e il ruolo IAM (`AmazonEKSLoadBalancerControllerRole`) possono essere riutilizzati su più cluster EKS nello stesso account. AWS
+ Se stai installando il controller sullo stesso cluster in cui il ruolo (`AmazonEKSLoadBalancerControllerRole`) è stato originariamente creato, vai a [Step 2: Install cert-manager](#lbc-cert) dopo aver verificato l’esistenza del ruolo.
+ Se utilizzato, IRSA (IAM Roles for Service Accounts) deve essere configurato per ogni cluster e l’ARN del provider OpenID Connect (OIDC) nella policy di attendibilità del ruolo è specifico per ogni cluster EKS. Inoltre, se stai installando il controller su un nuovo cluster con un`AmazonEKSLoadBalancerControllerRole` esistente, aggiorna la policy di attendibilità del ruolo per includere il provider OIDC del nuovo cluster e crea un nuovo account di servizio con l’annotazione di ruolo appropriata. Per determinare se disponi già di un provider OIDC o per crearne uno, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md).
## Passaggio 1: configura IAM
I passaggi seguenti si riferiscono alla versione di rilascio del AWS Load Balancer Controller **v2.14.1**. Per ulteriori informazioni su tutte le versioni, consulta la [pagina di rilascio del AWS Load Balancer Controller](https://github.com/kubernetes-sigs/aws-load-balancer-controller/releases/) su. GitHub
1. Scarica una policy IAM per il AWS Load Balancer Controller che gli consenta di effettuare chiamate per tuo AWS APIs conto.
**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. Creare una policy IAM utilizzando le policy scaricate nel passaggio precedente.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerIAMPolicy \
--policy-document file://iam_policy.json
```
**Nota**
Se visualizzi la policy in Console di gestione AWS, la console mostra gli avvisi per il servizio **ELB**, ma non per il servizio **ELB** v2. Ciò accade perché alcune azioni nella policy esistono per **ELB v2**, ma non per **ELB**. Queste avvertenze per **ELB** possono essere ignorate.
**Example**
1. Sostituisci *my-cluster* con il nome del cluster e *111122223333* con il tuo ID account, quindi esegui il 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. Recupera l’ID del provider OIDC del cluster e memorizzalo in una variabile.
```
oidc_id=$(aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text | cut -d '/' -f 5)
```
1. Determina se un provider OIDC IAM con l’ID del cluster è già presente nell’account. È necessario configurare OIDC sia per il cluster che per IAM.
```
aws iam list-open-id-connect-providers | grep $oidc_id | cut -d "/" -f4
```
Se viene restituito un output, devi creare un provider OIDC IAM per il tuo cluster. Se non viene restituito alcun output, devi creare un provider OIDC IAM per il cluster. Per ulteriori informazioni, consulta [Per creare un provider di identità IAM OIDC per il cluster](enable-iam-roles-for-service-accounts.md).
1. Copia i seguenti contenuti sul dispositivo. Sostituisci *111122223333* con l'ID del tuo account. *region-code*Sostituiscilo con la AWS regione in cui si trova il cluster. Sostituisci *EXAMPLED539D4633E53DE1B71EXAMPLE* con l'output restituito nella fase precedente.
```
{
"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. Creare il ruolo IAM.
```
aws iam create-role \
--role-name AmazonEKSLoadBalancerControllerRole \
--assume-role-policy-document file://"load-balancer-role-trust-policy.json"
```
1. Allegare la policy IAM gestita da Amazon EKS richiesta al ruolo IAM. Sostituisci *111122223333* con l'ID del tuo account.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::111122223333:policy/AWSLoadBalancerControllerIAMPolicy \
--role-name AmazonEKSLoadBalancerControllerRole
```
1. Copia i seguenti contenuti sul dispositivo. Sostituisci *111122223333* con l'ID del tuo account. Dopo aver sostituito il testo, esegui il comando modificato per creare il file `aws-load-balancer-controller-service-account.yaml`.
```
cat >aws-load-balancer-controller-service-account.yaml <
Installa `cert-manager` utilizzando uno dei metodi seguenti per inserire la configurazione del certificato nei Webhook. Per ulteriori informazioni, consulta [Getting Started](https://cert-manager.io/docs/installation/#getting-started) nella *documentazione cert-manager*.
Si consiglia di utilizzare il registro dei container `quay.io` per installare `cert-manager`. Se i tuoi nodi non hanno accesso al registro dei container `quay.io`, installa `cert-manager` utilizzando Amazon ECR (vedi sotto).
**Example**
1. Se i tuoi nodi hanno accesso al registro del container `quay.io`, installa `cert-manager` per inserire la configurazione del certificato nei Webhook.
```
kubectl apply \
--validate=false \
-f https://github.com/jetstack/cert-manager/releases/download/v1.13.5/cert-manager.yaml
```
1. Installa `cert-manager` utilizzando uno dei metodi seguenti per inserire la configurazione del certificato nei Webhook. Per ulteriori informazioni, consulta [Getting Started](https://cert-manager.io/docs/installation/#getting-started) nella *documentazione cert-manager*.
1. Eseguire il download del manifesto.
```
curl -Lo cert-manager.yaml https://github.com/jetstack/cert-manager/releases/download/v1.13.5/cert-manager.yaml
```
1. Estrai le seguenti immagini e inviale a un repository a cui i tuoi nodi hanno accesso. Per ulteriori informazioni su come estrarre, taggare e inviare immagini al tuo repository, consulta la sezione [Copia di un'immagine di container da un repository a un altro](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. Nel manifesto, sostituisci `quay.io` per le tre immagini con il nome del tuo registro. Il comando seguente presuppone che il nome del repository privato sia lo stesso del repository di origine. Sostituisci *111122223333.dkr.ecr.region-code.amazonaws.com* con il tuo registro privato.
```
sed -i.bak -e 's|quay.io|111122223333.dkr.ecr.region-code.amazonaws.com|' ./cert-manager.yaml
```
1. Applicare il file manifesto.
```
kubectl apply \
--validate=false \
-f ./cert-manager.yaml
```
## Fase 3: Installare AWS Load Balancer Controller
1. Scaricare le specifiche del controller. Per ulteriori informazioni sull'utilizzo del controller, consulta la [documentazione](https://kubernetes-sigs.github.io/aws-load-balancer-controller/) su 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. Apporta le seguenti modifiche al file.
1. Se hai scaricato il file `v2_14_1_full.yaml`, emetti il seguente comando per rimuovere la sezione `ServiceAccount` nel manifesto. Se non rimuovi questa sezione, l’annotazione richiesta apportata all’account del servizio in un passaggio precedente viene sovrascritta. Inoltre, se elimini il controller, conserva l’account del servizio creato in una fase precedente.
```
sed -i.bak -e '764,772d' ./v2_14_1_full.yaml
```
Se hai scaricato una versione diversa del file, apri il file in un editor e rimuovi le righe seguenti.
```
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. Sostituisci `your-cluster-name` nella sezione `Deployment` `spec` del file con il nome del cluster sostituendo *my-cluster* con il nome del tuo cluster.
```
sed -i.bak -e 's|your-cluster-name|my-cluster|' ./v2_14_1_full.yaml
```
1. Se i tuoi nodi non hanno accesso ai repository di immagini Amazon EKS Amazon ECR, devi estrarre la seguente immagine e inviarla a un repository a cui i tuoi nodi hanno accesso. Per ulteriori informazioni su come estrarre, taggare e inviare un’immagine al tuo repository, consulta la sezione [Copia di un'immagine di container da un repository a un altro](copy-image-to-repository.md).
```
public.ecr.aws/eks/aws-load-balancer-controller:v2.14.1
```
Aggiungi il nome del tuo registro al manifesto. Il comando seguente presuppone che il nome del repository privato sia lo stesso del repository di origine e aggiunge il nome del tuo registro privato al file. Sostituisci *111122223333.dkr.ecr.region-code.amazonaws.com* con il tuo registro. Questa riga presuppone che il nome del repository privato sia lo stesso del repository di origine. In caso contrario, sostituisci il testo `eks/aws-load-balancer-controller` dopo il nome del registro privato con il nome del tuo repository.
```
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. (Richiesto solo per Fargate o IMDS con restrizioni)
Se stai distribuendo il controller su EC2 nodi Amazon con [accesso limitato al servizio di metadati di Amazon EC2 Instance (IMDS)](https://aws.github.io/aws-eks-best-practices/security/docs/iam/#restrict-access-to-the-instance-profile-assigned-to-the-worker-node) o se lo stai distribuendo su Fargate o su nodi ibridi Amazon EKS, aggiungi il seguente. `following parameters` `- args:`
```
[...]
spec:
containers:
- args:
- --cluster-name=your-cluster-name
- --ingress-class=alb
- --aws-vpc-id=vpc-xxxxxxxx
- --aws-region=region-code
[...]
```
1. Applicare il file.
```
kubectl apply -f v2_14_1_full.yaml
```
1. Scarica il manifesto di `IngressClass` e `IngressClassParams` sul 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. Applica il file manifesto al cluster.
```
kubectl apply -f v2_14_1_ingclass.yaml
```
## Passaggio 4: verifica che il controller sia installato
1. Verificare che il controller sia installato.
```
kubectl get deployment -n kube-system aws-load-balancer-controller
```
Di seguito viene riportato un output di esempio:
```
NAME READY UP-TO-DATE AVAILABLE AGE
aws-load-balancer-controller 2/2 2 2 84s
```
Riceverai l’output precedente se hai eseguito l’implementazione con Helm. Se hai eseguito l’implementazione utilizzando il manifesto Kubernetes, hai una sola replica.
1. Prima di utilizzare il controller per il provisioning AWS delle risorse, il cluster deve soddisfare requisiti specifici. Per ulteriori informazioni, consultare [Instradare il traffico di applicazioni e HTTP con Application Load Balancer](alb-ingress.md) e [Esecuzione del routing del traffico TCP e UDP con Network Load Balancer](network-load-balancing.md).
# Esegui la migrazione delle app da Controller di ingresso ALB obsoleto
Questo argomento descrive come migrare da versioni obsolete del Controller. Più specificamente, descrive come rimuovere le versioni obsolete del Load Balancer AWS Controller.
+ Le versioni obsolete non possono essere aggiornate. Devi prima rimuoverle e quindi installare una versione attuale.
+ Le versioni obsolete includono:
+ AWS ALB Ingress Controller for Kubernetes («Ingress Controller»), un predecessore del Load Balancer Controller. AWS
+ Qualsiasi `0.1.x ` versione del AWS Load Balancer Controller
## Rimuovi la versione obsoleta del controller
**Nota**
Potresti aver installato la versione obsoleta utilizzando Helm o manualmente con i manifesti di Kubernetes. Completare la procedura utilizzando lo strumento con cui è stata installata in origine.
1. Se il grafico Helm `incubator/aws-alb-ingress-controller` è installato, procedi alla disinstallazione.
```
helm delete aws-alb-ingress-controller -n kube-system
```
1. Se la versione `0.1.x ` del grafico `eks-charts/aws-load-balancer-controller` è installata, procedi alla disinstallazione. L’aggiornamento dalla versione `0.1.x ` alla versione `1.0.0` non ha esito positivo a causa di incompatibilità con la versione dell’API webhook.
```
helm delete aws-load-balancer-controller -n kube-system
```
1. Verificare che il controller sia già installato.
```
kubectl get deployment -n kube-system alb-ingress-controller
```
Questo è l’output restituito se il controller non è installato.
```
Error from server (NotFound): deployments.apps "alb-ingress-controller" not found
```
Questo è l’output restituito se il controller è installato.
```
NAME READY UP-TO-DATE AVAILABLE AGE
alb-ingress-controller 1/1 1 1 122d
```
1. Immettere i seguenti comandi per rimuovere il controller.
```
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
```
## Migrazione a AWS Load Balancer Controller
Per migrare dall'ALB Ingress Controller for Kubernetes al Load AWS Balancer Controller, devi:
1. Rimuovere il Controller di ingresso ALB (vedi sopra).
1. [Installa il AWS Load Balancer Controller.](aws-load-balancer-controller.md#lbc-overview)
1. Aggiungi una policy aggiuntiva al ruolo IAM utilizzato dal AWS Load Balancer Controller. Questa policy consente a LBC la gestione delle risorse create dal Controller di ingresso ALB per Kubernetes.
1. Scaricare la policy IAM. Questa policy consente al AWS Load Balancer Controller di gestire le risorse create dall'ALB Ingress Controller per Kubernetes. É anche possibile [consultare la policy](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. Se il cluster si trova nelle regioni AWS GovCloud (Stati Uniti orientali) o AWS GovCloud (Stati Uniti occidentali), sostituiscilo con. AWS ` 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. Creare la policy IAM e annotate l’ARN restituito.
```
aws iam create-policy \
--policy-name AWSLoadBalancerControllerAdditionalIAMPolicy \
--policy-document file://iam_policy_v1_to_v2_additional.json
```
1. Collega la policy IAM al ruolo IAM utilizzato dal AWS Load Balancer Controller. Sostituiscila *your-role-name* con il nome del ruolo, ad esempio`AmazonEKSLoadBalancerControllerRole`.
Se hai creato il ruolo utilizzando`eksctl`, allora per trovare il nome del ruolo che è stato creato, apri la [AWS CloudFormation console](https://console.aws.amazon.com/cloudformation) e seleziona lo stack **eksctl- *my-cluster* - addon-iamserviceaccount-kube-system - aws-load-balancer-controller**. Selezionare la scheda **Risorse**. Il nome del ruolo è nella colonna **ID fisico**.
```
aws iam attach-role-policy \
--role-name your-role-name \
--policy-arn arn:aws: iam::111122223333:policy/AWSLoadBalancerControllerAdditionalIAMPolicy
```