**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à.
# Avvio rapido: implementazione di un’app Web e archiviazione dei dati
[Questo tutorial di avvio rapido ti guida attraverso i passaggi per distribuire l'applicazione di esempio di gioco 2048 e mantenere i suoi dati su un cluster Amazon EKS Auto Mode utilizzando eksctl.](https://eksctl.io/)
[La modalità automatica di Amazon EKS](automode.md) semplifica la gestione dei cluster automatizzando attività di routine come lo storage a blocchi, il networking, il bilanciamento del carico e la scalabilità automatica del calcolo. Durante la configurazione, gestisce la creazione di nodi con istanze EC2 gestite, sistemi di bilanciamento del carico delle applicazioni e volumi EBS.
In sintesi, distribuirai un carico di lavoro di esempio con le annotazioni personalizzate necessarie per una perfetta integrazione con i servizi. AWS
## In questo tutorial
Utilizzando il modello di cluster `eksctl` che segue, creerai un cluster con modalità automatica EKS per il provisioning automatico dei nodi.
+ **Configurazione VPC**: quando si utilizza il modello di cluster eksctl che segue, eksctl crea automaticamente un Virtual Private Cloud ( IPv4 VPC) per il cluster. Per impostazione predefinita, eksctl configura un VPC che soddisfa tutti i requisiti di rete, oltre a creare endpoint pubblici e privati.
+ **Gestione delle istanze**: EKS Auto Mode aggiunge o rimuove dinamicamente i nodi nel cluster EKS in base alle esigenze delle applicazioni Kubernetes.
+ **Persistenza dei dati**: utilizzate la funzionalità di archiviazione a blocchi di EKS Auto Mode per garantire la persistenza dei dati delle applicazioni, anche in scenari che prevedono riavvii o guasti dei pod.
+ **Accesso esterno alle app**: utilizza la funzionalità di bilanciamento del carico di EKS Auto Mode per effettuare il provisioning dinamico di un Application Load Balancer (ALB).
## Prerequisiti
Prima di iniziare, esegui le seguenti attività:
+ [Configura il tuo ambiente per Amazon EKS](https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html)
+ [Installa la versione più recente di eksctl](https://eksctl.io/installation/)
## Configurazione del cluster
In questa sezione creerai un cluster utilizzando la modalità automatica EKS per il provisioning dinamico dei nodi.
Crea un file `cluster-config.yaml` e incollaci il seguente contenuto. Sostituisci `region-code` con una regione valida (ad es.). `us-east-1`
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: web-quickstart
region:
autoModeConfig:
enabled: true
```
Ora siamo pronti per creare il cluster.
Crea il cluster EKS utilizzando`cluster-config.yaml``:
```
eksctl create cluster -f cluster-config.yaml
```
**Importante**
Se non usi eksctl per creare il cluster, devi etichettare manualmente le sottoreti VPC.
## Crea IngressClass
Crea un Kubernetes `IngressClass` per la modalità automatica EKS. IngressClass Definisce come EKS Auto Mode gestisce le risorse di Ingress. Questo passaggio configura la capacità di bilanciamento del carico della modalità automatica EKS. Quando create risorse Ingress per le vostre applicazioni, EKS Auto Mode le utilizza per fornire e IngressClass gestire automaticamente i sistemi di bilanciamento del carico, integrando le applicazioni Kubernetes con i servizi di bilanciamento del carico. AWS
Salva il seguente file yaml come `ingressclass.yaml`:
```
apiVersion: networking.k8s.io/v1
kind: IngressClass
metadata:
name: alb
annotations:
ingressclass.kubernetes.io/is-default-class: "true"
spec:
controller: eks.amazonaws.com/alb
```
Applica il al tuo cluster: IngressClass
```
kubectl apply -f ingressclass.yaml
```
## Distribuzione dell’applicazione di gioco 2048 esemplificativa
In questa sezione, ti illustreremo i passaggi per implementare il popolare “gioco 2048” come applicazione esemplificativa all’interno del cluster. Il manifesto fornito include annotazioni personalizzate per l’Application Load Balancer (ALB). Queste annotazioni si integrano e indicano a EKS di gestire il traffico HTTP in entrata come «rivolto a Internet» e di indirizzarlo al servizio appropriato nel `game-2048` namespace utilizzando il tipo di destinazione «ip».
**Nota**
L’immagine `docker-2048` nell’esempio è un’immagine di container `x86_64` e non sarà eseguita su altre architetture.
1. Crea un namespace Kubernetes chiamato `game-2048` con il flag `--save-config`.
```
kubectl create namespace game-2048 --save-config
```
Dovresti vedere il seguente messaggio di risposta:
```
namespace/game-2048 created
```
1. Implementare l’[applicazione di gioco 2048 esemplificativa](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml).
```
kubectl apply -n game-2048 -f https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml
```
Questo manifesto configura l’implementazione, il servizio e l’entrata Kubernetes per il namespace `game-2048`, creando le risorse necessarie per implementare ed esporre l’applicazione `game-2048` all’interno del cluster. Include la creazione di un servizio denominato `service-2048` che espone l’implementazione sulla porta `80` e una risorsa di entrata denominata `ingress-2048` che definisce le regole di routing per il traffico HTTP in entrata e le annotazioni per un Application Load Balancer (ALB) con accesso a Internet. Dovresti vedere il seguente messaggio di risposta:
```
namespace/game-2048 configured
deployment.apps/deployment-2048 created
service/service-2048 created
ingress.networking.k8s.io/ingress-2048 created
```
1. Esegui il seguente comando per ottenere la risorsa di ingresso per il namespace `game-2048`.
```
kubectl get ingress -n game-2048
```
Dovresti vedere il seguente messaggio di risposta:
```
NAME CLASS HOSTS ADDRESS PORTS AGE
ingress-2048 alb * k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com 80 31s
```
Dovrai attendere alcuni minuti per effettuare il provisioning dell’Application Load Balancer (ALB) prima di iniziare con i passaggi seguenti.
1. Apri un browser Web e inserisci `ADDRESS` dal passaggio precedente per accedere all’applicazione Web. Esempio:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Il gioco 2048 dovrebbe essere visualizzato nel browser in uso. Gioca\$1
![\[Gioca al gioco 2048.\]](http://docs.aws.amazon.com/it_it/eks/latest/userguide/images/quick2048.png)
## Dati persistenti utilizzando la modalità automatica Amazon EKS
Ora che il gioco 2048 è attivo e funzionante sul tuo cluster Amazon EKS, è il momento di garantire che i tuoi dati di gioco siano conservati in modo sicuro, utilizzando la funzionalità di archiviazione a blocchi della modalità automatica Amazon EKS.
1. Creare un file denominato `storage-class.yaml`:
```
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: auto-ebs-sc
annotations:
storageclass.kubernetes.io/is-default-class: "true"
provisioner: ebs.csi.eks.amazonaws.com
volumeBindingMode: WaitForFirstConsumer
parameters:
type: gp3
encrypted: "true"
```
1. Applica `StorageClass`:
```
kubectl apply -f storage-class.yaml
```
1. Crea una richiesta di volumi persistenti (PVC) per richiedere lo spazio di archiviazione per i tuoi dati di gioco. Crea un file denominato `ebs-pvc.yaml` che contenga quando segue e aggiungilo a .
```
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: game-data-pvc
namespace: game-2048
spec:
accessModes:
- ReadWriteOnce
resources:
requests:
storage: 10Gi
storageClassName: auto-ebs-sc
```
1. Applica PVC al cluster:
```
kubectl apply -f ebs-pvc.yaml
```
Dovresti vedere il seguente messaggio di risposta:
```
persistentvolumeclaim/game-data-pvc created
```
1. Ora devi aggiornare l’implementazione del gioco 2048 per utilizzare questo PVC per archiviare i dati. La seguente implementazione è configurata per utilizzare PVC per l’archiviazione dei dati di gioco. Crea un file denominato `ebs-deployment.yaml` e aggiungilo a esso:
```
apiVersion: apps/v1
kind: Deployment
metadata:
namespace: game-2048
name: deployment-2048
spec:
replicas: 3 # Adjust the number of replicas as needed
selector:
matchLabels:
app.kubernetes.io/name: app-2048
template:
metadata:
labels:
app.kubernetes.io/name: app-2048
spec:
containers:
- name: app-2048
image: public.ecr.aws/l6m2t8p7/docker-2048:latest
imagePullPolicy: Always
ports:
- containerPort: 80
volumeMounts:
- name: game-data
mountPath: /var/lib/2048
volumes:
- name: game-data
persistentVolumeClaim:
claimName: game-data-pvc
```
1. Applica l’implementazione aggiornata:
```
kubectl apply -f ebs-deployment.yaml
```
Dovresti vedere il seguente messaggio di risposta:
```
deployment.apps/deployment-2048 configured
```
Con questi passaggi, il gioco 2048 sul cluster è ora configurato per rendere persistenti i dati, utilizzando la funzionalità di archiviazione a blocchi della modalità automatica Amazon EKS. Ciò garantisce che i progressi e i dati di gioco siano al sicuro anche in caso di guasti ai pod o ai nodi.
Se ti è piaciuto questo tutorial, faccelo sapere fornendo un feedback, così saremo in grado di fornirti altri tutorial rapidi di utilizzo specifici per ogni caso, come questo.
## Eliminazione
Per evitare di incorrere in addebiti futuri, è necessario eliminare manualmente lo CloudFormation stack associato per eliminare tutte le risorse create durante questa guida, inclusa la rete VPC.
Eliminare lo stack: CloudFormation
```
eksctl delete cluster -f ./cluster-config.yaml
```