Schnellstart: Bereitstellen einer Web-App und Speichern von Daten

Dieses Schnellstart-Tutorial führt Sie durch die Schritte, um die Beispielanwendung 2048 für das Spiel bereitzustellen und ihre Daten mithilfe von eksctl auf einem Amazon EKS Auto Mode-Cluster zu speichern.

Amazon EKS Auto Mode vereinfacht die Clusterverwaltung, indem er Routineaufgaben wie Blockspeicher, Netzwerke, Lastenausgleich und automatische Rechenskalierung automatisiert. Während der Einrichtung übernimmt es die Erstellung von Knoten mit EC2 verwalteten Instances, Anwendungs-Loadbalancern und EBS-Volumes.

Zusammenfassend stellen Sie einen Beispiel-Workload mit den benutzerdefinierten Anmerkungen bereit, die für eine nahtlose Integration mit Services erforderlich sind. AWS

In diesem Tutorial

Mit der folgenden eksctl-Cluster-Vorlage erstellen Sie einen Cluster mit EKS Auto Mode für die automatisierte Bereitstellung von Knoten.

• VPC-Konfiguration: Bei Verwendung der folgenden eksctl-Clustervorlage erstellt eksctl automatisch eine IPv4 Virtual Private Cloud (VPC) für den Cluster. Standardmäßig konfiguriert eksctl eine VPC, die alle Netzwerkanforderungen erfüllt und sowohl öffentliche als auch private Endpunkte erstellt.

• Instanzverwaltung: Der automatische Modus von EKS fügt je nach den Anforderungen Ihrer Kubernetes-Anwendungen dynamisch Knoten in Ihrem EKS-Cluster hinzu oder entfernt sie.

• Datenpersistenz: Verwenden Sie die Blockspeicherfunktion von EKS Auto Mode, um die Persistenz von Anwendungsdaten sicherzustellen, auch in Szenarien mit Pod-Neustarts oder -Ausfällen.

• Externer App-Zugriff: Verwenden Sie die Lastausgleichsfunktion von EKS Auto Mode, um einen Application Load Balancer (ALB) dynamisch bereitzustellen.

Voraussetzungen

Stellen Sie zunächst sicher, dass Sie die folgenden Aufgaben durchgeführt haben:

• Einrichtung Ihrer Umgebung für Amazon EKS

• Installation der neuesten Version von eksctl

Konfigurieren des Clusters

In diesem Abschnitt erstellen Sie einen Cluster unter Verwendung von EKS Auto Mode für die dynamische Bereitstellung von Knoten.

Erstellen Sie eine cluster-config.yaml-Datei und fügen Sie den folgenden Inhalt ein. Durch eine gültige Region region-code ersetzen (z. B.us-east-1).

apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

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

autoModeConfig:
  enabled: true

Nun können wir den Cluster erstellen.

