In diesem Tutorial Voraussetzungen Konfigurieren Sie den Cluster Erstellen IngressClass Stellen Sie die Beispielanwendung für das Spiel 2048 bereit Daten im automatischen Modus von Amazon EKS dauerhaft speichern Löschen Sie Ihren Cluster und Ihre Knoten

Hilf mit, diese Seite zu verbessern

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Wenn Sie zu diesem Benutzerhandbuch beitragen möchten, wählen Sie den GitHub Link Diese Seite bearbeiten auf, der sich im rechten Bereich jeder Seite befindet.

Schnellstart: Eine Web-App bereitstellen und Daten speichern

Stellen Sie eine Spieleanwendung bereit und speichern Sie ihre Daten auf Amazon EKS

Dieses Schnellstart-Tutorial zeigt die Schritte zur Bereitstellung der 2048-Spielbeispielanwendung und zur Persistenz ihrer Daten auf einem Amazon EKS Auto Mode-Cluster mithilfe von eksctl. Amazon EKS Auto Mode automatisiert Routineaufgaben für Cluster-Blockspeicher, Netzwerke, Lastenausgleich und automatische Rechenskalierung.

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

Insgesamt stellen Sie einen Beispiel-Workload mit den benutzerdefinierten Anmerkungen bereit, die für eine vollständige Integration mit Services erforderlich sind. AWS

In diesem Tutorial

Mithilfe der folgenden eksctl Clustervorlage erstellen Sie einen Cluster mit EKS Auto Mode für die automatisierte Knotenbereitstellung.

VPC-Konfiguration Wenn Sie die folgende eksctl-Clustervorlage 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 Management EKS Auto Mode fügt dynamisch Knoten in Ihrem EKS-Cluster hinzu oder entfernt sie, je nach den Anforderungen Ihrer Kubernetes-Anwendungen.

Datenpersistenz Verwenden Sie die Blockspeicherfunktion des 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

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen für die Verwendung von Amazon EKS erfüllt haben:

AWS CLI einrichten und Anmeldeinformationen konfigurieren
Installieren Sie eksctl
Installieren Sie kubectl

Weitere Informationen finden Sie unter Für die Verwendung von Amazon EKS einrichten.

Konfigurieren Sie den Cluster

In diesem Abschnitt erstellen Sie einen Cluster mit dem automatischen EKS-Modus für die dynamische Knotenbereitstellung.

Erstellen Sie eine cluster-config.yaml Datei und fügen Sie den folgenden Inhalt ein. region-codeErsetzen Sie durch eine gültige Region, z. B.us-east-1:


apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig

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

autoModeConfig:
  enabled: true

Jetzt sind wir bereit, den Cluster zu erstellen.

Erstellen Sie den Amazon EKS-Cluster:


eksctl create cluster -f cluster-config.yaml

Wichtig

Wenn Sie eksctl nicht verwenden, um den Cluster zu erstellen, müssen Sie die VPC-Subnetze manuell taggen.

Erstellen IngressClass

Erstellen Sie einen Kubernetes IngressClass für EKS Auto Mode. Das IngressClass definiert, wie der automatische EKS-Modus mit Ingress-Ressourcen umgeht. In diesem Schritt wird die Lastenausgleichsfunktion 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 als: 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 IngressClass auf Ihren Cluster an:


kubectl apply -f ingressclass.yaml

Stellen Sie die Beispielanwendung für das Spiel 2048 bereit

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

Erstellen Sie einen Kubernetes-Namespace, der mit dem Flag aufgerufen wird. game-2048 --save-config
```
kubectl create namespace game-2048 --save-config
```
Die ausgegebene Antwort sollte wie folgt aussehen:
```
namespace/game-2048 created
```
Stellen Sie die 2048 Game Sample-Anwendung 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 ein Kubernetes-Deployment, einen Dienst und einen Ingress für den game-2048 Namespace ein und schafft so die erforderlichen Ressourcen, um die Anwendung innerhalb des Clusters bereitzustellen und verfügbar zu machen. game-2048 Es umfasst die Erstellung eines Dienstes mit dem Namenservice-2048, der die Bereitstellung auf dem Port verfügbar macht80, und einer Ingress-Ressource mit dem Namen, ingress-2048 die Routing-Regeln für eingehenden HTTP-Verkehr und Anmerkungen 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 Namespace abzurufen. game-2048
```
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 Webbrowser und geben Sie den Code ADDRESS aus dem vorherigen Schritt ein, um auf die Webanwendung zuzugreifen. Zum Beispiel:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Sie sollten das Spiel 2048 in Ihrem Browser sehen. Spiel!

Daten im automatischen Modus von Amazon EKS dauerhaft speichern

Jetzt, da das Spiel 2048 auf Ihrem Amazon EKS-Cluster läuft, 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 Folgendes an: StorageClass
```
kubectl apply -f storage-class.yaml
```

Erstellen Sie einen Persistent Volume Claim (PVC), um Speicherplatz für Ihre Spieldaten anzufordern. Erstelle eine Datei mit dem Namen ebs-pvc.yaml und füge ihr 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

Tragen Sie das PVC auf Ihren Cluster auf:
```
kubectl apply -f ebs-pvc.yaml
```
Die ausgegebene Antwort sollte wie folgt aussehen:
```
persistentvolumeclaim/game-data-pvc created
```

Jetzt müssen Sie Ihre 2048-Spielbereitstellung aktualisieren, um dieses PVC zum Speichern von Daten zu verwenden. Die folgende Bereitstellung ist so konfiguriert, dass das PVC zum Speichern von Spieldaten verwendet wird. 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 2048-Spiel auf dem Cluster jetzt so eingerichtet, dass es Daten mithilfe der Blockspeicherfunktion von Amazon EKS Auto Mode persistiert. Dadurch wird sichergestellt, dass Ihr Spielfortschritt und Ihre Daten auch bei Pod- oder Node-Ausfällen sicher sind.

Wenn dir dieses Tutorial gefallen hat, lass es uns wissen, indem du uns Feedback gibst, damit wir dir weitere anwendungsfallspezifische Schnellstart-Tutorials wie dieses zur Verfügung stellen können.

Löschen Sie Ihren Cluster und Ihre Knoten

Wenn Sie mit dem Cluster fertig sind, den Sie für dieses Tutorial erstellt haben, sollten Sie ihn bereinigen, indem Sie den Cluster mit dem folgenden Befehl löschen. Wenn Sie vor dem Aufräumen mehr aus diesem Cluster machen möchten, finden Sie weitere Informationen unter Nächste Schritte.


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

EKS bereinigt automatisch alle Knoten, die es bereitgestellt hat, 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

Richten Sie kubectl und eksctl ein

Lernen Sie Amazon EKS kennen