Prerequisiti Fase 1: Creazione del namespace Fase 2: Implementazione dell’applicazione Fase 3: Creazione del servizio Fase 4: Configurazione del bilanciamento del carico Fase 5: Verifica dell’implementazione Fase 6: Accesso al gioco Fase 7: Eliminazione Cosa succede dietro le quinte Risoluzione dei problemi

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

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

Controlla che tutti i pod siano in esecuzione:
```
kubectl get pods -n game-2048
```
Verifica che il servizio sia stato creato:
```
kubectl get svc -n game-2048
```
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

L’implementazione crea 5 pod che eseguono il gioco 2048
Il servizio fornisce un accesso stabile alla rete a questi pod
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

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

Implementa un carico di lavoro di decompressione

Implementazione di un carico di lavoro stateful