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

# Bereitstellung einer Beispiel-Workload mit Statusverwaltung in EKS Auto Mode
<a name="sample-storage-workload"></a>

Dieses Tutorial führt Sie durch die Bereitstellung einer Beispielanwendung mit Statusverwaltung in Ihrem Cluster von EKS Auto Mode. Die Anwendung schreibt Zeitstempel in ein persistentes Volume und demonstriert damit die automatische EBS-Volume-Bereitstellung und die Persistenzfunktionen von EKS Auto Mode.

## Voraussetzungen
<a name="_prerequisites"></a>
+ Ein EKS-Auto-Mode-Cluster
+ Die AWS CLI ist mit entsprechenden Berechtigungen konfiguriert
+  `kubectl` installiert und konfiguriert
  + Weitere Informationen finden Sie unter [Einrichtung zur Verwendung von Amazon EKS](setting-up.md).

## Schritt 1: Umgebung konfigurieren
<a name="_step_1_configure_your_environment"></a>

1. Legen Sie Ihre Umgebungsvariablen fest:

   ```
   export CLUSTER_NAME=my-auto-cluster
   export AWS_REGION="us-west-2"
   ```

1. Aktualisieren Sie Ihre kubeconfig:

   ```
   aws eks update-kubeconfig --name "${CLUSTER_NAME}"
   ```

## Schritt 2: Speicherklasse erstellen
<a name="_step_2_create_the_storage_class"></a>

`StorageClass` definiert, wie der EKS Auto Mode EBS-Volumes bereitstellt.

EKS Auto Mode erstellt keine `StorageClass` für Sie. Sie müssen eine `StorageClass`-Referenzierung `ebs.csi.eks.amazonaws.com` erstellen, um die Speicherfunktion von EKS Auto Mode zu nutzen.

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

 **Zentrale Komponenten:** 
+  `provisioner: ebs.csi.eks.amazonaws.com` – Verwendet EKS Auto Mode
+  `volumeBindingMode: WaitForFirstConsumer` – Verzögert die Volume-Erstellung, bis ein Pod sie benötigt
+  `type: gp3` – Gibt den EBS-Volume-Typ an
+  `encrypted: "true"` – EBS verwendet den Standardschlüssel `aws/ebs` zum Verschlüsseln von Volumes, die mit dieser Klasse erstellt wurden. Dies ist zwar optional, wird aber empfohlen.
+  `storageclass.kubernetes.io/is-default-class: "true"` – Kubernetes verwendet standardmäßig diese Speicherklasse, sofern Sie nicht für einen persistenten Volume-Anspruch eine andere Volume-Klasse angeben. Seien Sie beim Festlegen dieses Werts vorsichtig, wenn Sie von einem anderen Speicher-Controller migrieren. (optional)

## Schritt 3: Persistenten Volume-Anspruch erstellen
<a name="_step_3_create_the_persistent_volume_claim"></a>

Der PVC fordert Speicher von der `StorageClass` an.

1. Erstellen Sie eine Datei namens `pvc.yaml`:

   ```
   apiVersion: v1
   kind: PersistentVolumeClaim
   metadata:
     name: auto-ebs-claim
   spec:
     accessModes:
       - ReadWriteOnce
     storageClassName: auto-ebs-sc
     resources:
       requests:
         storage: 8Gi
   ```

1. Wenden Sie den PVC an:

   ```
   kubectl apply -f pvc.yaml
   ```

 **Zentrale Komponenten:** 
+  `accessModes: ReadWriteOnce` – Das Volume kann jeweils von einem Knoten eingebunden werden
+  `storage: 8Gi` – Fordert ein Volumen von 8 GiB an
+  `storageClassName: auto-ebs-sc` – Verweist auf die von uns erstellte `StorageClass`

## Schritt 4: Anwendung bereitstellen
<a name="_step_4_deploy_the_application"></a>

Die Bereitstellung führt einen Container aus, der Zeitstempel in das persistente Volume schreibt.

