**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.
# Verwendung von Anwendungsdatenspeichern für Ihren Cluster
Sie können mit Amazon EKS eine Reihe von AWS Speicherservices für die Speicheranforderungen Ihrer Anwendungen nutzen. Durch eine Vielzahl von AWS unterstützten Container Storage Interface (CSI) -Treibern können Sie Amazon EBS, Amazon S3, Amazon EFS, Amazon FSX und Amazon File Cache problemlos für die Speicheranforderungen Ihrer auf Amazon EKS ausgeführten Anwendungen verwenden. Informationen zur Verwaltung von Backups Ihres Amazon EKS-Clusters finden Sie unter [AWS Backup-Unterstützung für Amazon EKS](https://docs.aws.amazon.com/aws-backup/latest/devguide/working-with-supported-services.html#working-with-eks).
In diesem Kapitel werden Speicheroptionen für Amazon EKS-Cluster behandelt.
**Topics**
+ [Kubernetes-Volume-Speicher mit Amazon EBS verwenden](ebs-csi.md)
+ [Verwendung von elastischem Dateisystemspeicher mit Amazon EFS](efs-csi.md)
+ [Verwendung von leistungsstarkem App-Speicher mit Amazon FSx für Lustre](fsx-csi.md)
+ [Verwendung von leistungsstarkem App-Speicher mit FSx für NetApp ONTAP](fsx-ontap.md)
+ [Datenspeicherung mit Amazon FSx für OpenZFS verwenden](fsx-openzfs-csi.md)
+ [Minimierung der Latenz mit Amazon File Cache](file-cache-csi.md)
+ [Zugriff auf Amazon-S3-Objekte mit dem CSI-Treiber für Mountpoint für Amazon S3](s3-csi.md)
+ [Snapshot-Funktion für CSI-Volumes aktivieren](csi-snapshot-controller.md)
# Kubernetes-Volume-Speicher mit Amazon EBS verwenden
**Anmerkung**
**Neu:** Amazon EKS Auto Mode automatisiert Routineaufgaben für Blockspeicher. Weitere Informationen erhalten Sie unter [Bereitstellung einer Beispiel-Workload mit Statusverwaltung in EKS Auto Mode](sample-storage-workload.md).
Der [Amazon Elastic Block Store (Amazon EBS) Container-Storage-Interface (CSI)-Treiber](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/) verwaltet den Lebenszyklus von Amazon-EBS-Volumes als Speicher für von Ihnen erstellte Kubernetes-Volumes. Der Amazon-EBS-CSI-Treiber erstellt Amazon-EBS-Volumes für diese Arten von Kubernetes-Volumes: generische [flüchtige Volumes](https://kubernetes.io/docs/concepts/storage/ephemeral-volumes/) und [persistente Volumes](https://kubernetes.io/docs/concepts/storage/persistent-volumes/).
## Überlegungen
+ Es ist nicht erforderlich, den Amazon-EBS-CSI-Controller in Clustern von EKS Auto Mode zu installieren.
+ Sie können Amazon-EBS-Volumes nicht in Fargate-Pods mounten.
+ Sie können den Amazon-EBS-CSI-Controller auf Fargate-Knoten ausführen, aber der Amazon-EBS-CSI-Knoten `DaemonSet` kann nur auf Amazon-EC2-Instances ausgeführt werden.
+ Amazon-EBS-Volumes und der Amazon-EBS-CSI-Treiber sind nicht mit Amazon EKS Hybrid Nodes kompatibel.
+ Support wird für die neueste Add-On-Version und eine vorherige Version bereitgestellt. Korrekturen für Fehler oder Sicherheitslücken, die in der neuesten Version gefunden wurden, werden als neue Nebenversion auf die vorherige Version zurückportiert.
+ EKS Auto Mode erfordert, dass Speicherklassen `ebs.csi.eks.amazonaws.com` als Bereitsteller verwenden. Der Standard-Amazon-EBS-CSI-Treiber (`ebs.csi.aws.com`) verwaltet seine eigenen Volumes separat. Um vorhandene Volumes mit EKS Auto Mode zu verwenden, migrieren Sie diese mithilfe von Volume-Snapshots in eine Speicherklasse, die den Bereisteller im Automatikmodus verwendet.
**Wichtig**
Um die Snapshot-Funktionalität des Amazon-EBS-CSI-Treibers nutzen zu können, ist es erforderlich, zunächst den CSI-Snapshot-Controller zu installieren. Weitere Informationen finden Sie unter [Snapshot-Funktion für CSI-Volumes aktivieren](csi-snapshot-controller.md).
## Voraussetzungen
+ Einen vorhandenen -Cluster. Führen Sie den folgenden Befehl aus, um die erforderliche Plattformversion anzuzeigen.
```
aws eks describe-addon-versions --addon-name aws-ebs-csi-driver
```
+ Der EBS-CSI-Treiber benötigt AWS IAM-Berechtigungen.
+ AWS schlägt vor, EKS Pod Identities zu verwenden. Weitere Informationen finden Sie unter [Übersicht über die Einrichtung von EKS-Pod-Identitäten](pod-identities.md#pod-id-setup-overview).
+ Informationen zu IAM-Rollen für Servicekonten finden Sie unter [Erstellen Sie einen IAM-OIDC-Anbieter für Ihren Cluster](enable-iam-roles-for-service-accounts.md).
## Schritt 1: Erstellen einer IAM-Rolle
Das Amazon EBS CSI-Plugin benötigt IAM-Berechtigungen, um in Ihrem Namen Anrufe tätigen AWS APIs zu können. Wenn Sie diese Schritte nicht ausführen, wird beim Versuch, das Add-On zu installieren und `kubectl describe pvc` auszuführen, `failed to provision volume with StorageClass` zusammen mit einem `could not create volume in EC2: UnauthorizedOperation`-Fehler angezeigt. Weitere Informationen finden Sie unter [Treiberberechtigung einrichten](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#set-up-driver-permissions) auf GitHub.
**Anmerkung**
Pods haben Zugriff auf die Berechtigungen, die der IAM-Rolle zugewiesen sind, es sei denn, Sie blockieren den Zugriff auf IMDS. Weitere Informationen finden Sie unter [Amazon-EKS-Cluster mit bewährten Methoden sichern](security-best-practices.md).
Das folgende Verfahren zeigt Ihnen, wie Sie eine IAM-Rolle erstellen und ihr die AWS verwaltete Richtlinie zuordnen. Um dieses Verfahren umzusetzen, können Sie eines dieser Tools verwenden:
+ [`eksctl`](#eksctl_store_app_data)
+ [AWS-Managementkonsole](#console_store_app_data)
+ [AWS CLI](#awscli_store_app_data)
**Anmerkung**
Sie können eine selbstverwaltete Richtlinie mit eingeschränkten Berechtigungen erstellen. Überprüfen Sie [https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEBSCSIDriverPolicy.html](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonEBSCSIDriverPolicy.html) und erstellen Sie eine benutzerdefinierte IAM-Richtlinie mit eingeschränkten Berechtigungen.
**Anmerkung**
Die spezifischen Schritte in diesem Verfahren sind für die Verwendung des Treibers als Amazon-EKS-Add-on geschrieben. Es sind verschiedene Schritte erforderlich, um den Treiber als selbstverwaltetes Add-on zu verwenden. Weitere Informationen finden Sie unter [Fahrerberechtigungen einrichten](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#set-up-driver-permissions) für. GitHub
### `eksctl`
1. Erstellen Sie eine IAM-Rolle und fügen Sie eine Richtlinie hinzu. AWS verwaltet eine AWS verwaltete Richtlinie oder Sie können Ihre eigene benutzerdefinierte Richtlinie erstellen. Sie können eine IAM-Rolle erstellen und die AWS verwaltete Richtlinie mit dem folgenden Befehl anhängen. Ersetzen Sie *my-cluster* mit dem Namen Ihres Clusters. Der Befehl stellt einen AWS CloudFormation Stack bereit, der eine IAM-Rolle erstellt und ihr die IAM-Richtlinie anhängt.
```
eksctl create iamserviceaccount \
--name ebs-csi-controller-sa \
--namespace kube-system \
--cluster my-cluster \
--role-name AmazonEKS_EBS_CSI_DriverRole \
--role-only \
--attach-policy-arn arn:aws: iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
--approve
```
1. Sie können diesen Schritt überspringen, wenn Sie keinen benutzerdefinierten [KMS-Schlüssel](https://aws.amazon.com/kms/) verwenden. Wenn Sie einen zur Verschlüsselung Ihrer Amazon-EBS-Volumes verwenden, passen Sie die IAM-Rolle nach Bedarf an. Führen Sie beispielsweise folgende Schritte aus:
1. Kopieren Sie den folgenden Code und fügen Sie diesen in eine neue `kms-key-for-encryption-on-ebs.json`-Datei ein. Ersetzen Sie *custom-key-arn* durch den benutzerdefinierten [KMS-Schlüssel-ARN](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awskeymanagementservice.html#awskeymanagementservice-key).
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"],
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"]
}
]
}
```
1. Erstellen Sie die Richtlinie. Sie können *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy* in einen anderen Namen ändern. In diesem Fall ändern Sie sie auch in den späteren Schritten.
```
aws iam create-policy \
--policy-name KMS_Key_For_Encryption_On_EBS_Policy \
--policy-document file://kms-key-for-encryption-on-ebs.json
```
1. Hängen Sie die IAM-Richtlinie mit dem folgenden Befehl an die Rolle an. Ersetzen Sie *111122223333* durch Ihre Konto-ID.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::111122223333:policy/KMS_Key_For_Encryption_On_EBS_Policy \
--role-name AmazonEKS_EBS_CSI_DriverRole
```
### AWS-Managementkonsole
1. Öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/
1. Wählen Sie im linken Navigationsbereich **Roles** aus.
1. Klicken Sie auf der Seite **Roles (Rollen)** auf **Create role (Rolle erstellen)**.
1. Gehen Sie auf der Seite **Select trusted entity** (Vertrauenswürdige Entität auswählen) wie folgt vor:
1. Wählen Sie im Abschnitt **Trusted entity type** (Typ der vertrauenswürdigen Entität) die Option **Web identity** (Web-Identität) aus.
1. Wählen Sie für **Identity provider** (Identitätsanbieter) die Option **OpenID Connect provider URL** (OpenID-Connect-Anbieter-URL) für Ihren Cluster aus (wie unter **Overview** (Übersicht) in Amazon EKS gezeigt).
1. Wählen Sie für **Audience (Zielgruppe)** `sts.amazonaws.com`.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Add permissions** (Berechtigungen hinzufügen) wie folgt vor:
1. Geben Sie im Feld **Filter policies (Filterrichtlinien)** `AmazonEBSCSIDriverPolicy` ein.
1. Aktivieren Sie das Kontrollkästchen links neben der `AmazonEBSCSIDriverPolicy`, die bei der Suche zurückgegeben wurde.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Name, review, and create** (Benennen, überprüfen und erstellen) wie folgt vor:
1. Geben Sie unter **Role name** (Rollenname) einen eindeutigen Namen für die Rolle ein, z. B. *AmazonEKS\$1EBS\$1CSI\$1DriverRole*.
1. Fügen Sie der Rolle unter **Tags hinzufügen (optional)** Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Markieren von IAM-Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) im *IAM-Benutzerhandbuch*.
1. Wählen Sie **Create role (Rolle erstellen)** aus.
1. Nachdem die Rolle erstellt wurde, wählen Sie die Rolle in der Konsole aus, um sie zur Bearbeitung zu öffnen.
1. Wählen Sie die Registerkarte **Trust Relationships** (Vertrauensstellungen) und dann **Edit trust policy** (Vertrauensrichtlinie bearbeiten) aus.
1. Suchen Sie die Zeile, die der folgenden Zeile ähnelt:
```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
```
Fügen Sie am Ende der vorherigen Zeile ein Komma hinzu und fügen Sie anschließend die folgende Zeile nach der vorherigen Zeile hinzu. *region-code*Ersetzen Sie durch die AWS Region, in der sich Ihr Cluster befindet. Ersetzen Sie *EXAMPLED539D4633E53DE1B71EXAMPLE* mit dem OIDC-Anbieter-ID Ihres Clusters.
```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:ebs-csi-controller-sa"
```
1. Wählen Sie **Update Policy** (Richtlinie aktualisieren) aus, um den Vorgang abzuschließen.
1. Wenn Sie einen benutzerdefinierten [KMS-Schlüssel](https://aws.amazon.com/kms/) für die Verschlüsselung auf Ihren Amazon-EBS-Volumes verwenden, passen Sie die IAM-Rolle nach Bedarf an. Führen Sie beispielsweise folgende Schritte aus:
1. Wählen Sie im linken Navigationsbereich die Option **Policies** aus.
1. Wählen Sie auf der Seite **Policies** (Richtlinien) die Option **Create a policy** (Richtlinie erstellen).
1. Wählen Sie auf der Seite **Create policy (Richtlinie erstellen)** die Registerkarte **JSON** aus.
1. Kopieren Sie den folgenden Code in den Editor und ersetzen Sie *custom-key-arn* durch den benutzerdefinierten [KMS-Schlüssel-ARN](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awskeymanagementservice.html#awskeymanagementservice-key):
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"],
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"]
}
]
}
```
1. Wählen Sie **Next: Markierungen (Weiter: Markierungen)**.
1. Wählen Sie auf der Seite **Add Tags (optional)** (Tags hinzufügen (optional)) die Option **Next: Review** (Weiter: Prüfen).
1. Geben Sie unter ** Name** einen eindeutigen Namen für Ihre Richtlinie ein (z. B. *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy*).
1. Wählen Sie **Create Policy** (Richtlinie erstellen) aus.
1. Wählen Sie im linken Navigationsbereich **Roles** aus.
1. Wählen Sie ***AmazonEKS\$1EBS\$1CSI\$1DriverRole***in der Konsole das aus, um es zur Bearbeitung zu öffnen.
1. Wählen Sie in der Dropdown-Liste **Add permissions** (Berechtigungen hinzufügen) **Attach policies** (Richtlinien hinzufügen) aus.
1. Geben Sie im Feld **Filter policies (Filterrichtlinien)** *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy* ein.
1. Aktivieren Sie das Kontrollkästchen links neben der *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy*, die bei der Suche zurückgegeben wurde.
1. Wählen Sie **Attach Policies (Richtlinien hinzufügen)**.
### AWS CLI
1. Zeigen Sie die OIDC-Anbieter-URL Ihres Clusters an. Ersetzen Sie *my-cluster* durch Ihren Clusternamen. Wenn die Ausgabe des Befehls `None` ist, überprüfen Sie die **Voraussetzungen**.
```
aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text
```
Eine Beispielausgabe sieht wie folgt aus.
```
https://oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE
```
1. Erstellen Sie die IAM-Rolle und gewähren Sie ihr die `AssumeRoleWithWebIdentity`-Aktion.
1. Kopieren Sie den folgenden Inhalt in eine Datei mit dem Namen `aws-ebs-csi-driver-trust-policy.json`. Ersetzen Sie *111122223333* durch Ihre Konto-ID. Ersetzen Sie *EXAMPLED539D4633E53DE1B71EXAMPLE* und *region-code* mit den im vorherigen Schritt zurückgegebenen Werten.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:ebs-csi-controller-sa"
}
}
}
]
}
```
1. Erstellen Sie die Rolle. Sie können *AmazonEKS\$1EBS\$1CSI\$1DriverRole* in einen anderen Namen ändern. Wenn Sie es ändern, ändern Sie es in späteren Schritten.
```
aws iam create-role \
--role-name AmazonEKS_EBS_CSI_DriverRole \
--assume-role-policy-document file://"aws-ebs-csi-driver-trust-policy.json"
```
1. Hängen Sie eine Richtlinie an. AWS verwaltet eine AWS verwaltete Richtlinie oder Sie können Ihre eigene benutzerdefinierte Richtlinie erstellen. Hängen Sie die AWS verwaltete Richtlinie mit dem folgenden Befehl an die Rolle an.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::aws:policy/service-role/AmazonEBSCSIDriverPolicy \
--role-name AmazonEKS_EBS_CSI_DriverRole
```
1. Wenn Sie einen benutzerdefinierten [KMS-Schlüssel](https://aws.amazon.com/kms/) für die Verschlüsselung auf Ihren Amazon-EBS-Volumes verwenden, passen Sie die IAM-Rolle nach Bedarf an. Führen Sie beispielsweise folgende Schritte aus:
1. Kopieren Sie den folgenden Code und fügen Sie diesen in eine neue `kms-key-for-encryption-on-ebs.json`-Datei ein. Ersetzen Sie *custom-key-arn* durch den benutzerdefinierten [KMS-Schlüssel-ARN](https://docs.aws.amazon.com/service-authorization/latest/reference/list_awskeymanagementservice.html#awskeymanagementservice-key).
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:ListGrants",
"kms:RevokeGrant"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"],
"Condition": {
"Bool": {
"kms:GrantIsForAWSResource": "true"
}
}
},
{
"Effect": "Allow",
"Action": [
"kms:Encrypt",
"kms:Decrypt",
"kms:ReEncrypt*",
"kms:GenerateDataKey*",
"kms:DescribeKey"
],
"Resource": ["arn:aws:kms:us-east-1:123456789012:key/1234abcd-12ab-34cd-56ef-1234567890ab"]
}
]
}
```
1. Erstellen Sie die Richtlinie. Sie können *KMS\$1Key\$1For\$1Encryption\$1On\$1EBS\$1Policy* in einen anderen Namen ändern. In diesem Fall ändern Sie sie auch in den späteren Schritten.
```
aws iam create-policy \
--policy-name KMS_Key_For_Encryption_On_EBS_Policy \
--policy-document file://kms-key-for-encryption-on-ebs.json
```
1. Hängen Sie die IAM-Richtlinie mit dem folgenden Befehl an die Rolle an. Ersetzen Sie *111122223333* durch Ihre Konto-ID.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::111122223333:policy/KMS_Key_For_Encryption_On_EBS_Policy \
--role-name AmazonEKS_EBS_CSI_DriverRole
```
Nachdem Sie die IAM-Rolle des Amazon-EBS-CSI-Treibers erstellt haben, können Sie mit dem nächsten Abschnitt fortfahren. Wenn Sie das Add-on mit dieser IAM-Rolle bereitstellen, wird ein Servicekonto mit dem Namen `ebs-csi-controller-sa` erstellt und für die Verwendung konfiguriert. Das Servicekonto ist an ein Kubernetes `clusterrole` gebunden, dem die erforderlichen Kubernetes-Berechtigungen zugewiesen sind.
## Schritt 2: Amazon-EBS-CSI-Treiber herunterladen
Wir empfehlen Ihnen, den Amazon-EBS-CSI-Treiber über das Amazon-EKS-Add-On zu installieren, um die Sicherheit zu erhöhen und den Arbeitsaufwand zu reduzieren. Wenn Sie ein Amazon-EKS-Add-on zu Ihrem Cluster hinzufügen möchten, lesen Sie [Erstellung eines Amazon-EKS-Add-Ons](creating-an-add-on.md). Weitere Informationen zu Add-ons finden Sie unter [Amazon-EKS-Add-ons](eks-add-ons.md).
**Wichtig**
Bevor Sie den Amazon-EBS-Treiber als Amazon-EKS-Add-On hinzufügen, stellen Sie sicher, dass Sie keine selbstverwaltete Version des Treibers auf Ihrem Cluster installiert haben. Falls ja, siehe [Deinstallation eines selbstverwalteten Amazon-EBS-CSI-Treibers](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md#uninstalling-the-ebs-csi-driver) in GitHub.
**Anmerkung**
Standardmäßig ist die vom EBS-CSI verwendete RBAC-Rolle berechtigt, Knoten zu mutieren, um deren Funktion zum Entfernen von Verunreinigungen zu unterstützen. Aufgrund der Einschränkungen von Kubernetes RBAC kann Kubernetes dadurch auch jeden anderen Knoten im Cluster mutieren. Das Helm-Diagramm hat einen Parameter (`node.serviceAccount.disableMutation`), der die Änderung der Node-RBAC-Berechtigungen für das Dienstkonto deaktiviert. ebs-csi-node Wenn diese Option aktiviert ist, funktionieren Treiberfunktionen wie das Entfernen von Flecken nicht.
Wenn Sie alternativ eine selbstverwaltete Installation des Amazon EBS CSI-Treibers wünschen, finden Sie weitere Informationen unter [Installation](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/blob/master/docs/install.md) auf. GitHub
## Schritt 3: Beispielanwendung bereitstellen
Sie können eine Vielzahl von Beispiel-Apps bereitstellen und diese nach Bedarf ändern. Weitere Informationen finden Sie unter [Kubernetes-Beispiele](https://github.com/kubernetes-sigs/aws-ebs-csi-driver/tree/master/examples/kubernetes) unter. GitHub
# Verwendung von elastischem Dateisystemspeicher mit Amazon EFS
[Amazon Elastic File System](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) (Amazon EFS) bietet vollständig elastischen Serverless-Dateispeicher, sodass Sie Dateidaten gemeinsam nutzen können, ohne Speicherkapazität und Leistung bereitstellen oder verwalten zu müssen. Der [Amazon EFS Container Storage Interface (CSI) -Treiber](https://github.com/kubernetes-sigs/aws-efs-csi-driver) bietet eine CSI-Schnittstelle, über die Kubernetes-Cluster ausgeführt werden, AWS um den Lebenszyklus von Amazon EFS-Dateisystemen zu verwalten. In diesem Thema erfahren Sie, wie Sie den Amazon-EFS-CSI-Treiber für Ihren Amazon-EKS-Cluster bereitstellen.
## Überlegungen
+ Der Amazon-EFS-CSI-Treiber ist nicht mit Windows-basierten Container-Images kompatibel.
+ Sie können die [dynamische Bereitstellung](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/dynamic_provisioning/README.md) für persistente Volumes mit Fargate-Knoten nicht verwenden, aber Sie können die [statische Bereitstellung](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md) verwenden.
+ [Dynamische Bereitstellung](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/dynamic_provisioning/README.md) erfordert Version [1.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v12) oder höher des Treibers. Sie können die [statische Bereitstellung](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/examples/kubernetes/static_provisioning/README.md) für persistente Volumes mithilfe der `1.1`-Version des Treibers in jeder unterstützten Amazon-EKS-Cluster-Version verwenden (siehe [Unterstützte Amazon-EKS-Versionen](https://docs.aws.amazon.com/eks/latest/userguide/kubernetes-versions.html)).
+ Version [1.3.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v132) oder höher dieses Treibers unterstützt die Arm64-Architektur, einschließlich Amazon EC2 Graviton-basierter Instances.
+ Version [1.4.2](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-1.x.md#v142) oder höher dieses Treibers unterstützt die Verwendung von FIPS zum Einbinden von Dateisystemen.
+ Beachten Sie die Ressourcenkontingente für Amazon EFS. Beispielsweise gibt es ein Kontingent von 1 000 Zugriffspunkten, die für jedes Amazon-EFS-Dateisystem erstellt werden können. Weitere Informationen finden Sie unter [Amazon-EFS-Ressourcenkontingente, die Sie nicht ändern können](https://docs.aws.amazon.com/efs/latest/ug/limits.html#limits-efs-resources-per-account-per-region).
+ Ab Version [2.0.0](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/CHANGELOG-2.x.md#v200) wurde bei diesem Treiber für TLS-Verbindungen von der Verwendung von `stunnel` auf `efs-proxy` umgestellt. Bei Verwendung von `efs-proxy` wird eine Anzahl von Threads geöffnet, die eins plus der Anzahl der Kerne des Knotens entspricht, auf dem er ausgeführt wird.
+ Der Amazon-EFS-CSI-Treiber ist mit Amazon EKS Hybrid Nodes nicht kompatibel.
## Voraussetzungen
+ Der Amazon EFS CSI-Treiber benötigt AWS Identity and Access Management (IAM) -Berechtigungen.
+ AWS schlägt vor, EKS Pod Identities zu verwenden. Weitere Informationen finden Sie unter [Übersicht über die Einrichtung von EKS-Pod-Identitäten](pod-identities.md#pod-id-setup-overview).
+ Informationen zu IAM-Rollen für Servicekonten und zum Einrichten eines IAM OpenID Connect (OIDC)-Anbieters für Ihren Cluster finden Sie unter [Erstellen Sie einen IAM-OIDC-Anbieter für Ihren Cluster](enable-iam-roles-for-service-accounts.md).
+ Version `2.12.3` oder höher oder Version `1.27.160` oder höher der auf Ihrem Gerät installierten und konfigurierten AWS Befehlszeilenschnittstelle (AWS CLI) oder AWS CloudShell. Um Ihre aktuelle Version zu überprüfen, verwenden Sie `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Paketmanager wie `yum``apt-get`, oder Homebrew für macOS liegen oft mehrere Versionen hinter der neuesten Version der AWS CLI. Informationen zur Installation der neuesten Version finden Sie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) und [Schnellkonfiguration mit aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle*. Die AWS CLI-Version, in der installiert ist, AWS CloudShell kann auch mehrere Versionen hinter der neuesten Version liegen. Informationen zur Aktualisierung finden Sie im * AWS CloudShell Benutzerhandbuch* unter [AWS CLI in Ihrem Home-Verzeichnis installieren](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software).
+ Das `kubectl`-Befehlszeilen-Tool ist auf Ihrem Gerät oder in der AWS CloudShell installiert. Die Version kann mit der Kubernetes-Version Ihres Clusters identisch sein oder bis zu einer Nebenversion älter oder neuer sein. Wenn Ihre Clusterversion beispielsweise `1.29` ist, können Sie `kubectl`-Version `1.28`, `1.29`, oder `1.30` damit verwenden. Informationen zum Installieren oder Aktualisieren von `kubectl` finden Sie unter [`kubectl` und `eksctl` einrichten](install-kubectl.md).
**Anmerkung**
Ein in Fargate ausgeführter Pod bindet automatisch ein Amazon-EFS-Dateisystem ein, ohne dass manuelle Schritte zur Treiberinstallation erforderlich sind.
## Schritt 1: Erstellen einer IAM-Rolle
Der Amazon-EFS-CSI-Treiber benötigt IAM-Berechtigungen, um mit Ihrem Dateisystem zu interagieren. Erstellen Sie eine IAM-Rolle und fügen Sie ihr die erforderliche AWS verwaltete Richtlinie hinzu. Um dieses Verfahren umzusetzen, können Sie eines dieser Tools verwenden:
+ [`eksctl`](#eksctl_efs_store_app_data)
+ [AWS-Managementkonsole](#console_efs_store_app_data)
+ [AWS CLI](#awscli_efs_store_app_data)
**Anmerkung**
Die spezifischen Schritte in diesem Verfahren sind für die Verwendung des Treibers als Amazon-EKS-Add-on geschrieben. Ausführliche Informationen zu selbstverwalteten Installationen finden Sie auf GitHub unter [Set up driver permission](https://github.com/kubernetes-sigs/aws-efs-csi-driver#set-up-driver-permission).
### `eksctl`
#### Bei Verwendung von Pod Identities
Führen Sie die folgenden Befehle aus, um eine IAM-Rolle und eine Pod-Identity-Zuordnung mit `eksctl` zu erstellen. Ersetzen Sie `my-cluster` mit Ihrem Clusternamen. Sie können `AmazonEKS_EFS_CSI_DriverRole` durch einen anderen Namen ersetzen.
```
export cluster_name=my-cluster
export role_name=AmazonEKS_EFS_CSI_DriverRole
eksctl create podidentityassociation \
--service-account-name efs-csi-controller-sa \
--namespace kube-system \
--cluster $cluster_name \
--role-name $role_name \
--permission-policy-arns arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy
```
#### Bei Verwendung von IAM-Rollen für Servicekonten
Führen Sie die folgenden Befehle aus, um eine IAM-Rolle mit `eksctl` zu erstellen. Ersetzen Sie `my-cluster` mit Ihrem Clusternamen. Sie können `AmazonEKS_EFS_CSI_DriverRole` durch einen anderen Namen ersetzen.
```
export cluster_name=my-cluster
export role_name=AmazonEKS_EFS_CSI_DriverRole
eksctl create iamserviceaccount \
--name efs-csi-controller-sa \
--namespace kube-system \
--cluster $cluster_name \
--role-name $role_name \
--role-only \
--attach-policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
--approve
TRUST_POLICY=$(aws iam get-role --output json --role-name $role_name --query 'Role.AssumeRolePolicyDocument' | \
sed -e 's/efs-csi-controller-sa/efs-csi-*/' -e 's/StringEquals/StringLike/')
aws iam update-assume-role-policy --role-name $role_name --policy-document "$TRUST_POLICY"
```
### AWS-Managementkonsole
Führen Sie den folgenden Befehl aus, um eine IAM-Rolle mit zu erstellen. AWS-Managementkonsole
1. Öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/
1. Wählen Sie im linken Navigationsbereich **Roles** aus.
1. Klicken Sie auf der Seite **Roles (Rollen)** auf **Create role (Rolle erstellen)**.
1. Gehen Sie auf der Seite **Select trusted entity** (Vertrauenswürdige Entität auswählen) wie folgt vor:
1. Bei Verwendung von EKS Pod Identities:
1. Wählen Sie im Abschnitt **Vertrauenswürdiger Entitätstyp** die Option ** AWS Service** aus.
1. Wählen Sie im Dropdown-Menü **Service oder Anwendungsfall** die Option **EKS** aus.
1. Wählen Sie im Abschnitt **Anwendungsfall** die Option **EKS – Pod Identity** aus.
1. Wählen Sie **Weiter** aus.
1. Bei Verwendung von IAM-Rollen für Servicekonten:
1. Wählen Sie im Abschnitt **Trusted entity type** (Typ der vertrauenswürdigen Entität) die Option **Web identity** (Web-Identität) aus.
1. Wählen Sie für **Identity provider** (Identitätsanbieter) die Option **OpenID Connect provider URL** (OpenID-Connect-Anbieter-URL) für Ihren Cluster aus (wie unter **Overview** (Übersicht) in Amazon EKS gezeigt).
1. Wählen Sie für **Audience (Zielgruppe)** `sts.amazonaws.com`.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Add permissions** (Berechtigungen hinzufügen) wie folgt vor:
1. Geben Sie im Feld **Filter policies (Filterrichtlinien)** `AmazonEFSCSIDriverPolicy` ein.
1. Aktivieren Sie das Kontrollkästchen links neben der `AmazonEFSCSIDriverPolicy`, die bei der Suche zurückgegeben wurde.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Name, review, and create** (Benennen, überprüfen und erstellen) wie folgt vor:
1. Geben Sie unter **Role name** (Rollenname) einen eindeutigen Namen für die Rolle ein, z. B. `AmazonEKS_EFS_CSI_DriverRole`.
1. Fügen Sie der Rolle unter **Tags hinzufügen (optional)** Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Markieren von IAM-Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) im *IAM-Benutzerhandbuch*.
1. Wählen Sie **Rolle erstellen** aus.
1. Nachdem die Rolle erstellt wurde:
1. Bei Verwendung von EKS Pod Identities:
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie im linken Navigationsbereich **Cluster** aus und anschließend den Namen des Clusters, für den Sie die EKS-Pod-Identity-Zuordnung konfigurieren möchten.
1. Wählen Sie die Registerkarte **Zugriff** aus.
1. Wählen Sie unter **Pod-Identity-Zuordnungen** die Option **Erstellen** aus.
1. Wählen Sie das Dropdown-Menü **IAM-Rolle** und wählen Sie Ihre neu erstellte Rolle aus.
1. Wählen Sie das Feld **Kubernetes-Namespace** und geben Sie `kube-system` ein.
1. Wählen Sie das Feld **Kubernetes-Servicekonto** und geben Sie `efs-csi-controller-sa` ein.
1. Wählen Sie **Erstellen** aus.
1. Weitere Informationen zum Erstellen von Pod-Identity-Zuordnungen finden Sie unter [Erstellen Sie eine Pod Identity-Zuordnung (AWS Konsole)](pod-id-association.md#pod-id-association-create).
1. Bei Verwendung von IAM-Rollen für Servicekonten:
1. Wählen Sie die Rolle aus, um sie zur Bearbeitung zu öffnen.
1. Wählen Sie die Registerkarte **Trust Relationships** (Vertrauensstellungen) und dann **Edit trust policy** (Vertrauensrichtlinie bearbeiten) aus.
1. Suchen Sie die Zeile, die der folgenden Zeile ähnelt:
```
"oidc.eks.region-code.amazonaws.com/id/:aud": "sts.amazonaws.com"
```
Fügen Sie die folgende Zeile über der vorherigen Zeile hinzu. ``Ersetzen Sie es durch die AWS Region, in der sich Ihr Cluster befindet. Ersetzen Sie `` mit dem OIDC-Anbieter-ID Ihres Clusters.
```
"oidc.eks..amazonaws.com/id/:sub": "system:serviceaccount:kube-system:efs-csi-*",
```
1. Ändern Sie den `Condition`-Operator von `"StringEquals"` zu `"StringLike"`.
1. Wählen Sie **Update Policy** (Richtlinie aktualisieren) aus, um den Vorgang abzuschließen.
### AWS CLI
Führen Sie die folgenden Befehle aus, um eine IAM-Rolle mit AWS CLI zu erstellen.
#### Bei Verwendung von Pod Identities
1. Erstellen Sie die IAM-Rolle, die dem `pods.eks.amazonaws.com`-Service die Aktionen `AssumeRole` und `TagSession` gewährt.
1. Kopieren Sie den folgenden Inhalt in eine Datei namens `aws-efs-csi-driver-trust-policy-pod-identity.json`.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "AllowEksAuthToAssumeRoleForPodIdentity",
"Effect": "Allow",
"Principal": {
"Service": "pods.eks.amazonaws.com"
},
"Action": [
"sts:AssumeRole",
"sts:TagSession"
]
}
]
}
```
1. Erstellen Sie die Rolle. Ersetzen Sie `my-cluster` mit Ihrem Clusternamen. Sie können `AmazonEKS_EFS_CSI_DriverRole` durch einen anderen Namen ersetzen.
```
export cluster_name=my-cluster
export role_name=AmazonEKS_EFS_CSI_DriverRole
aws iam create-role \
--role-name $role_name \
--assume-role-policy-document file://"aws-efs-csi-driver-trust-policy-pod-identity.json"
```
1. Fügen Sie der Rolle mit dem folgenden Befehl die erforderliche AWS verwaltete Richtlinie hinzu.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
--role-name $role_name
```
1. Führen Sie den folgenden Befehl aus, um die Pod-Identity-Zuordnung zu erstellen. Ersetzen Sie ` arn:aws: iam::<111122223333>:role/my-role` durch die in den vorherigen Schritten erstellte Rolle.
```
aws eks create-pod-identity-association --cluster-name $cluster_name --role-arn {arn-aws}iam::<111122223333>:role/my-role --namespace kube-system --service-account efs-csi-controller-sa
```
1. Weitere Informationen zum Erstellen von Pod-Identity-Zuordnungen finden Sie unter [Erstellen Sie eine Pod Identity-Zuordnung (AWS Konsole)](pod-id-association.md#pod-id-association-create).
#### Bei Verwendung von IAM-Rollen für Servicekonten
1. Zeigen Sie die OIDC-Anbieter-URL Ihres Clusters an. Ersetzen Sie `my-cluster` mit Ihrem Clusternamen. Sie können `AmazonEKS_EFS_CSI_DriverRole` durch einen anderen Namen ersetzen.
```
export cluster_name=my-cluster
export role_name=AmazonEKS_EFS_CSI_DriverRole
aws eks describe-cluster --name $cluster_name --query "cluster.identity.oidc.issuer" --output text
```
Eine Beispielausgabe sieht wie folgt aus.
```
https://oidc.eks..amazonaws.com/id/
```
Wenn die Ausgabe des Befehls `None` ist, überprüfen Sie die **Voraussetzungen**.
1. Erstellen Sie die IAM-Rolle, die die Aktion `AssumeRoleWithWebIdentity` erlaubt.
1. Kopieren Sie den folgenden Inhalt in eine Datei namens `aws-efs-csi-driver-trust-policy.json`. Ersetzen Sie `<111122223333>` durch Ihre Konto-ID. Ersetzen Sie `` und `` mit den im vorherigen Schritt zurückgegebenen Werten.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::123456789012:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringLike": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:efs-csi-*",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
}
}
}
]
}
```
1. Erstellen Sie die Rolle.
```
aws iam create-role \
--role-name $role_name \
--assume-role-policy-document file://"aws-efs-csi-driver-trust-policy.json"
```
1. Fügen Sie der Rolle mit dem folgenden Befehl die erforderliche AWS verwaltete Richtlinie hinzu.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::aws:policy/service-role/AmazonEFSCSIDriverPolicy \
--role-name $role_name
```
## Schritt 2: Amazon-EFS-CSI-Treiber herunterladen
Wir empfehlen, den Amazon-EFS-CSI-Treiber über das Amazon-EKS-Add-on zu installieren. Wenn Sie ein Amazon-EKS-Add-on zu Ihrem Cluster hinzufügen möchten, lesen Sie [Erstellung eines Amazon-EKS-Add-Ons](creating-an-add-on.md). Weitere Informationen zu Add-ons finden Sie unter [Amazon-EKS-Add-ons](eks-add-ons.md). Wenn Sie das Amazon EKS-Add-on nicht verwenden können, empfehlen wir Ihnen, ein Problem mit der Begründung, warum Sie das nicht können, an das [ GitHub Container-Roadmap-Repository](https://github.com/aws/containers-roadmap/issues) zu senden.
**Wichtig**
Bevor Sie den Amazon-EFS-Treiber als Amazon-EKS-Add-On hinzufügen, vergewissern Sie sich, dass auf Ihrem Cluster keine selbstverwaltete Version des Treibers installiert ist. Falls ja, finden Sie weitere Informationen unter [Deinstallieren des Amazon EFS CSI-Treibers](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/README.md#uninstalling-the-amazon-efs-csi-driver) auf GitHub.
Wenn Sie alternativ eine selbstverwaltete Installation des Amazon-EFS-CSI-Treibers wünschen, finden Sie Informationen unter [Installation](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/README.md#installation) in GitHub.
## Schritt 3: Erstellen eines Amazon EFS-Dateisystems
Informationen zum Erstellen eines Amazon-EFS-Dateisystems finden Sie unter [Erstellen eines Amazon-EFS-Dateisystems für Amazon EKS](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/efs-create-filesystem.md) in GitHub.
## Schritt 4: Beispielanwendung bereitstellen
Sie können eine Vielzahl von Beispiel-Apps bereitstellen und diese nach Bedarf ändern. Weitere Informationen finden Sie unter [Beispiele](https://github.com/kubernetes-sigs/aws-efs-csi-driver/blob/master/docs/README.md#examples) unter GitHub.
# Verwendung von leistungsstarkem App-Speicher mit Amazon FSx für Lustre
Der [Treiber für Amazon FSx für Lustre Container Storage Interface (CSI)](https://github.com/kubernetes-sigs/aws-fsx-csi-driver) bietet eine CSI-Schnittstelle, mit der Amazon-EKS-Cluster den Lebenszyklus von FSx-für-Lustre-Dateisystemen verwalten können. Weitere Informationen finden Sie im [Benutzerhandbuch zu Amazon FSx für Lustre](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html).
Einzelheiten zum Bereitstellen des CSI-Treibers für Amazon FSx für Lustre in Ihrem Amazon-EKS-Cluster und zum Überprüfen seiner Funktion finden Sie unter [Stellen Sie den FSx for Lustre-Treiber bereit](fsx-csi-create.md).
# Stellen Sie den FSx for Lustre-Treiber bereit
In diesem Thema erfahren Sie, wie Sie den [FSx for Lustre CSI-Treiber](fsx-csi.md) in Ihrem Amazon EKS-Cluster bereitstellen und überprüfen, ob er funktioniert. Wir empfehlen die neueste Version des Treibers zu verwenden. Die verfügbaren Versionen finden Sie in der [Kompatibilitätsmatrix der CSI-Spezifikation](https://github.com/kubernetes-sigs/aws-fsx-csi-driver/blob/master/docs/README.md#csi-specification-compatibility-matrix) unter GitHub.
**Anmerkung**
Der Treiber wird in Fargate oder Amazon EKS Hybrid Nodes nicht unterstützt.
Eine ausführliche Beschreibung der verfügbaren Parameter und vollständige Beispiele zur Veranschaulichung der Treiberfunktionen finden Sie im [Treiberprojekt FSx for Lustre Container Storage Interface (CSI)](https://github.com/kubernetes-sigs/aws-fsx-csi-driver) unter GitHub.
## Voraussetzungen
+ Einen vorhandenen -Cluster.
+ Das Amazon FSx CSI Driver EKS-Add-On benötigt den EKS Pod Identity-Agenten für die Authentifizierung. Ohne diese Komponente schlägt das Add-On mit dem Fehler `Amazon EKS Pod Identity agent is not installed in the cluster` fehl, wodurch Volume-Operationen verhindert werden. Installieren Sie den Pod Identity-Agenten vor oder nach der Bereitstellung des FSx CSI-Treiber-Add-ons. Weitere Informationen finden Sie unter [Einrichtung des Amazon-EKS-Pod-Identity-Agenten](pod-id-agent-setup.md).
+ Version `2.12.3` oder höher oder Version `1.27.160` oder höher der auf Ihrem Gerät installierten und konfigurierten AWS Befehlszeilenschnittstelle (AWS CLI) oder AWS CloudShell. Um Ihre aktuelle Version zu überprüfen, verwenden Sie `aws --version | cut -d / -f2 | cut -d ' ' -f1`. Paketmanager wie `yum``apt-get`, oder Homebrew für macOS liegen oft mehrere Versionen hinter der neuesten Version der AWS CLI. Informationen zur Installation der neuesten Version finden Sie unter [Installation](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-install.html) und [Schnellkonfiguration mit aws configure](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) im *Benutzerhandbuch für die AWS Befehlszeilenschnittstelle*. Die AWS CLI-Version, in der installiert ist, AWS CloudShell kann auch mehrere Versionen hinter der neuesten Version liegen. Informationen zur Aktualisierung finden Sie im * AWS CloudShell Benutzerhandbuch* unter [AWS CLI in Ihrem Home-Verzeichnis installieren](https://docs.aws.amazon.com/cloudshell/latest/userguide/vm-specs.html#install-cli-software).
+ Version `0.215.0` oder höher des `eksctl`-Befehlszeilen-Tools, das auf Ihrem Computer oder in der AWS CloudShell installiert ist. Informationen zum Installieren und Aktualisieren von `eksctl` finden Sie in der Dokumentation zu `eksctl` unter [Installation](https://eksctl.io/installation).
+ Das `kubectl`-Befehlszeilen-Tool ist auf Ihrem Gerät oder in der AWS CloudShell installiert. Die Version kann mit der Kubernetes-Version Ihres Clusters identisch sein oder bis zu einer Nebenversion älter oder neuer sein. Wenn Ihre Clusterversion beispielsweise `1.29` ist, können Sie `kubectl`-Version `1.28`, `1.29`, oder `1.30` damit verwenden. Informationen zum Installieren oder Aktualisieren von `kubectl` finden Sie unter [`kubectl` und `eksctl` einrichten](install-kubectl.md).
## Schritt 1: Erstellen einer IAM-Rolle
Das Amazon FSx CSI-Plugin benötigt IAM-Berechtigungen, um in Ihrem Namen Anrufe tätigen AWS APIs zu können.
**Anmerkung**
Pods haben Zugriff auf die Berechtigungen, die der IAM-Rolle zugewiesen sind, es sei denn, Sie blockieren den Zugriff auf IMDS. Weitere Informationen finden Sie unter [Amazon-EKS-Cluster mit bewährten Methoden sichern](security-best-practices.md).
Das folgende Verfahren zeigt Ihnen, wie Sie eine IAM-Rolle erstellen und ihr die AWS verwaltete Richtlinie zuordnen.
1. Erstellen Sie eine IAM-Rolle und fügen Sie die AWS verwaltete Richtlinie mit dem folgenden Befehl an. Ersetzen Sie `my-cluster` durch den Namen des Clusters, den Sie verwenden möchten. Der Befehl stellt einen AWS CloudFormation Stack bereit, der eine IAM-Rolle erstellt und ihr die IAM-Richtlinie anhängt.
```
eksctl create iamserviceaccount \
--name fsx-csi-controller-sa \
--namespace kube-system \
--cluster my-cluster \
--role-name AmazonEKS_FSx_CSI_DriverRole \
--role-only \
--attach-policy-arn arn:aws: iam::aws:policy/AmazonFSxFullAccess \
--approve
```
Beim Erstellen des Servicekontos werden Ihnen mehrere Ausgabezeilen angezeigt. Die letzten Ausgabezeilen ähneln den folgenden.
```
[ℹ] 1 task: {
2 sequential sub-tasks: {
create IAM role for serviceaccount "kube-system/fsx-csi-controller-sa",
create serviceaccount "kube-system/fsx-csi-controller-sa",
} }
[ℹ] building iamserviceaccount stack "eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa"
[ℹ] deploying stack "eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa"
[ℹ] waiting for CloudFormation stack "eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa"
[ℹ] created serviceaccount "kube-system/fsx-csi-controller-sa"
```
Notieren Sie sich den Namen des AWS CloudFormation Stacks, der bereitgestellt wurde. In der vorigen Beispielausgabe lautet der Name des Stacks `eksctl-my-cluster-addon-iamserviceaccount-kube-system-fsx-csi-controller-sa`.
Nachdem Sie die IAM-Rolle des Amazon FSx CSI-Treibers erstellt haben, können Sie mit dem nächsten Abschnitt fortfahren. Wenn Sie das Add-on mit dieser IAM-Rolle bereitstellen, wird ein Servicekonto mit dem Namen `fsx-csi-controller-sa` erstellt und für die Verwendung konfiguriert. Das Servicekonto ist an ein Kubernetes `clusterrole` gebunden, dem die erforderlichen Kubernetes-Berechtigungen zugewiesen sind.
## Schritt 2: Installieren Sie den Amazon FSx CSI-Treiber
Wir empfehlen, den Amazon FSx CSI-Treiber über das Amazon EKS-Add-on zu installieren, um die Sicherheit zu verbessern und den Arbeitsaufwand zu reduzieren. Wenn Sie ein Amazon-EKS-Add-on zu Ihrem Cluster hinzufügen möchten, lesen Sie [Erstellung eines Amazon-EKS-Add-Ons](creating-an-add-on.md). Weitere Informationen zu Add-ons finden Sie unter [Amazon-EKS-Add-ons](eks-add-ons.md).
**Wichtig**
Bereits vorhandene Amazon FSx CSI-Treiberinstallationen im Cluster können zu Fehlern bei der Installation von Add-Ons führen. Wenn Sie versuchen, die Amazon EKS-Add-On-Version zu installieren, während ein FSx Nicht-EKS-CSI-Treiber vorhanden ist, schlägt die Installation aufgrund von Ressourcenkonflikten fehl. Verwenden Sie während der Installation das `OVERWRITE`-Flag, um dieses Problem zu beheben.
```
aws eks create-addon --addon-name aws-fsx-csi-driver --cluster-name my-cluster --resolve-conflicts OVERWRITE
```
Wenn Sie alternativ eine selbstverwaltete Installation des Amazon FSx CSI-Treibers wünschen, finden Sie weitere Informationen unter [Installation](https://github.com/kubernetes-sigs/aws-fsx-csi-driver/blob/master/docs/install.md) auf GitHub.
## Schritt 3: Speicherklasse, persistenter Volume-Anspruchs und Beispiel-App bereitstellen
Bei diesem Verfahren wird das [ GitHub Treiber-Repository FSx für Lustre Container Storage Interface (CSI)](https://github.com/kubernetes-sigs/aws-fsx-csi-driver) verwendet, um ein dynamisch FSx bereitgestelltes Volume für Lustre zu nutzen.
1. Beachten Sie die Sicherheitsgruppe für Ihren Cluster. Sie können es im AWS-Managementkonsole Abschnitt **Netzwerk** oder mit dem folgenden AWS CLI-Befehl sehen. Ersetzen Sie `my-cluster` durch den Namen des Clusters, den Sie verwenden möchten.
```
aws eks describe-cluster --name my-cluster --query cluster.resourcesVpcConfig.clusterSecurityGroupId
```
1. Erstellen Sie eine Sicherheitsgruppe für Ihr FSx Amazon-Dateisystem gemäß den Kriterien, die im [Amazon FSx for Lustre-Benutzerhandbuch unter Amazon VPC-Sicherheitsgruppen](https://docs.aws.amazon.com/fsx/latest/LustreGuide/limit-access-security-groups.html#fsx-vpc-security-groups) aufgeführt sind. Als **VPC** wählen Sie die VPC Ihres Clusters aus, die im Abschnitt **Networking** (Netzwerk) gezeigt wird. Unter „the security groups associated with your Lustre clients“ (die mit Ihren Lustre-Clients verknüpften Sicherheitsgruppen) wählen Sie Ihre Cluster-Sicherheitsgruppe aus. Wenn Sie keine Regeln für ausgehenden Datenverkehr festlegen, können Sie den **All traffic** (gesamten Datenverkehr) erlauben.
1. Laden Sie das Speicherklassen-Manifest mit dem folgenden Befehl herunter.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-fsx-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/storageclass.yaml
```
1. Bearbeiten Sie den Parameterabschnitt in der Datei `storageclass.yaml`. Ersetzen Sie jeden Beispielwert durch Ihre eigenen Werte.
```
parameters:
subnetId: subnet-0eabfaa81fb22bcaf
securityGroupIds: sg-068000ccf82dfba88
deploymentType: PERSISTENT_1
automaticBackupRetentionDays: "1"
dailyAutomaticBackupStartTime: "00:00"
copyTagsToBackups: "true"
perUnitStorageThroughput: "200"
dataCompressionType: "NONE"
weeklyMaintenanceStartTime: "7:09:00"
fileSystemTypeVersion: "2.12"
```
+ **`subnetId`**— Die Subnetz-ID, in der das Amazon FSx for Lustre-Dateisystem erstellt werden soll. Amazon FSx for Lustre wird nicht in allen Availability Zones unterstützt. Öffnen Sie die Amazon FSx for Lustre-Konsole unter, https://console.aws.amazon.com/fsx/ um zu bestätigen, dass sich das Subnetz, das Sie verwenden möchten, in einer unterstützten Availability Zone befindet. Das Subnetz kann Ihre Knoten enthalten oder ein anderes Subnetz oder eine andere VPC sein:
+ **Sie können nach den Knoten-Subnetzen in der suchen, AWS-Managementkonsole indem Sie die Knotengruppe im Abschnitt Compute auswählen.**
+ Wenn das von Ihnen angegebene Subnetz nicht dasselbe Subnetz ist, in dem Sie Knoten haben, VPCs müssen Sie [verbunden](https://docs.aws.amazon.com/whitepapers/latest/aws-vpc-connectivity-options/amazon-vpc-to-amazon-vpc-connectivity-options.html) sein und sicherstellen, dass die erforderlichen Ports in Ihren Sicherheitsgruppen geöffnet sind.
+ ** `securityGroupIds` ** – Die ID der Sicherheitsgruppe, die Sie für das Dateisystem erstellt haben.
+ ** `deploymentType` (optional)** – Der Bereitstellungstyp des Dateisystems. Gültige Werte sind `SCRATCH_1`, `SCRATCH_2`, `PERSISTENT_1` und `PERSISTENT_2`. Weitere Informationen zu Bereitstellungstypen finden Sie unter [Erstellen Sie Ihr Amazon FSx for Lustre-Dateisystem](https://docs.aws.amazon.com/fsx/latest/LustreGuide/getting-started-step1.html).
+ **andere Parameter (optional)** — Informationen zu den anderen Parametern finden Sie unter [Bearbeiten StorageClass](https://github.com/kubernetes-sigs/aws-fsx-csi-driver/tree/master/examples/kubernetes/dynamic_provisioning#edit-storageclass) am GitHub.
1. Erstellen Sie das Speicherklassen-Manifest.
```
kubectl apply -f storageclass.yaml
```
Eine Beispielausgabe sieht wie folgt aus.
```
storageclass.storage.k8s.io/fsx-sc created
```
1. Laden Sie das Manifest für den dauerhaften Volume-Anspruch herunter.
```
curl -O https://raw.githubusercontent.com/kubernetes-sigs/aws-fsx-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/claim.yaml
```
1. (Optional) Bearbeiten Sie die `claim.yaml`-Datei. Ändern Sie `1200Gi` in einen der folgenden Inkrementwerte, basierend auf Ihren Speicheranforderungen und dem `deploymentType`, den Sie in einem vorherigen Schritt ausgewählt haben.
```
storage: 1200Gi
```
+ `SCRATCH_2` und `PERSISTENT` – `1.2 TiB`, `2.4 TiB` oder Schritte von 2,4 TiB über 2,4 TiB.
+ `SCRATCH_1` – `1.2 TiB`, `2.4 TiB`, `3.6 TiB` oder Schritte von 3,6 TiB über 3,6 TiB.
1. Erstellen Sie den dauerhaften Volume-Anspruch.
```
kubectl apply -f claim.yaml
```
Eine Beispielausgabe sieht wie folgt aus.
```
persistentvolumeclaim/fsx-claim created
```
1. Vergewissern Sie sich, dass das Dateisystem bereitgestellt wurde.
```
kubectl describe pvc
```
Eine Beispielausgabe sieht wie folgt aus.
```
Name: fsx-claim
Namespace: default
StorageClass: fsx-sc
Status: Bound
[...]
```
**Anmerkung**
Der `Status` kann für 5-10 Minuten als `Pending` angezeigt werden, bevor er zu `Bound` wechselt. Fahren Sie nicht mit dem nächsten Schritt fort, bis der `Status` `Bound` ist. Wenn der `Status` länger als 10 Minuten `Pending` anzeigt, verwenden Sie die Warnmeldungen in den `Events` als Referenz zur Behebung von Problemen.
1. Stellen Sie die Beispielanwendung bereit.
```
kubectl apply -f https://raw.githubusercontent.com/kubernetes-sigs/aws-fsx-csi-driver/master/examples/kubernetes/dynamic_provisioning/specs/pod.yaml
```
1. Stellen Sie sicher, dass die Beispielanwendung ausgeführt wird.
```
kubectl get pods
```
Eine Beispielausgabe sieht wie folgt aus.
```
NAME READY STATUS RESTARTS AGE
fsx-app 1/1 Running 0 8s
```
1. Überprüfen Sie, ob das Dateisystem ordnungsgemäß von der Anwendung aufgespielt wurde.
```
kubectl exec -ti fsx-app -- df -h
```
Eine Beispielausgabe sieht wie folgt aus.
```
Filesystem Size Used Avail Use% Mounted on
overlay 80G 4.0G 77G 5% /
tmpfs 64M 0 64M 0% /dev
tmpfs 3.8G 0 3.8G 0% /sys/fs/cgroup
192.0.2.0@tcp:/abcdef01 1.1T 7.8M 1.1T 1% /data
/dev/nvme0n1p1 80G 4.0G 77G 5% /etc/hosts
shm 64M 0 64M 0% /dev/shm
tmpfs 6.9G 12K 6.9G 1% /run/secrets/kubernetes.io/serviceaccount
tmpfs 3.8G 0 3.8G 0% /proc/acpi
tmpfs 3.8G 0 3.8G 0% /sys/firmware
```
1. Stellen Sie sicher, dass Daten von der Beispiel-App in das FSx for Lustre-Dateisystem geschrieben wurden.
```
kubectl exec -it fsx-app -- ls /data
```
Eine Beispielausgabe sieht wie folgt aus.
```
out.txt
```
Diese Beispielausgabe zeigt, dass die Beispiel-App erfolgreich die `out.txt`-Datei in das Dateisystem geschrieben hat.
**Anmerkung**
Stellen Sie vor dem Löschen des Clusters sicher, dass Sie das FSx for Lustre-Dateisystem löschen. Weitere Informationen finden Sie unter [Ressourcen bereinigen](https://docs.aws.amazon.com/fsx/latest/LustreGuide/getting-started-step4.html) im *FSx for Lustre-Benutzerhandbuch*.
## Leistungssteigerung für FSx für Lustre
Wenn Sie FSx for Lustre mit Amazon EKS verwenden, können Sie die Leistung optimieren, indem Sie Lustre-Tunings während der Knoteninitialisierung anwenden. Der empfohlene Ansatz besteht darin, Startvorlagen-Benutzerdaten zu verwenden, um eine konsistente Konfiguration auf allen Knoten sicherzustellen.
Diese Optimierungen umfassen:
+ Netzwerk- und RPC-Optimierungen
+ Lustre-Modulverwaltung
+ LRU-Abstimmungen (Lock Resource Unit)
+ Einstellungen für die Client-Cache-Steuerung
+ RPC-Steuerungen für OST und MDC
Für detaillierte Anweisungen zur Implementierung dieser Leistungsoptimierungen:
+ Zur Optimierung der Leistung für Standardknoten (nicht EFA) finden Sie unter [Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (ohne EFA)](fsx-csi-tuning-non-efa.md) ein vollständiges Skript, das Sie zu Ihren Benutzerdaten der Startvorlage hinzufügen können.
+ Informationen zur Optimierung der Leistung für EFA-fähige Knoten finden Sie unter [Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (EFA)](fsx-csi-tuning-efa.md).
# Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (EFA)
In diesem Thema wird beschrieben, wie Sie das Elastic Fabric Adapter (EFA) -Tuning mit Amazon EKS und Amazon FSx for Lustre einrichten.
**Anmerkung**
Informationen zur Erstellung und Bereitstellung des CSI-Treibers FSx für Lustre finden Sie unter. [Stellen Sie den FSx for Lustre-Treiber bereit](fsx-csi-create.md)
Informationen zur Optimierung von Standardknoten ohne EFA finden Sie unter [Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (ohne EFA)](fsx-csi-tuning-non-efa.md).
## Schritt 1. EKS-Cluster erstellen
Erstellen Sie einen Cluster unter Verwendung der bereitgestellten Konfigurationsdatei:
```
# Create cluster using efa-cluster.yaml
eksctl create cluster -f efa-cluster.yaml
```
Beispiel: `efa-cluster.yaml`
```
#efa-cluster.yaml
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: csi-fsx
region: us-east-1
version: "1.30"
iam:
withOIDC: true
availabilityZones: ["us-east-1a", "us-east-1d"]
managedNodeGroups:
- name: my-efa-ng
instanceType: c6gn.16xlarge
minSize: 1
desiredCapacity: 1
maxSize: 1
availabilityZones: ["us-east-1b"]
volumeSize: 300
privateNetworking: true
amiFamily: Ubuntu2204
efaEnabled: true
preBootstrapCommands:
- |
#!/bin/bash
eth_intf="$(/sbin/ip -br -4 a sh | grep $(hostname -i)/ | awk '{print $1}')"
efa_version=$(modinfo efa | awk '/^version:/ {print $2}' | sed 's/[^0-9.]//g')
min_efa_version="2.12.1"
if [[ "$(printf '%s\n' "$min_efa_version" "$efa_version" | sort -V | head -n1)" != "$min_efa_version" ]]; then
sudo curl -O https://efa-installer.amazonaws.com/aws-efa-installer-1.37.0.tar.gz
tar -xf aws-efa-installer-1.37.0.tar.gz && cd aws-efa-installer
echo "Installing EFA driver"
sudo apt-get update && apt-get upgrade -y
sudo apt install -y pciutils environment-modules libnl-3-dev libnl-route-3-200 libnl-route-3-dev dkms
sudo ./efa_installer.sh -y
modinfo efa
else
echo "Using EFA driver version $efa_version"
fi
echo "Installing Lustre client"
sudo wget -O - https://fsx-lustre-client-repo-public-keys.s3.amazonaws.com/fsx-ubuntu-public-key.asc | gpg --dearmor | sudo tee /usr/share/keyrings/fsx-ubuntu-public-key.gpg > /dev/null
sudo echo "deb [signed-by=/usr/share/keyrings/fsx-ubuntu-public-key.gpg] https://fsx-lustre-client-repo.s3.amazonaws.com/ubuntu jammy main" > /etc/apt/sources.list.d/fsxlustreclientrepo.list
sudo apt update | tail
sudo apt install -y lustre-client-modules-$(uname -r) amazon-ec2-utils | tail
modinfo lustre
echo "Loading Lustre/EFA modules..."
sudo /sbin/modprobe lnet
sudo /sbin/modprobe kefalnd ipif_name="$eth_intf"
sudo /sbin/modprobe ksocklnd
sudo lnetctl lnet configure
echo "Configuring TCP interface..."
sudo lnetctl net del --net tcp 2> /dev/null
sudo lnetctl net add --net tcp --if $eth_intf
# For P5 instance type which supports 32 network cards,
# by default add 8 EFA interfaces selecting every 4th device (1 per PCI bus)
echo "Configuring EFA interface(s)..."
instance_type="$(ec2-metadata --instance-type | awk '{ print $2 }')"
num_efa_devices="$(ls -1 /sys/class/infiniband | wc -l)"
echo "Found $num_efa_devices available EFA device(s)"
if [[ "$instance_type" == "p5.48xlarge" || "$instance_type" == "p5e.48xlarge" ]]; then
for intf in $(ls -1 /sys/class/infiniband | awk 'NR % 4 == 1'); do
sudo lnetctl net add --net efa --if $intf --peer-credits 32
done
else
# Other instances: Configure 2 EFA interfaces by default if the instance supports multiple network cards,
# or 1 interface for single network card instances
# Can be modified to add more interfaces if instance type supports it
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | head -n1) --peer-credits 32
if [[ $num_efa_devices -gt 1 ]]; then
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | tail -n1) --peer-credits 32
fi
fi
echo "Setting discovery and UDSP rule"
sudo lnetctl set discovery 1
sudo lnetctl udsp add --src efa --priority 0
sudo /sbin/modprobe lustre
sudo lnetctl net show
echo "Added $(sudo lnetctl net show | grep -c '@efa') EFA interface(s)"
```
## Schritt 2. Knotengruppen erstellen
EFA-fähige Knotengruppe erstellen:
```
# Create node group using efa-ng.yaml
eksctl create nodegroup -f efa-ng.yaml
```
**Wichtig**
=== Passen Sie diese Werte in Abschnitt `# 5. Mount FSx filesystem` an Ihre Umgebung an.
```
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
```
===
Beispiel`efa-ng.yaml`:
```
apiVersion: eksctl.io/v1alpha5
kind: ClusterConfig
metadata:
name: final-efa
region: us-east-1
managedNodeGroups:
- name: ng-1
instanceType: c6gn.16xlarge
minSize: 1
desiredCapacity: 1
maxSize: 1
availabilityZones: ["us-east-1a"]
volumeSize: 300
privateNetworking: true
amiFamily: Ubuntu2204
efaEnabled: true
preBootstrapCommands:
- |
#!/bin/bash
exec 1> >(logger -s -t $(basename $0)) 2>&1
#########################################################################################
# Configuration Section #
#########################################################################################
# File System Configuration
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
# Lustre Tuning Parameters
LUSTRE_LRU_MAX_AGE=600000
LUSTRE_MAX_CACHED_MB=64
LUSTRE_OST_MAX_RPC=32
LUSTRE_MDC_MAX_RPC=64
LUSTRE_MDC_MOD_RPC=50
# File paths
FUNCTIONS_SCRIPT="/usr/local/bin/lustre_functions.sh"
TUNINGS_SCRIPT="/usr/local/bin/apply_lustre_tunings.sh"
SERVICE_FILE="/etc/systemd/system/lustre-tunings.service"
#EFA
MIN_EFA_VERSION="2.12.1"
# Function to check if a command was successful
check_success() {
if [ $? -eq 0 ]; then
echo "SUCCESS: $1"
else
echo "FAILED: $1"
return 1
fi
}
echo "********Starting FSx for Lustre configuration********"
# 1. Install Lustre client
if grep -q '^ID=ubuntu' /etc/os-release; then
echo "Detected Ubuntu, proceeding with Lustre setup..."
# Add Lustre repository
sudo wget -O - https://fsx-lustre-client-repo-public-keys.s3.amazonaws.com/fsx-ubuntu-public-key.asc | sudo gpg --dearmor | sudo tee /usr/share/keyrings/fsx-ubuntu-public-key.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/fsx-ubuntu-public-key.gpg] https://fsx-lustre-client-repo.s3.amazonaws.com/ubuntu jammy main" | sudo tee /etc/apt/sources.list.d/fsxlustreclientrepo.list
sudo apt-get update
sudo apt-get install -y lustre-client-modules-$(uname -r)
sudo apt-get install -y lustre-client
else
echo "Not Ubuntu, exiting"
exit 1
fi
check_success "Install Lustre client"
# Ensure Lustre tools are in the PATH
export PATH=$PATH:/usr/sbin
# 2. Apply network and RPC tunings
echo "********Applying network and RPC tunings********"
if ! grep -q "options ptlrpc ptlrpcd_per_cpt_max" /etc/modprobe.d/modprobe.conf; then
echo "options ptlrpc ptlrpcd_per_cpt_max=64" | sudo tee -a /etc/modprobe.d/modprobe.conf
check_success "Set ptlrpcd_per_cpt_max"
else
echo "ptlrpcd_per_cpt_max already set in modprobe.conf"
fi
if ! grep -q "options ksocklnd credits" /etc/modprobe.d/modprobe.conf; then
echo "options ksocklnd credits=2560" | sudo tee -a /etc/modprobe.d/modprobe.conf
check_success "Set ksocklnd credits"
else
echo "ksocklnd credits already set in modprobe.conf"
fi
# 3. Load Lustre modules
manage_lustre_modules() {
echo "Checking for existing Lustre modules..."
if lsmod | grep -q lustre; then
echo "Existing Lustre modules found."
# Check for mounted Lustre filesystems
echo "Checking for mounted Lustre filesystems..."
if mount | grep -q "type lustre"; then
echo "Found mounted Lustre filesystems. Attempting to unmount..."
mounted_fs=$(mount | grep "type lustre" | awk '{print $3}')
for fs in $mounted_fs; do
echo "Unmounting $fs"
sudo umount $fs
check_success "Unmount filesystem $fs"
done
else
echo "No Lustre filesystems mounted."
fi
# After unmounting, try to remove modules
echo "Attempting to remove Lustre modules..."
sudo lustre_rmmod
if [ $? -eq 0 ]; then
echo "SUCCESS: Removed existing Lustre modules"
else
echo "WARNING: Could not remove Lustre modules. They may still be in use."
echo "Please check for any remaining Lustre processes or mounts."
return 1
fi
else
echo "No existing Lustre modules found."
fi
echo "Loading Lustre modules..."
sudo modprobe lustre
check_success "Load Lustre modules" || exit 1
echo "Checking loaded Lustre modules:"
lsmod | grep lustre
}
# Managing Lustre kernel modules
echo "********Managing Lustre kernel modules********"
manage_lustre_modules
# 4. Initializing Lustre networking
echo "********Initializing Lustre networking********"
sudo lctl network up
check_success "Initialize Lustre networking" || exit 1
# 4.5 EFA Setup and Configuration
setup_efa() {
echo "********Starting EFA Setup********"
# Get interface and version information
eth_intf="$(/sbin/ip -br -4 a sh | grep $(hostname -i)/ | awk '{print $1}')"
efa_version=$(modinfo efa | awk '/^version:/ {print $2}' | sed 's/[^0-9.]//g')
min_efa_version=$MIN_EFA_VERSION
# Install or verify EFA driver
if [[ "$(printf '%s\n' "$min_efa_version" "$efa_version" | sort -V | head -n1)" != "$min_efa_version" ]]; then
echo "Installing EFA driver..."
sudo curl -O https://efa-installer.amazonaws.com/aws-efa-installer-1.37.0.tar.gz
tar -xf aws-efa-installer-1.37.0.tar.gz && cd aws-efa-installer
# Install dependencies
sudo apt-get update && apt-get upgrade -y
sudo apt install -y pciutils environment-modules libnl-3-dev libnl-route-3-200 libnl-route-3-dev dkms
# Install EFA
sudo ./efa_installer.sh -y
modinfo efa
else
echo "Using existing EFA driver version $efa_version"
fi
}
configure_efa_network() {
echo "********Configuring EFA Network********"
# Load required modules
echo "Loading network modules..."
sudo /sbin/modprobe lnet
sudo /sbin/modprobe kefalnd ipif_name="$eth_intf"
sudo /sbin/modprobe ksocklnd
# Initialize LNet
echo "Initializing LNet..."
sudo lnetctl lnet configure
# Configure TCP interface
echo "Configuring TCP interface..."
sudo lnetctl net del --net tcp 2> /dev/null
sudo lnetctl net add --net tcp --if $eth_intf
# For P5 instance type which supports 32 network cards,
# by default add 8 EFA interfaces selecting every 4th device (1 per PCI bus)
echo "Configuring EFA interface(s)..."
instance_type="$(ec2-metadata --instance-type | awk '{ print $2 }')"
num_efa_devices="$(ls -1 /sys/class/infiniband | wc -l)"
echo "Found $num_efa_devices available EFA device(s)"
if [[ "$instance_type" == "p5.48xlarge" || "$instance_type" == "p5e.48xlarge" ]]; then
# P5 instance configuration
for intf in $(ls -1 /sys/class/infiniband | awk 'NR % 4 == 1'); do
sudo lnetctl net add --net efa --if $intf --peer-credits 32
done
else
# Standard configuration
# Other instances: Configure 2 EFA interfaces by default if the instance supports multiple network cards,
# or 1 interface for single network card instances
# Can be modified to add more interfaces if instance type supports it
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | head -n1) --peer-credits 32
if [[ $num_efa_devices -gt 1 ]]; then
sudo lnetctl net add --net efa --if $(ls -1 /sys/class/infiniband | tail -n1) --peer-credits 32
fi
fi
# Configure discovery and UDSP
echo "Setting up discovery and UDSP rules..."
sudo lnetctl set discovery 1
sudo lnetctl udsp add --src efa --priority 0
sudo /sbin/modprobe lustre
# Verify configuration
echo "Verifying EFA network configuration..."
sudo lnetctl net show
echo "Added $(sudo lnetctl net show | grep -c '@efa') EFA interface(s)"
}
# Main execution
setup_efa
configure_efa_network
# 5. Mount FSx filesystem
if [ ! -z "$FSX_DNS" ] && [ ! -z "$MOUNT_NAME" ]; then
echo "********Creating mount point********"
sudo mkdir -p $MOUNT_POINT
check_success "Create mount point"
echo "Mounting FSx filesystem..."
sudo mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} ${MOUNT_POINT}
check_success "Mount FSx filesystem"
else
echo "Skipping FSx mount as DNS or mount name is not provided"
fi
# 6. Applying Lustre performance tunings
echo "********Applying Lustre performance tunings********"
# Get number of CPUs
NUM_CPUS=$(nproc)
# Calculate LRU size (100 * number of CPUs)
LRU_SIZE=$((100 * NUM_CPUS))
#Apply LRU tunings
echo "Apply LRU tunings"
sudo lctl set_param ldlm.namespaces.*.lru_max_age=${LUSTRE_LRU_MAX_AGE}
check_success "Set lru_max_age"
sudo lctl set_param ldlm.namespaces.*.lru_size=$LRU_SIZE
check_success "Set lru_size"
# Client Cache Control
sudo lctl set_param llite.*.max_cached_mb=${LUSTRE_MAX_CACHED_MB}
check_success "Set max_cached_mb"
# RPC Controls
sudo lctl set_param osc.*OST*.max_rpcs_in_flight=${LUSTRE_OST_MAX_RPC}
check_success "Set OST max_rpcs_in_flight"
sudo lctl set_param mdc.*.max_rpcs_in_flight=${LUSTRE_MDC_MAX_RPC}
check_success "Set MDC max_rpcs_in_flight"
sudo lctl set_param mdc.*.max_mod_rpcs_in_flight=${LUSTRE_MDC_MOD_RPC}
check_success "Set MDC max_mod_rpcs_in_flight"
# 7. Verify all tunings
echo "********Verifying all tunings********"
# Function to verify parameter value
verify_param() {
local param=$1
local expected=$2
local actual=$3
if [ "$actual" == "$expected" ]; then
echo "SUCCESS: $param is correctly set to $expected"
else
echo "WARNING: $param is set to $actual (expected $expected)"
fi
}
echo "Verifying all parameters:"
# LRU tunings
actual_lru_max_age=$(lctl get_param -n ldlm.namespaces.*.lru_max_age | head -1)
verify_param "lru_max_age" "600000" "$actual_lru_max_age"
actual_lru_size=$(lctl get_param -n ldlm.namespaces.*.lru_size | head -1)
verify_param "lru_size" "$LRU_SIZE" "$actual_lru_size"
# Client Cache
actual_max_cached_mb=$(lctl get_param -n llite.*.max_cached_mb | grep "max_cached_mb:" | awk '{print $2}')
verify_param "max_cached_mb" "64" "$actual_max_cached_mb"
# RPC Controls
actual_ost_rpcs=$(lctl get_param -n osc.*OST*.max_rpcs_in_flight | head -1)
verify_param "OST max_rpcs_in_flight" "32" "$actual_ost_rpcs"
actual_mdc_rpcs=$(lctl get_param -n mdc.*.max_rpcs_in_flight | head -1)
verify_param "MDC max_rpcs_in_flight" "64" "$actual_mdc_rpcs"
actual_mdc_mod_rpcs=$(lctl get_param -n mdc.*.max_mod_rpcs_in_flight | head -1)
verify_param "MDC max_mod_rpcs_in_flight" "50" "$actual_mdc_mod_rpcs"
# Network and RPC configurations from modprobe.conf
actual_ptlrpc=$(grep "ptlrpc ptlrpcd_per_cpt_max" /etc/modprobe.d/modprobe.conf | awk '{print $3}')
verify_param "ptlrpcd_per_cpt_max" "ptlrpcd_per_cpt_max=64" "$actual_ptlrpc"
actual_ksocklnd=$(grep "ksocklnd credits" /etc/modprobe.d/modprobe.conf | awk '{print $3}')
verify_param "ksocklnd credits" "credits=2560" "$actual_ksocklnd"
# 8. Setup persistence
setup_persistence() {
# Create functions file
cat << EOF > $FUNCTIONS_SCRIPT
#!/bin/bash
apply_lustre_tunings() {
local NUM_CPUS=\$(nproc)
local LRU_SIZE=\$((100 * NUM_CPUS))
echo "Applying Lustre performance tunings..."
lctl set_param ldlm.namespaces.*.lru_max_age=$LUSTRE_LRU_MAX_AGE
lctl set_param ldlm.namespaces.*.lru_size=\$LRU_SIZE
lctl set_param llite.*.max_cached_mb=$LUSTRE_MAX_CACHED_MB
lctl set_param osc.*OST*.max_rpcs_in_flight=$LUSTRE_OST_MAX_RPC
lctl set_param mdc.*.max_rpcs_in_flight=$LUSTRE_MDC_MAX_RPC
lctl set_param mdc.*.max_mod_rpcs_in_flight=$LUSTRE_MDC_MOD_RPC
}
EOF
# Create tuning script
cat << EOF > $TUNINGS_SCRIPT
#!/bin/bash
exec 1> >(logger -s -t \$(basename \$0)) 2>&1
source $FUNCTIONS_SCRIPT
# Function to check if Lustre is mounted
is_lustre_mounted() {
mount | grep -q "type lustre"
}
# Function to mount Lustre
mount_lustre() {
echo "Mounting Lustre filesystem..."
mkdir -p $MOUNT_POINT
mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} $MOUNT_POINT
return \$?
}
# Main execution
# Try to mount if not already mounted
if ! is_lustre_mounted; then
echo "Lustre filesystem not mounted, attempting to mount..."
mount_lustre
fi
# Wait for successful mount (up to 5 minutes)
for i in {1..30}; do
if is_lustre_mounted; then
echo "Lustre filesystem mounted, applying tunings..."
apply_lustre_tunings
exit 0
fi
echo "Waiting for Lustre filesystem to be mounted... (attempt $i/30)"
sleep 10
done
echo "Timeout waiting for Lustre filesystem mount"
exit 1
EOF
# Create systemd service
# Create systemd directory if it doesn't exist
sudo mkdir -p /etc/systemd/system/
# Create service file directly for Ubuntu
cat << EOF > $SERVICE_FILE
[Unit]
Description=Apply Lustre Performance Tunings
After=network.target remote-fs.target
[Service]
Type=oneshot
ExecStart=/bin/bash -c 'source $FUNCTIONS_SCRIPT && $TUNINGS_SCRIPT'
RemainAfterExit=yes
[Install]
WantedBy=multi-user.target
EOF
# Make scripts executable and enable service
sudo chmod +x $FUNCTIONS_SCRIPT
sudo chmod +x $TUNINGS_SCRIPT
systemctl enable lustre-tunings.service
systemctl start lustre-tunings.service
}
echo "********Setting up persistent tuning********"
setup_persistence
echo "FSx for Lustre configuration completed."
```
## (Optional) Schritt 3. EFA-Einrichtung überprüfen
SSH inherhalb Knoten:
```
# Get instance ID from EKS console or {aws} CLI
ssh -i /path/to/your-key.pem ec2-user@
```
EFA-Konfiguration überprüfen:
```
sudo lnetctl net show
```
Einrichtungsprotokolle überprüfen:
```
sudo cat /var/log/cloud-init-output.log
```
Hier ist ein Beispiel für die erwartete Ausgabe für `lnetctl net show`:
```
net:
- net type: tcp
...
- net type: efa
local NI(s):
- nid: xxx.xxx.xxx.xxx@efa
status: up
```
## Beispiel-Bereitstellungen
### a. claim.yaml erstellen
```
#claim.yaml
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
name: fsx-claim-efa
spec:
accessModes:
- ReadWriteMany
storageClassName: ""
resources:
requests:
storage: 4800Gi
volumeName: fsx-pv
```
Anspruch anwenden:
```
kubectl apply -f claim.yaml
```
### b. pv.yaml erstellen
Aktualisieren Sie das``:
```
#pv.yaml
apiVersion: v1
kind: PersistentVolume
metadata:
name: fsx-pv
spec:
capacity:
storage: 4800Gi
volumeMode: Filesystem
accessModes:
- ReadWriteMany
mountOptions:
- flock
persistentVolumeReclaimPolicy: Recycle
csi:
driver: fsx.csi.aws.com
volumeHandle: fs-<1234567890abcdef0>
volumeAttributes:
dnsname: fs-<1234567890abcdef0>.fsx.us-east-1.amazonaws.com
mountname:
```
Persistentes Volumen anwenden:
```
kubectl apply -f pv.yaml
```
### c. pod.yaml erstellen
```
#pod.yaml
apiVersion: v1
kind: Pod
metadata:
name: fsx-efa-app
spec:
containers:
- name: app
image: amazonlinux:2
command: ["/bin/sh"]
args: ["-c", "while true; do dd if=/dev/urandom bs=100M count=20 > data/test_file; sleep 10; done"]
resources:
requests:
vpc.amazonaws.com/efa: 1
limits:
vpc.amazonaws.com/efa: 1
volumeMounts:
- name: persistent-storage
mountPath: /data
volumes:
- name: persistent-storage
persistentVolumeClaim:
claimName: fsx-claim-efa
```
Pod anwenden:
```
kubectl apply -f pod.yaml
```
## Zusätzliche Überprüfungsbefehle
Überprüfung der Einbindung des Pods und des Schreibvorgangs in das Dateisystem:
```
kubectl exec -ti fsx-efa-app -- df -h | grep data
# Expected output:
# <192.0.2.0>@tcp:/ 4.5T 1.2G 4.5T 1% /data
kubectl exec -ti fsx-efa-app -- ls /data
# Expected output:
# test_file
```
SSH-Verbindung zum Knoten herstellen, um zu überprüfen, ob der Datenverkehr über EFA läuft:
```
sudo lnetctl net show -v
```
Die erwartete Ausgabe zeigt EFA-Schnittstellen mit Datenverkehrsstatistiken an.
## Ähnliche Informationen
+ [Stellen Sie den FSx for Lustre-Treiber bereit](fsx-csi-create.md)
+ [Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (ohne EFA)](fsx-csi-tuning-non-efa.md)
+ [Amazon FSx für Lustre Performance](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html)
+ [Elastic Fabric Adapter](https://docs.aws.amazon.com/ec2/latest/userguide/efa.html)
# Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (ohne EFA)
Sie können die Leistung von Amazon FSx for Lustre optimieren, indem Sie während der Knoteninitialisierung mithilfe von Benutzerdaten der Startvorlage Optimierungsparameter anwenden.
**Anmerkung**
Informationen zur Erstellung und Bereitstellung des CSI-Treibers FSx für Lustre finden Sie unter. [Stellen Sie den FSx for Lustre-Treiber bereit](fsx-csi-create.md) Informationen zur Leistungsoptimierung mit EFA-fähigen Knoten finden Sie unter [Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (EFA)](fsx-csi-tuning-efa.md).
## Warum Benutzerdaten von Startvorlagen verwenden?
+ Wendet Optimierungen automatisch während der Knoten-Initialisierung an.
+ Gewährleistet eine konsistente Konfiguration auf allen Knoten.
+ Macht die manuelle Knotenkonfiguration überflüssig.
## Übersicht über das Beispiel-Skript
Das in diesem Thema definierte Beispiel-Skript führt die folgenden Vorgänge aus:
### `# 1. Install Lustre client`
+ Erkennt automatisch Ihre Amazon Linux (AL) Betriebssystemversion.
+ Installation des entsprechenden Lustre-Client-Pakets.
### `# 2. Apply network and RPC tunings`
+ Festlegen von `ptlrpcd_per_cpt_max=64` für die parallele RPC-Verarbeitung.
+ Konfiguriert `ksocklnd credits=2560` zur Optimierung der Netzwerkpuffer.
### `# 3. Load Lustre modules`
+ Sichere Entfernung vorhandener Lustre-Module, falls vorhanden.
+ Entfernt vorhandene eingebundene Dateisysteme.
+ Lädt aktuelle Lustre-Module.
### `# 4. Lustre Network Initialization`
+ Initialisiert die Lustre-Netzwerkkonfiguration.
+ Richtet die erforderlichen Netzwerkparameter ein.
### `# 5. Mount FSx filesystem`
+ In diesem Abschnitt müssen Sie die Werte für Ihre Umgebung anpassen.
### `# 6. Apply tunings`
+ LRU-Abstimmungen (Lock Resource Unit):
+ `lru_max_age=600000`
+ `lru_size` berechnet basierend auf der CPU-Anzahl
+ Client-Cache-Steuerung: `max_cached_mb=64`
+ RPC-Steuerungen
+ OST `max_rpcs_in_flight=32`
+ MDC `max_rpcs_in_flight=64`
+ MDC `max_mod_rpcs_in_flight=50`
### `# 7. Verify tunings`
+ Überprüft alle angewendeten Abstimmungen.
+ Meldet Erfolg oder Warnung für jeden Parameter.
### `# 8. Setup persistence`
+ Auch in diesem Abschnitt müssen Sie die Werte für Ihre Umgebung anpassen.
+ Erkennt automatisch Ihre Betriebssystemversion (AL2023), um zu bestimmen, welcher `Systemd` Service angewendet werden soll.
+ Das System startet.
+ `Systemd` startet den `lustre-tunings`-Service (aufgrund von `WantedBy=multi-user.target`).
+ Service führt `apply_lustre_tunings.sh` aus, das:
+ Überprüft, ob das Dateisystem eingebunden ist.
+ Bindet das Dateisystem, falls es noch nicht eingebunden ist.
+ Wartet auf erfolgreiche Einbindung (bis zu fünf Minuten).
+ Wendet nach erfolgreicher Einbindung die Abstimmungsparameter an.
+ Einstellungen bleiben bis zum Neustart aktiv.
+ Service wird nach Abschluss des Skripts beendet.
+ Systemd kennzeichnet den Service als „aktiv (beendet)“.
+ Der Vorgang wiederholt sich beim nächsten Neustart.
## Erstellen einer Startvorlage
1. Öffnen Sie die EC2 Amazon-Konsole unter https://console.aws.amazon.com/ec2/.
1. Wählen Sie **Startvorlagen** aus.
1. Wählen Sie **Startvorlage erstellen**.
1. Suchen Sie unter **Erweiterte Details** den Abschnitt **Benutzerdaten**.
1. Fügen Sie das folgende Skript ein und aktualisieren Sie es nach Bedarf.
**Wichtig**
Passen Sie diese Werte sowohl im Abschnitt `# 5. Mount FSx filesystem` als auch in der `setup_persistence()`-Funktion von `apply_lustre_tunings.sh` im Abschnitt `# 8. Setup persistence` an Ihre Umgebung an:
```
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
```
```
MIME-Version: 1.0
Content-Type: multipart/mixed; boundary="==MYBOUNDARY=="
--==MYBOUNDARY==
Content-Type: text/x-shellscript; charset="us-ascii"
#!/bin/bash
exec 1> >(logger -s -t $(basename $0)) 2>&1
# Function definitions
check_success() {
if [ $? -eq 0 ]; then
echo "SUCCESS: $1"
else
echo "FAILED: $1"
return 1
fi
}
apply_tunings() {
local NUM_CPUS=$(nproc)
local LRU_SIZE=$((100 * NUM_CPUS))
local params=(
"ldlm.namespaces.*.lru_max_age=600000"
"ldlm.namespaces.*.lru_size=$LRU_SIZE"
"llite.*.max_cached_mb=64"
"osc.*OST*.max_rpcs_in_flight=32"
"mdc.*.max_rpcs_in_flight=64"
"mdc.*.max_mod_rpcs_in_flight=50"
)
for param in "${params[@]}"; do
lctl set_param $param
check_success "Set ${param%%=*}"
done
}
verify_param() {
local param=$1
local expected=$2
local actual=$3
if [ "$actual" == "$expected" ]; then
echo "SUCCESS: $param is correctly set to $expected"
else
echo "WARNING: $param is set to $actual (expected $expected)"
fi
}
verify_tunings() {
local NUM_CPUS=$(nproc)
local LRU_SIZE=$((100 * NUM_CPUS))
local params=(
"ldlm.namespaces.*.lru_max_age:600000"
"ldlm.namespaces.*.lru_size:$LRU_SIZE"
"llite.*.max_cached_mb:64"
"osc.*OST*.max_rpcs_in_flight:32"
"mdc.*.max_rpcs_in_flight:64"
"mdc.*.max_mod_rpcs_in_flight:50"
)
echo "Verifying all parameters:"
for param in "${params[@]}"; do
name="${param%%:*}"
expected="${param#*:}"
actual=$(lctl get_param -n $name | head -1)
verify_param "${name##*.}" "$expected" "$actual"
done
}
setup_persistence() {
# Create functions file
cat << 'EOF' > /usr/local/bin/lustre_functions.sh
#!/bin/bash
apply_lustre_tunings() {
local NUM_CPUS=$(nproc)
local LRU_SIZE=$((100 * NUM_CPUS))
echo "Applying Lustre performance tunings..."
lctl set_param ldlm.namespaces.*.lru_max_age=600000
lctl set_param ldlm.namespaces.*.lru_size=$LRU_SIZE
lctl set_param llite.*.max_cached_mb=64
lctl set_param osc.*OST*.max_rpcs_in_flight=32
lctl set_param mdc.*.max_rpcs_in_flight=64
lctl set_param mdc.*.max_mod_rpcs_in_flight=50
}
EOF
# Create tuning script
cat << 'EOF' > /usr/local/bin/apply_lustre_tunings.sh
#!/bin/bash
exec 1> >(logger -s -t $(basename $0)) 2>&1
# Source the functions
source /usr/local/bin/lustre_functions.sh
# FSx details
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
# Function to check if Lustre is mounted
is_lustre_mounted() {
mount | grep -q "type lustre"
}
# Function to mount Lustre
mount_lustre() {
echo "Mounting Lustre filesystem..."
mkdir -p ${MOUNT_POINT}
mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} ${MOUNT_POINT}
return $?
}
# Main execution
# Try to mount if not already mounted
if ! is_lustre_mounted; then
echo "Lustre filesystem not mounted, attempting to mount..."
mount_lustre
fi
# Wait for successful mount (up to 5 minutes)
for i in {1..30}; do
if is_lustre_mounted; then
echo "Lustre filesystem mounted, applying tunings..."
apply_lustre_tunings
exit 0
fi
echo "Waiting for Lustre filesystem to be mounted... (attempt $i/30)"
sleep 10
done
echo "Timeout waiting for Lustre filesystem mount"
exit 1
EOF
# Create systemd service
cat << 'EOF' > /etc/systemd/system/lustre-tunings.service
[Unit]
Description=Apply Lustre Performance Tunings
After=network.target remote-fs.target
StartLimitIntervalSec=0
[Service]
Type=oneshot
ExecStart=/usr/local/bin/apply_lustre_tunings.sh
RemainAfterExit=yes
Restart=on-failure
RestartSec=30
[Install]
WantedBy=multi-user.target
EOF
chmod +x /usr/local/bin/lustre_functions.sh
chmod +x /usr/local/bin/apply_lustre_tunings.sh
systemctl enable lustre-tunings.service
systemctl start lustre-tunings.service
}
echo "Starting FSx for Lustre configuration..."
# 1. Install Lustre client
if grep -q 'VERSION="2"' /etc/os-release; then
amazon-linux-extras install -y lustre
elif grep -q 'VERSION="2023"' /etc/os-release; then
dnf install -y lustre-client
fi
check_success "Install Lustre client"
# 2. Apply network and RPC tunings
export PATH=$PATH:/usr/sbin
echo "Applying network and RPC tunings..."
if ! grep -q "options ptlrpc ptlrpcd_per_cpt_max" /etc/modprobe.d/modprobe.conf; then
echo "options ptlrpc ptlrpcd_per_cpt_max=64" | tee -a /etc/modprobe.d/modprobe.conf
echo "options ksocklnd credits=2560" | tee -a /etc/modprobe.d/modprobe.conf
fi
# 3. Load Lustre modules
modprobe lustre
check_success "Load Lustre modules" || exit 1
# 4. Lustre Network Initialization
lctl network up
check_success "Initialize Lustre networking" || exit 1
# 5. Mount FSx filesystem
FSX_DNS="" # Needs to be adjusted.
MOUNT_NAME="" # Needs to be adjusted.
MOUNT_POINT="" # Needs to be adjusted.
if [ ! -z "$FSX_DNS" ] && [ ! -z "$MOUNT_NAME" ]; then
mkdir -p $MOUNT_POINT
mount -t lustre ${FSX_DNS}@tcp:/${MOUNT_NAME} ${MOUNT_POINT}
check_success "Mount FSx filesystem"
fi
# 6. Apply tunings
apply_tunings
# 7. Verify tunings
verify_tunings
# 8. Setup persistence
setup_persistence
echo "FSx for Lustre configuration completed."
--==MYBOUNDARY==--
```
1. Wählen Sie beim Erstellen von Amazon-EKS-Knotengruppen diese Startvorlage aus. Weitere Informationen finden Sie unter [Eine verwaltete Knotengruppe für Ihren Cluster erstellen](create-managed-node-group.md).
## Ähnliche Informationen
+ [Stellen Sie den FSx for Lustre-Treiber bereit](fsx-csi-create.md)
+ [Optimieren Sie die Leistung von Amazon FSx for Lustre auf Knoten (EFA)](fsx-csi-tuning-efa.md)
+ [Amazon FSx für Lustre Performance](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html)
# Verwendung von leistungsstarkem App-Speicher mit FSx für NetApp ONTAP
Der NetApp Trident bietet dynamische Speicher-Orchestrierung mithilfe eines Container Storage Interface (CSI)-kompatiblen Treibers. Das ermöglicht es Amazon-EKS-Clustern, den Lebenszyklus persistenter Volumes (PVs) zu verwalten, die von Amazon-FSx-für-NetApp-ONTAP Dateisystemen gestützt werden. Beachten Sie, dass der CSI-Treiber für Amazon FSx für NetApp ONTAP nicht mit Amazon EKS Hybrid Nodes kompatibel ist. Informationen zu den ersten Schritten finden Sie unter [Verwendung von Trident mit Amazon FSx für NetApp ONTAP](https://docs.netapp.com/us-en/trident/trident-use/trident-fsx.html) in der NetApp-Trident-Dokumentation.
Amazon FSx für NetApp ONTAP ist ein Speicher-Service, mit dem Sie vollständig verwaltete ONTAP-Dateisysteme in der Cloud starten und ausführen können. ONTAP ist die Dateisystem-Technologie von NetApp, die eine weit verbreitete Reihe von Datenzugriffs- und Datenverwaltungs-Funktionen bietet. FSx für ONTAP bietet die Feature, Leistung und APIs von On-Premises-NetApp-Dateisysteme mit der Agilität, Skalierbarkeit und Einfachheit eines vollständig verwalteten AWS-Services. Weitere Informationen finden Sie im [FSx für ONTAP-Benutzerhandbuch](https://docs.aws.amazon.com/fsx/latest/ONTAPGuide/what-is-fsx-ontap.html).
**Wichtig**
Wenn Sie Amazon FSx für NetApp ONTAP zusammen mit dem Amazon-EBS-CSI-Treiber verwenden, um EBS-Volumes bereitzustellen, müssen Sie in der `multipath.conf`-Datei angeben, dass keine EBS-Geräte verwendet werden sollen. Unterstützte Methoden finden Sie unter [Blacklist der Konfigurationsdatei](https://docs.redhat.com/en/documentation/red_hat_enterprise_linux/7/html/dm_multipath/config_file_blacklist#config_file_blacklist). Ein Beispiel.
```
defaults {
user_friendly_names yes
find_multipaths no
}
blacklist {
device {
vendor "NVME"
product "Amazon Elastic Block Store"
}
}
```
# Datenspeicherung mit Amazon FSx für OpenZFS verwenden
Amazon FSx für OpenZFS ist ein vollständig verwalteter Dateispeicherservice, der das Verschieben von Daten zu AWS von On-Premises-ZFS- oder anderen Linux-basierten Dateiservern erleichtert. Sie können dies tun, ohne Ihren Anwendungscode oder die Art und Weise, wie Sie Daten verwalten, zu ändern. Es bietet einen äußerst zuverlässigen, skalierbaren, effizienten und featurereichen Dateispeicher, der auf dem Open-Source-Dateisystem OpenZFS basiert. Es kombiniert diese Funktionen mit der Agilität, Skalierbarkeit und Einfachheit eines vollständig verwalteten AWS-Services. Weitere Informationen finden Sie im [Benutzerhandbuch für Amazon FSx für OpenZFS](https://docs.aws.amazon.com/fsx/latest/OpenZFSGuide/what-is-fsx.html).
Der FSx für OpenZFS Container Storage Interface (CSI)-Treiber bietet eine CSI-Schnittstelle, die es Amazon-EKS-Clustern ermöglicht, den Lebenszyklus von FSx für OpenZFS-Volumes zu verwalten. Beachten Sie, dass der Amazon FSx für OpenZFS-CSI-Treiber nicht mit Amazon EKS Hybrid Nodes kompatibel ist. Informationen zum Bereitstellen des CSI-Treibers für FSx für OpenZFS in Ihrem Amazon-EKS-Cluster finden Sie unter [aws-fsx-openzfs-csi-driver](https://github.com/kubernetes-sigs/aws-fsx-openzfs-csi-driver) auf GitHub.
# Minimierung der Latenz mit Amazon File Cache
Amazon File Cache ist ein vollständig verwalteter Hochgeschwindigkeits-Cache in AWS, der zur Verarbeitung von Dateidaten verwendet wird, unabhängig davon, wo die Daten gespeichert sind. Amazon File Cache lädt Daten automatisch in den Cache, wenn sie zum ersten Mal abgerufen werden, und gibt sie frei, wenn sie nicht verwendet werden. Weitere Informationen finden Sie in [Benutzerhandbuch zu Amazon File Cache](https://docs.aws.amazon.com/fsx/latest/FileCacheGuide/what-is.html).
Der Container Storage Interface (CSI)-Treiber für Amazon File Cache bietet eine CSI-Schnittstelle, die es Amazon-EKS-Clustern ermöglicht, den Lebenszyklus von Amazon-Datei-Caches zu verwalten. Beachten Sie, dass der Amazon-File-Cache-CSI-Treiber nicht mit Amazon EKS Hybrid Nodes kompatibel ist. Informationen zur Bereitstellung des Amazon-File-Cache-CSI-Treibers in Ihrem Amazon-EKS-Cluster finden Sie unter [aws-file-cache-csi-driver](https://github.com/kubernetes-sigs/aws-file-cache-csi-driver) auf GitHub.
# Zugriff auf Amazon-S3-Objekte mit dem CSI-Treiber für Mountpoint für Amazon S3
Mit dem [Mountpoint für Amazon S3 Container Storage Interface (CSI)-Treiber](https://github.com/awslabs/mountpoint-s3-csi-driver) können Ihre Kubernetes-Anwendungen über eine Dateisystemschnittstelle auf Amazon-S3-Objekte zugreifen und so einen hohen Gesamtdurchsatz erzielen, ohne dass Änderungen am Anwendungscode erforderlich sind. Der CSI-Treiber basiert auf [Mountpoint für Amazon S3](https://github.com/awslabs/mountpoint-s3) und stellt einen Amazon-S3-Bucket als Volume dar, auf das Container in Amazon EKS und selbstverwalteten Kubernetes-Clustern zugreifen können.
## Überlegungen
+ Der CSI-Treiber für Mountpoint für Amazon S3 ist derzeit nicht mit Windows-basierten Container-Images kompatibel.
+ Der CSI-Treiber für Mountpoint für Amazon S3 ist derzeit nicht mit Amazon EKS Hybrid Nodes kompatibel.
+ AWS Fargate wird vom CSI-Treiber für Mountpoint für Amazon S3 nicht unterstützt. Container, die in Amazon EC2 ausgeführt werden (entweder mit Amazon EKS oder einer benutzerdefinierten Kubernetes-Installation), werden unterstützt.
+ Der CSI-Treiber für Mountpoint für Amazon S3 unterstützt nur die statische Bereitstellung. Dynamische Bereitstellung oder die Erstellung neuer Buckets wird nicht unterstützt.
**Anmerkung**
Statische Bereitstellung bezieht sich auf die Verwendung eines vorhandenen Amazon-S3-Buckets, der als `bucketName` in `volumeAttributes` des `PersistentVolume`-Objekts angegeben ist. Weitere Informationen finden Sie unter [Statische Bereitstellung](https://github.com/awslabs/mountpoint-s3-csi-driver/blob/main/examples/kubernetes/static_provisioning/README.md) auf GitHub.
+ Volumes, die mit dem CSI-Treiber für Mountpoint für Amazon S3 bereitgestellt wurden, unterstützen nicht alle Feature des POSIX-Dateisystems. Weitere Informationen zum Verhalten des Dateisystems finden Sie unter [Dateisystemverhalten von Mountpoint für Amazon S3](https://github.com/awslabs/mountpoint-s3/blob/main/doc/SEMANTICS.md) auf GitHub.
Einzelheiten zum Bereitstellen des Treibers finden Sie unter [Bereitstellung des CSI-Treibers für Mountpoint für Amazon S3](s3-csi-create.md). Informationen zum Entfernen des Treibers finden Sie unter [Amazon-EKS-Add-On von Mountpoint für Amazon S3 entfernen](removing-s3-csi-eks-add-on.md).
# Bereitstellung des CSI-Treibers für Mountpoint für Amazon S3
Mit dem [Mountpoint für Amazon S3 Container Storage Interface (CSI)-Treiber](https://github.com/awslabs/mountpoint-s3-csi-driver) können Ihre Kubernetes-Anwendungen über eine Dateisystemschnittstelle auf Amazon-S3-Objekte zugreifen und so einen hohen Gesamtdurchsatz erzielen, ohne dass Änderungen am Anwendungscode erforderlich sind.
Dieses Verfahren zeigt Ihnen, wie Sie den [CSI-Amazon-EKS-Treiber für Mountpoint für Amazon S3](s3-csi.md) bereitstellen. Lesen Sie sich die [Hinweise](s3-csi.md#s3-csi-considerations) durch, bevor Sie fortfahren.
## Voraussetzungen
+ Ein vorhandener AWS Identity and Access Management (IAM) OpenID Connect (OIDC) -Anbieter für Ihren Cluster. Informationen zum Feststellen, ob Sie bereits über einen verfügen oder einen erstellen müssen, finden Sie unter [Erstellen Sie einen IAM-OIDC-Anbieter für Ihren Cluster](enable-iam-roles-for-service-accounts.md).
+ Version 2.12.3 oder höher der AWS CLI, die auf Ihrem Gerät installiert und konfiguriert ist, oder. AWS CloudShell
+ Das `kubectl`-Befehlszeilen-Tool ist auf Ihrem Gerät oder in der AWS CloudShell installiert. Die Version kann mit der Kubernetes-Version Ihres Clusters identisch sein oder bis zu einer Nebenversion älter oder neuer sein. Wenn Ihre Clusterversion beispielsweise `1.29` ist, können Sie `kubectl`-Version `1.28`, `1.29`, oder `1.30` damit verwenden. Informationen zum Installieren oder Aktualisieren von `kubectl` finden Sie unter [`kubectl` und `eksctl` einrichten](install-kubectl.md).
## Schritt 1: Erstellen einer IAM-Richtlinie
Der CSI-Treiber für Mountpoint für Amazon S3 erfordert Amazon-S3-Berechtigungen, um mit Ihrem Dateisystem zu interagieren. In diesem Abschnitt wird erläutert, wie Sie eine IAM-Richtlinie erstellen, die die erforderlichen Berechtigungen gewährt.
Die folgende Beispielrichtlinie richtet sich nach den IAM-Berechtigungsempfehlungen für Mountpoint. Alternativ können Sie die AWS verwaltete Richtlinie [AmazonS3](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/AmazonS3FullAccess$jsonEditor) verwendenFullAccess, aber diese verwaltete Richtlinie gewährt mehr Berechtigungen, als für Mountpoint benötigt werden.
[Weitere Informationen zu den empfohlenen Berechtigungen für Mountpoint finden Sie unter Mountpoint IAM-Berechtigungen für.](https://github.com/awslabs/mountpoint-s3/blob/main/doc/CONFIGURATION.md#iam-permissions) GitHub
1. Öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/
1. Wählen Sie im linken Navigationsbereich die Option **Policies** aus.
1. Wählen Sie auf der Seite **Richtlinien** die Option **Richtlinie erstellen**.
1. Wählen Sie für **Richtlinien-Editor** die Option **JSON** aus.
1. Kopieren Sie unter **Richtlinien-Editor** Folgendes und fügen Sie es ein:
**Wichtig**
Ersetzen Sie `amzn-s3-demo-bucket1` durch den Namen Ihres eigenen Amazon-S3-Bucket.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "MountpointFullBucketAccess",
"Effect": "Allow",
"Action": [
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1"
]
},
{
"Sid": "MountpointFullObjectAccess",
"Effect": "Allow",
"Action": [
"s3:GetObject",
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:DeleteObject"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket1/*"
]
}
]
}
```
Verzeichnis-Buckets, die mit der Speicherklasse für Amazon S3 Express One Zone eingeführt wurden, verwenden einen anderen Authentifizierungs-Mechanismus als allgemeine Buckets. Anstatt `s3:*`-Aktionen zu verwenden, sollten Sie die `s3express:CreateSession`-Aktion verwenden. Informationen zu Verzeichnis-Buckets finden Sie unter [Verzeichnis-Buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) im *Amazon-S3-Benutzerhandbuch*.
Nachfolgend finden Sie ein Beispiel für eine Richtlinie mit geringsten Berechtigungen, die Sie für einen Verzeichnis-Bucket verwenden würden.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3express:CreateSession",
"Resource": "arn:aws:s3express:us-west-2:111122223333:bucket/amzn-s3-demo-bucket1--usw2-az1--x-s3"
}
]
}
```
1. Wählen Sie **Weiter** aus.
1. Geben Sie Ihrer Richtlinie auf der Seite **Überprüfen und erstellen** einen Namen. In dieser Beispielanleitung wird der Name `AmazonS3CSIDriverPolicy` verwendet.
1. Wählen Sie **Richtlinie erstellen** aus.
## Schritt 2: Erstellen einer IAM-Rolle
Der CSI-Treiber für Mountpoint für Amazon S3 erfordert Amazon-S3-Berechtigungen, um mit Ihrem Dateisystem zu interagieren. In diesem Abschnitt wird erläutert, wie Sie eine IAM-Rolle erstellen, mit der Sie diese Berechtigungen delegieren. Um diese Rolle zu erstellen, können Sie eines der folgenden Tools verwenden:
+ [eksctl](#eksctl_s3_store_app_data)
+ [AWS-Managementkonsole](#console_s3_store_app_data)
+ [AWS CLI](#awscli_s3_store_app_data)
**Anmerkung**
Die IAM-Richtlinie `AmazonS3CSIDriverPolicy` wurde im vorherigen Abschnitt erstellt.
### eksctl
**So erstellen Sie Ihre IAM-Rolle für CSI-Treiber für Mountpoint für Amazon S3 mit `eksctl`**
Führen Sie die folgenden Befehle aus, um die IAM-Rolle und das Kubernetes-Servicekonto zu erstellen. Über diese Befehle wird außerdem die `AmazonS3CSIDriverPolicy` IAM-Richtlinie an die Rolle angefügt, das Kubernetes-Servicekonto (`s3-csi-controller-sa`) mit dem Amazon-Ressourcennamen (ARN) der IAM-Rolle versehen und der Name des Kubernetes-Servicekontos zur Vertrauensrichtlinie für die IAM-Rolle hinzugefügt.
```
CLUSTER_NAME=my-cluster
REGION=region-code
ROLE_NAME=AmazonEKS_S3_CSI_DriverRole
POLICY_ARN=AmazonEKS_S3_CSI_DriverRole_ARN
eksctl create iamserviceaccount \
--name s3-csi-driver-sa \
--namespace kube-system \
--cluster $CLUSTER_NAME \
--attach-policy-arn $POLICY_ARN \
--approve \
--role-name $ROLE_NAME \
--region $REGION \
--role-only
```
### AWS-Managementkonsole
1. Öffnen Sie die IAM-Konsole unter. https://console.aws.amazon.com/iam/
1. Wählen Sie im linken Navigationsbereich **Roles** aus.
1. Klicken Sie auf der Seite **Roles (Rollen)** auf **Create role (Rolle erstellen)**.
1. Gehen Sie auf der Seite **Select trusted entity** (Vertrauenswürdige Entität auswählen) wie folgt vor:
1. Wählen Sie im Abschnitt **Trusted entity type** (Typ der vertrauenswürdigen Entität) die Option **Web identity** (Web-Identität) aus.
1. Wählen Sie für **Identity provider** (Identitätsanbieter) die Option **OpenID Connect provider URL** (OpenID-Connect-Anbieter-URL) für Ihren Cluster aus (wie unter **Overview** (Übersicht) in Amazon EKS gezeigt).
Wenn keine angezeigt URLs werden, überprüfen Sie die [Voraussetzungen](#s3-csi-prereqs).
1. Wählen Sie für **Audience (Zielgruppe)** `sts.amazonaws.com`.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Berechtigungen hinzufügen** wie folgt vor:
1. Geben Sie im Feld **Richtlinien filtern** den Text AmazonS3-Richtlinie einCSIDriver.
**Anmerkung**
Diese Richtlinie wurde im vorherigen Abschnitt erstellt.
1. Aktivieren Sie das Kontrollkästchen links neben dem Ergebnis für `AmazonS3CSIDriverPolicy`, das bei der Suche zurückgegeben wurde.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Name, review, and create** (Benennen, überprüfen und erstellen) wie folgt vor:
1. Geben Sie **als Rollenname einen eindeutigen Namen für Ihre Rolle** ein, z. B. AmazonEKS\$1S3\$1CSI\$1. DriverRole
1. Fügen Sie der Rolle unter **Tags hinzufügen (optional)** Metadaten hinzu, indem Sie Tags als Schlüssel-Wert-Paare anfügen. Weitere Informationen zur Verwendung von Tags in IAM finden Sie unter [Markieren von IAM-Ressourcen](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_tags.html) im *IAM-Benutzerhandbuch*.
1. Wählen Sie **Create role (Rolle erstellen)** aus.
1. Nachdem die Rolle erstellt wurde, wählen Sie die Rolle in der Konsole aus, um sie zur Bearbeitung zu öffnen.
1. Wählen Sie die Registerkarte **Trust Relationships** (Vertrauensstellungen) und dann **Edit trust policy** (Vertrauensrichtlinie bearbeiten) aus.
1. Suchen Sie die Zeile, die wie folgt aussieht:
```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
```
Fügen Sie am Ende der vorherigen Zeile ein Komma und anschließend die folgende Zeile hinzu. Ersetzen Sie es durch die Region, in der *region-code* sich Ihr Cluster befindet AWS . Ersetzen Sie *EXAMPLED539D4633E53DE1B71EXAMPLE* mit dem OIDC-Anbieter-ID Ihres Clusters.
```
"oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:s3-csi-driver-sa"
```
1. Stellen Sie sicher, dass der `Condition`-Operator auf `"StringEquals"` eingestellt ist.
1. Wählen Sie **Update Policy** (Richtlinie aktualisieren) aus, um den Vorgang abzuschließen.
### AWS CLI
1. Zeigen Sie die OIDC-Anbieter-URL Ihres Clusters an. Ersetzen Sie *my-cluster* mit dem Namen Ihres Clusters. Wenn die Ausgabe des Befehls `None` ist, überprüfen Sie die [Voraussetzungen](#s3-csi-prereqs).
```
aws eks describe-cluster --name my-cluster --query "cluster.identity.oidc.issuer" --output text
```
Eine Beispielausgabe sieht wie folgt aus.
```
https://oidc.eks.region-code.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE
```
1. Erstellen Sie die IAM-Rolle und weisen Sie dem Kubernetes-Dienstkonto die `AssumeRoleWithWebIdentity`-Aktion zu.
1. Kopieren Sie den folgenden Inhalt in eine Datei namens `aws-s3-csi-driver-trust-policy.json`. Ersetzen Sie *111122223333* durch Ihre Konto-ID. Ersetzen Sie *EXAMPLED539D4633E53DE1B71EXAMPLE* und *region-code* mit den im vorherigen Schritt zurückgegebenen Werten.
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Federated": "arn:aws:iam::111122223333:oidc-provider/oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE"
},
"Action": "sts:AssumeRoleWithWebIdentity",
"Condition": {
"StringEquals": {
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:sub": "system:serviceaccount:kube-system:s3-csi-driver-sa",
"oidc.eks.us-east-1.amazonaws.com/id/EXAMPLED539D4633E53DE1B71EXAMPLE:aud": "sts.amazonaws.com"
}
}
}
]
}
```
1. Erstellen Sie die -Rolle. Sie können *AmazonEKS\$1S3\$1CSI\$1DriverRole* in einen anderen Namen ändern, aber wenn Sie dies tun, stellen Sie sicher, dass Sie ihn auch in späteren Schritten ändern.
```
aws iam create-role \
--role-name AmazonEKS_S3_CSI_DriverRole \
--assume-role-policy-document file://"aws-s3-csi-driver-trust-policy.json"
```
1. Hängen Sie die zuvor erstellte IAM-Richtlinie mit dem folgenden Befehl an die Rolle an.
```
aws iam attach-role-policy \
--policy-arn arn:aws: iam::aws:policy/AmazonS3CSIDriverPolicy \
--role-name AmazonEKS_S3_CSI_DriverRole
```
**Anmerkung**
Die IAM-Richtlinie `AmazonS3CSIDriverPolicy` wurde im vorherigen Abschnitt erstellt.
1. Überspringen Sie diesen Schritt, wenn Sie den Treiber als Amazon-EKS-Add-On installieren. Für selbstverwaltete Installationen des Treibers erstellen Sie Kubernetes-Servicekonten, die mit der ARN der von Ihnen erstellten IAM-Rolle vermerkt sind.
1. Speichern Sie den folgenden Inhalt in einer Datei mit dem Namen `mountpoint-s3-service-account.yaml`. Ersetzen Sie *111122223333* durch Ihre Konto-ID.
```
---
apiVersion: v1
kind: ServiceAccount
metadata:
labels:
app.kubernetes.io/name: aws-mountpoint-s3-csi-driver
name: mountpoint-s3-csi-controller-sa
namespace: kube-system
annotations:
eks.amazonaws.com/role-arn: arn:aws: iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole
```
1. Erstellen Sie das Kubernetes-Servicekonto in Ihrem Cluster. Das Kubernetes-Dienstkonto (`mountpoint-s3-csi-controller-sa`) ist mit der IAM-Rolle versehen, die Sie mit dem Namen erstellt haben. *AmazonEKS\$1S3\$1CSI\$1DriverRole*
```
kubectl apply -f mountpoint-s3-service-account.yaml
```
**Anmerkung**
Wenn Sie das Plugin in diesem Verfahren bereitstellen, wird es erstellt und für die Verwendung eines Servicekontos mit dem Namen `s3-csi-driver-sa` konfiguriert.
## Schritt 3: CSI-Treiber für Mountpoint für Amazon S3 installieren
Sie können den CSI-Treiber für Mountpoint für Amazon S3 über das Amazon-EKS-Add-On installieren. Sie können die folgenden Tools verwenden, um das Add-On zu Ihrem Cluster hinzuzufügen:
+ [eksctl](#eksctl_s3_add_store_app_data)
+ [AWS-Managementkonsole](#console_s3_add_store_app_data)
+ [AWS CLI](#awscli_s3_add_store_app_data)
Alternativ können Sie den CSI-Treiber für Mountpoint für Amazon S3 als selbstverwaltete Installation installieren. Anweisungen zur Durchführung einer selbstverwalteten Installation finden Sie im GitHub unter [Installation](https://github.com/awslabs/mountpoint-s3-csi-driver/blob/main/docs/install.md#deploy-driver).
Ab Version `v1.8.0` können Sie Taints konfigurieren, die für die Pods des CSI-Treibers toleriert werden sollen. Geben Sie dazu entweder einen benutzerdefinierten Satz von Taints an, die mit `node.tolerations` toleriert werden sollen, oder tolerieren Sie alle Taints mit `node.tolerateAllTaints`. Weitere Informationen finden Sie unter [Taints und Toleranzen](https://kubernetes.io/docs/concepts/scheduling-eviction/taint-and-toleration/) in der Kubernetes-Dokumentation.
### eksctl
**So fügen Sie das CSI-Add-On von Amazon S3 mit `eksctl` hinzu**
Führen Sie den folgenden Befehl aus. Ersetzen Sie *my-cluster* mit dem Namen Ihres Clusters, *111122223333* mit Ihrer Konto-ID und *AmazonEKS\$1S3\$1CSI\$1DriverRole* mit dem Namen der [zuvor erstellten IAM-Rolle](#s3-create-iam-role).
```
eksctl create addon --name aws-mountpoint-s3-csi-driver --cluster my-cluster \
--service-account-role-arn arn:aws: iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole --force
```
Wenn Sie die Option *--force* entfernen und eine der Amazon-EKS-Add-on-Einstellungen mit Ihren vorhandenen Einstellungen in Konflikt steht, schlägt die Aktualisierung des Amazon-EKS-Add-ons fehl und Sie erhalten eine Fehlermeldung, die Sie bei der Lösung des Konflikts unterstützt. Stellen Sie vor der Angabe dieser Option sicher, dass das Amazon-EKS-Add-On keine Einstellungen verwaltet, die Sie verwalten müssen, da diese Einstellungen mit dieser Option überschrieben werden. Weitere Informationen zu anderen Optionen für diese Einstellung finden Sie unter [Add-Ons](https://eksctl.io/usage/addons/) in der `eksctl`-Dokumentation. Weitere Informationen zur Amazon-EKS-Kubernetes-Feldverwaltung finden Sie unter [Felder für die Anpassung von Amazon-EKS-Add-Ons festlegen](kubernetes-field-management.md).
Sie können `eksctl` über Konfigurationsdateien anpassen. Weitere Informationen finden Sie unter [Arbeiten mit Konfigurationswerten](https://eksctl.io/usage/addons/#working-with-configuration-values) in der `eksctl`-Dokumentation. Das folgende Beispiel zeigt, wie alle Taints toleriert werden.
```
# config.yaml
...
addons:
- name: aws-mountpoint-s3-csi-driver
serviceAccountRoleARN: arn:aws: iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole
configurationValues: |-
node:
tolerateAllTaints: true
```
### AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie im linken Navigationsbereich **Cluster** aus.
1. Wählen Sie den Namen des Clusters, für den Sie den CSI-Treiber für Mountpoint für Amazon S3 konfigurieren möchten.
1. Wählen Sie die Registerkarte **Add-ons**.
1. Wählen Sie **Weitere Add-Ons erhalten**.
1. Führen Sie auf der Seite **Add-Ons auswählen** die folgenden Schritte aus:
1. Aktivieren Sie im Abschnitt **Amazon-EKS-Add-Ons** das Kontrollkästchen **CSI-Treiber für Mountpoint für Amazon S3**.
1. Wählen Sie **Weiter** aus.
1. Gehen Sie auf der Seite **Konfigurieren ausgewählter Add-Ons-Einstellungen** wie folgt vor:
1. Wählen Sie die **Version** aus, die Sie verwenden möchten.
1. Wählen Sie für **IAM-Rolle auswählen** den Namen einer IAM-Rolle aus, an die Sie die IAM-Richtlinie „CSI-Treiber für Mountpoint für Amazon S3“ angefügt haben.
1. (Optional) Aktualisieren Sie die **Methode zur Konfliktlösung**, nachdem Sie die **Optionalen Konfigurationseinstellungen** erweitert haben Wenn Sie **Überschreiben** auswählen, können eine oder mehrere Einstellungen für das vorhandene Add-On mit den Amazon-EKS-Add-On-Einstellungen überschrieben werden. Wenn Sie diese Option nicht aktivieren und ein Konflikt mit Ihren vorhandenen Einstellungen vorliegt, schlägt der Vorgang fehl. Sie können die sich daraus ergebende Fehlermeldung heranziehen, um den Konflikt zu beheben. Stellen Sie vor der Auswahl dieser Option sicher, dass das Amazon-EKS-Add-On keine Einstellungen verwaltet, die Sie selbst verwalten müssen.
1. (Optional) Konfigurieren Sie Toleranzen im Feld **Konfigurationswerte**, nachdem Sie die **Optionalen Konfigurationseinstellungen** erweitert haben.
1. Wählen Sie **Weiter** aus.
1. Wählen Sie auf der Seite **Überprüfen und hinzufügen** die Option **Erstellen** aus. Nachdem die Installation der Add-Ons abgeschlossen ist, wird Ihr installiertes Add-On angezeigt.
### AWS CLI
**So fügen Sie das Mountpoint for Amazon S3 CSI Add-on mit der CLI hinzu AWS **
Führen Sie den folgenden Befehl aus. Ersetzen Sie *my-cluster* mit dem Namen Ihres Clusters, *111122223333* mit Ihrer Konto-ID und *AmazonEKS\$1S3\$1CSI\$1DriverRole* mit dem Namen der zuvor erstellten Rolle.
```
aws eks create-addon --cluster-name my-cluster --addon-name aws-mountpoint-s3-csi-driver \
--service-account-role-arn arn:aws: iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole
```
Sie können den Befehl mit dem `--configuration-values`-Flag anpassen. Das folgende alternative Beispiel veranschaulicht, wie alle Taints toleriert werden.
```
aws eks create-addon --cluster-name my-cluster --addon-name aws-mountpoint-s3-csi-driver \
--service-account-role-arn arn:aws: iam::111122223333:role/AmazonEKS_S3_CSI_DriverRole \
--configuration-values '{"node":{"tolerateAllTaints":true}}'
```
## Schritt 4: Mountpoint für Amazon S3 konfigurieren
In den meisten Fällen können Sie Mountpoint für Amazon S3 mit lediglich einem Bucket-Namen konfigurieren. Anweisungen zur Konfiguration von Mountpoint für Amazon S3 finden Sie unter [Mountpoint für Amazon S3 konfigurieren](https://github.com/awslabs/mountpoint-s3/blob/main/doc/CONFIGURATION.md) auf. GitHub
## Schritt 5: Beispielanwendung bereitstellen
Sie können die statische Bereitstellung des Treibers in einem vorhandenen Amazon S3-Bucket einsetzen. [Weitere Informationen finden Sie unter Statische Bereitstellung auf.](https://github.com/awslabs/mountpoint-s3-csi-driver/blob/main/examples/kubernetes/static_provisioning/README.md) GitHub
# Amazon-EKS-Add-On von Mountpoint für Amazon S3 entfernen
Sie haben zwei Möglichkeiten, den [CSI-Treiber für Mountpoint für Amazon S3](s3-csi.md) zu entfernen.
+ **Beibehalten von Add-on-Software auf Ihrem Cluster** - Diese Option entfernt die Amazon-EKS-Verwaltung aller Einstellungen. Amazon EKS wird außerdem die Möglichkeit aufgehoben, Sie über Updates zu informieren und das Amazon-EKS-Add-on automatisch zu aktualisieren, nachdem Sie ein Update eingeleitet haben. Es behält jedoch die Add-on-Software auf Ihrem Cluster bei. Diese Option macht das Add-on zu einem selbstverwalteten Add-on statt einem Amazon-EKS-Add-on. Bei dieser Option gibt es keine Ausfallzeiten für das Add-On. Die Befehle in diesem Verfahren verwenden diese Option.
+ **Entfernen Sie die Add-on-Software vollständig aus Ihrem Cluster** – Wir empfehlen, dass Sie das Amazon-EKS-Add-on nur aus Ihrem Cluster entfernen, wenn auf Ihrem Cluster keine Ressourcen vorhanden sind, die davon abhängig sind. Um diese Option durchzuführen, löschen Sie `--preserve` aus dem Befehl, den Sie für dieses Verfahren verwenden.
Wenn dem Add-On ein IAM-Konto zugeordnet ist, wird das IAM-Konto nicht entfernt.
Sie können die folgenden Tools verwenden, um das Amazon-S3-CSI-Add-On zu entfernen:
+ [eksctl](#eksctl_s3_remove_store_app_data)
+ [AWS-Managementkonsole](#console_s3_remove_store_app_data)
+ [AWS-CLI](#awscli_s3_remove_store_app_data)
## eksctl
**So entfernen Sie das Amazon-S3-CSI-Add-On mithilfe von `eksctl` **
Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters und führen Sie dann den folgenden Befehl aus.
```
eksctl delete addon --cluster my-cluster --name aws-mountpoint-s3-csi-driver --preserve
```
## AWS-Managementkonsole
1. Öffnen Sie die [Amazon-EKS-Konsole](https://console.aws.amazon.com/eks/home#/clusters).
1. Wählen Sie im linken Navigationsbereich die Option **Cluster** aus.
1. Wählen Sie den Namen des Clusters aus, für den Sie das Amazon-EBS-CSI-Add-on entfernen möchten.
1. Wählen Sie die Registerkarte **Add-ons**.
1. Wählen Sie **CSI-Treiber für Mountpoint für Amazon S3** aus.
1. Wählen Sie **Remove (Entfernen)** aus.
1. Führen Sie im Bestätigungsdialogfeld **Entfernen: aws-mountpoint-s3-csi-driver** die folgenden Schritte aus:
1. Wenn Amazon EKS die Verwaltung von Einstellungen für das Add-on einstellen soll, wählen Sie **Auf dem Cluster beibehalten**. Tun Sie dies, wenn Sie die Add-on-Software auf Ihrem Cluster behalten möchten. Auf diese Weise können Sie alle Einstellungen des Add-ons selbst verwalten.
1. Geben Sie `aws-mountpoint-s3-csi-driver` ein.
1. Wählen Sie **Entfernen** aus.
## AWS-CLI
**So entfernen Sie das Amazon-S3-CSI-Add-On mithilfe der AWS-CLI**
Ersetzen Sie *my-cluster* durch den Namen Ihres Clusters und führen Sie dann den folgenden Befehl aus.
```
aws eks delete-addon --cluster-name my-cluster --addon-name aws-mountpoint-s3-csi-driver --preserve
```
# Snapshot-Funktion für CSI-Volumes aktivieren
Mit der Snapshot-Funktion können Sie zeitpunktgenaue Kopien Ihrer Daten erstellen. Damit diese Funktion in Kubernetes funktioniert, benötigen Sie sowohl einen CSI-Treiber mit Snapshot-Support (z. B. den Amazon-EBS-CSI-Treiber) als auch einen CSI-Snapshot-Controller. Der Snapshot-Controller ist entweder als verwaltetes Amazon-EKS-Add-On oder als selbstverwaltete Installation verfügbar.
Die folgenden Punkte sind bei der Verwendung des CSI-Snapshot-Controllers zu beachten.
+ Der Snapshot-Controller muss zusammen mit einem CSI-Treiber mit Snapshot-Funktion installiert werden. Installationsanweisungen für den Amazon-EBS-CSI-Treiber finden Sie unter [Kubernetes-Volume-Speicher mit Amazon EBS verwenden](ebs-csi.md).
+ Kubernetes unterstützt keine Snapshots von Volumes, die über die CSI-Migration bereitgestellt werden, wie z. B. Amazon-EBS-Volumes, die eine `StorageClass` mit Provisioner `kubernetes.io/aws-ebs` verwenden. Volumes müssen mit einer `StorageClass` erstellt werden, die auf den CSI-Treiber-Provisioner `ebs.csi.aws.com` verweist.
+ Amazon EKS Auto Mode beinhaltet keinen Snapshot-Controller. Die Speicher-Kapazität von EKS Auto Mode ist mit dem Snapshot-Controller kompatibel.
Wir empfehlen, den CSI-Snapshot über das von Amazon EKS verwaltete Add-on zu installieren. Dieses Add-On enthält die benutzerdefinierten Ressourcendefinitionen (CRDs), die zum Erstellen und Verwalten von Snapshots in Amazon EKS benötigt werden. Wenn Sie ein Amazon-EKS-Add-on zu Ihrem Cluster hinzufügen möchten, lesen Sie [Erstellung eines Amazon-EKS-Add-Ons](creating-an-add-on.md). Weitere Informationen zu Add-ons finden Sie unter [Amazon-EKS-Add-ons](eks-add-ons.md).
Wenn Sie alternativ eine selbstverwaltete Installation des CSI-Snapshot-Controllers wünschen, finden Sie weitere Informationen unter [Verwendung](https://github.com/kubernetes-csi/external-snapshotter/blob/master/README.md#usage) im Upstream-Kubernetes `external-snapshotter` auf GitHub.