Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# AWS nodos de inicio de sesión PCS
<a name="working-with_login-nodes"></a>

Por lo general, un clúster de AWS PCS necesita al menos un nodo de inicio de sesión para admitir el acceso interactivo y la administración de tareas. Una forma de lograrlo es con un grupo de nodos de cómputo AWS PCS estáticos configurado para funcionar con nodos de inicio de sesión. También puede configurar una instancia EC2 independiente para que actúe como nodo de inicio de sesión.

**Topics**
+ [Uso de un grupo de nodos de cómputo de AWS PCS para proporcionar nodos de inicio de sesión](working-with_login-nodes_compute-node-group-for-login.md)
+ [Uso de instancias independientes como nodos de inicio de sesión de AWS PCS](working-with_login-nodes_standalone.md)
+ [Conexión de un nodo de inicio de sesión independiente a varios clústeres en PCS AWS](multi-cluster-login-script.md)

# Uso de un grupo de nodos de cómputo de AWS PCS para proporcionar nodos de inicio de sesión
<a name="working-with_login-nodes_compute-node-group-for-login"></a>

 En este tema se proporciona una descripción general de las opciones de configuración sugeridas y se describe qué se debe tener en cuenta al utilizar un grupo de nodos de cómputo de AWS PCS para proporcionar un acceso persistente e interactivo a su clúster. 

## Crear un grupo de nodos de cómputo de AWS PCS para los nodos de inicio de sesión
<a name="working-with_login-nodes_compute-node-group-for-login_create"></a>

 Operacionalmente, esto no es muy diferente de crear un grupo de nodos de cómputo normal. Sin embargo, hay que tomar algunas decisiones de configuración clave: 
+  Establezca una configuración de escalado estático de al menos una instancia EC2 del grupo de nodos de procesamiento. 
+  Elija la opción de compra bajo demanda para evitar la recuperación de sus instancias. 
+  Elija un nombre informativo para el grupo de nodos de cómputo, como el inicio de sesión. 
+  Si desea que se pueda acceder a las instancias del nodo de inicio de sesión desde fuera de su VPC, considere la posibilidad de utilizar una subred pública. 
+  Si pretende permitir el acceso a SSH, la plantilla de lanzamiento necesitará tener un grupo de seguridad que exponga el puerto SSH a las direcciones IP que elija. 
+  El perfil de instancia de IAM debe tener solo los permisos de AWS que desee que tengan sus usuarios finales. Para obtener más información, consulte [Perfiles de instancia de IAM para AWS Parallel Computing Service](security-instance-profiles.md). 
+  Considere permitir que AWS Systems Manager Session Manager administre sus instancias de inicio de sesión. 
+  Considere restringir el acceso a las credenciales de AWS de la instancia solo a los usuarios administrativos 
+  Seleccione tipos de instancias menos costosos que los de los grupos de nodos de cómputo normales, ya que los nodos de inicio de sesión se ejecutarán de forma continua. 
+  Use la misma AMI (o una derivada) que para sus otros grupos de nodos de cómputo para garantizar que todas las instancias tengan instalado el mismo software. Para obtener más información sobre la personalización AMIs, consulte [Amazon Machine Images (AMIs) para AWS PCS](working-with_ami.md)
+  Configure el mismo sistema de archivos de red (Amazon EFS, Amazon FSx for Lustre, etc.) para montarlo en los nodos de inicio de sesión que en las instancias informáticas. Para obtener más información, consulte [Uso de sistemas de archivos de red con AWS PCS](working-with_file-systems.md).

**Acceda a sus nodos de inicio de sesión**  
Cuando su nuevo grupo de nodos de cómputo alcance el estado ACTIVO, podrá encontrar las instancias EC2 que ha creado e iniciar sesión en ellas. Para obtener más información, consulte [Búsqueda de instancias de grupos de nodos de cómputo en AWS PCS](working-with_compute-instances.md).

## Actualización de un grupo de nodos de procesamiento de AWS PCS para los nodos de inicio de sesión
<a name="working-with_login-nodes_compute-node-group-for-login_update"></a>

 Puede actualizar un grupo de nodos de inicio de sesión mediante UpdateComputeNodeGroup. Como parte del proceso de actualización del grupo de nodos, se sustituirán las instancias en ejecución. Ten en cuenta que esto interrumpirá cualquier sesión de usuario o proceso activo en la instancia. Los trabajos de Slurm en ejecución o en cola no se verán afectados. Para obtener más información, consulte [Actualización de un grupo de nodos de cómputo AWS PCS](working-with_cng_update.md). 

 También puede editar la plantilla de lanzamiento utilizada por su grupo de nodos de cómputo. Debe utilizarla UpdateComputeNodeGroup para aplicar la plantilla de lanzamiento actualizada al grupo de nodos de procesamiento. Las nuevas instancias de EC2 lanzadas en el grupo de nodos de procesamiento utilizan la plantilla de lanzamiento actualizada. Para obtener más información, consulte [Uso de plantillas de lanzamiento de Amazon EC2 con PCS AWS](working-with_launch-templates.md).

