**Unterstützung für die Verbesserung dieser Seite beitragen**
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.
Um zu diesem Benutzerhandbuch beizutragen, wählen Sie den GitHub Link **Diese Seite bearbeiten auf**, der sich im rechten Bereich jeder Seite befindet.
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.
# 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.](https://eksctl.io/)
[Amazon EKS Auto Mode](automode.md) 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](https://docs.aws.amazon.com/eks/latest/userguide/setting-up.html)
+ [Installation der neuesten Version von eksctl](https://eksctl.io/installation/)
## 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:
autoModeConfig:
enabled: true
```
Nun können wir den Cluster erstellen.
Erstellen Sie den EKS-Cluster mit dem`cluster-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
```
1. Stellen Sie die [Beispielanwendung „Spiel 2048“](https://raw.githubusercontent.com/kubernetes-sigs/aws-load-balancer-controller/v2.8.0/docs/examples/2048/2048_full.yaml) 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
```
1. 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.
1. Ö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\$1
![\[Das Spiel 2048 spielen\]](http://docs.aws.amazon.com/de_de/eks/latest/userguide/images/quick2048.png)
## 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"
```
1. Wenden Sie `StorageClass` an:
```
kubectl apply -f storage-class.yaml
```
1. 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
```
1. 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
```
1. 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
```
1. 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
```