**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à.
# Implementa un carico di lavoro del bilanciatore del carico esemplificativo in EKS Auto Mode
Questa guida mostra come implementare una versione containerizzata del gioco 2048 su Amazon EKS, completa di bilanciamento del carico e accessibilità a Internet.
## Prerequisiti
+ Un cluster EKS Auto Mode
+ `kubectl` configurato per interagire con il cluster
+ Autorizzazioni IAM appropriate per la creazione di risorse ALB
## Fase 1: Creazione del namespace
Innanzitutto, crea un namespace dedicato per l’applicazione di gioco 2048.
Creare un file denominato `01-namespace.yaml`:
```
apiVersion: v1
kind: Namespace
metadata:
name: game-2048
```
Applica la configurazione del namespace:
```
kubectl apply -f 01-namespace.yaml
```
## Fase 2: Implementazione dell’applicazione
L’applicazione esegue più repliche del container del gioco 2048.
Creare un file denominato `02-deployment.yaml`:
```
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: game-2048
name: deployment-2048
spec:
selector:
matchLabels:
app.kubernetes.io/name: app-2048
replicas: 5
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
resources:
requests:
cpu: "0.5"
```
**Nota**
Se ricevi un errore durante il caricamento dell’immagine `public.ecr.aws/l6m2t8p7/docker-2048:latest`, conferma che il ruolo IAM del nodo dispone delle autorizzazioni sufficienti per estrarre immagini da ECR. Per ulteriori informazioni, consulta [Ruolo IAM del nodo](auto-learn-iam.md#auto-learn-node-iam-role). Inoltre, l’immagine `docker-2048` nell’esempio è un’immagine `x86_64` e non sarà eseguita su altre architetture.
**Componenti chiave:**
+ Implementa 5 repliche dell’applicazione
+ Utilizza un’immagine ECR pubblica
+ Richiede 0,5 core CPU per pod
+ Espone la porta 80 per il traffico HTTP
Applica l’implementazione:
```
kubectl apply -f 02-deployment.yaml
```
## Fase 3: Creazione del servizio
Il servizio espone l’implementazione alla rete di cluster.
Creare un file denominato `03-service.yaml`:
```
apiVersion: v1
kind: Service
metadata:
namespace: game-2048
name: service-2048
spec:
ports:
- port: 80
targetPort: 80
protocol: TCP
selector:
app.kubernetes.io/name: app-2048
```
**Componenti chiave:**
+ Crea un servizio NodePort
+ Mappa la porta 80 alla porta 80 del container
+ Utilizza il selettore di etichette per trovare i pod
Applica il servizio:
```
kubectl apply -f 03-service.yaml
```
## Fase 4: Configurazione del bilanciamento del carico
Configurerai un ingresso per esporre l’applicazione a Internet.
Innanzitutto, crea la `IngressClass`. Creare un file denominato `04-ingressclass.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
labels:
app.kubernetes.io/name: LoadBalancerController
name: alb
spec:
controller: eks.amazonaws.com/alb
```
**Nota**
EKS Auto Mode 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).
Poi, crea la risorsa Ingress. Creare un file denominato `05-ingress.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
namespace: game-2048
name: ingress-2048
annotations:
alb.ingress.kubernetes.io/scheme: internet-facing
alb.ingress.kubernetes.io/target-type: ip
spec:
ingressClassName: alb
rules:
- http:
paths:
- path: /
pathType: Prefix
backend:
service:
name: service-2048
port:
number: 80
```
**Componenti chiave:**
+ Crea un ALB connesso a Internet
+ Utilizza il tipo di destinazione IP per l’instradamento diretto al pod
+ Instrada tutto il traffico (/) al servizio di gioco
Applica le configurazioni di ingresso:
```
kubectl apply -f 04-ingressclass.yaml
kubectl apply -f 05-ingress.yaml
```
## Fase 5: Verifica dell’implementazione
1. Controlla che tutti i pod siano in esecuzione:
```
kubectl get pods -n game-2048
```
1. Verifica che il servizio sia stato creato:
```
kubectl get svc -n game-2048
```
1. Ottieni l’endpoint di ALB:
```
kubectl get ingress -n game-2048
```
Il campo ADDRESS nell’output di ingresso mostrerà l’endpoint di ALB. Attendi 2-3 minuti affinché l’ALB effettui il provisioning e registri tutti gli obiettivi.
## Fase 6: Accesso al gioco
Apri il browser web e accedi all’URL dell’endpoint di ALB della fase precedente. Dovresti vedere l’interfaccia di gioco 2048.
## Fase 7: Eliminazione
Per rimuovere tutte le risorse create in questo tutorial:
```
kubectl delete namespace game-2048
```
Questo eliminerà tutte le risorse nel namespace, incluse le risorse di implementazione, di servizio e di ingresso.
## Cosa succede dietro le quinte
1. L’implementazione crea 5 pod che eseguono il gioco 2048
1. Il servizio fornisce un accesso stabile alla rete a questi pod
1. EKS Auto Mode:
+ Crea un Application Load Balancer in AWS
+ Configura i gruppi di destinazione per i pod
+ Imposta le regole di instradamento per indirizzare il traffico al servizio
## Risoluzione dei problemi
Se il gioco non si carica:
+ Assicurati che tutti i pod siano in esecuzione: `kubectl get pods -n game-2048`
+ Verifica lo stato di ingresso: `kubectl describe ingress -n game-2048`
+ Verifica i controlli dell’integrità di ALB: Verificare lo stato del gruppo di destinazione nella Console AWS