## Eliminar un grupo de nodos de cómputo de AWS PCS para los nodos de inicio de sesión
<a name="working-with_login-nodes_compute-node-group-for-login_delete"></a>

 Puede actualizar un grupo de nodos de inicio de sesión mediante el mecanismo de **eliminación del grupo de nodos de cálculo** de AWS PCS. Las instancias en ejecución se cancelarán como parte de la eliminación del grupo de nodos. Ten en cuenta que esto interrumpirá cualquier sesión de usuario o proceso activo en la instancia. Los trabajos de Slurm en ejecución o en cola no se verán afectados. Para obtener más información, consulte [Eliminar un grupo de nodos de cómputo en AWS PCS](working-with_cng_delete.md). 

# Uso de instancias independientes como nodos de inicio de sesión de AWS PCS
<a name="working-with_login-nodes_standalone"></a>

Puede configurar instancias EC2 independientes para que interactúen con el programador Slurm de un clúster de AWS PCS. Esto resulta útil para crear nodos de inicio de sesión, estaciones de trabajo o hosts de administración de flujos de trabajo dedicados que funcionen con clústeres de PCS pero que operen fuera de la administración de AWS PCS. AWS Para ello, cada instancia independiente debe:

1. Tener instalada una versión de software Slurm compatible.

1. Podrá conectarse al punto final Slurmctld del clúster AWS PCS.

1. Configure correctamente el Slurm Auth and Cred Kiosk Daemon (`sackd`) con el punto final y el secreto del clúster de PCS. AWS [Para obtener más información, consulte sackd en la documentación de Slurm.](https://slurm.schedmd.com/sackd.html)

 Este tutorial le ayuda a configurar una instancia independiente que se conecta a un clúster de PCS. AWS 

**Contents**
+ [Paso 1: Recupere la dirección y el secreto del clúster de AWS PCS de destino](working-with_login-nodes_standalone_get-addr.md)
+ [Paso 2: lanzar una instancia EC2](working-with_login-nodes_standalone_launch.md)
+ [Paso 3: Instala Slurm en la instancia](working-with_login-nodes_standalone_install-slurm.md)
+ [Paso 4: Recupere y almacene el secreto del clúster](working-with_login-nodes_standalone_get-secret.md)
+ [Paso 5: Configurar la conexión al clúster de PCS AWS](working-with_login-nodes_standalone_configure-connection.md)
+ [Paso 6: (opcional) Pruebe la conexión](working-with_login-nodes_standalone_test.md)

# Paso 1: Recupere la dirección y el secreto del clúster de AWS PCS de destino
<a name="working-with_login-nodes_standalone_get-addr"></a>

Recupere los detalles sobre el clúster AWS PCS AWS CLI de destino mediante el comando siguiente. Antes de ejecutar el comando, realice los siguientes reemplazos:
+ *region-code*Sustitúyalo por el Región de AWS lugar en el que se ejecuta el clúster de destino.
+ *cluster-ident*Sustitúyalo por el nombre o identificador del clúster de destino

```
aws pcs get-cluster --region region-code --cluster-identifier cluster-ident
```

El comando devolverá un resultado similar al de este ejemplo.

```
{
    "cluster": {
        "name": "get-started",
        "id": "pcs_123456abcd",
        "arn": "arn:aws:pcs:us-east-1:111122223333:cluster/pcs_123456abcd",
        "status": "ACTIVE",
        "createdAt": "2024-12-17T21:03:52+00:00",
        "modifiedAt": "2024-12-17T21:03:52+00:00",
        "scheduler": {
            "type": "SLURM",
            "version": "25.05"
        },
        "size": "SMALL",
        "slurmConfiguration": {
            "authKey": {
                "secretArn": "arn:aws:secretsmanager:us-east-1:111122223333:secret:pcs!slurm-secret-pcs_123456abcd-a12ABC",
                "secretVersion": "ef232370-d3e7-434c-9a87-ec35c1987f75"
            }
        },
        "networking": {
            "subnetIds": [
                "subnet-0123456789abcdef0"
            ],
            "securityGroupIds": [
                "sg-0123456789abcdef0"
            ]
        },
        "endpoints": [
            {
                "type": "SLURMCTLD",
                "privateIpAddress": "10.3.149.220",
                "port": "6817"
            }
        ]
    }
}
```

En este ejemplo, el punto final del controlador Slurm del clúster tiene una dirección IP de `10.3.149.220` y se ejecuta en el puerto. `6817` Se `secretArn` usará en pasos posteriores para recuperar el secreto del clúster. La dirección IP y el puerto se utilizarán en pasos posteriores para configurar el `sackd` servicio. 

# Paso 2: lanzar una instancia EC2
<a name="working-with_login-nodes_standalone_launch"></a>

**Para iniciar una instancia de EC2**

1. Abra la [consola de Amazon EC2](https://console.aws.amazon.com/ec2).

1. En el panel de navegación, elija **Instancias** y, a continuación, **Iniciar instancias** para abrir el nuevo asistente de inicialización de instancias.

1. (Opcional) En la sección **Nombre y etiquetas**, proporciona un nombre para la instancia, por ejemplo. `PCS-LoginNode` El nombre se asigna a la instancia como etiqueta de recurso (`Name=PCS-LoginNode`).

1. En la sección **Imágenes de aplicaciones y sistemas operativos**, seleccione una AMI para uno de los sistemas operativos compatibles con AWS PCS. Para obtener más información, consulte [Sistemas operativos compatibles](working-with_ami_installers.md#working-with_ami_installers_os).

1. En la sección **Tipo de instancia**, seleccione un tipo de instancia compatible. Para obtener más información, consulte [Tipos de instancias admitidas](working-with_ami_installers.md#working-wth_ami_installers_instance-types).

1. En la sección **Par de claves**, selecciona el par de claves SSH que quieres usar en la instancia.

1. En la sección **Configuración de red**:

   1. Elija **Edit (Edición de)**.

     1. Seleccione la VPC de su clúster de AWS PCS.

     1. En **Firewall (grupos de seguridad)**, elija **Seleccionar un grupo de seguridad existente**.

        1. Seleccione un grupo de seguridad que permita el tráfico entre la instancia y el controlador Slurm del clúster AWS PCS de destino. Para obtener más información, consulte [Requisitos y consideraciones sobre los grupos de seguridad](working-with_networking_sg.md#working-with_networking_sg-requirements).

        1. (Opcional) Seleccione un grupo de seguridad que permita el acceso SSH entrante a su instancia.

1. En la sección **Almacenamiento**, configura los volúmenes de almacenamiento según sea necesario. Asegúrese de configurar suficiente espacio para instalar aplicaciones y bibliotecas a fin de habilitar su caso de uso.

1.  En **Avanzado**, elija un rol de IAM que permita el acceso al secreto del clúster. Para obtener más información, consulte [Obtén el secreto del cúmulo de Slurm](working-with_clusters_secrets_get.md). 

1.  En el panel de **resumen**, elija **Launch instance**. 

# Paso 3: Instala Slurm en la instancia
<a name="working-with_login-nodes_standalone_install-slurm"></a>

Cuando la instancia se haya lanzado y se active, conéctese a ella mediante el mecanismo que prefiera. Use el instalador de Slurm proporcionado por AWS para instalar Slurm en la instancia. Para obtener más información, consulte [Instalador de Slurm](working-with_ami_installers.md#working-with_ami_installers_slurm).

Descarga el instalador de Slurm, descomprímelo y usa el script para instalar Slurm. `installer.sh` Para obtener más información, consulte [Paso 3: Instalar Slurm](working-with_ami_custom_install-slurm.md).

# Paso 4: Recupere y almacene el secreto del clúster
<a name="working-with_login-nodes_standalone_get-secret"></a>

Estas instrucciones requieren la AWS CLI. Para obtener más información, consulte [Instalar o actualizar a la última versión de AWS CLI en la](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) *Guía del AWS Command Line Interface usuario de la versión 2*.

Guarde el secreto del clúster con los siguientes comandos.
+ Cree el directorio de configuración de Slurm.

  ```
  sudo mkdir -p /etc/slurm
  ```
+ Recupere, decodifique y almacene el secreto del clúster. Antes de ejecutar este comando, *region-code* sustitúyalo por la región en la que se ejecuta el clúster de destino y *secret-arn* sustitúyalo por el valor `secretArn` obtenido en el [paso 1](working-with_login-nodes_standalone_get-addr.md).

  ```
  aws secretsmanager get-secret-value \
   --region region-code \
   --secret-id 'secret-arn' \
   --version-stage AWSCURRENT \
   --query 'SecretString' \
   --output text | base64 -d | sudo tee /etc/slurm/slurm.key
  ```
**aviso**  
En un entorno multiusuario, cualquier usuario con acceso a la instancia podría obtener el secreto del clúster si puede acceder al servicio de metadatos de la instancia (IMDS). Esto, a su vez, podría permitirles hacerse pasar por otros usuarios. Considere la posibilidad de restringir el acceso al IMDS únicamente a los usuarios root o administrativos. Como alternativa, considere la posibilidad de utilizar un mecanismo diferente que no dependa del perfil de la instancia para obtener y configurar el secreto.
+ Configura la propiedad y los permisos en el archivo de claves de Slurm.

  ```
  sudo chmod 0600 /etc/slurm/slurm.key
  sudo chown slurm:slurm /etc/slurm/slurm.key
  ```
**nota**  
La clave Slurm debe ser propiedad del usuario y del grupo en los que se ejecuta el `sackd` servicio. 

# Paso 5: Configurar la conexión al clúster de PCS AWS
<a name="working-with_login-nodes_standalone_configure-connection"></a>

Para establecer una conexión con el clúster de AWS PCS, ejecútelo `sackd` como un servicio del sistema siguiendo estos pasos.

**nota**  
 Si usa Slurm 25.05 o una versión posterior, puede usar un script para configurar su nodo de inicio de sesión para que se conecte a varios clústeres. Para obtener más información, consulte [Conexión de un nodo de inicio de sesión independiente a varios clústeres en PCS AWS](multi-cluster-login-script.md). 

1. Configure el archivo de entorno del `sackd` servicio con el siguiente comando. Antes de ejecutar el comando, sustituya *ip-address* y por *port* los valores recuperados de los puntos finales en el [paso 1](working-with_login-nodes_standalone_get-addr.md).

   ```
   sudo echo "SACKD_OPTIONS='--conf-server=ip-address:port'" > /etc/sysconfig/sackd
   ```

1. Cree un archivo `systemd` de servicio para gestionar el `sackd` proceso.

   ```
   sudo cat << EOF > /etc/systemd/system/sackd.service
   [Unit]
   Description=Slurm auth and cred kiosk daemon
   After=network-online.target remote-fs.target
   Wants=network-online.target
   ConditionPathExists=/etc/sysconfig/sackd
   
   [Service]
   Type=notify
   EnvironmentFile=/etc/sysconfig/sackd
   User=slurm
   Group=slurm
   RuntimeDirectory=slurm
   RuntimeDirectoryMode=0755
   ExecStart=/opt/aws/pcs/scheduler/slurm-25.05/sbin/sackd --systemd \$SACKD_OPTIONS
   ExecReload=/bin/kill -HUP \$MAINPID
   KillMode=process
   LimitNOFILE=131072
   LimitMEMLOCK=infinity
   LimitSTACK=infinity
   
   [Install]
   WantedBy=multi-user.target
   EOF
   ```

1. Establezca la propiedad del archivo `sackd` de servicio.

   ```
   sudo chown root:root /etc/systemd/system/sackd.service && \
       sudo chmod 0644 /etc/systemd/system/sackd.service
   ```

1. Habilite el `sackd` servicio.

   ```
   sudo systemctl daemon-reload && sudo systemctl enable sackd
   ```

1. Inicie el servicio `sackd`.

   ```
   sudo systemctl start sackd
   ```

# Paso 6: (opcional) Pruebe la conexión
<a name="working-with_login-nodes_standalone_test"></a>

Confirme que el `sackd` servicio se esté ejecutando. A continuación, se muestra un resultado de ejemplo. Si hay errores, por lo general aparecen aquí.

```
[root@ip-10-3-27-112 ~]# systemctl status sackd
[x] sackd.service - Slurm auth and cred kiosk daemon
   Loaded: loaded (/etc/systemd/system/sackd.service; enabled; vendor preset: disabled)
   Active: active (running) since Tue 2024-12-17 16:34:55 UTC; 8s ago
 Main PID: 9985 (sackd)
   CGroup: /system.slice/sackd.service
           └─9985 /opt/aws/pcs/scheduler/slurm-25.05/sbin/sackd --systemd --conf-server=10.3.149.220:6817

Dec 17 16:34:55 ip-10-3-27-112.ec2.internal systemd[1]: Starting Slurm auth and cred kiosk daemon...
Dec 17 16:34:55 ip-10-3-27-112.ec2.internal systemd[1]: Started Slurm auth and cred kiosk daemon.
Dec 17 16:34:55 ip-10-3-27-112.ec2.internal sackd[9985]: sackd: running
```

Confirme que las conexiones al clúster funcionan mediante comandos del cliente de Slurm como `sinfo` y. `squeue` A continuación, se muestra un ejemplo de la salida de. `sinfo`

```
[root@ip-10-3-27-112 ~]# /opt/aws/pcs/scheduler/slurm-25.05/bin/sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
all up infinite 4 idle~ compute-[1-4]
```

También deberías poder enviar trabajos. Por ejemplo, un comando similar a este ejemplo lanzaría un trabajo interactivo en un nodo del clúster. 

```
/opt/aws/pcs/scheduler/slurm-25.05/bin/srun --nodes=1 -p all --pty bash -i
```

# Conexión de un nodo de inicio de sesión independiente a varios clústeres en PCS AWS
<a name="multi-cluster-login-script"></a>

El `pcs-multi-cluster-login-configure.sh` script proporciona una forma automática de configurar varios `sackd` daemons de Slurm en un único nodo de inicio de sesión independiente. Permite que el nodo de inicio de sesión se comunique con varios clústeres. El script automatiza las siguientes operaciones:
+ Utiliza las acciones de la API de AWS PCS para obtener información del clúster
+ Solicita la clave de autenticación Slurm codificada en base64
+ Crea un archivo JWKS de Slurm con la clave de autenticación del clúster
+ Configura el `sackd` servicio con puntos finales y puertos del clúster
+ Crea un archivo de `systemd` servicio para un daemon específico de un clúster `sackd`
+ Genera un script de activación para la configuración del entorno de clústeres
+ Activa e inicia el `sackd` servicio

**nota**  
Este script requiere la versión 25.05 o posterior de Slurm.

Slurm ya debe estar instalado en la instancia (lo que equivale al [paso 3](working-with_login-nodes_standalone_install-slurm.md) del proceso manual). La instancia debe poder llegar a los puntos finales del clúster de destino. El script realiza las operaciones equivalentes a las de los [pasos 4](working-with_login-nodes_standalone_get-secret.md) y [5](working-with_login-nodes_standalone_configure-connection.md) del proceso de configuración manual. Obtiene automáticamente la información del clúster, configura el `sackd` servicio, crea los archivos de `systemd` servicio necesarios y crea un script de activación que los usuarios pueden usar para configurar su entorno de shell para la interacción del clúster.

**Topics**
+ [Requisitos previos para el script de configuración del nodo de inicio de sesión multiclúster de AWS PCS](multi-cluster-login-script-prerequisites.md)
+ [AWS Código de script de configuración del nodo de inicio de sesión multiclúster PCS](multi-cluster-login-script-code.md)
+ [Uso del script de configuración del nodo de inicio de sesión multiclúster AWS PCS](multi-cluster-login-script-usage.md)

# Requisitos previos para el script de configuración del nodo de inicio de sesión multiclúster de AWS PCS
<a name="multi-cluster-login-script-prerequisites"></a>

## Requisitos del sistema
<a name="system-requirements"></a>
+ Sistema operativo Linux con soporte `systemd`
+ Privilegios de root para la configuración del sistema

## Comandos y paquetes necesarios
<a name="required-commands"></a>
+ `bash`— Intérprete de shell (versión 4.0\$1)
+ `curl`— Para la recuperación de AWS metadatos de IMDS v2
+ `jq`— Procesador JSON para analizar las respuestas de la API AWS 
+ `aws`— AWS CLI v2 para ejecutar acciones de la API de AWS PCS y para acceder a Secrets Manager
+ `systemctl`— gestión `systemd` de servicios
+ `find`— Utilidad de búsqueda del sistema de archivos
+ `grep`— Coincidencia de patrones de texto
+ `sed`— Editor de secuencias para la manipulación de texto
+ `sort`— Utilidad de clasificación de texto
+ `tail`— Muestra las últimas líneas de un archivo
+ `mkdir`— Creación de directorios
+ `chmod`— Cambia los permisos de los archivos
+ `chown`— Cambia la propiedad del archivo
+ `ldconfig`— Configuración dinámica del enlazador

## AWS requisitos
<a name="aws-requirements"></a>
+ Un clúster de AWS PCS que ejecute la versión 25.05 o posterior de Slurm
+ AWS credenciales configuradas (mediante un rol de IAM, un archivo de credenciales o variables de entorno)
+ Permisos para:
  + `pcs:GetCluster`
  + `secretsmanager:GetSecretValue`(si utilizas un secreto alternativo)

## Usuarios y grupos del sistema
<a name="system-users-groups"></a>
+ El `slurm` usuario y el grupo deben existir en el sistema

## Instalación de Slurm
<a name="slurm-installation"></a>
+ Slurm debe instalarse en la misma ubicación que los paquetes de instalación de AWS PCS Slurm:

  ```
  /opt/aws/pcs/scheduler/slurm-version
  ```

# AWS Código de script de configuración del nodo de inicio de sesión multiclúster PCS
<a name="multi-cluster-login-script-code"></a>

Guarde el siguiente código fuente en un archivo con el siguiente nombre:

```
pcs-multi-cluster-login-configure.sh
```

## Código fuente del script
<a name="multi-cluster-login-script-code-content"></a>

```
#!/bin/bash
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.

# AWS PCS Multi-Cluster Standalone Login Node Configuration Script
# 
# This script configures AWS Parallel Computing Service (PCS) multi-cluster stand alone login nodes
# by setting up the Slurm authentication and credential kiosk daemon (sackd)
# for connecting to remote PCS clusters.
#
# Prerequisites:
# - AWS CLI configured with appropriate permissions
# - Slurm version 25.05 or later
# - Root privileges for system configuration
# - Network connectivity to AWS PCS endpoints


set -eo pipefail

# Function to display usage
usage() {
    echo "Usage: $0 --cluster-identifier <cluster-identifier> [--endpoint-url <endpoint-url>]"
    echo "       $0 -h|--help"
}

# Function to display help
help() {
    echo "AWS PCS Multi-Cluster Standalone Login Node Configuration Script"
    echo "==============================================="
    echo
    echo "This script configures multi-cluster standalone login node for AWS Parallel Computing Service (PCS)"
    echo "by setting up the Slurm authentication and credential kiosk daemon (sackd)."
    echo
    usage
    echo
    echo "Options:"
    echo "  --cluster-identifier <id>    AWS PCS cluster identifier (required)"
    echo "  --endpoint-url <url>         Custom PCS endpoint URL (optional)"
    echo "  -h, --help                   Show this help message"
    echo
    echo "Examples:"
    echo "  $0 --cluster-identifier my-pcs-cluster"
    echo
    echo "Note: This script requires root privileges and Slurm version 25.05 or later."
}

# Function to retrieve authentication key
get_auth_key() {
    if [ "$ALTERNATE_SECRET_RETRIEVAL" = "true" ]; then
        echo "Retrieving authentication key from AWS Secrets Manager..." >&2
        local auth_key_arn=$(echo "$CLUSTER_INFO" | jq -r '.cluster.slurmConfiguration.authKey.secretArn')
        local auth_key_version=$(echo "$CLUSTER_INFO" | jq -r '.cluster.slurmConfiguration.authKey.secretVersion')
        
        if [ "$auth_key_arn" = "null" ] || [ "$auth_key_version" = "null" ]; then
            echo "Error: Auth key information not found in cluster configuration" >&2
            exit 1
        fi
        
        if ! aws secretsmanager get-secret-value --secret-id "$auth_key_arn" --version-id "$auth_key_version" --query SecretString --output text --region "$REGION" 2>/dev/null; then
            echo "Error: Failed to retrieve auth key from Secrets Manager" >&2
            exit 1
        fi
    else
        echo "Please enter the base64-encoded Slurm authentication key:" >&2
        echo -n "Base64 of the Slurm secret key: " >&2
        local key
        read -rs key
        echo >&2
        echo "$key"
    fi
}

# Function to get next available SACKD port
get_next_sackd_port() {
    local exclude_file="$1"
    local port=6918
    local used_ports=()
    
    # Get all currently used SACKD ports into an array
    while IFS= read -r line; do
        used_ports+=("$line")
    done < <(find /etc/sysconfig -name "sackd-pcs-*" ! -path "$exclude_file" \
             -exec grep SACKD_PORT= '{}' ';' 2>/dev/null | \
             sed 's/.*SACKD_PORT=//' | sort -n)
    
    # Loop through used ports to find first available port
    for used_port in "${used_ports[@]}"; do
        if [ "$port" -lt "$used_port" ]; then
            break
        elif [ "$port" -eq "$used_port" ]; then
            ((port++))
        fi
    done
    
    echo "$port"
}

# Function to configure cluster
configure_cluster() {
    mkdir -p /etc/slurm
    SLURM_JWKS_FILE="/etc/slurm/slurm-${CLUSTER_NAME}.jwks"
    echo '{"keys":[{"alg":"HS256","kty":"oct","kid":"key-'"${CLUSTER_ID}"'","k":"'"${BASE64_SLURM_KEY}"'"}]}' | jq -c '.' > "${SLURM_JWKS_FILE}"
    
    chmod 0600 "$SLURM_JWKS_FILE"
    chown slurm:slurm "$SLURM_JWKS_FILE"
    
    SLURM_INSTALL_PATH="/opt/aws/pcs/scheduler/slurm-${SLURM_VERSION}"
    
    SACKD_RUNTIME_DIRECTORY="/run/slurm-${CLUSTER_NAME}"
    mkdir -p "${SACKD_RUNTIME_DIRECTORY}"
    chown slurm:slurm "${SACKD_RUNTIME_DIRECTORY}"
    
    mkdir -p /etc/sysconfig
    SACKD_SERVICE_NAME="sackd-pcs-${CLUSTER_NAME}"
    SACKD_SERVICE_ENV="/etc/sysconfig/${SACKD_SERVICE_NAME}"
    SACKD_PORT=$(get_next_sackd_port "$SACKD_SERVICE_ENV")
    cat > "${SACKD_SERVICE_ENV}" << EOF
SACKD_OPTIONS='--conf-server=$ENDPOINTS'
SLURM_SACK_JWKS='$SLURM_JWKS_FILE'
RUNTIME_DIRECTORY='$SACKD_RUNTIME_DIRECTORY'
SACKD_PORT=$SACKD_PORT
EOF
    
    SACKD_SERVICE_PATH="/etc/systemd/system/${SACKD_SERVICE_NAME}.service"
    
    cat << EOF > "$SACKD_SERVICE_PATH"
[Unit]
Description=Slurm auth and cred kiosk daemon
After=network-online.target remote-fs.target
Wants=network-online.target
ConditionPathExists=${SACKD_SERVICE_ENV}

[Service]
Type=notify
EnvironmentFile=${SACKD_SERVICE_ENV}
User=slurm
Group=slurm
RuntimeDirectory=slurm-${CLUSTER_NAME}
RuntimeDirectoryMode=0755
ExecStart=${SLURM_INSTALL_PATH}/sbin/sackd --systemd \$SACKD_OPTIONS
ExecReload=/bin/kill -HUP \$MAINPID
KillMode=process
LimitNOFILE=131072
LimitMEMLOCK=infinity
LimitSTACK=infinity

[Install]
WantedBy=multi-user.target
EOF
    
    chown root:root "$SACKD_SERVICE_PATH"
    chmod 0644 "$SACKD_SERVICE_PATH"
    systemctl daemon-reload && systemctl enable "$SACKD_SERVICE_NAME"
    systemctl restart "$SACKD_SERVICE_NAME"
    
    ACTIVATE_SCRIPT="activate-pcs-${CLUSTER_NAME}"
    cat > "$ACTIVATE_SCRIPT" << EOF
# Activate script for Slurm cluster ${CLUSTER_NAME}

# Add Slurm paths
export PATH="${SLURM_INSTALL_PATH}/bin:\$PATH"
export MANPATH="${SLURM_INSTALL_PATH}/share/man:\$MANPATH"
export LD_LIBRARY_PATH="${SLURM_INSTALL_PATH}/lib:\$LD_LIBRARY_PATH"
ldconfig

# Set Slurm configuration
export SLURM_CONF="/run/slurm-${CLUSTER_NAME}/conf/slurm.conf"
export PCS_CLUSTER_NAME="${CLUSTER_NAME}"
export PCS_CLUSTER_IDENTIFIER="${CLUSTER_IDENTIFIER}"
export PCS_CLUSTER_ID="${CLUSTER_ID}"

echo "Activated PCS cluster environment: ${CLUSTER_NAME}"

# Deactivate function
function deactivate-pcs-${CLUSTER_NAME}() {
    export PATH="\$(echo "\$PATH" | sed -e "s|${SLURM_INSTALL_PATH}/bin:||g" -e "s|:${SLURM_INSTALL_PATH}/bin||g" -e "s|^${SLURM_INSTALL_PATH}/bin\$||")"
    export MANPATH="\$(echo "\$MANPATH" | sed -e "s|${SLURM_INSTALL_PATH}/share/man:||g" -e "s|:${SLURM_INSTALL_PATH}/share/man||g" -e "s|^${SLURM_INSTALL_PATH}/share/man\$||")"
    export LD_LIBRARY_PATH="\$(echo "\$LD_LIBRARY_PATH" | sed -e "s|${SLURM_INSTALL_PATH}/lib:||g" -e "s|:${SLURM_INSTALL_PATH}/lib||g" -e "s|^${SLURM_INSTALL_PATH}/lib\$||")"
    unset SLURM_CONF
    unset PCS_CLUSTER_NAME
    unset PCS_CLUSTER_IDENTIFIER
    unset PCS_CLUSTER_ID
    unset -f deactivate-pcs-${CLUSTER_NAME}
    ldconfig
    echo "Deactivated PCS cluster environment: ${CLUSTER_NAME}"
}

export -f deactivate-pcs-${CLUSTER_NAME}

EOF
}

# Main function
main() {
    # Parse arguments
    CLUSTER_IDENTIFIER=""
    PCS_ENDPOINT_URL=""
    
    while [ "$1" != "" ]; do
        case $1 in
            --cluster-identifier)
                shift
                CLUSTER_IDENTIFIER="$1"
                ;;
            --endpoint-url)
                shift
                PCS_ENDPOINT_URL="--endpoint-url $1"
                ;;
            -h|--help)
                help
                exit 0
                ;;
            *)
                echo "Invalid argument: $1" >&2
                usage >&2
                exit 1
                ;;
        esac
        shift
    done
    
    # Validate required arguments
    if [ -z "$CLUSTER_IDENTIFIER" ]; then
        echo "Error: --cluster-identifier is required" >&2
        usage >&2
        exit 1
    fi
    
    # Validate running as root
    if [ "$EUID" -ne 0 ]; then
        echo "Error: This script must be run as root" >&2
        exit 1
    fi
    
    # Validate required commands are available
    for cmd in aws jq curl; do
        if ! command -v "$cmd" &> /dev/null; then
            echo "Error: Required command '$cmd' not found" >&2
            exit 1
        fi
    done
    
    # Get the region name from IMDS v2 with error handling (try IPv6 first, fallback to IPv4)
    echo "Retrieving AWS region from instance metadata..."
    # Try IPv6 IMDS endpoint first (fd00:ec2::254) with fast timeout (1s connect, 2s total)
    # If IPv6 fails, fallback to IPv4 IMDS endpoint (169.254.169.254)
    IMDS_ENDPOINT="http://[fd00:ec2::254]"
    if ! TOKEN=$(curl -s -X PUT "${IMDS_ENDPOINT}/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" --connect-timeout 1 --max-time 2 2>/dev/null); then
        IMDS_ENDPOINT="http://169.254.169.254"
        if ! TOKEN=$(curl -s -X PUT "${IMDS_ENDPOINT}/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600" --max-time 5); then
            echo "Error: Failed to retrieve IMDS token. Ensure this script is running on an EC2 instance." >&2
            exit 1
        fi
    fi
    
    if ! REGION=$(curl -s -H "X-aws-ec2-metadata-token: $TOKEN" "${IMDS_ENDPOINT}/latest/dynamic/instance-identity/document" --max-time 5 | jq -r '.region'); then
        echo "Error: Failed to retrieve AWS region from instance metadata" >&2
        exit 1
    fi
    
    echo "Detected AWS region: $REGION"
    
    # Retrieve cluster information from AWS PCS
    echo "Retrieving cluster information for: $CLUSTER_IDENTIFIER"
    # shellcheck disable=SC2086
    if ! CLUSTER_INFO=$(aws pcs get-cluster --region "$REGION" --cluster-identifier "$CLUSTER_IDENTIFIER" $PCS_ENDPOINT_URL 2>/dev/null); then
        echo "Error: Failed to retrieve cluster information. Check cluster identifier and AWS permissions." >&2
        exit 1
    fi
    
    CLUSTER_ID=$(echo "$CLUSTER_INFO" | jq -r '.cluster.id')
    CLUSTER_NAME="$(echo "$CLUSTER_INFO" | jq -r '.cluster.name')"
    SLURM_VERSION=$(echo "$CLUSTER_INFO" | jq -r '.cluster.scheduler.version')
    SLURM_VERSION=${SLURM_VERSION#Slurm_}
    
    # Check if Slurm version is >= 25.05
    # shellcheck disable=SC2072
    if [[ "$SLURM_VERSION" < "25.05" ]]; then
        echo "Error: This script requires Slurm version 25.05 or later. Found version: $SLURM_VERSION" >&2
        exit 1
    fi
    
    ENDPOINTS=$(echo "$CLUSTER_INFO" | jq -r '.cluster.endpoints[] | select(.type == "SLURMCTLD") | (if .privateIpAddress != "" then .privateIpAddress else "[" + .ipv6Address + "]" end) + ":" + .port' | tr '\n' ',' | sed 's/,$//')
    
    # Get BASE64_SLURM_KEY
    BASE64_SLURM_KEY=$(get_auth_key)
    
    if [ -z "$BASE64_SLURM_KEY" ]; then
        echo "Error: base64 Slurm key cannot be empty" >&2
        exit 1
    fi
    
    configure_cluster
    
    # Final configuration summary
    echo "========================================"
    echo "Configuration completed successfully!"
    echo "========================================"
    echo "Cluster Name: $CLUSTER_NAME"
    echo "Cluster ID: $CLUSTER_ID"
    echo "Slurm Version: $SLURM_VERSION"
    echo "Service Name: $SACKD_SERVICE_NAME"
    echo "SACKD Port: $SACKD_PORT"
    echo
    echo "To activate this cluster environment, run:"
    echo "  source ./$ACTIVATE_SCRIPT"
    echo
    echo "To deactivate this cluster environment, run:"
    echo "  deactivate-pcs-${CLUSTER_NAME}"
    echo
    echo "To check service status:"
    echo "  systemctl status $SACKD_SERVICE_NAME"
    echo
    echo "To view service logs:"
    echo "  journalctl -u $SACKD_SERVICE_NAME -f"
}

# Exit if being sourced for testing
[[ "${BASH_SOURCE[0]}" != "${0}" ]] && return

# Execute main function
main "$@"
```

# Uso del script de configuración del nodo de inicio de sesión multiclúster AWS PCS
<a name="multi-cluster-login-script-usage"></a>

## Ejecución del script
<a name="running-script"></a>

**Ejecución del script de configuración**

1. Guarde el [contenido del script](multi-cluster-login-script-code.md#multi-cluster-login-script-code-content) en un archivo denominado:

   ```
   pcs-multi-cluster-login-configure.sh
   ```

1. Hágalo ejecutable:

   ```
   chmod +x pcs-multi-cluster-login-configure.sh
   ```

1. Ejecute el script :

   ```
   ./pcs-multi-cluster-login-configure.sh --cluster-identifier cluster-name
   ```

## Entornos de interacción en clúster
<a name="activation-script-usage"></a>

Tras una configuración correcta, el script genera un script de activación específico del clúster en el directorio actual. El script tiene el nombre. `activate-pcs-cluster-name` El script de activación configura las variables de entorno y las rutas necesarias para interactuar con el clúster de destino.

**Para activar un entorno de clúster**
+ Utilice el `source` comando para ejecutar el script de activación

  ```
  source ./activate-pcs-cluster-name
  ```  
**Example**  

  ```
  # Activate cluster environment for cluster 'my-cluster'
  source ./activate-pcs-my-cluster
  
  # Now you can use Slurm commands
  sinfo
  squeue
  sbatch my-job.sh
  ```

**Qué hace el script de activación**
+ Establece la variable de `SLURM_CONF` entorno para que apunte a la configuración del clúster.
+ Actualiza el `PATH` para incluir los binarios de Slurm del clúster.
+ Configura otras variables de entorno de Slurm necesarias (,). `MANPATH` `LD_LIBRARY_PATH`
+ Establece las variables de AWS identificación del clúster de PCS.
+ Permite una interacción fluida con el clúster de AWS PCS de destino.

**Para desactivar un entorno de clúster**
+ Ejecute el comando de desactivación.

  ```
  deactivate-pcs-cluster-name
  ```  
**Example**  

  ```
  # After activating a cluster
  source ./activate-pcs-my-cluster
  
  # Work with the cluster
  sinfo
  
  # Deactivate when done
  deactivate-pcs-my-cluster
  ```

**Qué hace el comando de desactivación**
+ Restaura la variable de `PATH` entorno original.
+ Desactiva las variables de entorno de Slurm específicas del clúster.
+ Devuelve el entorno del shell a su estado previo a la activación.

**nota**  
La activación es específica de la sesión y debe originarse en la sesión de shell en la que desee interactuar con el clúster.