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.

# Führen Sie statusbehaftete Workloads mit persistentem Datenspeicher aus, indem Sie Amazon EFS auf Amazon EKS mit AWS Fargate verwenden
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate"></a>

*Ricardo Morais, Rodrigo Bersa und Lucio Pereira, Amazon Web Services*

## Zusammenfassung
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-summary"></a>

Dieses Muster bietet Anleitungen zur Aktivierung von Amazon Elastic File System (Amazon EFS) als Speichergerät für Container, die auf Amazon Elastic Kubernetes Service (Amazon EKS) ausgeführt werden, indem Sie AWS Fargate zur Bereitstellung Ihrer Rechenressourcen verwenden.

Das in diesem Muster beschriebene Setup folgt bewährten Sicherheitsmethoden und bietet standardmäßig Sicherheit im Ruhezustand und Sicherheit bei der Übertragung. Um Ihr Amazon EFS-Dateisystem zu verschlüsseln, verwendet es einen AWS Key Management Service (AWS KMS) -Schlüssel, aber Sie können auch einen Schlüsselalias angeben, der den Prozess der Erstellung eines KMS-Schlüssels auslöst.

Sie können den Schritten in diesem Muster folgen, um einen Namespace und ein Fargate-Profil für eine proof-of-concept (PoC-) Anwendung zu erstellen, den Amazon EFS Container Storage Interface (CSI) -Treiber zu installieren, der für die Integration des Kubernetes-Clusters in Amazon EFS verwendet wird, die Speicherklasse zu konfigurieren und die PoC-Anwendung bereitzustellen. Diese Schritte führen zu einem Amazon EFS-Dateisystem, das von mehreren Kubernetes-Workloads gemeinsam genutzt wird und über Fargate ausgeführt wird. Das Muster wird von Skripten begleitet, die diese Schritte automatisieren.

Sie können dieses Muster verwenden, wenn Sie Datenpersistenz in Ihren containerisierten Anwendungen wünschen und Datenverluste bei Skalierungsvorgängen vermeiden möchten. Beispiel:
+ **DevOps Tools** — Ein gängiges Szenario ist die Entwicklung eines Tools für kontinuierliche Integration und kontinuierliche Bereitstellung (Continuous Delivery). CI/CD) strategy. In this case, you can use Amazon EFS as a shared file system to store configurations among different instances of the CI/CD tool or to store a cache (for example, an Apache Maven repository) for pipeline stages among different instances of the CI/CD
+ **Webserver** — Ein gängiges Szenario ist die Verwendung von Apache als HTTP-Webserver. Sie können Amazon EFS als gemeinsam genutztes Dateisystem verwenden, um statische Dateien zu speichern, die von verschiedenen Instanzen des Webservers gemeinsam genutzt werden. In diesem Beispielszenario werden Änderungen direkt auf das Dateisystem angewendet, anstatt statische Dateien in ein Docker-Image zu integrieren.

## Voraussetzungen und Einschränkungen
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-prereqs"></a>

**Voraussetzungen**
+ Ein aktives AWS-Konto
+ Ein vorhandener Amazon EKS-Cluster mit Kubernetes Version 1.17 oder höher (getestet bis Version 1.27)
+ Ein vorhandenes Amazon EFS-Dateisystem zum Binden von Kubernetes StorageClass und zum dynamischen Bereitstellen von Dateisystemen
+ Berechtigungen für die Clusterverwaltung
+ Kontext, der so konfiguriert ist, dass er auf den gewünschten Amazon EKS-Cluster verweist

