In questo tutorial Prerequisiti Configura il cluster Crea IngressClass Implementa l'applicazione di esempio del gioco 2048 Persistenza dei dati utilizzando la modalità Amazon EKS Auto Elimina il cluster e i nodi

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

Vuoi contribuire a questa guida per l'utente? Scorri fino alla fine di questa pagina e seleziona Modifica questa pagina su GitHub. I tuoi contributi contribuiranno a rendere la nostra guida utente migliore per tutti.

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: distribuisci un'app Web e archivia i dati

Implementa un'applicazione di gioco e conserva i suoi dati su Amazon EKS

Questo tutorial di avvio rapido mostra 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. Amazon EKS Auto Mode automatizza le attività di routine per lo storage a blocchi di cluster, il networking, il bilanciamento del carico e la scalabilità automatica dell'elaborazione.

Man mano che procediamo, ti guideremo attraverso il processo di configurazione del cluster. Amazon EKS Auto Mode automatizzerà le attività per la creazione di un nodo utilizzando un'istanza EC2 gestita, la creazione di un sistema di bilanciamento del carico delle applicazioni e la creazione di un EBS volume.

Nel complesso, distribuirai un carico di lavoro di esempio con le annotazioni personalizzate necessarie per l'integrazione completa con i servizi. AWS

In questo tutorial

Utilizzando il modello di eksctl cluster che segue, creerai un cluster con modalità EKS automatica per il provisioning automatico dei nodi.

VPCConfigurazione Quando si utilizza il modello di cluster eksctl che segue, eksctl crea automaticamente un IPv4 Virtual Private Cloud () VPC per il cluster. Per impostazione predefinita, eksctl configura un dispositivo VPC che soddisfa tutti i requisiti di rete, oltre a creare endpoint pubblici e privati.

La modalità EKS automatica di gestione delle istanze aggiunge o rimuove dinamicamente i nodi del EKS cluster in base alle esigenze delle applicazioni Kubernetes.

Persistenza dei dati Utilizza 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 Utilizzate la funzionalità di bilanciamento del carico di EKS Auto Mode per effettuare il provisioning dinamico di un Application Load ALB Balancer ().

Prerequisiti

Prima di iniziare, assicurati di aver configurato i seguenti prerequisiti per utilizzare AmazonEKS:

Imposta AWS CLI e configura le credenziali
Installa eksctl
Installa kubectl

Per ulteriori informazioni, consulta Configurazione per l'utilizzo di Amazon EKS.

Configura il cluster

In questa sezione, creerai un cluster utilizzando la modalità EKS automatica per il provisioning dinamico dei nodi.

Crea un cluster-config.yaml file e incolla i seguenti contenuti al suo interno. Sostituisci region-code con una regione valida, ad esempious-east-1:


apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

metadata:
  name: web-quickstart
  region: <region-code>

autoModeConfig:
  enabled: true

Ora siamo pronti per creare il cluster.

Crea il EKS cluster Amazon:


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 EKS la modalità automatica. IngressClass Definisce come EKS Auto Mode gestisce le risorse di Ingress. Questo passaggio configura la capacità di bilanciamento del carico di EKS Auto Mode. Quando crei risorse Ingress per le tue applicazioni, EKS Auto Mode le utilizza per fornire e gestire automaticamente i sistemi di bilanciamento del carico, integrando le tue applicazioni Kubernetes con i servizi di bilanciamento del carico. IngressClass AWS

Salva ingressclass.yaml il seguente file yaml come:


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 IngressClass al tuo cluster:


kubectl apply -f ingressclass.yaml

Implementa l'applicazione di esempio del gioco 2048

In questa sezione, ti illustreremo i passaggi per implementare il popolare «gioco 2048" come applicazione di esempio all'interno del cluster. Il manifesto fornito include annotazioni personalizzate per Application Load Balancer ALB (). Queste annotazioni si integrano e le indicano di gestire il HTTP traffico in entrata come «rivolto EKS a Internet» e di indirizzarlo al servizio appropriato nello spazio dei nomi «game-2048» utilizzando il tipo di destinazione «ip».

Crea game-2048 uno spazio dei --save-config nomi Kubernetes chiamato con il flag.
```
kubectl create namespace game-2048 --save-config
```
Dovresti vedere il seguente messaggio di risposta:
```
namespace/game-2048 created
```
Distribuisci l'applicazione 2048 Game Sample.
```
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 manifest configura Kubernetes Deployment, Service e Ingress per il game-2048 namespace, creando le risorse necessarie per distribuire ed esporre l'applicazione all'interno del cluster. game-2048 Include la creazione di un servizio denominato service-2048 che espone l'implementazione sulla porta 80 e una risorsa Ingress denominata ingress-2048 che definisce le regole di routing per il HTTP traffico in entrata e le annotazioni per un Application Load Balancer () con accesso a Internet. ALB 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
```

Eseguite il comando seguente per ottenere la risorsa Ingress per lo spazio dei nomi. 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

Dovrete attendere alcuni minuti per il provisioning di Application Load Balancer (ALB) prima di iniziare i passaggi seguenti.

Aprite un browser Web e immettete il ADDRESS passaggio precedente per accedere all'applicazione Web. Per esempio:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Dovresti vedere il gioco 2048 nel tuo browser. Gioca!

Persistenza dei dati utilizzando la modalità Amazon EKS Auto

Ora che il gioco 2048 è attivo e funzionante sul tuo EKS cluster Amazon, è il momento di assicurarti che i tuoi dati di gioco siano conservati in modo sicuro utilizzando la funzionalità di archiviazione a blocchi di Amazon EKS Auto Mode.

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"

Applica: StorageClass
```
kubectl apply -f storage-class.yaml
```

Crea un Persistent Volume Claim (PVC) per richiedere lo spazio di archiviazione per i tuoi dati di gioco. Crea un file denominato ebs-pvc.yaml e aggiungi il seguente contenuto:


apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: game-data-pvc
  namespace: game-2048
spec:
  accessModes:
    - ReadWriteOnce
  resources:
    requests:
      storage: 10Gi
  storageClassName: auto-ebs-sc

Applica il PVC al tuo cluster:
```
kubectl apply -f ebs-pvc.yaml
```
Dovresti vedere il seguente messaggio di risposta:
```
persistentvolumeclaim/game-data-pvc created
```

Ora devi aggiornare la distribuzione del gioco 2048 per utilizzarla PVC per archiviare i dati. La seguente distribuzione è configurata per utilizzare la PVC per l'archiviazione dei dati di gioco. Crea un file denominato ebs-deployment.yaml e aggiungi i seguenti contenuti:


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

Applica la distribuzione 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 storage a blocchi di Amazon EKS Auto Mode. 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.

Elimina il cluster e i nodi

Dopo aver finito con il cluster che hai creato per questo tutorial, dovresti ripulirlo eliminando con il seguente comando. Se vuoi fare di più con questo cluster prima di ripulirlo, vedi Passaggi successivi.


eksctl delete cluster -f ./cluster-config.yaml

EKSpulirà automaticamente tutti i nodi a cui è stato assegnato il provisioning quando il cluster viene eliminato.

📝 Modifica questa pagina su GitHub

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Configura kubectl ed eksctl

Impara Amazon EKS