1. Erstellen Sie eine Datei namens `deployment.yaml`:

   ```
   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: inflate-stateful
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: inflate-stateful
     template:
       metadata:
         labels:
           app: inflate-stateful
       spec:
         terminationGracePeriodSeconds: 0
         nodeSelector:
           eks.amazonaws.com/compute-type: auto
         containers:
           - name: bash
             image: public.ecr.aws/docker/library/bash:4.4
             command: ["/usr/local/bin/bash"]
             args: ["-c", "while true; do echo $(date -u) >> /data/out.txt; sleep 60; done"]
             resources:
               requests:
                 cpu: "1"
             volumeMounts:
               - name: persistent-storage
                 mountPath: /data
         volumes:
           - name: persistent-storage
             persistentVolumeClaim:
               claimName: auto-ebs-claim
   ```

1. Bereitstellung durchführen:

   ```
   kubectl apply -f deployment.yaml
   ```

 **Zentrale Komponenten:** 
+ Einfacher Bash-Container, der Zeitstempel in eine Datei schreibt
+ Bindet den PVC bei `/data` ein 
+ Fordert 1 CPU-Kern an
+ Verwendet Knotenselektor für EKS-verwaltete Knoten

## Schritt 5: Einrichtung überprüfen
<a name="_step_5_verify_the_setup"></a>

1. Überprüfen Sie, ob der Pod ausgeführt wird:

   ```
   kubectl get pods -l app=inflate-stateful
   ```

1. Überprüfen Sie, ob der PVC eingebunden ist:

   ```
   kubectl get pvc auto-ebs-claim
   ```

1. Überprüfen Sie das EBS-Volume:

   ```
   # Get the PV name
   PV_NAME=$(kubectl get pvc auto-ebs-claim -o jsonpath='{.spec.volumeName}')
   # Describe the EBS volume
   aws ec2 describe-volumes \
     --filters Name=tag:CSIVolumeName,Values=${PV_NAME}
   ```

1. Überprüfen Sie, ob Daten geschrieben werden:

   ```
   kubectl exec "$(kubectl get pods -l app=inflate-stateful \
     -o=jsonpath='{.items[0].metadata.name}')" -- \
     cat /data/out.txt
   ```

## Schritt 6: Bereinigen
<a name="_step_6_cleanup"></a>

Führen Sie den folgenden Befehl aus, um alle in diesem Tutorial erstellten Ressourcen zu entfernen:

```
# Delete all resources in one command
kubectl delete deployment/inflate-stateful pvc/auto-ebs-claim storageclass/auto-ebs-sc
```

## Was hinter den Kulissen passiert
<a name="_whats_happening_behind_the_scenes"></a>

1. Der PVC fordert Speicher von der `StorageClass` an 

1. Wenn der Pod geplant ist:

   1. EKS Auto Mode stellt ein EBS-Volume bereit

   1. Erstellt ein PersistentVolume

   1. Fügt das Volume zum Knoten hinzu

1. Der Pod bindet das Volume ein und beginnt mit dem Schreiben von Zeitstempeln

## Snapshot-Controller
<a name="_snapshot_controller"></a>

EKS Auto Mode ist mit dem Kubernetes CSI Snapshotter, auch bekannt als Snapshot-Controller, kompatibel. EKS Auto Mode umfasst jedoch keinen Snapshot-Controller. Sie sind für die Installation und Konfiguration des Snapshot-Controllers verantwortlich. Weitere Informationen finden Sie unter [Snapshot-Funktion für CSI-Volumes aktivieren](csi-snapshot-controller.md).

Überprüfen Sie die folgenden `VolumeSnapshotClass`, die sich auf die Speicherkapazität von EKS Auto Mode beziehen.

```
apiVersion: snapshot.storage.k8s.io/v1
kind: VolumeSnapshotClass
metadata:
  name: auto-ebs-vsclass
driver: ebs.csi.eks.amazonaws.com
deletionPolicy: Delete
```

 [Weitere Informationen zum Kubernetes CSI Snapshotter.](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage)