

 **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à.

# Installa AWS Load Balancer Controller con manifesti
<a name="lbc-manifest"></a>

**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
<a name="lbc-manifest-prereqs"></a>

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
<a name="lbc-manifest-considerations"></a>

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
<a name="lbc-iam"></a>

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 <<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. Creare l’account del servizio Kubernetes nel cluster. L'account del servizio Kubernetes denominato `aws-load-balancer-controller` è annotato con il ruolo IAM che hai creato denominato. *AmazonEKSLoadBalancerControllerRole*

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

## Passaggio 2: installa `cert-manager`
<a name="lbc-cert"></a>

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
<a name="lbc-install"></a>

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
<a name="lbc-verify"></a>

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).