

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

# Creare e IngressClass configurare un Application Load Balancer
<a name="auto-configure-alb"></a>

La modalità automatica di EKS automatizza le attività di routine per il bilanciamento del carico, inclusa l’esposizione delle app del cluster a Internet.

 AWS suggerisce di utilizzare Application Load Balancers (ALB) per servire il traffico HTTP e HTTPS. Gli Application Load Balancer possono instradare le richieste in base al contenuto della richiesta. Per ulteriori informazioni sugli Application Load Balancer, consulta [What is Elastic Load Balancing?](https://docs.aws.amazon.com/elasticloadbalancing/latest/userguide/what-is-load-balancing.html) 

La modalità automatica di EKS crea e configura Application Load Balancer (ALB). Ad esempio, modalità automatica di EKS crea un bilanciatore del carico quando crei un oggetto Kubernetes `Ingress` e lo configura per indirizzare il traffico verso il carico di lavoro del cluster.

 **Panoramica** 

1. Crea un carico di lavoro da esporre a Internet.

1. Crea una `IngressClassParams` risorsa, specificando valori di configurazione AWS specifici come il certificato da utilizzare per le SSL/TLS sottoreti VPC.

1. Creare una risorsa `IngressClass`, specificando che modalità automatica di EKS sarà il controller della risorsa.

1. Crea una risorsa `Ingress` da associare a un percorso e una porta HTTP a un carico di lavoro del cluster.

La modalità automatica di EKS creerà un Application Load Balancer che punta al carico di lavoro specificato nella risorsa `Ingress`, utilizzando la configurazione del bilanciatore del carico specificata nella risorsa `IngressClassParams`.

## Prerequisiti
<a name="_prerequisites"></a>
+ La modalità automatica di EKS su un cluster Amazon EKS
+ Kubectl configurato per connettersi al cluster
  + Puoi usare `kubectl apply -f <filename>` per applicare i file di configurazione di esempio YAML riportati di seguito al cluster.

**Nota**  
La modalità automatica di EKS richiede i tag di sottorete per identificare le sottoreti pubbliche e private.  
Se hai creato il cluster con `eksctl`, disponi già di questi tag.  
Informazioni su come [Assegnazione di tag alle sottoreti per la modalità automatica EKS](tag-subnets-auto.md).

## Fase 1: Creare un carico di lavoro
<a name="_step_1_create_a_workload"></a>

Per iniziare, crea un carico di lavoro da esporre a Internet. Può trattarsi di qualsiasi risorsa di Kubernetes che serve il traffico HTTP, ad esempio un’implementazione o un servizio.

Questo esempio utilizza un semplice servizio HTTP chiamato `service-2048` che ascolta sulla porta `80`. Creare questo servizio e la sua implementazione applicando il seguente manifesto, `2048-deployment-service.yaml`:

```
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: deployment-2048
spec:
  selector:
    matchLabels:
      app.kubernetes.io/name: app-2048
  replicas: 2
  template:
    metadata:
      labels:
        app.kubernetes.io/name: app-2048
    spec:
      containers:
        - image: public.ecr.aws/l6m2t8p7/docker-2048:latest
          imagePullPolicy: Always
          name: app-2048
          ports:
            - containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
  name: service-2048
spec:
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  type: NodePort
  selector:
    app.kubernetes.io/name: app-2048
```

Applica la configurazione al cluster:

```
kubectl apply -f 2048-deployment-service.yaml
```

Le risorse sopra elencate verranno create nel namespace predefinito. Puoi verificarlo eseguendo il comando seguente:

```
kubectl get all -n default
```

## Fase 2: Creare IngressClassParams
<a name="_step_2_create_ingressclassparams"></a>

Crea un `IngressClassParams` oggetto per specificare opzioni di configurazione AWS specifiche per l'Application Load Balancer. In questo esempio, creiamo una risorsa `IngressClassParams` denominata `alb` (che verrà utilizzata nella fase successiva) che specifica lo schema del bilanciatore del carico come `internet-facing` in un file chiamato `alb-ingressclassparams.yaml`.

```
apiVersion: eks.amazonaws.com/v1
kind: IngressClassParams
metadata:
  name: alb
spec:
  scheme: internet-facing
```

Applica la configurazione al cluster:

```
kubectl apply -f alb-ingressclassparams.yaml
```

## Fase 3: Creare IngressClass
<a name="_step_3_create_ingressclass"></a>

Crea un file `IngressClass` che faccia riferimento ai valori di configurazione AWS specifici impostati nella `IngressClassParams` risorsa in un file denominato`alb-ingressclass.yaml`. Annotare il nome della `IngressClass`. In questo esempio, sia `IngressClass` che `IngressClassParams` sono denominati `alb`.

Utilizzare l’annotazione `is-default-class` per controllare se le risorse `Ingress` devono utilizzare questa classe per impostazione predefinita.

```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
  name: alb
  annotations:
    # Use this annotation to set an IngressClass as Default
    # If an Ingress doesn't specify a class, it will use the Default
    ingressclass.kubernetes.io/is-default-class: "true"
spec:
  # Configures the IngressClass to use EKS Auto Mode
  controller: eks.amazonaws.com/alb
  parameters:
    apiGroup: eks.amazonaws.com
    kind: IngressClassParams
    # Use the name of the IngressClassParams set in the previous step
    name: alb
```

Per ulteriori informazioni sulle opzioni di configurazione, consultare [IngressClassParams Riferimento](#ingress-reference).

Applica la configurazione al cluster:

```
kubectl apply -f alb-ingressclass.yaml
```

## Fase 4: Creare Ingress
<a name="_step_4_create_ingress"></a>

Creare una risorsa `Ingress` in un file denominato `alb-ingress.yaml`. Lo scopo di questa risorsa è associare percorsi e porte sull’Application Load Balancer ai carichi di lavoro del cluster. Per questo esempio, creiamo una risorsa `Ingress` denominata `2048-ingress` che instrada il traffico verso un servizio denominato `service-2048` sulla porta 80.

Per ulteriori informazioni sulla configurazione di questa risorsa, consultare [Ingress](https://kubernetes.io/docs/concepts/services-networking/ingress/) nella documentazione su Kubernetes.

```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: 2048-ingress
spec:
  # this matches the name of IngressClass.
  # this can be omitted if you have a default ingressClass in cluster: the one with ingressclass.kubernetes.io/is-default-class: "true"  annotation
  ingressClassName: alb
  rules:
    - http:
        paths:
          - path: /*
            pathType: ImplementationSpecific
            backend:
              service:
                name: service-2048
                port:
                  number: 80
```

Applica la configurazione al cluster:

```
kubectl apply -f alb-ingress.yaml
```

## Fase 5: Controllare lo stato
<a name="_step_5_check_status"></a>

Utilizza `kubectl` per trovare lo stato di `Ingress`. Prima che il bilanciatore del carico sia disponibile, potrebbero essere necessari alcuni minuti.

Utilizza il nome della risorsa `Ingress` impostata nella fase precedente. Esempio:

```
kubectl get ingress 2048-ingress
```

Una volta che la risorsa è pronta, recuperare il nome di dominio del bilanciatore del carico.

```
kubectl get ingress 2048-ingress -o jsonpath='{.status.loadBalancer.ingress[0].hostname}'
```

Per visualizzare il servizio in un browser Web, esaminate la porta e il percorso specificati nella `Ingress` risorsa.

## Fase 6: Eliminazione
<a name="_step_6_cleanup"></a>

Per eliminare il bilanciatore del carico, utilizza il seguente comando:

```
kubectl delete ingress 2048-ingress
kubectl delete ingressclass alb
kubectl delete ingressclassparams alb
```

EKS Auto Mode eliminerà automaticamente il sistema di bilanciamento del carico associato nel tuo AWS account.

## IngressClassParams Riferimento
<a name="ingress-reference"></a>

La tabella seguente è un riferimento rapido per le opzioni di configurazione più comunemente utilizzate.


| Campo | Description | Valore di esempio | 
| --- | --- | --- | 
|  `scheme`  | Definisce se l’ALB è interno o esposto a Internet |  `internet-facing`  | 
|  `namespaceSelector`  | Limita quali namespace possono utilizzarlo IngressClass |  `environment: prod`  | 
|  `group.name`  | Raggruppa più ingressi per condividere un singolo ALB |  `retail-apps`  | 
|  `ipAddressType`  | Imposta il tipo di indirizzo IP per ALB |  `dualstack`  | 
|  `subnets.ids`  | Elenco di ID di sottorete per l’implementazione di ALB |  `subnet-xxxx, subnet-yyyy`  | 
|  `subnets.tags`  | Filtri di tag per selezionare le sottoreti per ALB |  `Environment: prod`  | 
|  `certificateARNs`  | ARN di certificati SSL da utilizzare |  ` arn:aws: acm:region:account:certificate/id`  | 
|  `tags`  | Tag personalizzati per le risorse AWS  |  `Environment: prod, Team: platform`  | 
|  `loadBalancerAttributes`  | Attributi specifici del bilanciatore del carico |  `idle_timeout.timeout_seconds: 60`  | 

## Considerazioni
<a name="_considerations"></a>
+ Non è possibile utilizzare Annotations su un PC IngressClass per configurare i sistemi di bilanciamento del carico con EKS Auto Mode. IngressClass la configurazione deve essere eseguita tramite. IngressClassParams Tuttavia, è possibile utilizzare le annotazioni sulle singole risorse Ingress per configurare il comportamento del load balancer (ad `alb.ingress.kubernetes.io/security-group-prefix-lists` esempio o). `alb.ingress.kubernetes.io/conditions.*`
+ Non è possibile impostare [ListenerAttribute](https://docs.aws.amazon.com/elasticloadbalancing/latest/APIReference/API_ListenerAttribute.html)con EKS Auto Mode.
+ È necessario aggiornare il ruolo Cluster IAM per abilitare la propagazione dei tag dalle risorse Kubernetes alle risorse Load AWS Balancer. Per ulteriori informazioni, consulta [AWS Tag personalizzati per le risorse EKS Auto](auto-cluster-iam-role.md#tag-prop).
+ Per informazioni sull'associazione di risorse a EKS Auto Mode o al Load AWS Balancer Controller autogestito, vedere. [Materiale di riferimento per le migrazioni](migrate-auto.md#migration-reference)
+ Per informazioni sulla risoluzione dei problemi con i bilanciatori del carico, consulta [Risoluzione dei problemi della modalità automatica di EKS](auto-troubleshoot.md).
+ Per ulteriori considerazioni sull’utilizzo della funzionalità di bilanciamento del carico della modalità automatica di EKS, consulta [Sistema di bilanciamento del carico](auto-networking.md#auto-lb-consider).

Le tabelle seguenti forniscono un confronto dettagliato delle modifiche IngressClassParams, delle annotazioni di Ingress e delle TargetGroupBinding configurazioni per EKS Auto Mode. Queste tabelle evidenziano le principali differenze tra la capacità di bilanciamento del carico della modalità automatica di EKS e il controller del bilanciatore del carico open source, comprese le modifiche alla versione dell’API, le funzionalità obsolete e i nomi dei parametri aggiornati.

### IngressClassParams
<a name="_ingressclassparams"></a>


| Precedente | Novità | Description | 
| --- | --- | --- | 
|  `elbv2.k8s.aws/v1beta1`  |  `eks.amazonaws.com/v1`  | Modifica alla versione dell’API | 
|  `spec.certificateArn`  |  `spec.certificateARNs`  | Supporto per più ARN dei certificati | 
|  `spec.subnets.tags`  |  `spec.subnets.matchTags`  | Schema di corrispondenza delle sottoreti modificato | 
|  `spec.listeners.listenerAttributes`  | Non supportata | Non ancora supportato dalla modalità automatica di EKS | 

### Annotazioni di ingresso
<a name="_ingress_annotations"></a>


| Precedente | Novità | Description | 
| --- | --- | --- | 
|  `kubernetes.io/ingress.class`  | Non supportata | Utilizzare `spec.ingressClassName` su oggetti di ingresso | 
|  `alb.ingress.kubernetes.io/group.name`  | Non supportata | Specificate i gruppi solo in IngressClass  | 
|  `alb.ingress.kubernetes.io/waf-acl-id`  | Non supportata | Usare invece WAF v2 | 
|  `alb.ingress.kubernetes.io/web-acl-id`  | Non supportata | Usare invece WAF v2 | 
|  `alb.ingress.kubernetes.io/shield-advanced-protection`  | Non supportata | Integrazione Shield disattivata | 
|  `alb.ingress.kubernetes.io/auth-type: oidc`  | Non supportata | Il tipo di autenticazione OIDC non è attualmente supportato | 

### TargetGroupBinding
<a name="_targetgroupbinding"></a>


| Precedente | Novità | Description | 
| --- | --- | --- | 
|  `elbv2.k8s.aws/v1beta1`  |  `eks.amazonaws.com/v1`  | Modifica alla versione dell’API | 
|  `spec.targetType` facoltativo |  `spec.targetType` obbligatorio | Specifica esplicita del tipo di destinazione | 
|  `spec.networking.ingress.from`  | Non supportata | Non supporta più NLB senza gruppi di sicurezza | 

Per utilizzare la TargetGroupBinding funzionalità personalizzata, devi etichettare il gruppo target con il tag eks:eks-cluster-name con il nome del cluster per concedere al controller le autorizzazioni IAM necessarie. Tieni presente che il controller eliminerà il gruppo target quando la risorsa o il cluster vengono eliminati TargetGroupBinding .