**Ayude a mejorar esta página** Para contribuir a esta guía del usuario, elija el enlace **Edit this page on GitHub** que se encuentra en el panel derecho de cada página. # Optimización del rendimiento de Amazon FSx para Lustre en nodos (sin EFA) Es posible optimizar el rendimiento de Amazon FSx para Lustre mediante la aplicación de parámetros de ajuste durante la inicialización de los nodos, con datos de usuario de la plantilla de lanzamiento. **nota** Para obtener información sobre la creación e implementación del controlador de CSI de FSx para Lustre, consulte [Implementación del controlador de FSx para Lustre](fsx-csi-create.md). Para optimizar el rendimiento con nodos compatibles con EFA, consulte [Optimización del rendimiento de Amazon FSx para Lustre en nodos (EFA)](fsx-csi-tuning-efa.md). ## ¿Por qué usar los datos de usuario de la plantilla de lanzamiento? + Aplica ajustes de forma automática durante la inicialización del nodo. + Garantiza una configuración coherente en todos los nodos. + Elimina la necesidad de configurar los nodos de forma manual. ## Información general del script de ejemplo El script de ejemplo definido en este tema realiza las siguientes operaciones: ### `# 1. Install Lustre client` + Detecta automáticamente la versión del sistema operativo de Amazon Linux (AL). + Instala el paquete de cliente de Lustre correspondiente. ### `# 2. Apply network and RPC tunings` + Configura `ptlrpcd_per_cpt_max=64` para el procesamiento paralelo de RPC. + Configura `ksocklnd credits=2560` para optimizar los búferes de red. ### `# 3. Load Lustre modules` + Elimina de forma segura los módulos Lustre existentes, si están presentes. + Se encarga del desmontaje de sistemas de archivos existentes. + Carga módulos Lustre nuevos. ### `# 4. Lustre Network Initialization` + Inicializa la configuración de red de Lustre. + Configura los parámetros de red requeridos. ### `# 5. Mount FSx filesystem` + Debe ajustar los valores de esta sección según el entorno. ### `# 6. Apply tunings` + Ajustes de LRU (unidad de recurso de bloqueo): + `lru_max_age=600000` + `lru_size` calculado con base en la cantidad de CPU + Control de caché del cliente: `max_cached_mb=64` + Controles de RPC: + OST `max_rpcs_in_flight=32` + MDC `max_rpcs_in_flight=64` + MDC `max_mod_rpcs_in_flight=50` ### `# 7. Verify tunings` + Verifica todos los ajustes aplicados. + Informa si cada parámetro se aplicó correctamente o si generó una advertencia. ### `# 8. Setup persistence` + También debe ajustar los valores de esta sección según el entorno. + Detecta automáticamente la versión del sistema operativo (AL2023) para determinar qué servicio de `Systemd` aplicar. + El sistema se inicia. + `Systemd` inicia el servicio `lustre-tunings` (debido a `WantedBy=multi-user.target`). + El servicio ejecuta `apply_lustre_tunings.sh`, que: + Verifica si el sistema de archivos está montado. + Monta el sistema de archivos si no está montado. + Espera a que se monte correctamente (hasta cinco minutos). + Aplica los parámetros de ajuste después de un montaje exitoso. + Los ajustes permanecen activos hasta el reinicio. + El servicio finaliza después de completar el script. + Systemd marca el servicio como “activo (finalizado)”. + El proceso se repite en el próximo reinicio. ## Crear una plantilla de lanzamiento 1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/. 1. Seleccione **Plantillas de lanzamiento**. 1. Elija **Crear plantilla de inicialización**. 1. En **Detalles avanzados**, ubique la sección de **Datos de usuario**. 1. Pegue el siguiente script y actualice los valores según sea necesario. **importante** Ajuste estos valores según el entorno tanto en la sección `# 5. Mount FSx filesystem` como en la función `setup_persistence()` de `apply_lustre_tunings.sh` dentro de la sección `# 8. Setup persistence`: ``` 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. Al crear grupos de nodos de Amazon EKS, seleccione esta plantilla de lanzamiento. Para obtener más información, consulte [Creación de un grupo de nodos administrados para un clúster](create-managed-node-group.md). ## Información relacionada + [Implementación del controlador de FSx para Lustre](fsx-csi-create.md) + [Optimización del rendimiento de Amazon FSx para Lustre en nodos (EFA)](fsx-csi-tuning-efa.md) + [Amazon FSx for Lustre Performance](https://docs.aws.amazon.com/fsx/latest/LustreGuide/performance.html)