**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 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 auf Fargate nicht unterstützt. Eine ausführliche Beschreibung der verfügbaren Parameter und vollständige Beispiele, die die Funktionen des Treibers demonstrieren, finden Sie im Treiberprojekt [FSx für 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 unterstützt die Authentifizierung entweder über EKS Pod Identity oder IAM Roles for Service Accounts (IRSA). Um EKS Pod Identity zu verwenden, 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). Informationen zur Verwendung von IRSA stattdessen 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). + 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)