In diesem Tutorial Voraussetzungen Konfigurieren Sie den Cluster Erstellen IngressClass Stellen Sie die Beispielanwendung für das Spiel 2048 bereit Daten im Amazon EKS Auto Mode persistieren Löschen Sie Ihren Cluster und Ihre Knoten

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

Möchten Sie zu diesem Benutzerhandbuch beitragen? Scrollen Sie zum Ende dieser Seite und wählen Sie Diese Seite bearbeiten am aus GitHub. Ihre Beiträge werden dazu beitragen, unser Benutzerhandbuch für alle zu verbessern.

Schnellstart: Eine Web-App bereitstellen und Daten speichern

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

Dieses Schnellstart-Tutorial zeigt, wie Sie die Beispielanwendung 2048 für das Spiel bereitstellen und ihre Daten mithilfe von eksctl auf einem Amazon EKS Auto Mode-Cluster speichern. 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 die vollständige Integration mit AWS den Services erforderlich sind.

In diesem Tutorial

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

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

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

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 des EKS Auto-Modus, um einen Application Load Balancer (ALB) dynamisch bereitzustellen.

Voraussetzungen

Bevor Sie beginnen, stellen Sie sicher, dass Sie die folgenden Voraussetzungen für die Nutzung von Amazon erfüllt habenEKS:

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

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

Konfigurieren Sie den Cluster

In diesem Abschnitt erstellen Sie einen Cluster im EKS automatischen 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 EKS Amazon-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 ein Kubernetes IngressClass für den EKS automatischen Modus. Das IngressClass definiert, wie der EKS automatische Modus mit Ingress-Ressourcen umgeht. In diesem Schritt wird die Lastenausgleichsfunktion des EKS automatischen Modus 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 lassen sich in das System integrieren und weisen den an, eingehenden HTTP Datenverkehr als „mit dem Internet verbunden“ EKS 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 notwendigen 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 Datenverkehr und Anmerkungen für einen mit dem Internet verbundenen Application Load Balancer () definiert. ALB 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. Beispielsweise:
```
k8s-game2048-ingress2-eb379a0f83-378466616.region-code.elb.amazonaws.com
```
Sie sollten das Spiel 2048 in Ihrem Browser sehen. Spiel!

Daten im Amazon EKS Auto Mode persistieren

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

Erstellen Sie einen dauerhaften Volumenanspruch (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

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

Jetzt müssen Sie Ihre 2048-Spielbereitstellung aktualisieren, um diese PVC zum Speichern von Daten zu verwenden. Die folgende Bereitstellung ist so konfiguriert, dass sie 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

EKSbereinigt automatisch alle Knoten, die es bereitgestellt hat, wenn der Cluster gelöscht wird.

📝 Bearbeiten Sie diese Seite auf GitHub

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 kennen EKS