Erstellen Sie den EKS-Cluster mit demcluster-config.yaml`:

eksctl create cluster -f cluster-config.yaml

Wichtig

Wenn Sie den Cluster nicht mit eksctl erstellen, müssen Sie die VPC-Subnetze manuell kennzeichnen.

Erstellen IngressClass

Erstellen Sie ein Kubernetes IngressClass für EKS Auto Mode. Das IngressClass definiert, wie EKS Auto Mode mit Ingress-Ressourcen umgeht. In diesem Schritt wird die Load-Balancing-Funktion von EKS Auto Mode konfiguriert. Wenn Sie Ingress-Ressourcen für Ihre Anwendungen erstellen, verwendet EKS Auto Mode diese, IngressClass um automatisch Load Balancer bereitzustellen und zu verwalten und Ihre Kubernetes-Anwendungen mit Lastausgleichsdiensten zu integrieren. AWS

Speichern Sie die folgende YAML-Datei unter dem Namen 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

Wenden Sie das auf Ihren Cluster an IngressClass :

kubectl apply -f ingressclass.yaml

Bereitstellung der Beispielanwendung für das Game 2048

In diesem Abschnitt führen wir Sie durch die Schritte zum Bereitstellen des beliebten „Spiel 2048“ als Beispielanwendung innerhalb des Clusters. Das bereitgestellte Manifest enthält benutzerdefinierte Annotationen für den Application Load Balancer (ALB). Diese Anmerkungen sind in EKS integriert und weisen EKS an, eingehenden HTTP-Verkehr als „mit dem Internet verbunden“ zu behandeln und ihn unter Verwendung des Zieltyps „ip“ an den entsprechenden Dienst im game-2048 Namespace weiterzuleiten.

Anmerkung

Das docker-2048-Image im Beispiel ist ein x86_64-Container-Image und funktioniert nicht auf anderen Architekturen.

1. Erstellen Sie mit dem --save-config-Flag einen Kubernetes-Namespace mit dem Namen game-2048.

   kubectl create namespace game-2048 --save-config

   Die ausgegebene Antwort sollte wie folgt aussehen:

   namespace/game-2048 created

2. Stellen Sie die Beispielanwendung „Spiel 2048“ bereit.

   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

   Dieses Manifest richtet eine Kubernetes-Bereitstellung, einen Service und einen Ingress für den game-2048-Namespace ein und erstellt die erforderlichen Ressourcen, um die game-2048-Anwendung innerhalb des Clusters bereitzustellen und verfügbar zu machen. Es umfasst die Erstellung eines Service mit dem Name service-2048, der die Bereitstellung auf Port 80 verfügbar macht, sowie einer Ingress-Ressource mit dem Namen ingress-2048, die Routing-Regeln für eingehenden HTTP-Datenverkehr und Annotationen für einen mit dem Internet verbundenen Application Load Balancer (ALB) definiert. Die ausgegebene Antwort sollte wie folgt aussehen:

   namespace/game-2048 configured
   deployment.apps/deployment-2048 created
   service/service-2048 created
   ingress.networking.k8s.io/ingress-2048 created

3. Führen Sie den folgenden Befehl aus, um die Ingress-Ressource für den game-2048-Namespace abzurufen.

   kubectl get ingress -n game-2048

   Die ausgegebene Antwort sollte wie folgt aussehen:

   NAME           CLASS   HOSTS   ADDRESS                                                                    PORTS   AGE
   ingress-2048   alb     *       k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com   80      31s

   Sie müssen einige Minuten warten, bis der Application Load Balancer (ALB) bereitgestellt ist, bevor Sie mit den folgenden Schritten beginnen.

4. Öffnen Sie einen Web-Browser und geben Sie ADDRESS aus dem vorherigen Schritt ein, um auf die Web-Anwendung zuzugreifen. Beispiel:

   k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com

   Das Spiel 2048 sollte in Ihrem Browser angezeigt werden. Spielen!

   

Persistente Daten unter Verwendung von Amazon EKS Auto Mode

Nachdem das Spiel 2048 nun in Ihrem Amazon-EKS-Cluster ausgeführt wird, ist es an der Zeit, sicherzustellen, dass Ihre Spieldaten mithilfe der Blockspeicherfunktion von Amazon EKS Auto Mode sicher gespeichert werden.

1. Erstellen Sie eine Datei namens 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"

2. Wenden Sie StorageClass an:

   kubectl apply -f storage-class.yaml

3. Erstellen Sie einen Persistent Volume Claim (PVC), um Speicherplatz für Ihre Spieldaten anzufordern. Erstellen Sie eine Datei mit dem Namen ebs-pvc.yaml und fügen Sie den folgenden Inhalt hinzu:

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

4. Wenden Sie das PVC auf Ihren Cluster an:

   kubectl apply -f ebs-pvc.yaml

   Die ausgegebene Antwort sollte wie folgt aussehen:

   persistentvolumeclaim/game-data-pvc created

5. Nun müssen Sie Ihre 2048-Spielbereitstellung aktualisieren, um diesen PVC für die Speicherung von Daten zu verwenden. Die folgende Bereitstellung ist so konfiguriert, dass sie den PVC für die Speicherung von Spieldaten verwendet. Erstellen Sie eine Datei mit dem Namen ebs-deployment.yaml und fügen Sie ihr den folgenden Inhalt hinzu:

   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

6. Wenden Sie die aktualisierte Bereitstellung an:

   kubectl apply -f ebs-deployment.yaml

   Die ausgegebene Antwort sollte wie folgt aussehen:

   deployment.apps/deployment-2048 configured

Mit diesen Schritten ist Ihr Spiel 2048 im Cluster nun so eingerichtet, dass Daten mithilfe der Blockspeicherfunktion von Amazon EKS Auto Mode dauerhaft gespeichert werden. Dadurch wird sichergestellt, dass Ihr Spielfortschritt und Ihre Daten auch bei Pod- oder Knotenausfällen sicher sind.

Wenn Ihnen dieses Tutorial gefallen hat, teilen Sie uns dies mit, damit wir Ihnen weitere anwendungsspezifische Schnellstart-Tutorials wie dieses anbieten können.

Bereinigen

Um future Gebühren zu vermeiden, müssen Sie den zugehörigen CloudFormation Stack manuell löschen, um alle in diesem Handbuch erstellten Ressourcen, einschließlich des VPC-Netzwerks, zu löschen.

Löschen Sie den Stack: CloudFormation

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