In diesem Tutorial Voraussetzungen Konfigurieren des Clusters IngressClass erstellen Bereitstellung der Beispielanwendung für das Game 2048 Persistente Daten unter Verwendung von Amazon EKS Auto Mode Löschen Sie Ihren Cluster und Ihre Knoten

Schnellstart: Bereitstellen einer Web-App und Speichern von Daten

Spielanwendung bereitstellen und Daten in Amazon EKS speichern

Dieses Schnellstart-Tutorial zeigt die Schritte zum Bereitstellen der Beispielanwendung für das Spiel 2048 und zum Speichern ihrer Daten auf einem Cluster für Amazon EKS Auto Mode mithilfe von eksctl. Amazon EKS Auto Mode automatisiert Routineaufgaben für Cluster-Blockspeicher, Vernetzung, Lastausgleich und automatische Skalierung der Datenverarbeitung.

Im weiteren Verlauf führen wir Sie durch den Cluster-Einrichtungsprozess. Amazon EKS Auto Mode automatisiert Aufgaben zum Erstellen eines Knotens mithilfe einer EC2-verwalteten Instance, zum Erstellen eines Application Load Balancer und zum Erstellen eines EBS-Volumes.

Im Großen und Ganzen werden Sie eine Beispiel-Workload mit den benutzerdefinierten Annotationen bereitstellen, die für die vollständige Integration mit den AWS-Services erforderlich sind.

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 Wenn Sie die folgende eksctl-Cluster-Vorlage verwenden, 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.

Instance-Verwaltung EKS Auto Mode fügt basierend auf 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, selbst in Szenarien mit Pod-Neustarts oder -Fehlern.

Externer Anwendungszugriff Nutzen Sie die Load-Balancing-Funktion von EKS Auto Mode, um dynamisch einen Application Load Balancer (ALB) bereitzustellen.

Voraussetzungen

Stellen Sie vor Beginn sicher, dass Sie die folgenden Voraussetzungen für die Verwendung von Amazon EKS erfüllen:

Einrichtung der AWS-CLI und Konfiguration der Anmeldeinformationen
eksctl installieren
kubectl installieren

Weitere Informationen finden Sie unter Einrichtung zur Verwendung von Amazon EKS.

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. Ersetzen Sie region-code durch eine gültige Region, beispielsweise 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 Amazon-EKS-Cluster:


eksctl create cluster -f cluster-config.yaml

Wichtig

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

IngressClass erstellen

Erstellen Sie ein Kubernetes IngressClass für EKS Auto Mode. Die IngressClass definiert, wie der 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 Load Balancer automatisch bereitzustellen, zu verwalten und Ihre Kubernetes-Anwendungen in AWS-Load-Balancing-Services zu integrieren.

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 die IngressClass auf Ihren Cluster an:


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 Annotationen werden in EKS integriert und weisen EKS an, eingehenden HTTP-Datenverkehr als „internetfähig“ zu behandeln und ihn unter Verwendung des Zieltyps „ip“ an den entsprechenden Service im game-2048-Namespace weiterzuleiten.

Anmerkung

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

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
```
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
```
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.
Öffnen Sie einen Web-Browser und geben Sie ADDRESS aus dem vorherigen Schritt ein, um auf die Web-Anwendung zuzugreifen. Zum 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.

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"

Wenden Sie StorageClass an:
```
kubectl apply -f storage-class.yaml
```

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

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

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

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.

Löschen Sie Ihren Cluster und Ihre Knoten

Nachdem Sie mit dem Cluster, den Sie für dieses Tutorial erstellt haben, fertig sind, sollten Sie ihn mit dem folgenden Befehl löschen Wenn Sie vor dem Bereinigen mehr mit diesem Cluster tun möchten, lesen Sie „Nächste Schritte“.


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

EKS bereinigt automatisch alle bereitgestellten Knoten, wenn der Cluster gelöscht wird.

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

kubectl und eksctl einrichten

Amazon EKS kennenlernen