**Einschränkungen**
+ Bei der Verwendung von Amazon EKS mit Fargate sind einige Einschränkungen zu beachten. Beispielsweise wird die Verwendung einiger Kubernetes-Konstrukte, wie z. B. DaemonSets privilegierte Container, nicht unterstützt. Weitere Informationen zu den Einschränkungen von Fargate finden Sie in den [Überlegungen zu AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html#fargate-considerations) in der Amazon EKS-Dokumentation.
+ Der mit diesem Muster bereitgestellte Code unterstützt Workstations, auf denen Linux oder macOS ausgeführt wird.

**Produktversionen**
+ AWS-Befehlszeilenschnittstelle (AWS CLI) Version 2 oder höher
+ Amazon EFS CSI-Treiber Version 1.0 oder höher (getestet bis Version 2.4.8)
+ eksctl Version 0.24.0 oder höher (getestet bis Version 0.158.0)
+ jq Version 1.6 oder höher
+ kubectl Version 1.17 oder höher (getestet bis Version 1.27)
+ Kubernetes Version 1.17 oder höher (getestet bis Version 1.27)

## Architektur
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-architecture"></a>

![Architekturdiagramm der Ausführung von statusbehafteten Workloads mit persistentem Datenspeicher mithilfe von Amazon EFS](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/images/pattern-img/2487e285-269b-415b-a270-877f973e3aaf/images/ec8de63c-3307-4010-9e03-2bd7b9881fff.png)


Die Zielarchitektur besteht aus der folgenden Infrastruktur:
+ Eine Virtual Private Cloud (VPC)
+ Zwei Verfügbarkeitszonen
+ Ein öffentliches Subnetz mit einem NAT-Gateway, das Internetzugang bietet
+ Ein privates Subnetz mit einem Amazon EKS-Cluster und Amazon EFS-Mount-Zielen (auch bekannt als *Mount-Points*)
+ Amazon EFS auf VPC-Ebene

Im Folgenden finden Sie die Umgebungsinfrastruktur für den Amazon EKS-Cluster:
+ AWS Fargate-Profile, die die Kubernetes-Konstrukte auf Namespace-Ebene berücksichtigen
+ Ein Kubernetes-Namespace mit:
  + Zwei Anwendungs-Pods, die über Availability Zones verteilt sind
  + Ein persistenter Volume Claim (PVC), der an ein persistentes Volume (PV) auf Clusterebene gebunden ist
+ Ein clusterweiter PV, der an das PVC im Namespace gebunden ist und auf die Amazon EFS-Mount-Ziele im privaten Subnetz außerhalb des Clusters verweist

## Tools
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-tools"></a>

**AWS-Services**
+ [AWS Command Line Interface (AWS CLI)](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) ist ein Open-Source-Tool, mit dem Sie über die Befehlszeile mit AWS-Services interagieren können.
+ [Amazon Elastic File System (Amazon EFS)](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) unterstützt Sie bei der Erstellung und Konfiguration gemeinsam genutzter Dateisysteme in der AWS-Cloud. In diesem Muster bietet es ein einfaches, skalierbares, vollständig verwaltetes und gemeinsam genutztes Dateisystem für die Verwendung mit Amazon EKS.
+ [Amazon Elastic Kubernetes Service (Amazon EKS)](https://docs.aws.amazon.com/eks/latest/userguide/getting-started.html) hilft Ihnen, Kubernetes auf AWS auszuführen, ohne Ihre eigenen Cluster installieren oder betreiben zu müssen.
+ [AWS Fargate](https://docs.aws.amazon.com/eks/latest/userguide/fargate.html) ist eine serverlose Rechen-Engine für Amazon EKS. Sie erstellt und verwaltet Rechenressourcen für Ihre Kubernetes-Anwendungen.
+ [AWS Key Management Service (AWS KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html) unterstützt Sie bei der Erstellung und Kontrolle kryptografischer Schlüssel, um Ihre Daten zu schützen.

**Andere Tools**
+ [Docker](https://www.docker.com/) ist eine Reihe von Platform-as-a-Service (PaaS) -Produkten, die Virtualisierung auf Betriebssystemebene nutzen, um Software in Containern bereitzustellen.
+ [eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html) ist ein Befehlszeilenprogramm zum Erstellen und Verwalten von Kubernetes-Clustern auf Amazon EKS.
+ [kubectl](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html) ist eine Befehlszeilenschnittstelle, mit der Sie Befehle für Kubernetes-Cluster ausführen können.
+ [jq ist ein Befehlszeilentool](https://stedolan.github.io/jq/download/) zum Parsen von JSON.

**Code**

Der Code für dieses Muster wird in der GitHub [Persistenzkonfiguration mit Amazon EFS auf Amazon EKS mithilfe des AWS Fargate-Repos](https://github.com/aws-samples/eks-efs-share-within-fargate) bereitgestellt. Die Skripts sind nach Epic in den Ordnern `epic01` bis angeordnet`epic06`, entsprechend der Reihenfolge im Abschnitt [Epics](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-epics) in diesem Muster.

## Best Practices
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-best-practices"></a>

Die Zielarchitektur umfasst die folgenden Services und Komponenten und entspricht den Best Practices von [AWS Well-Architected Framework](https://aws.amazon.com/architecture/well-architected/):
+ Amazon EFS, das ein einfaches, skalierbares, vollständig verwaltetes elastisches NFS-Dateisystem bietet. Dies wird als gemeinsam genutztes Dateisystem für alle Replikationen der PoC-Anwendung verwendet, die in Pods ausgeführt werden, die in den privaten Subnetzen des ausgewählten Amazon EKS-Clusters verteilt sind.
+ Ein Amazon EFS-Mount-Ziel für jedes private Subnetz. Dies bietet Redundanz pro Availability Zone innerhalb der Virtual Private Cloud (VPC) des Clusters.
+ Amazon EKS, das die Kubernetes-Workloads ausführt. Sie müssen einen Amazon EKS-Cluster bereitstellen, bevor Sie dieses Muster verwenden können, wie im Abschnitt [Voraussetzungen](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-prereqs) beschrieben.
+ AWS KMS bietet Verschlüsselung im Ruhezustand für den Inhalt, der im Amazon EFS-Dateisystem gespeichert ist.
+ Fargate, das die Rechenressourcen für die Container verwaltet, sodass Sie sich auf die Geschäftsanforderungen konzentrieren können, anstatt die Infrastruktur zu belasten. Das Fargate-Profil wird für alle privaten Subnetze erstellt. Es bietet Redundanz pro Availability Zone innerhalb der Virtual Private Cloud (VPC) des Clusters.
+ Kubernetes-Pods, mit denen überprüft wird, ob Inhalte von verschiedenen Instanzen einer Anwendung gemeinsam genutzt, genutzt und geschrieben werden können.

## Epen
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-epics"></a>

### Bereitstellen eines Amazon EKS-Clusters (optional)
<a name="provision-an-amazon-eks-cluster-optional"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie einen Amazon-EKS-Cluster. | Wenn Sie bereits einen Cluster bereitgestellt haben, fahren Sie mit dem nächsten Epic fort. Erstellen Sie einen Amazon EKS-Cluster in Ihrem bestehenden AWS-Konto. Verwenden Sie im [GitHub Verzeichnis](https://github.com/aws-samples/eks-efs-share-within-fargate/tree/master/bootstrap) eines der Muster, um einen Amazon EKS-Cluster mithilfe von Terraform oder eksctl bereitzustellen. Weitere Informationen finden Sie unter [Erstellen eines Amazon EKS-Clusters](https://docs.aws.amazon.com/eks/latest/userguide/create-cluster.html) in der Amazon EKS-Dokumentation. Das Terraform-Muster enthält auch Beispiele, die zeigen, wie Sie: Fargate-Profile mit Ihrem Amazon EKS-Cluster verknüpfen, ein Amazon EFS-Dateisystem erstellen und den Amazon EFS-CSI-Treiber in Ihrem Amazon EKS-Cluster bereitstellen können. | AWS-Administrator, Terraform- oder eksctl-Administrator, Kubernetes-Administrator | 
| Exportieren Sie Umgebungsvariablen. | Führen Sie das Skript env.sh aus. Es enthält die Informationen, die für die nächsten Schritte erforderlich sind.<pre>source ./scripts/env.sh<br />Inform the AWS Account ID:<br /><13-digit-account-id><br />Inform your AWS Region:<br /><aws-Region-code><br />Inform your Amazon EKS Cluster Name:<br /><amazon-eks-cluster-name><br />Inform the Amazon EFS Creation Token:<br /><self-genereated-uuid></pre><br />Falls noch nicht angegeben, können Sie alle oben angeforderten Informationen mit den folgenden CLI-Befehlen abrufen.<pre># ACCOUNT ID<br />aws sts get-caller-identity --query "Account" --output text</pre><pre># REGION CODE<br />aws configure get region</pre><pre># CLUSTER EKS NAME<br />aws eks list-clusters --query "clusters" --output text</pre><pre># GENERATE EFS TOKEN<br />uuidgen</pre> | AWS-Systemadministrator | 

### Erstellen Sie einen Kubernetes-Namespace und ein verknüpftes Fargate-Profil
<a name="create-a-kubernetes-namespace-and-a-linked-fargate-profile"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Erstellen Sie einen Kubernetes-Namespace und ein Fargate-Profil für Anwendungsworkloads. | Erstellen Sie einen Namespace für den Empfang der Anwendungs-Workloads, die mit Amazon EFS interagieren. Führen Sie das `create-k8s-ns-and-linked-fargate-profile.sh`-Skript aus. Sie können wählen, ob Sie einen benutzerdefinierten Namespace-Namen oder den standardmäßig bereitgestellten Namespace verwenden möchten. `poc-efs-eks-fargate`<br />**Mit einem benutzerdefinierten Anwendungs-Namespace-Namen:**<pre>export $APP_NAMESPACE=<CUSTOM_NAME><br />./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \<br />-c "$CLUSTER_NAME" -n "$APP_NAMESPACE"</pre><br />**Ohne einen benutzerdefinierten Anwendungs-Namespace-Namen:**<pre>./scripts/epic01/create-k8s-ns-and-linked-fargate-profile.sh \<br />    -c "$CLUSTER_NAME"</pre><br />wo `$CLUSTER_NAME` ist der Name Ihres Amazon EKS-Clusters. Der `-n <NAMESPACE>` Parameter ist optional. Wenn Sie nicht darüber informiert werden, wird ein standardmäßig generierter Namespace-Name bereitgestellt. | Kubernetes-Benutzer mit erteilten Berechtigungen | 

### Erstellen eines Amazon EFS-Dateisystems
<a name="create-an-amazon-efs-file-system"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Generieren Sie ein eindeutiges Token. | Amazon EFS benötigt ein Erstellungstoken, um einen idempotenten Vorgang sicherzustellen (der Aufruf des Vorgangs mit demselben Erstellungstoken hat keine Auswirkung). Um diese Anforderung zu erfüllen, müssen Sie mithilfe einer verfügbaren Technik ein eindeutiges Token generieren. Sie können beispielsweise einen Universally Unique Identifier (UUID) generieren, um ihn als Erstellungstoken zu verwenden. | AWS-Systemadministrator | 
| Erstellen Sie ein Amazon EFS-Dateisystem. | Erstellen Sie das Dateisystem für den Empfang der Datendateien, die von den Anwendungsworkloads gelesen und geschrieben werden. Sie können ein verschlüsseltes oder ein unverschlüsseltes Dateisystem erstellen. (Es hat sich bewährt, dass der Code für dieses Muster ein verschlüsseltes System erstellt, sodass die Verschlüsselung im Ruhezustand standardmäßig aktiviert ist.) Sie können einen eindeutigen, symmetrischen AWS-KMS-Schlüssel verwenden, um Ihr Dateisystem zu verschlüsseln. Wenn kein benutzerdefinierter Schlüssel angegeben ist, wird ein von AWS verwalteter Schlüssel verwendet.<br />Verwenden Sie das Skript create-efs.sh, um ein verschlüsseltes oder unverschlüsseltes Amazon EFS-Dateisystem zu erstellen, nachdem Sie ein eindeutiges Token für Amazon EFS generiert haben.<br />**Mit Verschlüsselung im Ruhezustand, ohne KMS-Schlüssel:**<pre>./scripts/epic02/create-efs.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre><br />wo `$CLUSTER_NAME` ist der Name Ihres Amazon EKS-Clusters und `$EFS_CREATION_TOKEN` ist ein eindeutiges Erstellungstoken für das Dateisystem.<br />**Mit Verschlüsselung im Ruhezustand, mit einem KMS-Schlüssel:**<pre>./scripts/epic02/create-efs.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN" \<br />    -k "$KMS_KEY_ALIAS"</pre><br />wobei `$CLUSTER_NAME` der Name Ihres Amazon EKS-Clusters, `$EFS_CREATION_TOKEN` ein eindeutiges Erstellungstoken für das Dateisystem und der Alias für den KMS-Schlüssel `$KMS_KEY_ALIAS` ist.<br />**Ohne Verschlüsselung:**<pre>./scripts/epic02/create-efs.sh -d \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre><br />wobei `$CLUSTER_NAME` der Name Ihres Amazon EKS-Clusters `$EFS_CREATION_TOKEN` steht, ein eindeutiges Erstellungstoken für das Dateisystem ist und die Verschlüsselung im Ruhezustand `–d` deaktiviert. | AWS-Systemadministrator | 
| Erstellen einer Sicherheitsgruppe. | Erstellen Sie eine Sicherheitsgruppe, um dem Amazon EKS-Cluster den Zugriff auf das Amazon EFS-Dateisystem zu ermöglichen. | AWS-Systemadministrator | 
| Aktualisieren Sie die Regel für eingehende Nachrichten für die Sicherheitsgruppe. | Aktualisieren Sie die Regeln für eingehenden Datenverkehr der Sicherheitsgruppe, um eingehenden Datenverkehr für die folgenden Einstellungen zuzulassen:[See the AWS documentation website for more details](http://docs.aws.amazon.com/de_de/prescriptive-guidance/latest/patterns/run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate.html) | AWS-Systemadministrator | 
| Fügen Sie für jedes private Subnetz ein Mount-Ziel hinzu. | Erstellen Sie für jedes private Subnetz des Kubernetes-Clusters ein Mount-Ziel für das Dateisystem und die Sicherheitsgruppe. | AWS-Systemadministrator | 

### Installieren Sie Amazon EFS-Komponenten im Kubernetes-Cluster
<a name="install-amazon-efs-components-into-the-kubernetes-cluster"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Stellen Sie den Amazon EFS CSI-Treiber bereit. | Stellen Sie den Amazon EFS CSI-Treiber im Cluster bereit. Der Treiber stellt Speicher entsprechend den von Anwendungen generierten persistenten Volume-Ansprüchen bereit. Führen Sie das `create-k8s-efs-csi-sc.sh` Skript aus, um den Amazon EFS CSI-Treiber und die Speicherklasse im Cluster bereitzustellen.<pre>./scripts/epic03/create-k8s-efs-csi-sc.sh</pre><br />Dieses Skript verwendet das `kubectl` Hilfsprogramm. Stellen Sie also sicher, dass der Kontext konfiguriert wurde, und verweisen Sie auf den gewünschten Amazon EKS-Cluster. | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie die Speicherklasse bereit. | Stellen Sie die Speicherklasse im Cluster für den Amazon EFS-Provisioner bereit (efs.csi.aws.com). | Kubernetes-Benutzer mit erteilten Berechtigungen | 

### Installieren Sie die PoC-Anwendung im Kubernetes-Cluster
<a name="install-the-poc-application-into-the-kubernetes-cluster"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Stellen Sie das persistente Volume bereit. | Stellen Sie das persistente Volume bereit und verknüpfen Sie es mit der erstellten Speicherklasse und der ID des Amazon EFS-Dateisystems. Die Anwendung verwendet das persistente Volume zum Lesen und Schreiben von Inhalten. Sie können eine beliebige Größe für das persistente Volumen im Speicherfeld angeben. Kubernetes erfordert dieses Feld, aber da Amazon EFS ein elastisches Dateisystem ist, erzwingt es keine Dateisystemkapazität. Sie können das persistente Volume mit oder ohne Verschlüsselung bereitstellen. (Der Amazon EFS CSI-Treiber aktiviert standardmäßig die Verschlüsselung als bewährte Methode.) Führen Sie das `deploy-poc-app.sh` Skript aus, um das persistente Volume, den Anspruch auf persistente Volumes und die beiden Workloads bereitzustellen.<br />**Bei Verschlüsselung während der Übertragung:**<pre>./scripts/epic04/deploy-poc-app.sh \<br />    -t "$EFS_CREATION_TOKEN"</pre><br />wo `$EFS_CREATION_TOKEN` ist das eindeutige Erstellungstoken für das Dateisystem.<br />**Ohne Verschlüsselung bei der Übertragung:**<pre>./scripts/epic04/deploy-poc-app.sh -d \<br />    -t "$EFS_CREATION_TOKEN"</pre><br />wo `$EFS_CREATION_TOKEN` ist das eindeutige Erstellungstoken für das Dateisystem und `–d` deaktiviert die Verschlüsselung bei der Übertragung. | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie den von der Anwendung angeforderten Anspruch auf persistentes Volumen bereit. | Stellen Sie den von der Anwendung angeforderten Anspruch auf beständiges Volumen bereit und verknüpfen Sie ihn mit der Speicherklasse. Verwenden Sie denselben Zugriffsmodus wie das persistente Volume, das Sie zuvor erstellt haben. Sie können im Speicherfeld eine beliebige Größe für den Anspruch auf persistentes Volumen angeben. Kubernetes erfordert dieses Feld, aber da Amazon EFS ein elastisches Dateisystem ist, erzwingt es keine Dateisystemkapazität. | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie Workload 1 bereit. | Stellen Sie den Pod bereit, der Workload 1 der Anwendung darstellt. Dieser Workload schreibt Inhalt in die Datei`/data/out1.txt`. | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie Workload 2 bereit. | Stellen Sie den Pod bereit, der Workload 2 der Anwendung darstellt. Dieser Workload schreibt Inhalt in die Datei`/data/out2.txt`. | Kubernetes-Benutzer mit erteilten Berechtigungen | 

### Überprüfen Sie die Persistenz, Haltbarkeit und gemeinsame Nutzung des Dateisystems
<a name="validate-file-system-persistence-durability-and-shareability"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Überprüfen Sie den Status von`PersistentVolume`. | Geben Sie den folgenden Befehl ein, um den Status von zu überprüfen`PersistentVolume`.<pre>kubectl get pv</pre><br />Eine Beispielausgabe finden Sie im Abschnitt [Zusätzliche Informationen](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Überprüfen Sie den Status von. `PersistentVolumeClaim` | Geben Sie den folgenden Befehl ein, um den Status von zu überprüfen`PersistentVolumeClaim`.<pre>kubectl -n poc-efs-eks-fargate get pvc</pre><br />Eine Beispielausgabe finden Sie im Abschnitt [Zusätzliche Informationen](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional). | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie sicher, dass Workload 1 in das Dateisystem schreiben kann. | Geben Sie den folgenden Befehl ein, um zu überprüfen, ob Workload 1 schreibt`/data/out1.txt`.<pre>kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -f /data/out1.txt</pre><br />Die Ergebnisse ähneln den folgenden:<pre>...<br />Thu Sep  3 15:25:07 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:25:12 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:25:17 UTC 2023 - PoC APP 1<br />...</pre> | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie sicher, dass Workload 2 in das Dateisystem schreiben kann. | Geben Sie den folgenden Befehl ein, um zu überprüfen, ob Workload 2 schreibt`/data/out2.txt`.<pre>kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -f /data/out2.txt</pre><br />Die Ergebnisse ähneln den folgenden:<pre>...<br />Thu Sep  3 15:26:48 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:53 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:58 UTC 2023 - PoC APP 2<br />...</pre> | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie sicher, dass Workload 1 die von Workload 2 geschriebene Datei lesen kann. | Geben Sie den folgenden Befehl ein, um zu überprüfen, ob Workload 1 die von Workload 2 geschriebene `/data/out2.txt` Datei lesen kann.<pre>kubectl exec -ti poc-app1 -n poc-efs-eks-fargate -- tail -n 3 /data/out2.txt</pre><br />Die Ergebnisse ähneln den folgenden:<pre>...<br />Thu Sep  3 15:26:48 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:53 UTC 2023 - PoC APP 2<br />Thu Sep  3 15:26:58 UTC 2023 - PoC APP 2<br />...</pre> | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie sicher, dass Workload 2 die von Workload 1 geschriebene Datei lesen kann. | Geben Sie den folgenden Befehl ein, um zu überprüfen, ob Workload 2 die von Workload 1 geschriebene `/data/out1.txt` Datei lesen kann.<pre>kubectl -n $APP_NAMESPACE exec -ti poc-app2 -- tail -n 3 /data/out1.txt</pre><br />Die Ergebnisse ähneln den folgenden:<pre>...<br />Thu Sep  3 15:29:22 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:29:27 UTC 2023 - PoC APP 1<br />Thu Sep  3 15:29:32 UTC 2023 - PoC APP 1<br />...</pre> | Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Stellen Sie sicher, dass Dateien nach dem Entfernen von Anwendungskomponenten beibehalten werden. | Als Nächstes verwenden Sie ein Skript, um die Anwendungskomponenten (persistentes Volume, Persistentes Volume Claim und Pods) zu entfernen und zu überprüfen, ob die Dateien `/data/out1.txt` im Dateisystem aufbewahrt `/data/out2.txt` werden. Führen Sie das Skript `validate-efs-content.sh` mit dem folgenden Befehl aus.<pre>./scripts/epic05/validate-efs-content.sh \<br />    -t "$EFS_CREATION_TOKEN"</pre><br />wo `$EFS_CREATION_TOKEN` ist das eindeutige Erstellungstoken für das Dateisystem.<br />Die Ergebnisse ähneln den folgenden:<pre>pod/poc-app-validation created<br />Waiting for pod get Running state...<br />Waiting for pod get Running state...<br />Waiting for pod get Running state...<br />Results from execution of 'find /data' on validation process pod:<br />/data<br />/data/out2.txt<br />/data/out1.txt</pre> | Kubernetes-Benutzer mit erteilten Berechtigungen, Systemadministrator | 

### Überwachen Sie den Betrieb
<a name="monitor-operations"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Überwachen Sie Anwendungsprotokolle. | Senden Sie die Anwendungsprotokolle im Rahmen eines Vorgangs am zweiten Tag CloudWatch zur Überwachung an Amazon. | AWS-Systemadministrator, Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Überwachen Sie Amazon EKS- und Kubernetes-Container mit Container Insights. | Überwachen Sie im Rahmen eines Vorgangs am zweiten Tag die Amazon EKS- und Kubernetes-Systeme mithilfe von Amazon CloudWatch Container Insights. Dieses Tool sammelt, aggregiert und fasst Metriken aus containerisierten Anwendungen auf verschiedenen Ebenen und Dimensionen zusammen. [Weitere Informationen finden Sie im Abschnitt Verwandte Ressourcen.](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources) | AWS-Systemadministrator, Kubernetes-Benutzer mit erteilten Berechtigungen | 
| Überwachen Sie Amazon EFS mit CloudWatch. | Überwachen Sie im Rahmen eines Vorgangs am zweiten Tag die Dateisysteme mithilfe von Amazon CloudWatch, das Rohdaten von Amazon EFS sammelt und zu lesbaren Metriken nahezu in Echtzeit verarbeitet. Weitere Informationen finden Sie im Abschnitt [Verwandte Ressourcen](#run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources). | AWS-Systemadministrator | 

### Bereinigen von Ressourcen
<a name="clean-up-resources"></a>


| Aufgabe | Description | Erforderliche Fähigkeiten | 
| --- | --- | --- | 
| Bereinigen Sie alle erstellten Ressourcen für das Muster. | Nachdem Sie dieses Muster abgeschlossen haben, bereinigen Sie alle Ressourcen, um zu vermeiden, dass AWS-Gebühren anfallen. Führen Sie das `clean-up-resources.sh` Skript aus, um alle Ressourcen zu entfernen, nachdem Sie die PoC-Anwendung nicht mehr verwendet haben. Füllen Sie eine der folgenden Optionen aus.<br />**Mit Verschlüsselung im Ruhezustand, mit einem KMS-Schlüssel:**<pre>./scripts/epic06/clean-up-resources.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN" \<br />    -k "$KMS_KEY_ALIAS"</pre><br />wobei `$CLUSTER_NAME` der Name Ihres Amazon EKS-Clusters, `$EFS_CREATION_TOKEN` das Erstellungstoken für das Dateisystem und der Alias für den KMS-Schlüssel `$KMS_KEY_ALIAS` ist.<br />**Ohne Verschlüsselung im Ruhezustand:**<pre>./scripts/epic06/clean-up-resources.sh \<br />    -c "$CLUSTER_NAME" \<br />    -t "$EFS_CREATION_TOKEN"</pre><br />wobei `$CLUSTER_NAME` der Name Ihres Amazon EKS-Clusters und das Erstellungstoken für das Dateisystem `$EFS_CREATION_TOKEN` ist. | Kubernetes-Benutzer mit erteilten Berechtigungen, Systemadministrator | 

## Zugehörige Ressourcen
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-resources"></a>

**Referenzen**
+ [AWS Fargate für Amazon EKS unterstützt jetzt Amazon EFS](https://aws.amazon.com/blogs/aws/new-aws-fargate-for-amazon-eks-now-supports-amazon-efs/) (Ankündigung)
+ [So erfassen Sie Anwendungsprotokolle bei der Verwendung von Amazon EKS auf AWS Fargate](https://aws.amazon.com/blogs/containers/how-to-capture-application-logs-when-using-amazon-eks-on-aws-fargate/) (Blogbeitrag)
+ [Verwenden von Container Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/ContainerInsights.html) ( CloudWatch Amazon-Dokumentation)
+ [Container Insights auf Amazon EKS und Kubernetes einrichten](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/deploy-container-insights-EKS.html) ( CloudWatch Amazon-Dokumentation)
+ [Kennzahlen zu Amazon EKS und Kubernetes Container Insights](https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/Container-Insights-metrics-EKS.html) ( CloudWatch Amazon-Dokumentation)
+ [Überwachung von Amazon EFS mit Amazon CloudWatch](https://docs.aws.amazon.com/efs/latest/ug/monitoring-cloudwatch.html) (Amazon EFS-Dokumentation)

**GitHub Tutorials und Beispiele**
+ [Statische Bereitstellung](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md)
+ [Verschlüsselung während der Übertragung](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/encryption_in_transit/README.md)
+ [Zugriff auf das Dateisystem von mehreren Pods aus](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/multiple_pods/README.md)
+ [Nutzung von Amazon EFS in StatefulSets](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/statefulset/README.md)
+ [Unterpfade werden eingebunden](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/volume_path/README.md)
+ [Verwenden von Amazon EFS-Zugriffspunkten](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/access_points/README.md)
+ [Amazon EKS Blueprints für Terraform](https://aws-ia.github.io/terraform-aws-eks-blueprints/)

**Erforderliche Tools**
+ [Installation der AWS-CLI Version 2](https://docs.aws.amazon.com/cli/latest/userguide/install-cliv2.html)
+ [Installation von eksctl](https://docs.aws.amazon.com/eks/latest/userguide/getting-started-eksctl.html)
+ [Kubectl wird installiert](https://docs.aws.amazon.com/eks/latest/userguide/install-kubectl.html)
+ [jq installieren](https://stedolan.github.io/jq/download/)

## Zusätzliche Informationen
<a name="run-stateful-workloads-with-persistent-data-storage-by-using-amazon-efs-on-amazon-eks-with-aws-fargate-additional"></a>

Im Folgenden finden Sie ein Beispiel für die Ausgabe des `kubectl get pv` Befehls.

```
NAME         CAPACITY   ACCESS MODES   RECLAIM POLICY   STATUS   CLAIM                             STORAGECLASS   REASON   AGE
poc-app-pv   1Mi        RWX            Retain           Bound    poc-efs-eks-fargate/poc-app-pvc   efs-sc                  3m56s
```

Im Folgenden finden Sie ein Beispiel für die Ausgabe des `kubectl -n poc-efs-eks-fargate get pvc` Befehls.

```
NAME          STATUS   VOLUME       CAPACITY   ACCESS MODES   STORAGECLASS   AGE
poc-app-pvc   Bound    poc-app-pv   1Mi        RWX            efs-sc         4m34s
```