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.
# Tutoriales sobre cómo usar AWS ParallelCluster
En los siguientes tutoriales se muestra cómo empezar a utilizar la AWS ParallelCluster versión 3 y se proporcionan instrucciones sobre las prácticas recomendadas para algunas tareas habituales.
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Topics**
+ [Ejecutar su primer trabajo en AWS ParallelCluster](tutorials-running-your-first-job-on-version-3.md)
+ [Creación de una AWS ParallelCluster AMI personalizada](building-custom-ami-v3.md)
+ [Integración de Active Directory](tutorials_05_multi-user-ad.md)
+ [Configuración del cifrado de almacenamiento compartido con una AWS KMS clave](tutorials_04_encrypted_kms_fs-v3.md)
+ [Ejecución de trabajos en un clúster en modo de cola múltiple](multi-queue-tutorial-v3.md)
+ [Uso de la AWS ParallelCluster API](tutorials_06_API_use.md)
+ [Crear un clúster con Slurm contabilidad](tutorials_07_slurm-accounting-v3.md)
+ [Crear un clúster con un externo Slurmdbd contabilidad](external-slurmdb-accounting.md)
+ [Volver a una versión anterior del documento de AWS Systems Manager](tutorials_08_ssm-document-version-rev-v3.md)
+ [Crear un clúster con CloudFormation](tutorials_09_cfn-custom-resource-v3.md)
+ [Implemente ParallelCluster la API con Terraform](tutorial-deploy-terraform.md)
+ [Creación de un clúster con Terraform](tutorial-create-cluster-terraform.md)
+ [Creación de una AMI personalizada con Terraform](tutorial-create-ami-terraform.md)
+ [AWS ParallelCluster Integración de la interfaz de usuario con Identity Center](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Ejecución de trabajos en contenedores con Pyxis](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [Creación de un clúster con un Lustre habilitado para EFA FSx](tutorial-efa-enabled-fsx-lustre.md)
+ [Support nVidia-IMEX con instancia p6e-gb200](support-nvidia-imex-p6e-gb200-instance.md)
+ [Personalice las interfaces de red de nodos de cómputo con anulaciones de plantillas de lanzamiento](tutorial-network-customization-v3.md)
# Ejecutar su primer trabajo en AWS ParallelCluster
Este tutorial te muestra cómo ejecutar tu primer trabajo en Hello World en AWS ParallelCluster
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
## Comprobación de la instalación
En primer lugar, verificamos que AWS ParallelCluster esté correctamente instalada y configurada, incluida la dependencia de Node.js.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
Esto devuelve la versión en ejecución de AWS ParallelCluster.
## Creación de su primer clúster
Ahora ha llegado el momento de crear su primer clúster. Debido a que la carga de trabajo de este tutorial no es excesiva, podemos usar el tamaño de instancia predeterminado de `t2.micro`. (Para las cargas de trabajo de producción, puede elegir el tamaño de instancia que mejor se adapte a sus necesidades). Llamemos a su clúster `hello-world`.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**nota**
Debe especificarse Región de AWS lo que se debe utilizar para la mayoría de `pcluster` los comandos. Si no se especifica en la variable de entorno `AWS_DEFAULT_REGION`, o el ajuste `region` en la sección `[default]` del archivo `~/.aws/config`, el parámetro `--region` debe proporcionarse en la línea de comando `pcluster`.
Si recibe un mensaje del resultado sobre la configuración, tiene que ejecutar lo siguiente para configurar :
```
$ pcluster configure --config hello-world.yaml
```
Si el comando [`pcluster create-cluster`](pcluster.create-cluster-v3.md) se ejecuta correctamente, verá un resultado similar al siguiente:
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
La creación del clúster se supervisa mediante:
```
$ pcluster describe-cluster --cluster-name hello-world
```
Los `clusterStatus` informes "`CREATE_IN_PROGRESS`" mientras se crea el clúster. `clusterStatus` pasa a “`CREATE_COMPLETE`” cuando el clúster se haya creado correctamente. El resultado también nos proporciona las `publicIpAddress` y `privateIpAddress` de nuestro nodo principal.
## Inicio de sesión en su nodo principal
Use su archivo OpenSSH para iniciar sesión en el nodo principal.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
Después de iniciar sesión, ejecute el comando `sinfo` para comprobar que sus nodos de computación se instalan y configuran.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
El resultado muestra que tenemos una cola en nuestro clúster, con hasta diez nodos.
## Ejecución de su primer trabajo con Slurm
A continuación, creamos un trabajo que entra en suspensión durante un tiempo y luego genera su propio nombre de host. Cree un archivo denominado `hellojob.sh` con el siguiente contenido.
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
A continuación, envíe el trabajo mediante `sbatch` y compruebe que se ejecuta.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
Ahora puede ver la cola y comprobar el estado del trabajo. El aprovisionamiento de una nueva instancia Amazon EC2 se inicia en segundo plano. Puede monitorizar el estado de las instancias del clúster con el comando `sinfo`.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
El resultado muestra que se ha enviado el trabajo a `queue1`. Espere 30 segundos a que el trabajo se termine y, a continuación, vuelva a ejecutar `squeue`.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
Ahora que no hay trabajos en la cola, podemos comprobar el resultado en nuestro directorio actual.
```
$ ls -l
total 8
-rw-rw-r-- 1 ec2-user ec2-user 57 Sep 1 14:25 hellojob.sh
-rw-rw-r-- 1 ec2-user ec2-user 43 Sep 1 14:30 slurm-2.out
```
En el resultado, vemos un archivo “`out`”. Podemos ver el resultado de nuestro trabajo:
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
El resultado también muestra que nuestro trabajo se ha ejecutado correctamente en la instancia `queue1-dy-queue1t2micro-1`.
En el clúster que acaba de crear, solo el directorio principal se comparte entre todos los nodos del clúster.
Para obtener más información acerca de la creación y el uso de clústeres, consulte [Prácticas recomendadas](best-practices-v3.md).
Si la aplicación requiere software, bibliotecas o datos compartidos, considere las siguientes opciones:
+ Cree una AMI personalizada y AWS ParallelCluster habilitada que incluya su software, tal y como se describe en[Creación de una AWS ParallelCluster AMI personalizada](building-custom-ami-v3.md).
+ Utilice la [StorageSettings](SharedStorage-v3.md)opción del archivo de AWS ParallelCluster configuración para especificar un sistema de archivos compartido y almacenar el software instalado en la ubicación de montaje especificada.
+ Use [Acciones de arranque personalizadas](custom-bootstrap-actions-v3.md) para automatizar el procedimiento de arranque de cada nodo del clúster.
# Creación de una AWS ParallelCluster AMI personalizada
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**importante**
Si crea una AMI personalizada, debe repetir los pasos que utilizó para crear la AMI personalizada con cada nueva versión de AWS ParallelCluster .
Antes de seguir leyendo le recomendamos revisar la sección [Acciones de arranque personalizadas](custom-bootstrap-actions-v3.md). Determine si las modificaciones que desea realizar se pueden incluir en un script y son compatibles con futuras versiones de AWS ParallelCluster .
Si bien crear una AMI personalizada en general no es lo ideal, hay situaciones específicas en las que AWS ParallelCluster es necesario crear una AMI personalizada. En este tutorial encontrará una introducción a una AMI personalizada para estos escenarios.
**Requisitos previos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md) y crear imágenes.
## Cómo personalizar la AWS ParallelCluster AMI
Hay dos formas de crear una AWS ParallelCluster AMI personalizada. Uno de estos dos métodos consiste en crear una AMI nueva mediante la AWS ParallelCluster CLI. Otro método requiere que realice modificaciones manuales para crear una nueva AMI que esté disponible en su Cuenta de AWS.
## Cree una AWS ParallelCluster AMI personalizada
Si tiene una AMI y un software personalizados, puede aplicar los cambios necesarios AWS ParallelCluster sobre ellos. AWS ParallelCluster se basa en el servicio EC2 Image Builder para crear AMIs productos personalizados. Para obtener más información, consulte la [Guía de usuario de Generador de imágenes](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
Puntos clave
+ El proceso tarda unos 60 minutos. Este tiempo puede variar si hay más [`Build`](Build-v3.md)/[`Components`](Build-v3.md#Build-v3-Components) que instalar en el momento de la construcción.
+ La AMI está etiquetada con las versiones de los componentes principales. Estas incluyen el núcleo, el programador y el controlador [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). En la descripción de la AMI también se indica un subconjunto de las versiones de los componentes.
+ A partir de la AWS ParallelCluster versión 3.0.0, se puede utilizar un nuevo conjunto de comandos CLI para gestionar el ciclo de vida de las imágenes. Esto incluye [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md) y [`delete-image`](pcluster.delete-image-v3.md).
+ Este método se puede repetir. Puede volver a ejecutarlo para mantenerlo AMIs actualizado (por ejemplo, las actualizaciones del sistema operativo) y, a continuación, utilizarlos cuando actualice un clúster existente.
**nota**
Si utiliza este método en la partición de AWS China, es posible que se produzcan errores de red. Por ejemplo, es posible que veas estos errores en el `pcluster build-image` comando cuando descarga paquetes desde GitHub o desde un repositorio del sistema operativo. Si esto ocurre, le recomendamos que utilice uno de los siguientes métodos alternativos:
Siga el [Modificar una AWS ParallelCluster AMI](#modify-an-aws-parallelcluster-ami-v3) enfoque que omite este comando.
Cree la imagen en otra partición o región, por ejemplo`us-east-1`, y luego store/restore muévala a la región de China. Para obtener más información, consulte [Almacenamiento y restauración de una AMI usando S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) en la *Guía del usuario de Amazon EC2*.
Pasos:
1. Configura tus Cuenta de AWS credenciales para que el AWS ParallelCluster cliente pueda realizar llamadas a las operaciones de la AWS API en tu nombre. Para obtener una lista de los permisos necesarios, consulte [AWS Identity and Access Management permisos en AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md).
1. Cree un archivo de configuración de *imagen de compilación* básico. Para ello, especifique el [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType)que se utilizará para crear la imagen y el [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage). Se utilizan como punto de partida para crear la AMI. Para obtener más información acerca de los parámetros de configuración opcionales, consulte [Configuración de imagen](image-builder-configuration-file-v3.md).
```
Build:
InstanceType:
ParentImage:
```
1. Utilice el comando CLI [`pcluster build-image`](pcluster.build-image-v3.md)para crear una AWS ParallelCluster AMI a partir de la AMI que proporciona como base.
```
$ pcluster build-image --image-id IMAGE_ID --image-configuration IMAGE_CONFIG.yaml --region REGION
{
"image": {
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_IN_PROGRESS",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"region": "us-east-1",
"version": "3.15.0"
}
}
```
**aviso**
`pcluster build-image` utiliza la VPC predeterminada. Si elimina la VPC predeterminada mediante AWS Control Tower una zona de AWS destino, el ID de subred debe especificarse en el archivo de configuración de la imagen. Para obtener más información, consulte [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId).
Para obtener una lista de otros parámetros, consulte la página de referencia de comandos [`pcluster build-image`](pcluster.build-image-v3.md). Los resultados del comando anterior son los siguientes:
+ Se crea una CloudFormation pila en función de la configuración de la imagen. La pila incluye todos los recursos de Generador de imágenes de EC2 necesarios para la compilación.
+ Los recursos creados incluyen los AWS ParallelCluster componentes oficiales de Image Builder a los que se pueden añadir componentes personalizados de Image Builder. Para obtener más información, consulte [Creación de un componente personalizado con Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) en la Guía del *usuario de EC2 Image Builder*.
+ EC2 Image Builder lanza una instancia de compilación, aplica AWS ParallelCluster el libro de cocina, instala la pila de software y realiza AWS ParallelCluster las tareas de configuración necesarias. El AWS ParallelCluster libro de cocina se utiliza para compilar y arrancar. AWS ParallelCluster
+ La instancia se detiene y se crea una nueva AMI a partir de ella.
+ Se lanza otra instancia desde la AMI recién creada. Durante la fase de prueba, Generador de imágenes de EC2 ejecuta las pruebas definidas en los componentes de Generador de imágenes.
+ Si la compilación se realiza correctamente, se elimina la pila. Si la compilación falla, la pila se retiene y está disponible para su inspección.
1. Puede monitorear el estado del proceso de compilación si ejecuta el siguiente comando. Una vez completada la compilación, puede ejecutarla para recuperar el ID de AMI indicado en la respuesta.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
# BEFORE COMPLETE
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?...",
},
"imageId": "IMAGE_ID",
"imagebuilderImageStatus": "BUILDING",
"imageBuildStatus": "BUILD_IN_PROGRESS",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"region": "us-east-1",
"version": "3.15.0",
"cloudformationStackTags": [
{
"value": "3.15.0",
"key": "parallelcluster:version"
},
{
"value": "IMAGE_ID",
"key": "parallelcluster:image_name"
},
...
],
"imageBuildLogsArn": "arn:aws:logs:us-east-1:123456789012:log-group:/aws/imagebuilder/ParallelClusterImage-IMAGE_ID",
"cloudformationStackCreationTime": "2022-04-05T21:36:26.176Z"
}
# AFTER COMPLETE
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.us-east-1.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?Signature=..."
},
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_COMPLETE",
"region": "us-east-1",
"ec2AmiInfo": {
"amiName": "IMAGE_ID 2022-04-05T21-39-24.020Z",
"amiId": "ami-1234stuv5678wxyz",
"description": "AWS ParallelCluster AMI for alinux2, kernel-4.14.238-182.422.amzn2.x86_64, lustre-2.10.8-5.amzn2.x86_64, efa-1.13.0-1.amzn2.x86_64, dcv-2021.1.10598-1.el7.x86_64, slurm-20-11-8-1",
"state": "AVAILABLE",
"tags": [
{
"value": "2021.3.11591-1.el7.x86_64",
"key": "parallelcluster:dcv_version"
},
...
],
"architecture": "x86_64"
},
"version": "3.15.0"
}
```
1. Para crear el clúster, especifique el ID de AMI en el campo [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) de la configuración del clúster.
**Solución de problemas y supervisión del proceso de creación de AMI**
La creación de la imagen se completa en aproximadamente una hora. Puede supervisar el proceso ejecutando el comando [`pcluster describe-image`](pcluster.describe-image-v3.md) o los comandos de recuperación de registros.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
El [`build-image`](pcluster.build-image-v3.md)comando crea una CloudFormation pila con todos los recursos de Amazon EC2 necesarios para crear la imagen e inicia el proceso de EC2 Image Builder.
Tras ejecutar el [`build-image`](pcluster.build-image-v3.md)comando, es posible recuperar los eventos de la CloudFormation pila mediante. [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md) Puede filtrar los resultados con el `--query` parámetro para ver los eventos más recientes. Para obtener más información, consulte [Filtrar los AWS CLI resultados](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html) en la *Guía del AWS Command Line Interface usuario*.
```
$ pcluster get-image-stack-events --image-id IMAGE_ID --region REGION --query "events[0]"
{
"eventId": "ParallelClusterImage-CREATE_IN_PROGRESS-2022-04-05T21:39:24.725Z",
"physicalResourceId": "arn:aws:imagebuilder:us-east-1:123456789012:image/parallelclusterimage-IMAGE_ID/3.15.0/1",
"resourceStatus": "CREATE_IN_PROGRESS",
"resourceStatusReason": "Resource creation Initiated",
"resourceProperties": "{\"InfrastructureConfigurationArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:infrastructure-configuration/parallelclusterimage-abcd1234-ef56-gh78-ij90-1234abcd5678\",\"ImageRecipeArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:image-recipe/parallelclusterimage-IMAGE_ID/3.15.0\",\"DistributionConfigurationArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:distribution-configuration/parallelclusterimage-abcd1234-ef56-gh78-ij90-1234abcd5678\",\"Tags\":{\"parallelcluster:image_name\":\"IMAGE_ID\",\"parallelcluster:image_id\":\"IMAGE_ID\"}}",
"stackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"stackName": "IMAGE_ID",
"logicalResourceId": "ParallelClusterImage",
"resourceType": "AWS::ImageBuilder::Image",
"timestamp": "2022-04-05T21:39:24.725Z"
}
```
Después de unos 15 minutos, los eventos de la pila aparecen en la entrada del evento de registro relacionada con la creación de Generador de imágenes. Ahora puede enumerar los flujos de registro de imágenes y supervisar los pasos de Generador de imágenes mediante los comandos [`pcluster list-image-log-streams`](pcluster.list-image-log-streams-v3.md) y [`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md).
```
$ pcluster list-image-log-streams --image-id IMAGE_ID --region REGION \
--query 'logStreams[*].logStreamName'
"3.15.0/1"
]
$ pcluster get-image-log-events --image-id IMAGE_ID --region REGION \
--log-stream-name 3.15.0/1 --limit 3
{
"nextToken": "f/36295977202298886557255241372854078762600452615936671762",
"prevToken": "b/36295977196879805474012299949460899222346900769983430672",
"events": [
{
"message": "ExecuteBash: FINISHED EXECUTION",
"timestamp": "2022-04-05T22:13:26.633Z"
},
{
"message": "Document arn:aws:imagebuilder:us-east-1:123456789012:component/parallelclusterimage-test-abcd1234-ef56-gh78-ij90-1234abcd5678/3.15.0/1",
"timestamp": "2022-04-05T22:13:26.741Z"
},
{
"message": "TOE has completed execution successfully",
"timestamp": "2022-04-05T22:13:26.819Z"
}
]
}
```
Continúe comprobando con el comando [`describe-image`](pcluster.describe-image-v3.md) hasta que vea el estado `BUILD_COMPLETE`.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.us-east-1.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?Signature=..."
},
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_COMPLETE",
"region": "us-east-1",
"ec2AmiInfo": {
"amiName": "IMAGE_ID 2022-04-05T21-39-24.020Z",
"amiId": "ami-1234stuv5678wxyz",
"description": "AWS ParallelCluster AMI for alinux2, kernel-4.14.238-182.422.amzn2.x86_64, lustre-2.10.8-5.amzn2.x86_64, efa-1.13.0-1.amzn2.x86_64, dcv-2021.1.10598-1.el7.x86_64, slurm-20-11-8-1",
"state": "AVAILABLE",
"tags": [
{
"value": "2021.3.11591-1.el7.x86_64",
"key": "parallelcluster:dcv_version"
},
...
],
"architecture": "x86_64"
},
"version": "3.15.0"
}
```
Si necesita solucionar un problema de creación de una AMI personalizada, cree un archivo con los registros de imágenes tal y como se describe en los pasos siguientes.
Puede archivar los registros en Amazon S3 o en un archivo local (según el parámetro `--output`).
```
$ pcluster export-image-logs --image-id IMAGE_ID --region REGION \
--bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER
{
"url": "https://BUCKET_NAME.s3.us-east-1.amazonaws.com/BUCKET-FOLDER/IMAGE_ID-logs-202209071136.tar.gz?AWSAccessKeyId=..."
}
$ pcluster export-image-logs --image-id IMAGE_ID \
--region REGION --bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER --output-file /tmp/archive.tar.gz
{
"path": "/tmp/archive.tar.gz"
}
```
El archivo contiene los flujos de CloudWatch registros relacionados con el proceso de Image Builder y los eventos de CloudFormation pila. El proceso puede tardar varios minutos en completarse.
**Gestión personalizada AMIs**
A partir de la AWS ParallelCluster versión 3.0.0, se ha agregado un nuevo conjunto de comandos a la CLI para crear, monitorear y administrar el ciclo de vida de la imagen. Para obtener más información sobre el comando, consulte [Comandos pcluster](pcluster-v3.md).
## Modificar una AWS ParallelCluster AMI
Este método consiste en modificar una AWS ParallelCluster AMI oficial añadiéndole personalización por encima. La base AWS ParallelCluster AMIs se actualiza con las nuevas versiones. AMIs Tienen todos los componentes necesarios AWS ParallelCluster para funcionar cuando se instalan y configuran. Puede empezar con una de ellas como base.
Puntos clave:
+ Este método es más rápido que el comando [`build-image`](pcluster.build-image-v3.md). Sin embargo, es un proceso manual y no se puede repetir automáticamente.
+ Con este método, no tiene acceso a los comandos de recuperación de registros y administración del ciclo de vida de las imágenes que están disponibles a través de la CLI.
Pasos:
------
#### [ New Amazon EC2 console ]
1. Busque la AMI que corresponda a la específica Región de AWS que utiliza. Para encontrarlo, utilice el [`pcluster list-official-images`](pcluster.list-official-images-v3.md)comando con el `--region` parámetro para seleccionar los `--architecture` parámetros Región de AWS y `--os` y filtros específicos para la AMI deseada con el sistema operativo y la arquitectura que desee utilizar. De la salida, recupere el ID de imagen de Amazon EC2.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, elija **Imágenes** y, a continuación **AMIs**. Busque el ID de imagen EC2 recuperado, seleccione la AMI y elija **Lanzar instancia a partir de una AMI**.
1. Desplácese hacia abajo y elija el **tipo de instancia**.
1. Elija su **Par de claves** y **Lanzar instancias**.
1. Inicie sesión en la instancia mediante el usuario del sistema operativo y su clave de SSH.
1. Personalice la instancia de forma manual para cumplir con sus requisitos.
1. Ejecute el siguiente comando para preparar su instancia para la creación de la AMI:
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Desde la consola, seleccione **Estado de instancia** y a continuación seleccione **Detener instancia**.
Navegue a **Instancias**, elija la nueva instancia, seleccione **Estado de la instancia**, y **Detener instancia**
1. [Cree una AMI nueva a partir de la instancia mediante la consola Amazon EC2 o AWS CLI cree una imagen.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Desde la consola de Amazon EC2**
1. Elija **Instances** (Instancia[s]) en el panel de navegación.
1. Elija la instancia que creó y modificó.
1. Elija **Acciones**, **Imagen** y a continuación, **Crear imagen**.
1. Elija **Create Image (Crear imagen)**.
1. Especifique el ID de AMI en el campo [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) de la configuración del clúster y cree un clúster.
------
#### [ Old Amazon EC2 console ]
1. Busque la AWS ParallelCluster AMI que corresponda a la específica Región de AWS que utiliza. Para encontrarlo, puede usar el [`pcluster list-official-images`](pcluster.list-official-images-v3.md)comando con el `--region` parámetro para seleccionar los `--architecture` parámetros Región de AWS y `--os` y filtrar específicos para la AMI deseada con el sistema operativo y la arquitectura que desee usar. De la salida, puede recuperar el ID de imagen de Amazon EC2.
1. Inicie sesión en la consola Amazon EC2 Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. En el panel de navegación, elija **Imágenes** y, a continuación **AMIs**. Defina el filtro para **imágenes públicas** y busque el ID de imagen EC2 recuperado, seleccione la AMI y elija **Launch**.
1. Elija el tipo de instancia y seleccione **Siguiente: configurar los detalles de la instancia** o **Revisar y lanzar** para lanzar la instancia.
1. Elija **Lanzar**, seleccione su **par de claves** y **lance las instancias**.
1. Inicie sesión en la instancia mediante el usuario del sistema operativo y su clave de SSH. Para obtener más información, vaya a **Instancias**, seleccione la nueva instancia y **Conectar**.
1. Personalice la instancia de forma manual para cumplir con sus requisitos.
1. Ejecute el siguiente comando para preparar su instancia para la creación de la AMI:
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. En la consola de Amazon EC2, elija **Instancias** en el panel de navegación, seleccione la nueva instancia y elija **Acciones**, **Estado de la instancia** y **Detener**.
1. [Cree una AMI nueva a partir de la instancia mediante la consola Amazon EC2 o AWS CLI cree una imagen.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Desde la consola de Amazon EC2**
1. Elija **Instances** (Instancia[s]) en el panel de navegación.
1. Elija la instancia que creó y modificó.
1. Elija **Acciones**, **Imagen** y a continuación, **Crear imagen**.
1. Elija **Create Image (Crear imagen)**.
1. Especifique el ID de AMI en el campo [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) de la configuración del clúster y cree un clúster.
------
# Integración de Active Directory
En este tutorial, se crea un entorno de varios usuarios. Este entorno incluye un AWS ParallelCluster que está integrado con un AWS Managed Microsoft AD (Active Directory) en`corp.example.com`. Se configura un `Admin` usuario para que administre el directorio, un `ReadOnly` usuario para que lea el directorio y un `user000` usuario para que inicie sesión en el clúster. Puede usar la ruta automática o la ruta manual para crear los recursos de red, un Active Directory (AD) y la instancia de Amazon EC2 que utiliza para configurar el AD. Independientemente de la ruta, la infraestructura que cree está preconfigurada para integrarse AWS ParallelCluster mediante uno de los siguientes métodos:
+ LDAPS con verificación de certificados (se recomienda como la opción más segura)
+ sobre LDAPS sin verificación de certificados
+ LDAP
El LDAP por sí solo *no proporciona cifrado*. Para garantizar la transmisión segura de información potencialmente confidencial, le recomendamos encarecidamente que utilice LDAPS (LDAP sobre TLS/SSL) para los clústeres integrados con ellos. ADs *Para obtener más información, consulte [Habilitar el uso de LDAPS del lado del servidor en la Guía de administración. AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html) Directory Service *
Tras crear estos recursos, proceda a configurar y crear el clúster integrado con su Active Directory (AD). Una vez que se cree el clúster, inicie sesión como el usuario que creó. Para obtener más información sobre la configuración que se crea en este tutorial, consulte [Acceso de varios usuarios a los clústeres](multi-user-v3.md) la sección [`DirectoryService`](DirectoryService-v3.md)de configuración.
En este tutorial se explica cómo crear un entorno que admita el acceso de varios usuarios a los clústeres. En este tutorial no se explica cómo crear y utilizar un AD. Directory Service Los pasos que debe seguir para configurar un AWS Managed Microsoft AD en este tutorial se proporcionan únicamente con fines de prueba. *No* se proporcionan para reemplazar la documentación oficial y las mejores prácticas que puede encontrar en [AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)[Simple AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html) en la *Guía de Directory Service administración*.
**nota**
Las contraseñas de los usuarios de directorios caducan según las definiciones de propiedades de la política de contraseñas de los directorios. Para restablecer las contraseñas de los directorios con AWS ParallelCluster, consulte[Cómo restablecer una contraseña de usuario y contraseñas caducadas](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd).
**nota**
Las direcciones IP del controlador de dominio del directorio pueden cambiar debido a los cambios en el controlador de dominio y al mantenimiento del directorio. Si ha elegido el método de creación rápida automática para crear la infraestructura de directorios, debe alinear manualmente el equilibrador de carga frente a los controladores de directorios cuando cambien las direcciones IP del directorio. Si utiliza el método de creación rápida, las direcciones IP del directorio no se alinean automáticamente con los equilibradores de carga.
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
A medida que avance en el tutorial`inputs highlighted in red`, reemplace, como `region-id` y`d-abcdef01234567890`, por sus propios nombres y IDs. `0123456789012`Sustitúyalo por tu Cuenta de AWS número.
# Creación de la infraestructura de AD
Seleccione la pestaña *Automatizado* para crear la infraestructura de Active Directory (AD) con una plantilla de creación CloudFormation rápida.
Seleccione la pestaña *Manual* para crear manualmente la infraestructura de AD.
## Automatizado
1. Inicie sesión en Consola de administración de AWS.
1. Abre [CloudFormation Quick Create (region us-east-1](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-ad&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/ad-integration.yaml)) para crear los siguientes recursos en la consola: CloudFormation
+ Una VPC con dos subredes y enrutamiento para acceso público, si no se especifica ninguna VPC.
+ Un. AWS Managed Microsoft AD
+ Una instancia de Amazon EC2 unida al AD que puede usar para administrar el directorio.
1. En la sección **Parámetros** **Creación rápida de pila**, proporcione valores para los parámetros siguientes:
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Anote la contraseña. Los necesitará más adelante en este tutorial.
1. En **DomainName**, introduzca **corp.example.com**
1. En **Par de claves**, escriba el nombre del par de claves de Amazon EC2.
1. Elija las casillas de verificación para confirmar las capacidades de acceso en la parte inferior de la página.
1. Seleccione **Creación de pila**.
1. Una vez que la CloudFormation pila haya alcanzado el `CREATE_COMPLETE` estado, seleccione la pestaña **Salidas** de la pila. Anote los nombres de los recursos de salida y las razones IDs por las que necesitará usarlos en pasos posteriores. Los resultados proporcionan la información necesaria para crear el clúster.
![\[Un diagrama que muestra los resultados de la pila creada en Consola de administración de AWS.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/ad-cfn.png)
1. Para completar los ejercicios[(Opcional) Administrar los usuarios y grupos de AD](tutorials_05_multi-user-ad-step2.md), necesitará el ID del directorio. Elija **Recursos** y desplácese hacia abajo para anotar el ID del directorio.
1. Continúe en [(Opcional) Administrar los usuarios y grupos de AD](tutorials_05_multi-user-ad-step2.md) o[Cree el clúster](tutorials_05_multi-user-ad-step3.md).
## Manual
Los servidores de directorio se crean en dos subredes en dos zonas de disponibilidad diferentes dentro de una VPC.
### Crea el AD
**nota**
El directorio y el nombre de dominio son`corp.example.com`. El formato del nombre es `CORP`.
Cambie la `Admin` contraseña en el script.
La creación de Active Directory (AD) tarda al menos 15 minutos.
Utilice la siguiente secuencia de comandos de Python para crear los recursos de VPC, subredes y AD en su entorno local. Región de AWS Guarda este archivo como `ad.py` y ejecútalo.
```
import boto3
import time
from pprint import pprint
vpc_name = "PclusterVPC"
ad_domain = "corp.example.com"
admin_password = "asdfASDF1234"
ec2 = boto3.client("ec2")
ds = boto3.client("ds")
region = boto3.Session().region_name
# Create the VPC, Subnets, IGW, Routes
vpc = ec2.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
vpc_id = vpc["VpcId"]
time.sleep(30)
ec2.create_tags(Resources=[vpc_id], Tags=[{"Key": "Name", "Value": vpc_name}])
subnet1 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.0.0/17", AvailabilityZone=f"{region}a")["Subnet"]
subnet1_id = subnet1["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet1_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet1"}])
ec2.modify_subnet_attribute(SubnetId=subnet1_id, MapPublicIpOnLaunch={"Value": True})
subnet2 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.128.0/17", AvailabilityZone=f"{region}b")["Subnet"]
subnet2_id = subnet2["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet2_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet2"}])
ec2.modify_subnet_attribute(SubnetId=subnet2_id, MapPublicIpOnLaunch={"Value": True})
igw = ec2.create_internet_gateway()["InternetGateway"]
ec2.attach_internet_gateway(InternetGatewayId=igw["InternetGatewayId"], VpcId=vpc_id)
route_table = ec2.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])["RouteTables"][0]
ec2.create_route(RouteTableId=route_table["RouteTableId"], DestinationCidrBlock="0.0.0.0/0", GatewayId=igw["InternetGatewayId"])
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={"Value": True})
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={"Value": True})
# Create the Active Directory
ad = ds.create_microsoft_ad(
Name=ad_domain,
Password=admin_password,
Description="ParallelCluster AD",
VpcSettings={"VpcId": vpc_id, "SubnetIds": [subnet1_id, subnet2_id]},
Edition="Standard",
)
directory_id = ad["DirectoryId"]
# Wait for completion
print("Waiting for the directory to be created...")
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
while directory["Stage"] in {"Requested", "Creating"}:
time.sleep(3)
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
dns_ip_addrs = directory["DnsIpAddrs"]
pprint({"directory_id": directory_id,
"vpc_id": vpc_id,
"subnet1_id": subnet1_id,
"subnet2_id": subnet2_id,
"dns_ip_addrs": dns_ip_addrs})
```
A continuación se muestra un ejemplo de salida del comando.
```
{
"directory_id": "d-abcdef01234567890",
"dns_ip_addrs": ["192.0.2.254", "203.0.113.237"],
"subnet1_id": "subnet-021345abcdef6789",
"subnet2_id": "subnet-1234567890abcdef0",
"vpc_id": "vpc-021345abcdef6789"
}
```
Anote los nombres de los recursos de salida y. IDs Los usará en pasos posteriores.
Una vez finalizada la secuencia de comandos, continúe con el siguiente paso.
### Crear una instancia de Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Inicie sesión en Consola de administración de AWS.
1. Si no tiene un rol al que se adjunten las políticas enumeradas en el paso 4, abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). De lo contrario, vaya al paso 8.
1. Cree la `ResetUserPassword` política y sustituya el contenido resaltado en rojo por su Región de AWS ID, ID de cuenta y ID de directorio del resultado del script que ejecutó para crear el AD.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Cree un rol de IAM con la siguiente política asociada.
+ AWS política gestionada [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS política gestionada [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword política
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el **panel de Amazon EC2**, elija **Lanzar instancia**.
1. En **Imágenes de aplicaciones y sistemas operativos**, seleccione una AMI reciente de Amazon Linux 2.
1. Para **Tipo de instancia**, elija t2.micro.
1. En **Par de claves**, elija un par de claves.
1. En **Configuración de red**, elija **Editar**.
1. Seleccione la VPC del directorio.
1. Desplácese hacia abajo y seleccione **Detalles avanzados**.
1. En **Detalles avanzados**, **Directorio de unión al dominio**, elija **corp.example.com**.
1. Para el **perfil de instancia de IAM**, elija el rol que creó en el paso 1 o un rol al que se adjunten las políticas enumeradas en el paso 4.
1. En **Resumen**, elija **Lanzar instancia**.
1. Anote el ID de la instancia (por ejemplo, i-1234567890abcdef0) y espere a que la instancia termine de lanzarse.
1. Una vez que el estado de la instancia cambie a , proceda con el siguiente paso.
------
#### [ Old Amazon EC2 console ]
1. Inicie sesión en Consola de administración de AWS.
1. Si no tiene un rol al que se adjunten las políticas enumeradas en el paso 4, abra la consola de IAM en [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). De lo contrario, vaya al paso 8.
1. Cree la política de `ResetUserPassword`. Sustituya el contenido resaltado en rojo por su Región de AWS Cuenta de AWS ID, ID y ID de directorio del resultado del script que ejecutó para crear Active Directory (AD).
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Cree un rol de IAM con la siguiente política asociada.
+ AWS política gestionada [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS política gestionada [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ Política ResetUserPassword
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el **panel de Amazon EC2**, elija **Lanzar instancia**.
1. En **Imágenes de aplicaciones y sistemas operativos**, seleccione una AMI reciente de Amazon Linux 2.
1. Para **Tipo de instancia**, elija t2.micro.
1. En **Par de claves**, elija un par de claves.
1. En **Configuración de red**, elija **Editar**.
1. En **Configuración de red**, **VPC**, seleccione el directorio VPC.
1. Desplácese hacia abajo y seleccione **Detalles avanzados**.
1. En **Detalles avanzados**, **Directorio de unión al dominio**, elija **corp.example.com**.
1. En **Detalles avanzados**, **perfil de instancia**, elija el rol que creó en el paso 1 o un rol al que se adjunten las políticas que se enumeran en el paso 4.
1. En **Resumen**, elija **Lanzar instancia**.
1. Anote el ID de la instancia (por ejemploi-1234567890abcdef0) y espere a que la instancia termine de lanzarse.
1. Una vez que el estado de la instancia cambie a , proceda con el siguiente paso.
------
### Unión de su instancia al AD
1.
**Conéctese a su instancia y únase al dominio AD como`admin`.**
Conéctese a la instancia y ejecute el siguiente comando.
```
$ INSTANCE_ID="i-1234567890abcdef0"
```
```
$ PUBLIC_IP=$(aws ec2 describe-instances \
--instance-ids $INSTANCE_ID \
--query "Reservations[0].Instances[0].PublicIpAddress" \
--output text)
```
```
$ ssh -i ~/.ssh/keys/keypair.pem ec2-user@$PUBLIC_IP
```
1.
**Instala el software necesario y únete al reino.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Sustituya la contraseña por la nueva contraseña.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Si lo anterior se ha realizado correctamente, se unirá al reino y continúe con el siguiente paso.
### Añada usuarios a la cuenta.
1.
**Crea el ReadOnlyUser y un usuario adicional.**
En este paso, utilizará las herramientas [adcli](https://www.mankier.com/package/adcli) y [openldap-clients](https://www.mankier.com/package/openldap-clients) que instaló en el paso anterior.
```
$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=ReadOnlyUser ReadOnlyUser
```
```
$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=user000 user000
```
1. **Compruebe que se hayan creado los usuarios:**
Las direcciones IP DNS del directorio son salidas del script de Python.
```
$ DIRECTORY_IP="192.0.2.254"
```
```
$ ldapsearch -x -h $DIRECTORY_IP -D Admin -w $ADMIN_PW -b "cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com"
```
```
$ ldapsearch -x -h $DIRECTORY_IP -D Admin -w $ADMIN_PW -b "cn=user000,ou=Users,ou=CORP,dc=corp,dc=example,dc=com"
```
De forma predeterminada, cuando se crea un usuario con`ad-cli`, el usuario está deshabilitado.
1.
****Restablezca y active las contraseñas de los usuarios desde su máquina local:****
Cierre la sesión de su instancia de Amazon EC2.
**nota**
`ro-p@ssw0rd`es la contraseña de`ReadOnlyUser`, recuperada de AWS Secrets Manager.
`user-p@ssw0rd` es la contraseña de un usuario del clúster que se proporciona cuando se conecta (`ssh`) al clúster.
`directory-id`Es una salida del script de Python.
```
$ DIRECTORY_ID="d-abcdef01234567890"
```
```
$ aws ds reset-user-password \
--directory-id $DIRECTORY_ID \
--user-name "ReadOnlyUser" \
--new-password "ro-p@ssw0rd" \
--region "region-id"
```
```
$ aws ds reset-user-password \
--directory-id $DIRECTORY_ID \
--user-name "user000" \
--new-password "user-p@ssw0rd" \
--region "region-id"
```
1. **Añade la contraseña a un secreto de Secrets Manager.**
Ahora que ha creado una contraseña `ReadOnlyUser` y la ha establecido, guárdela en un lugar secreto que se AWS ParallelCluster utilice para validar los inicios de sesión.
Use Secrets Manager para crear un nuevo secreto que contenga la contraseña `ReadOnlyUser` como valor. El formato del valor secreto debe ser solo texto plano (no formato JSON). Toma nota del ARN secreto para futuros pasos.
```
$ aws secretsmanager create-secret --name "ADSecretPassword" \
--region region_id \
--secret-string "ro-p@ssw0rd" \
--query ARN \
--output text
arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
```
### Configuración de LDAPS con verificación de certificados (recomendada)
Toma nota del recurso. IDs Los usará en pasos posteriores.
1.
**Genere el certificado de dominio de forma local.**
```
$ PRIVATE_KEY="corp-example-com.key"
CERTIFICATE="corp-example-com.crt"
printf ".\n.\n.\n.\n.\ncorp.example.com\n.\n" | openssl req -x509 -sha256 -nodes -newkey rsa:2048 -keyout $PRIVATE_KEY -days 365 -out $CERTIFICATE
```
1.
**Guarde el certificado en Secrets Manager para poder recuperarlo del clúster más adelante.**
```
$ aws secretsmanager create-secret --name example-cert \
--secret-string file://$CERTIFICATE \
--region region-id
{
"ARN": "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
"Name": "example-cert",
"VersionId": "14866070-092a-4d5a-bcdd-9219d0566b9c"
}
```
1. Agregue la siguiente política al rol de IAM que creó para unir la instancia de Amazon EC2 con el dominio de AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Importe el certificado a AWS Certificate Manager (ACM).**
```
$ aws acm import-certificate --certificate fileb://$CERTIFICATE \
--private-key fileb://$PRIVATE_KEY \
--region region-id
{
"CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
}
```
1.
**Cree el equilibrador de carga que se coloca delante de los puntos de conexión de Active Directory.**
```
$ aws elbv2 create-load-balancer --name CorpExampleCom-NLB \
--type network \
--scheme internal \
--subnets subnet-1234567890abcdef0 subnet-021345abcdef6789 \
--region region-id
{
"LoadBalancers": [
{
"LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"CanonicalHostedZoneId": "Z2IFOLAFXWLO4F",
"CreatedTime": "2022-05-05T12:56:55.988000+00:00",
"LoadBalancerName": "CorpExampleCom-NLB",
"Scheme": "internal",
"VpcId": "vpc-021345abcdef6789",
"State": {
"Code": "provisioning"
},
"Type": "network",
"AvailabilityZones": [
{
"ZoneName": "region-idb",
"SubnetId": "subnet-021345abcdef6789",
"LoadBalancerAddresses": []
},
{
"ZoneName": "region-ida",
"SubnetId": "subnet-1234567890abcdef0",
"LoadBalancerAddresses": []
}
],
"IpAddressType": "ipv4"
}
]
}
```
1.
**Cree el grupo objetivo que se dirige a los puntos de conexión de Active Directory.**
```
$ aws elbv2 create-target-group --name CorpExampleCom-Targets --protocol TCP \
--port 389 \
--target-type ip \
--vpc-id vpc-021345abcdef6789 \
--region region-id
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
"TargetGroupName": "CorpExampleCom-Targets",
"Protocol": "TCP",
"Port": 389,
"VpcId": "vpc-021345abcdef6789",
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 10,
"HealthyThresholdCount": 3,
"UnhealthyThresholdCount": 3,
"TargetType": "ip",
"IpAddressType": "ipv4"
}
]
}
```
1.
**Registre los puntos de conexión de Active Directory (AD) en el grupo de destino.**
```
$ aws elbv2 register-targets --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
--targets Id=192.0.2.254,Port=389 Id=203.0.113.237,Port=389 \
--region region-id
```
1.
**Cree el oyente de LB con el certificado.**
```
$ aws elbv2 create-listener --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 \
--protocol TLS \
--port 636 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
--ssl-policy ELBSecurityPolicy-TLS-1-2-2017-01 \
--certificates CertificateArn=arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 \
--region region-id
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
"Port": 636,
"Protocol": "TLS",
"Certificates": [
{
"CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
}
],
"SslPolicy": "ELBSecurityPolicy-TLS-1-2-2017-01",
"DefaultActions": [
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81"
}
]
}
}
]
}
]
}
```
1.
**Cree la zona alojada para que el dominio se pueda detectar en la VPC del clúster.**
```
$ aws route53 create-hosted-zone --name corp.example.com \
--vpc VPCRegion=region-id,VPCId=vpc-021345abcdef6789 \
--caller-reference "ParallelCluster AD Tutorial"
{
"Location": "https://route53.amazonaws.com/2013-04-01/hostedzone/Z09020002B5MZQNXMSJUB",
"HostedZone": {
"Id": "/hostedzone/Z09020002B5MZQNXMSJUB",
"Name": "corp.example.com.",
"CallerReference": "ParallelCluster AD Tutorial",
"Config": {
"PrivateZone": true
},
"ResourceRecordSetCount": 2
},
"ChangeInfo": {
"Id": "/change/C05533343BF3IKSORW1TQ",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T13:21:53.863000+00:00"
},
"VPC": {
"VPCRegion": "region-id",
"VPCId": "vpc-021345abcdef6789"
}
}
```
1.
**Cree un archivo denominado `recordset-change.json` con el contenido siguiente. `HostedZoneId` es el ID de zona alojada canónico del equilibrador de carga.**
```
{
"Changes": [
{
"Action": "CREATE",
"ResourceRecordSet": {
"Name": "corp.example.com",
"Type": "A",
"Region": "region-id",
"SetIdentifier": "example-active-directory",
"AliasTarget": {
"HostedZoneId": "Z2IFOLAFXWLO4F",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"EvaluateTargetHealth": true
}
}
}
]
}
```
1.
**Envía el cambio del conjunto de registros a la zona alojada, esta vez con el ID de la zona alojada.**
```
$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
--change-batch file://recordset-change.json
{
"ChangeInfo": {
"Id": "/change/C0137926I56R3GC7XW2Y",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T13:40:36.553000+00:00"
}
}
```
1.
**Cree un documento de política `policy.json` con el siguiente contenido.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Cree un documento de política denominado `policy.json` con el siguiente contenido.**
```
$ aws iam create-policy --policy-name ReadCertExample \
--policy-document file://policy.json
{
"Policy": {
"PolicyName": "ReadCertExample",
"PolicyId": "ANPAUUXUVBC42VZSI4LDY",
"Arn": "arn:aws:iam::123456789012:policy/ReadCertExample-efg456",
"Path": "/",
"DefaultVersionId": "v1",
"AttachmentCount": 0,
"PermissionsBoundaryUsageCount": 0,
"IsAttachable": true,
"CreateDate": "2022-05-05T13:42:18+00:00",
"UpdateDate": "2022-05-05T13:42:18+00:00"
}
}
```
1. Siga los pasos indicados en [(Opcional) Administrar los usuarios y grupos de AD](tutorials_05_multi-user-ad-step2.md) o[Cree el clúster](tutorials_05_multi-user-ad-step3.md).
# (Opcional) Administrar los usuarios y grupos de AD
En este paso, administra los usuarios y los grupos desde una instancia de EC2 de Amazon Linux 2 que está unida al dominio Active Delivery (AD).
Si ha seguido la ruta *automática*, reinicie e inicie sesión en la instancia unida a AD que se creó como parte de la automatización.
Si ha seguido la ruta *manual*, reinicie e inicie sesión en la instancia que creó y unió al AD en los pasos anteriores.
En estos pasos, se utilizan las herramientas [adcli](https://www.mankier.com/package/adcli) y [openldap-clients](https://www.mankier.com/package/openldap-clients) que se instalaron en la instancia como parte del paso anterior.
**Inicie sesión en una instancia de Amazon EC2 que esté unida al dominio AD**
1. En la consola de Amazon EC2, seleccione la instancia de Amazon EC2 sin título que se creó en los pasos anteriores. La instancia debe tener el estado **Stopped**.
1. **Si el estado de la instancia es **Detenido**, elija Estado de **instancia** y, a continuación, Iniciar instancia.**
1. Una vez superadas las comprobaciones de estado, seleccione la instancia y elija **Conectar** y SSH en la instancia.
**Administre los usuarios y grupos al iniciar sesión en una instancia EC2 de Amazon Linux 2 que se haya unido al AD**
Cuando ejecute los `adcli` comandos con la ` -U "Admin"` opción, se le solicitará que introduzca la `Admin` contraseña de AD. Incluyes la `Admin` contraseña de AD como parte de los `ldapsearch` comandos.
1.
**Crear un usuario.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Para restablecer una contraseña de usuario**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**Crear un grupo**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**Adición de un usuario a un grupo**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Describa los usuarios y los grupos.**
Describa a todos los usuarios.
```
$ ldapsearch "(&(objectClass=user))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Describa a un usuario específico.
```
$ ldapsearch "(&(objectClass=user)(cn=clusteruser))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Describa a todos los usuarios con un patrón de nombres.
```
$ ldapsearch "(&(objectClass=user)(cn=user*))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Describa a todos los usuarios que forman parte de un grupo específico.
```
$ ldapsearch "(&(objectClass=user)(memberOf=CN=clusterteam,OU=Users,OU=CORP,DC=corp,DC=example,DC=com))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descripción de grupos de registros
```
$ ldapsearch "objectClass=group" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Describir un grupo específico
```
$ ldapsearch "(&(objectClass=group)(cn=clusterteam))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
1.
**Eliminación de un usuario de un grupo**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Elimina un usuario.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Eliminación de un grupo**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# Cree el clúster
Si no ha salido de la instancia de Amazon EC2, hágalo ahora.
El entorno está configurado para crear un clúster que pueda autenticar a los usuarios en Active Directory (AD).
Cree una configuración de clúster sencilla y proporcione los ajustes pertinentes para conectarse al AD. Para obtener más información, consulte la sección [`DirectoryService`](DirectoryService-v3.md).
Elija una de las siguientes configuraciones de clúster y cópiela en un archivo con el nombre `ldaps_config.yaml``ldaps_nocert_config.yaml`, o`ldap_config.yaml`.
Se recomienda elegir la configuración de LDAPS con verificación de certificado. Si elige esta configuración, también debe copiar el script de arranque en un archivo que lleve el nombre. `active-directory.head.post.sh` Además, debe almacenarlo en un bucket de Amazon S3, tal y como se indica en el archivo de configuración.
## LDAPS con configuración de verificación de certificados (recomendado)
**nota**
`KeyName`: uno de sus pares de claves de Amazon EC2.
`SubnetId / SubnetIds`: Una de las subredes que IDs se proporcionan en el resultado de la pila de creación CloudFormation rápida (tutorial automatizado) o en el script de Python (tutorial manual).
`Region`: La región en la que creó la infraestructura de AD.
`DomainAddr`: Esta dirección IP es una de las direcciones DNS de su servicio de AD.
`PasswordSecretArn`: el nombre de recurso de Amazon (ARN) del secreto que contiene la contraseña del `DomainReadOnlyUser`.
`BucketName`: el nombre del bucket que contiene el script de arranque.
`AdditionalPolicies`/`Policy`: El nombre de recurso de Amazon (ARN) de la política de certificación de dominio de lectura. ReadCertExample
`CustomActions`/`OnNodeConfigured`/`Args`: el nombre de recurso de Amazon (ARN) secreto que contiene la política de certificación de dominios.
Para una mejor postura de seguridad, sugerimos utilizar la configuración `HeadNode` / `Ssh` / `AllowedIps` para limitar el acceso SSH al nodo principal.
Tenga en cuenta que todos los nodos del clúster `LdapTlsCaCert` deben poder acceder al certificado especificado en.
**Requisitos estrictos**
El certificado especificado en `LdapTlsCaCert` debe estar accesible para todos los nodos del clúster.
Un nodo sin acceso al certificado no podrá resolver los usuarios del directorio.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::123456789012:policy/ReadCertExample
S3Access:
- BucketName: amzn-s3-demo-bucket
EnableWriteAccess: false
KeyName: bootstrap/active-directory/active-directory.head.post.sh
CustomActions:
OnNodeConfigured:
Script: s3://amzn-s3-demo-bucket/bootstrap/active-directory/active-directory.head.post.sh
Args:
- arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc
- /opt/parallelcluster/shared/directory_service/domain-certificate.crt
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: corp.example.com
DomainAddr: ldaps://corp.example.com
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
LdapTlsCaCert: /opt/parallelcluster/shared/directory_service/domain-certificate.crt
LdapTlsReqCert: hard
```
**Secuencia de comandos de arranque**
Tras crear el archivo de arranque y antes de subirlo a su bucket de S3, ejecute `chmod +x active-directory.head.post.sh` para conceder el permiso de AWS ParallelCluster ejecución.
```
#!/bin/bash
set -e
CERTIFICATE_SECRET_ARN="$1"
CERTIFICATE_PATH="$2"
[[ -z $CERTIFICATE_SECRET_ARN ]] && echo "[ERROR] Missing CERTIFICATE_SECRET_ARN" && exit 1
[[ -z $CERTIFICATE_PATH ]] && echo "[ERROR] Missing CERTIFICATE_PATH" && exit 1
source /etc/parallelcluster/cfnconfig
REGION="${cfn_region:?}"
mkdir -p $(dirname $CERTIFICATE_PATH)
aws secretsmanager get-secret-value --region $REGION --secret-id $CERTIFICATE_SECRET_ARN --query SecretString --output text > $CERTIFICATE_PATH
```
## LDAPS sin configuración de verificación de certificados
**nota**
`KeyName`: uno de sus pares de claves de Amazon EC2.
`SubnetId / SubnetIds`: Una de las subredes IDs que se encuentran en el resultado de la pila de creación CloudFormation rápida (tutorial automatizado) o del script de Python (tutorial manual).
`Region`: La región en la que creó la infraestructura de AD.
`DomainAddr`: Esta dirección IP es una de las direcciones DNS de su servicio de AD.
`PasswordSecretArn`: el nombre de recurso de Amazon (ARN) del secreto que contiene la contraseña del `DomainReadOnlyUser`.
Para mejorar la seguridad, sugerimos usar la AllowedIps configuración HeadNode /Ssh/ para limitar el acceso SSH al nodo principal.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: corp.example.com
DomainAddr: ldaps://corp.example.com
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
LdapTlsReqCert: never
```
## Configuraciones de PHP
**nota**
`KeyName`: uno de sus pares de claves de Amazon EC2.
`SubnetId / SubnetIds`: Una de las subredes que IDs se proporcionan en el resultado de la pila de creación CloudFormation rápida (tutorial automatizado) o en el script de Python (tutorial manual).
`Region`: La región en la que creó la infraestructura de AD.
`DomainAddr`: Esta dirección IP es una de las direcciones DNS de su servicio de AD.
`PasswordSecretArn`: el nombre de recurso de Amazon (ARN) del secreto que contiene la contraseña del `DomainReadOnlyUser`.
Para mejorar la seguridad, sugerimos usar la AllowedIps configuración HeadNode /Ssh/ para limitar el acceso SSH al nodo principal.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: dc=corp,dc=example,dc=com
DomainAddr: ldap://192.0.2.254,ldap://203.0.113.237
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
AdditionalSssdConfigs:
ldap_auth_disable_tls_never_use_in_production: True
```
Cree el clúster con el comando siguiente.
```
$ pcluster create-cluster --cluster-name "ad-cluster" --cluster-configuration "./ldaps_config.yaml"
{
"cluster": {
"clusterName": "pcluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:region-id:123456789012:stack/ad-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "region-id",
"version": 3.15.0,
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
# Conexión al clúster como un usuario
Puede consultar el estado del clúster con el comando siguiente.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
El resultado es el siguiente.
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
Cuando llegue el estado`"CREATE_COMPLETE"`, inicie sesión con el nombre de usuario y la contraseña creados.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
Puede iniciar sesión sin la contraseña proporcionando la SSH clave que se creó para el nuevo usuario en`/home/user000@HEAD_NODE_IP/.ssh/id_rsa`.
Si el `ssh` comando se ejecutó correctamente, se conectó correctamente al clúster como usuario autenticado para usar Active Directory (AD).
# Limpieza
1.
**Desde su máquina local, elimine el clúster.**
```
$ pcluster delete-cluster --cluster-name "ad-cluster" --region "region-id"
{
"cluster": {
"clusterName": "ad-cluster",
"cloudformationStackStatus": "DELETE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:region-id:123456789012:stack/ad-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "region-id",
"version": "3.15.0",
"clusterStatus": "DELETE_IN_PROGRESS"
}
}
```
1.
**Compruebe el progreso de la eliminación del clúster.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Una vez que el clúster se haya eliminado correctamente, continúe con el siguiente paso.
## automatizar
**Elimine los recursos de Active Directory**
1. De [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/).
1. En el panel de navegación, seleccione **Stacks** (Pilas).
1. De la lista de pilas, elija la pila AD (por ejemplo,`pcluster-ad`).
1. Elija **Eliminar**.
## Manual
1.
**Elimine la instancia de Amazon EC2.**
1. Desde [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/), elija **Instances** en el panel de navegación.
1. De la lista de instancias, elija la que creó para añadir usuarios al directorio.
1. Elija **Estado de instancia** y luego **Terminar instancia**.
1.
**Elimine la zona alojada.**
1. Cree un archivo `recordset-delete.json`, con el siguiente contenido: En este ejemplo, HostedZoneId es el ID canónico de zona alojada del balanceador de cargas.
```
{
"Changes": [
{
"Action": "DELETE",
"ResourceRecordSet": {
"Name": "corp.example.com",
"Type": "A",
"Region": "region-id",
"SetIdentifier": "pcluster-active-directory",
"AliasTarget": {
"HostedZoneId": "Z2IFOLAFXWLO4F",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"EvaluateTargetHealth": true
}
}
}
]
}
```
1. Envíe el cambio del conjunto de registros a la zona alojada mediante el ID de la zona alojada.
```
$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
--change-batch file://recordset-delete.json
{
"ChangeInfo": {
"Id": "/change/C04853642A0TH2TJ5NLNI",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:25:51.046000+00:00"
}
}
```
1. Elimine la zona alojada.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**Elimine el oyente de LB.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**Elimine el grupo de destino**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**Eliminar el equilibrador de carga.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**Elimine la política que usa el clúster para leer el certificado de Secrets Manager.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**Elimine el secreto que contiene el certificado de dominio.**
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc \
--region region-id
{
"ARN": "arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc",
"Name": "example-cert",
"DeletionDate": "2022-06-04T16:27:36.183000+02:00"
}
```
1.
**Elimine el certificado de ACM.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Elimine los recursos de Active Directory (AD).**
1. Obtenga el siguiente recurso IDs de la salida del script de Python: `ad.py`
+ ID de AD
+ Subred AD IDs
+ ID de AD VPC
1. Elimine los puentes ejecutando el siguiente comando.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. Enumere los grupos de seguridad de la VPC.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. Elimine el grupo de seguridad personalizado.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. Eliminar las subredes.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. Describe la puerta de enlace de Internet.
```
$ aws ec2 describe-internet-gateways \
--filters Name=attachment.vpc-id,Values=vpc-021345abcdef6789 \
--region region-id
{
"InternetGateways": [
{
"Attachments": [
{
"State": "available",
"VpcId": "vpc-021345abcdef6789"
}
],
"InternetGatewayId": "igw-1234567890abcdef",
"OwnerId": "123456789012",
"Tags": []
}
]
}
```
1. Separa la puerta de enlace de Internet.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Elimina la puerta de enlace de Internet.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. Elimine la VPC.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Elimine el secreto que contiene la contraseña de `ReadOnlyUser`.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# Configuración del cifrado de almacenamiento compartido con una AWS KMS clave
Aprenda a configurar una AWS KMS clave administrada por el cliente para cifrar y proteger sus datos en los sistemas de almacenamiento de archivos en clúster para los que están configurados. AWS ParallelCluster
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster admite las siguientes opciones de configuración de almacenamiento compartido:
+ [`SharedStorage`](SharedStorage-v3.md) / [`EbsSettings`](SharedStorage-v3.md#SharedStorage-v3-EbsSettings) / [`KmsKeyId`](SharedStorage-v3.md#yaml-SharedStorage-EbsSettings-KmsKeyId)
+ [`SharedStorage`](SharedStorage-v3.md) / [`EfsSettings`](SharedStorage-v3.md#SharedStorage-v3-EfsSettings) / [`KmsKeyId`](SharedStorage-v3.md#yaml-SharedStorage-EfsSettings-KmsKeyId)
+ [`SharedStorage`](SharedStorage-v3.md) / [`FsxLustreSettings`](SharedStorage-v3.md#SharedStorage-v3-FsxLustreSettings) / [`KmsKeyId`](SharedStorage-v3.md#yaml-SharedStorage-FsxLustreSettings-KmsKeyId)
Puede utilizar estas opciones para proporcionar una AWS KMS clave gestionada por el cliente para Amazon EBS, Amazon EFS y FSx para el cifrado del sistema de almacenamiento compartido Lustre. Para usarlos, debe crear y configurar una política de IAM para lo siguiente:
+ [`HeadNode`](HeadNode-v3.md) / [`Iam`](HeadNode-v3.md#HeadNode-v3-Iam) / [`AdditionalIamPolicies`](HeadNode-v3.md#yaml-HeadNode-Iam-AdditionalIamPolicies) / [`Policy`](HeadNode-v3.md#yaml-HeadNode-Iam-AdditionalIamPolicies-Policy)
+ [`Scheduler`](Scheduling-v3.md#yaml-Scheduling-Scheduler) / [`SlurmQueues`](Scheduling-v3.md#Scheduling-v3-SlurmQueues) / [`Iam`](Scheduling-v3.md#Scheduling-v3-SlurmQueues-Iam) / [`AdditionalIamPolicies`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Iam-AdditionalIamPolicies) / [`Policy`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Iam-AdditionalIamPolicies-Policy)
**Requisitos previos**
+ AWS ParallelCluster [está](install-v3-parallelcluster.md) instalado.
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
**Topics**
+ [Creación de la política](creating-the-role-v3.md)
+ [Configuración y creación del clúster](creating-the-cluster-v3.md)
# Creación de la política
En este tutorial, creará una política para configurar el cifrado del almacenamiento compartido con una AWS KMS clave.
**Cree una política.**
1. Vaya a la consola de IAM: [https://console.aws.amazon.com/iam/inicio.](https://console.aws.amazon.com/iam/home)
1. Seleccione **Políticas**.
1. Elija **Crear política**.
1. Elija la pestaña **JSON** y pegue la siguiente política: Asegúrese de sustituir todas las apariciones de `123456789012` por su Cuenta de AWS ID y la clave Amazon Resource Name (ARN) y por la Región de AWS suya propia.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kms:DescribeKey",
"kms:ReEncrypt*",
"kms:CreateGrant",
"kms:Decrypt"
],
"Resource": [
"arn:aws:kms:us-east-1:123456789012:key/abcd1234-ef56-gh78-ij90-abcd1234efgh5678"
]
}
]
}
```
------
1. para este tutorial, escriba un nombre para la política `ParallelClusterKmsPolicy` y elija **Crear política**.
1. Tome nota de la política del ARN. La necesita para configurar el clúster.
# Configuración y creación del clúster
El siguiente es un ejemplo de configuración de clúster que incluye un sistema de archivos compartidos de Amazon Elastic Block Store con cifrado.
```
Region: eu-west-1
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: my-ssh-key
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::123456789012:policy/ParallelClusterKmsPolicy
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: q1
ComputeResources:
- Name: t2micro
InstanceType: t2.micro
MinCount: 0
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::123456789012:policy/ParallelClusterKmsPolicy
SharedStorage:
- MountDir: /shared/ebs1
Name: shared-ebs1
StorageType: Ebs
EbsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
Sustituya los elementos en rojo por sus propios valores. A continuación, cree un clúster que utilice su AWS KMS clave para cifrar los datos en Amazon EBS.
La configuración es similar para Amazon EFS y FSx para los sistemas de archivos Lustre.
La configuración `SharedStorage` de Amazon EFS es la siguiente.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
La `SharedStorage` configuración FSx de Lustre es la siguiente.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# Ejecución de trabajos en un clúster en modo de cola múltiple
En este tutorial se explica cómo ejecutar su primer «Hello World» trabajo AWS ParallelCluster con el [modo de cola múltiple](configuration-of-multiple-queues-v3.md).
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
## Configuración de su clúster
En primer lugar, compruebe que AWS ParallelCluster está correctamente instalado ejecutando el siguiente comando.
```
$ pcluster version
```
Para obtener más información acerca de `pcluster version`, consulte [`pcluster version`](pcluster.version-v3.md).
Este comando devuelve la versión en ejecución de AWS ParallelCluster.
A continuación, ejecute `pcluster configure` para generar un archivo de configuración básico. Siga todas las instrucciones que aparecen después de este comando.
```
$ pcluster configure --config multi-queue-mode.yaml
```
Para obtener más información acerca del comando `pcluster configure`, consulte [`pcluster configure`](pcluster.configure-v3.md).
Cuando realice este paso, `multi-queue-mode.yaml` aparecerá un archivo de configuración básico con el nombre. Este archivo contiene una configuración de clúster básica.
En el siguiente paso, modificará el nuevo archivo de configuración y lanzará un clúster con varias colas.
**nota**
Algunas instancias que se utilizan en este tutorial no son aptas para la versión gratuita.
Para este tutorial, modifique el archivo de configuración para que coincida con la siguiente configuración. Los elementos que están resaltados en rojo representan los valores del archivo de configuración. Mantenga sus propios valores.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: yourkeypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: spot
ComputeResources:
- Name: c5xlarge
InstanceType: c5.xlarge
MinCount: 1
MaxCount: 10
- Name: t2micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
- Name: ondemand
ComputeResources:
- Name: c52xlarge
InstanceType: c5.2xlarge
MinCount: 0
MaxCount: 10
Networking:
SubnetIds:
- subnet-021345abcdef6789
```
## Cree su clúster de
Cree un clúster con un nombre `multi-queue-cluster` basado en su archivo de configuración.
```
$ pcluster create-cluster --cluster-name multi-queue-cluster --cluster-configuration multi-queue-mode.yaml
{
"cluster": {
"clusterName": "multi-queue-cluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:eu-west-1:123456789012:stack/multi-queue-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "eu-west-1",
"version": "3.15.0",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Para obtener más información acerca del comando `pcluster create-cluster`, consulte [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
Para comprobar el estado del clúster, use el comando siguiente.
```
$ pcluster list-clusters
{
"cluster": {
"clusterName": "multi-queue-cluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:eu-west-1:123456789012:stack/multi-queue-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "eu-west-1",
"version": "3.15.0",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Cuando se crea el clúster, se muestra el `clusterStatus` campo `CREATE_COMPLETE`.
## Inicie sesión en el nodo director
Use su archivo de clave SSH privado para iniciar sesión en el nodo principal.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
Para obtener más información acerca de `pcluster ssh`, consulte [`pcluster ssh`](pcluster.ssh-v3.md).
Después de iniciar sesión, ejecute el comando `sinfo` para comprobar que sus colas de programador se instalan y configuran.
Para obtener más información acerca de `sinfo`, consulte [sinfo](https://slurm.schedmd.com/sinfo.html) en la *documentación de Slurm*.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
spot* up infinite 18 idle~ spot-dy-c5xlarge-[1-9],spot-dy-t2micro-[1-9]
spot* up infinite 2 idle spot-st-c5xlarge-1,spot-st-t2micro-1
ondemand up infinite 10 idle~ ondemand-dy-c52xlarge-[1-10]
```
El resultado muestra que tiene uno `t2.micro` y un nodo de `c5.xlarge` cómputo en el `idle` estado que están disponibles en su clúster.
Todos los demás nodos están en estado de ahorro de energía, lo que se indica con el sufijo `~` en el estado de nodo, sin que ninguna instancia de Amazon EC2 los respalde. La cola predeterminada se indica con un `*` sufijo después del nombre de la cola. `spot`es la cola de trabajos predeterminada.
## Ejecute el trabajo en modo de cola múltiple
A continuación, intente ejecutar un trabajo para dormir un rato. Posteriormente, el trabajo genera su propio nombre de servidor. Asegúrese de que el usuario actual pueda ejecutar este script.
```
$ tee <
En este tutorial, creará y probará la API con [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) y una AWS ParallelCluster CloudFormation plantilla. A continuación, utilice el cliente de ejemplo disponible GitHub para utilizar la API. Para obtener más información sobre el uso de la API, consulte [AWS ParallelCluster API](api-reference-v3.md).
Para obtener más información, consulte [Crear un componente personalizado con Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) en la *Guía del usuario de EC2 Image Builder*.
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos**
+ AWS CLI Se [instala](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) y configura en su entorno informático.
+ AWS ParallelCluster está instalado en un entorno virtual. Para obtener más información, consulte [Instalar AWS ParallelCluster en un entorno virtual (recomendado)](install-v3-virtual-environment.md).
+ Tienes un [par de EC2 claves de Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
## Paso 1: Cree la API con Amazon API Gateway
**Permanezca en su directorio de usuarios principal y active su entorno virtual:**
1. Instale un útil procesador de línea de comandos JSON.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. Ejecute el siguiente comando para obtener su AWS ParallelCluster versión y asignarla a una variable de entorno.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. Cree una variable de entorno y asígnele su ID de región.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. Ejecute los siguientes comandos para implementar la API.
```
API_STACK_NAME="pc-api-stack"
echo "export API_STACK_NAME=${API_STACK_NAME}" |tee -a ~/.bashrc
```
```
aws cloudformation create-stack \
--region ${AWS_DEFAULT_REGION} \
--stack-name ${API_STACK_NAME} \
--template-url https://${AWS_DEFAULT_REGION}-aws-parallelcluster.s3.${AWS_DEFAULT_REGION}.amazonaws.com/parallelcluster/${PCLUSTER_VERSION}/api/parallelcluster-api.yaml \
--capabilities CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND \
--parameters ParameterKey=EnableIamAdminAccess,ParameterValue=true
{
"StackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/my-api-stack/abcd1234-ef56-gh78-ei90-1234abcd5678"
}
```
Una vez finalizada la operación, continúe con el siguiente paso.
## Paso 2: Probar la API en la consola de Amazon API Gateway
1. Inicie sesión en Consola de administración de AWS.
1. Vaya a la [consola de Amazon API Gateway](https://console.aws.amazon.com/apigateway/home).
1. Elija implementación de la API.
![\[Consola Amazon API Gateway con una lista de sus puertas de enlace entre las que puede elegir.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/gateway_choose.png)
1. Elija **Etapas** y seleccione una etapa.
![\[Una vista de consola de las etapas entre las que puede elegir. También puede ver la URL que API Gateway proporciona para su API.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/gateway_address.png)
1. Anote la URL que API Gateway proporciona para acceder a su API o invocarla. Está resaltada en azul.
1. Elija **Recursos** y seleccione **`GET`** en **`/clusters`**.
1. Seleccione el icono de **PRUEBA** y, a continuación, desplácese hacia abajo y seleccione el icono de **PRUEBA**.
![\[Vista de consola de los recursos de la API y los mecanismos de prueba.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/gateway_test.png)
Aparece la respuesta a su `/clusters GET`.
![\[Una vista de consola de los recursos de la API, los mecanismos de prueba y la respuesta a su solicitud de prueba.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/gateway.png)
## Paso 3: Prepare y pruebe un cliente de ejemplo para invocar la API
Clona el código AWS ParallelCluster fuente en el `api` directorio e instala las bibliotecas cliente de Python. `cd`
1.
```
$ git clone -b v${PCLUSTER_VERSION} https://github.com/aws/aws-parallelcluster aws-parallelcluster-v${PCLUSTER_VERSION}
cd aws-parallelcluster-v${PCLUSTER_VERSION}/api
```
```
$ pip3 install client/src
```
1. Vuelva al directorio de usuarios principal.
1. Exporte la URL base de API Gateway que el cliente usa cuando se ejecuta.
```
$ export PCLUSTER_API_URL=$( aws cloudformation describe-stacks --stack-name ${API_STACK_NAME} --query 'Stacks[0].Outputs[?OutputKey==`ParallelClusterApiInvokeUrl`].OutputValue' --output text )
echo "export PCLUSTER_API_URL=${PCLUSTER_API_URL}" |tee -a ~/.bashrc
```
1. Exporte el nombre de un clúster que el cliente utilice para crear un clúster.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. Ejecute los siguientes comandos para almacenar las credenciales que el cliente de ejemplo usa para acceder a la API.
```
$ export PCLUSTER_API_USER_ROLE=$( aws cloudformation describe-stacks --stack-name ${API_STACK_NAME} --query 'Stacks[0].Outputs[?OutputKey==`ParallelClusterApiUserRole`].OutputValue' --output text )
echo "export PCLUSTER_API_USER_ROLE=${PCLUSTER_API_USER_ROLE}" |tee -a ~/.bashrc
```
## Paso 4: Copie el script de código del cliente y ejecute las pruebas de clúster
1. Copie el siguiente código de cliente de ejemplo `test_pcluster_client.py` en su directorio de usuarios principal. El código de cliente solicita lo siguiente:
+ Cree el clúster.
+ Describir el clúster.
+ Enumerar los clústeres.
+ Describa la flota de computación.
+ Describa las instancias de un clúster.
```
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Author: Evan F. Bollig (Github: bollig)
import time, datetime
import os
import pcluster_client
from pprint import pprint
from pcluster_client.api import (
cluster_compute_fleet_api,
cluster_instances_api,
cluster_operations_api
)
from pcluster_client.model.create_cluster_request_content import CreateClusterRequestContent
from pcluster_client.model.cluster_status import ClusterStatus
region=os.environ.get("AWS_DEFAULT_REGION")
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = pcluster_client.Configuration(
host = os.environ.get("PCLUSTER_API_URL")
)
cluster_name=os.environ.get("CLUSTER_NAME")
# Enter a context with an instance of the API client
with pcluster_client.ApiClient(configuration) as api_client:
cluster_ops = cluster_operations_api.ClusterOperationsApi(api_client)
fleet_ops = cluster_compute_fleet_api.ClusterComputeFleetApi(api_client)
instance_ops = cluster_instances_api.ClusterInstancesApi(api_client)
# Create cluster
build_done = False
try:
with open('cluster-config.yaml', encoding="utf-8") as f:
body = CreateClusterRequestContent(cluster_name=cluster_name, cluster_configuration=f.read())
api_response = cluster_ops.create_cluster(body, region=region)
except pcluster_client.ApiException as e:
print("Exception when calling create_cluster: %s\n" % e)
build_done = True
time.sleep(60)
# Confirm cluster status with describe_cluster
while not build_done:
try:
api_response = cluster_ops.describe_cluster(cluster_name, region=region)
pprint(api_response)
if api_response.cluster_status == ClusterStatus('CREATE_IN_PROGRESS'):
print('. . . working . . .', end='', flush=True)
time.sleep(60)
elif api_response.cluster_status == ClusterStatus('CREATE_COMPLETE'):
print('READY!')
build_done = True
else:
print('ERROR!!!!')
build_done = True
except pcluster_client.ApiException as e:
print("Exception when calling describe_cluster: %s\n" % e)
# List clusters
try:
api_response = cluster_ops.list_clusters(region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling list_clusters: %s\n" % e)
# DescribeComputeFleet
try:
api_response = fleet_ops.describe_compute_fleet(cluster_name, region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling compute fleet: %s\n" % e)
# DescribeClusterInstances
try:
api_response = instance_ops.describe_cluster_instances(cluster_name, region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling describe_cluster_instances: %s\n" % e)
```
1. Cree una configuración de clúster:
```
$ pcluster configure --config cluster-config.yaml
```
1. La biblioteca API Client detecta automáticamente los detalles de configuración de las variables de entorno (por ejemplo `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, o `AWS_SESSION_TOKEN`) o `$HOME/.aws`. El siguiente comando cambia su rol de IAM actual al ParallelClusterApiUserRole designado.
```
$ eval $(aws sts assume-role --role-arn ${PCLUSTER_API_USER_ROLE} --role-session-name ApiTestSession | jq -r '.Credentials | "export AWS_ACCESS_KEY_ID=\(.AccessKeyId)\nexport AWS_SECRET_ACCESS_KEY=\(.SecretAccessKey)\nexport AWS_SESSION_TOKEN=\(.SessionToken)\n"')
```
**Error al que hay que prestar atención:**
Si ve un error similar al siguiente, ya ha dado por sentado que el ParallelClusterApiUserRole y `AWS_SESSION_TOKEN` han caducado.
```
An error occurred (AccessDenied) when calling the AssumeRole operation:
User: arn:aws:sts::XXXXXXXXXXXX:assumed-role/ParallelClusterApiUserRole-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/ApiTestSession
is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::XXXXXXXXXXXX:role/ParallelClusterApiUserRole-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
```
Elimine el rol y, a continuación, vuelva a ejecutar el `aws sts assume-role` comando para usar elParallelClusterApiUserRole.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
Para proporcionar sus permisos de usuario actuales para el acceso a la API, debe [ampliar la Política de recursos](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html).
1. Ejecute el siguiente comando para poner a prueba el cliente de ejemplo.
```
$ python3 test_pcluster_client.py
{'cluster_configuration': 'Region: us-east-1\n'
'Image:\n'
' Os: alinux2\n'
'HeadNode:\n'
' InstanceType: t2.micro\n'
' Networking . . . :\n'
' SubnetId: subnet-1234567890abcdef0\n'
' Ssh:\n'
' KeyName: adpc\n'
'Scheduling:\n'
' Scheduler: slurm\n'
' SlurmQueues:\n'
' - Name: queue1\n'
' ComputeResources:\n'
' - Name: t2micro\n'
' InstanceType: t2.micro\n'
' MinCount: 0\n'
' MaxCount: 10\n'
' Networking . . . :\n'
' SubnetIds:\n'
' - subnet-1234567890abcdef0\n',
'cluster_name': 'test-api-cluster'}
{'cloud_formation_stack_status': 'CREATE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'CREATE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
.
.
.
. . . working . . . {'cloud_formation_stack_status': 'CREATE_COMPLETE',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'CREATE_COMPLETE',
'compute_fleet_status': 'RUNNING',
'creation_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'head_node': {'instance_id': 'i-abcdef01234567890',
'instance_type': 't2.micro',
'launch_time': datetime.datetime(2022, 4, 28, 16, 21, 46, tzinfo=tzlocal()),
'private_ip_address': '172.31.27.153',
'public_ip_address': '52.90.156.51',
'state': 'running'},
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 18, 47, 972000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
READY!
```
## Paso 5: Copie el script de código del cliente y elimine el clúster
1. Copie el siguiente código de cliente de ejemplo en `delete_cluster_client.py`. El código de cliente solicita la eliminación del clúster.
```
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Author: Evan F. Bollig (Github: bollig)
import time, datetime
import os
import pcluster_client
from pprint import pprint
from pcluster_client.api import (
cluster_compute_fleet_api,
cluster_instances_api,
cluster_operations_api
)
from pcluster_client.model.create_cluster_request_content import CreateClusterRequestContent
from pcluster_client.model.cluster_status import ClusterStatus
region=os.environ.get("AWS_DEFAULT_REGION")
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = pcluster_client.Configuration(
host = os.environ.get("PCLUSTER_API_URL")
)
cluster_name=os.environ.get("CLUSTER_NAME")
# Enter a context with an instance of the API client
with pcluster_client.ApiClient(configuration) as api_client:
cluster_ops = cluster_operations_api.ClusterOperationsApi(api_client)
# Delete the cluster
gone = False
try:
api_response = cluster_ops.delete_cluster(cluster_name, region=region)
except pcluster_client.ApiException as e:
print("Exception when calling delete_cluster: %s\n" % e)
time.sleep(60)
# Confirm cluster status with describe_cluster
while not gone:
try:
api_response = cluster_ops.describe_cluster(cluster_name, region=region)
pprint(api_response)
if api_response.cluster_status == ClusterStatus('DELETE_IN_PROGRESS'):
print('. . . working . . .', end='', flush=True)
time.sleep(60)
except pcluster_client.ApiException as e:
gone = True
print("DELETE COMPLETE or Exception when calling describe_cluster: %s\n" % e)
```
1. Ejecute los siguientes comandos para eliminar el clúster de .
```
$ python3 delete_cluster_client.py
{'cloud_formation_stack_status': 'DELETE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'DELETE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'head_node': {'instance_id': 'i-abcdef01234567890',
'instance_type': 't2.micro',
'launch_time': datetime.datetime(2022, 4, 28, 16, 53, 48, tzinfo=tzlocal()),
'private_ip_address': '172.31.17.132',
'public_ip_address': '34.201.100.37',
'state': 'running'},
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
.
.
.
. . . working . . . {'cloud_formation_stack_status': 'DELETE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'DELETE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
. . . working . . . DELETE COMPLETE or Exception when calling describe_cluster: (404)
Reason: Not Found
.
.
.
HTTP response body: {"message":"Cluster 'test-api-cluster' does not exist or belongs to an incompatible ParallelCluster major version."}
```
1. Una vez finalizadas las pruebas, desactive las variables de entorno.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## Paso 6: limpiar
Puedes usar Consola de administración de AWS o AWS CLI para eliminar tu API.
1. En la CloudFormation consola, selecciona la pila de API y, a continuación, selecciona **Eliminar**.
1. Ejecute el siguiente comando si usa AWS CLI.
Usando CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Crear un clúster con Slurm contabilidad
Aprenda a configurar y crear un clúster con Slurm contabilidad. Para obtener más información, consulte [Slurmcontabilidad con AWS ParallelCluster](slurm-accounting-v3.md).
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
En este tutorial, utilizará una [plantilla de creación CloudFormation rápida (us-east-1) para crear una base de datos sin servidor para](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml) MySQL. [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) La plantilla indica CloudFormation que se creen todos los componentes necesarios para implementar una base de datos Amazon Aurora sin servidor en la misma VPC que el clúster. La plantilla también crea una configuración básica de red y seguridad para la conexión entre el clúster y la base de datos.
**nota**
A partir de la versión 3.3.0, admite AWS ParallelCluster Slurm contabilizar con el parámetro de configuración del clúster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[Base de datos](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database).
**nota**
La plantilla de creación rápida sirve de ejemplo. Esta plantilla no cubre todos los casos de uso posibles de un Slurm servidor de bases de datos de contabilidad. Es su responsabilidad crear un servidor de base de datos con la configuración y la capacidad adecuadas para sus cargas de trabajo de producción.
**Requisitos previos:**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tienes un [par de EC2 claves de Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
+ La región en la que implemente la plantilla de creación rápida es compatible con Amazon Aurora MySQL Serverless v2. Para obtener más información, consulte [Aurora Serverless v2 con Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Concepts.Aurora_Fea_Regions_DB-eng.Feature.ServerlessV2.html#Concepts.Aurora_Fea_Regions_DB-eng.Feature.ServerlessV2.amy).
## Paso 1: Crear la VPC y las subredes para AWS ParallelCluster
Para usar la CloudFormation plantilla proporcionada para Slurm base de datos de cuentas, debe tener lista la VPC del clúster. Puede hacerlo manualmente o como parte del procedimiento [Configure y cree un clúster con la interfaz de línea de AWS ParallelCluster comandos](install-v3-configuring.md). Si ya ha utilizado AWS ParallelCluster, es posible que tenga una VPC lista para la implementación del clúster y el servidor de base de datos.
## Paso 2: Crear la pila de la base de datos
Utilice la [plantilla de creación CloudFormation rápida (us-east-1) para crear](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml) una pila de bases de datos para Slurm contabilidad. La plantilla requiere las siguientes entradas:
+ Credenciales del servidor de base de datos, específicamente el nombre de usuario y la contraseña de administrador.
+ Dimensionamiento del clúster Amazon Aurora sin servidor. Esto depende de la carga prevista del clúster.
+ Parámetros de red, específicamente la VPC de destino y las subredes o bloques CIDR para la creación de las subredes.
Seleccione las credenciales y el tamaño adecuados para el servidor de base de datos. Para las opciones de red, debe usar la misma VPC en la que se implementa el clúster AWS ParallelCluster . Puede crear las subredes de la base de datos y pasarlas como entrada a la plantilla. O bien, proporcione dos bloques CIDR separados para las dos subredes y deje que la CloudFormation plantilla cree las dos subredes para los bloques CIDR. Asegúrese de que los bloques CIDR no se superpongan con las subredes existentes. Si los bloques CIDR se superponen con las subredes existentes, no se puede crear la pila.
La creación del servidor de base de datos tarda varios minutos.
## Paso 3: Cree un clúster con Slurm contabilidad habilitada
La CloudFormation plantilla proporcionada genera una CloudFormation pila con algunos resultados definidos. Desde Consola de administración de AWS, puede ver las salidas en la pestaña **Salidas** de la vista de CloudFormation pila. Para activar la Slurm teniendo en cuenta, algunos de estos resultados deben usarse en el archivo de configuración del AWS ParallelCluster clúster:
+ `DatabaseHost`: Se utiliza para el parámetro de configuración del clúster [`SlurmSettings`](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database) / [`Uri`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-Uri).
+ `DatabaseAdminUser`: se utiliza para el valor del parámetro de configuración del clúster de [`SlurmSettings`](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)/[`UserName`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-UserName).
+ `DatabaseSecretArn`: Se utiliza para el parámetro de configuración del clúster [`SlurmSettings`](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database) / [`PasswordSecretArn`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-PasswordSecretArn).
+ `DatabaseClientSecurityGroup`: Este es el grupo de seguridad que está conectado al nodo principal del clúster que se define en el parámetro de configuración [`HeadNode`](HeadNode-v3.md) / [`Networking`](HeadNode-v3.md#HeadNode-v3-Networking) / [`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups)
Actualice los parámetros `Database` del archivo de configuración del clúster con los valores de salida. Utilice la CLI [`pcluster`](pcluster-v3.md) para crear el clúster.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
Una vez creado el clúster, puede empezar a utilizar Slurm comandos de contabilidad como `sacctmgr` o`sacct`.
# Crear un clúster con un externo Slurmdbd contabilidad
Aprenda a configurar y crear un clúster con tecnología externa Slurmdbd contabilidad. Para obtener más información, consulte [Slurm contabilidad con AWS ParallelCluster](slurm-accounting-v3.md).
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS los servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
La AWS ParallelCluster interfaz de usuario se basa en una arquitectura sin servidor y puede utilizarla dentro del AWS Free Tier categoría en la mayoría de los casos. Para obtener más información, consulte [Costos de IU de AWS ParallelCluster](install-pcui-costs-v3.md).
En este tutorial, utilizarás una plantilla de AWS CloudFormation creación rápida para crear los componentes necesarios para implementar una instancia de Slurmdbd en la misma VPC que el clúster. La plantilla crea una configuración básica de red y seguridad para la conexión entre el clúster y la base de datos.
**nota**
En primer lugar`version 3.10.0`, AWS ParallelCluster es compatible con el Slurmdbd externo con el parámetro de configuración del clúster. `SlurmSettings / ExternelSlurmdbd`
**nota**
La plantilla de creación rápida sirve de ejemplo. Esta plantilla no cubre todos los casos de uso posibles. Es su responsabilidad crear una base de datos de Slurm externa con la configuración y la capacidad adecuadas para sus cargas de trabajo de producción.
**Requisitos previos:**
+ AWS ParallelCluster [está](install-v3-parallelcluster.md) instalado.
+ AWS CLI [está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un [par de claves de Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Tiene un AWS Identity and Access Management rol con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar la [`pcluster`](pcluster-v3.md) CLI.
+ Tiene un Slurm base de datos de contabilidad. Para seguir un tutorial de creación Slurm siga los pasos 1 y 2 de la sección [Crear la pila de bases de datos contables de Slurm](tutorials_07_slurm-accounting-v3.md).
## Paso 1: Creación de la pila de Slurmdbd
En este tutorial, utilice una [plantilla de creación CloudFormation rápida (`us-east-1`) para crear](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-dbd&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/external-slurmdbd.json) una pila de Slurmdbd. La plantilla requiere las siguientes entradas:
**Red**
+ **VPCId**: el ID de VPC para lanzar la instancia de Slurmdbd.
+ **SubnetId**: El ID de subred para lanzar la instancia de Slurmdbd.
+ **PrivatePrefix**: el prefijo CIDR de la VPC.
+ **PrivateIp**: una IP privada secundaria para asignarla a la instancia de Slurmdbd.
**Conexión a la base de datos**
+ **DBMSClientSG**: El grupo de seguridad que se va a adjuntar a la instancia de Slurmdbd. Este grupo de seguridad debe permitir las conexiones entre el servidor de base de datos y la instancia de Slurmdbd.
+ **DBMSDatabaseNombre**: el nombre de la base de datos.
+ **DBMSUsername**: el nombre de usuario de la base de datos.
+ **DBMSPasswordSecretArn**: El secreto que contiene la contraseña de la base de datos.
+ **DBMSUri**: El URI del servidor de la base de datos.
**Configuraciones de la instancia**
+ **InstanceType**: Un tipo de instancia que se usará en la instancia de slurmdbd.
+ **KeyName**: Un par de EC2 claves de Amazon para usar en la instancia slurmdbd.
**Configuración de Slurmdbd**
+ **AMIID**: una AMI de la instancia de Slurmdbd. La AMI debería ser una ParallelCluster AMI. La versión de la ParallelCluster AMI determina la versión de Slurmdbd.
+ **MungeKeySecretArn**: El secreto que contiene la clave munge que se utilizará para autenticar las comunicaciones entre Slurmdbd y los clústeres.
+ **SlurmdbdPort**: un número de puerto que utiliza el slurmdbd.
+ **EnableSlurmdbdSystemService**: habilita slurmdbd como servicio del sistema y lo ejecuta cuando se lanza una instancia.
**aviso**
Si la base de datos se creó con una versión diferente de SlurmDB, no utilice Slurmdbd como servicio del sistema.
Si la base de datos contiene un gran número de entradas, Slurm Database Daemon (SlurmDBD) puede tardar decenas de minutos en actualizar la base de datos y no responder durante este intervalo de tiempo.
Antes de actualizar SlurmDB, haga una copia de seguridad de la base de datos. Para obtener más información, consulte la [.Slurm documentación](https://slurm.schedmd.com/quickstart_admin.html#upgrade).
## Paso 2: Crear un clúster con una fuente externa Slurmdbd enabled
La CloudFormation plantilla proporcionada genera una CloudFormation pila con algunos resultados definidos.
Desde el Consola de administración de AWS, consulte la pestaña **Salidas** de la CloudFormation pila para revisar las entidades creadas. Para activar la Slurm teniendo en cuenta, algunos de estos resultados deben usarse en el AWS ParallelCluster archivo de configuración:
+ **SlurmdbdPrivateIp**: Se utiliza para el parámetro de configuración del [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)clúster de [hosts [ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Host)//.
+ **SlurmdbdPort**: Se utiliza para el valor del [ SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)parámetro de [ ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)configuración [del clúster de puertos](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Port)//.
+ **AccountingClientSecurityGroup**[: Este es el grupo de seguridad que está conectado al nodo principal del clúster y que se define en el parámetro de configuración/Networking [HeadNode](HeadNode-v3.md)/. [AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups)](HeadNode-v3.md#HeadNode-v3-Networking)
Además, en la pestaña **Parámetros de la vista** de pila: CloudFormation
+ **MungeKeySecretArn**: Se utiliza para el valor del parámetro de configuración del [MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn)clúster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/.
Actualice los parámetros de la base de datos del archivo de configuración del clúster con los valores de salida. Utilice el pcluster AWS CLI para crear el clúster.
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
Una vez creado el clúster, puede empezar a utilizar Slurm comandos de contabilidad como `sacctmgr` o`sacct`.
**aviso**
Tráfico entre `ParallelCluster` y lo externo SlurmDB no está cifrado. Se recomienda ejecutar el clúster y el externo SlurmDB en una red de confianza.
# Volver a una versión anterior del documento de AWS Systems Manager
Aprenda a volver a una versión anterior de un documento de AWS Systems Manager. Para obtener más información sobre documentos SSM, consulte [AWS Documentos de Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html) en la *AWS Guía del usuario Systems Manager*.
Al utilizar la interfaz de línea de AWS ParallelCluster comandos (CLI) o la API, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos:**
+ Y Cuenta de AWS con permisos para gestionar documentos SSM.
+ AWS CLI [Está instalado y configurado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
## Volver a una versión anterior del documento SSM
1. En su terminal, ejecute el siguiente comando para obtener la lista de documentos SSM existentes que le pertenecen.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. Volver a una versión anterior del documento SSM En este ejemplo, volvemos a una versión anterior del documento `SessionManagerRunShell`. Puede usar el documento SSM `SessionManagerRunShell` para personalizar cada sesión de intérprete de comandos de SSM que inicie.
1. Para encontrar el parámetro `DocumentVersion` para `SessionManagerRunShell`, ejecute el siguiente comando:
```
$ aws ssm describe-document --name "SSM-SessionManagerRunShell"
{
"Document": {
"Hash": "...",
"HashType": "Sha256",
"Name": "SSM-SessionManagerRunShell",
"Owner": "123456789012",
"CreatedDate": "2023-02-20T19:04:32.390000+00:00",
"Status": "Active",
"DocumentVersion": "1",
"Parameters": [
{
"Name": "linuxcmd",
"Type": "String",
"Description": "The command to run on connection...",
"DefaultValue": "if [ -d '/opt/parallelcluster' ]; then source /opt/parallelcluster/cfnconfig; sudo su - $cfn_cluster_user; fi; /bin/bash"
}
],
"PlatformTypes": [
"Windows",
"Linux",
"MacOS"
],
"DocumentType": "Session",
"SchemaVersion": "1.0",
"LatestVersion": "2",
"DefaultVersion": "1",
"DocumentFormat": "JSON",
"Tags": []
}
}
```
La última versión es `2`.
1. Vuelva a la versión anterior ejecutando el siguiente comando:
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. Compruebe que la versión del documento se ha revertido ejecutando de nuevo el `describe-document` comando:
```
$ aws ssm describe-document --name "SSM-SessionManagerRunShell"
{
"Document": {
"Hash": "...",
"HashType": "Sha256",
"Name": "SSM-SessionManagerRunShell",
"Owner": "123456789012",
"CreatedDate": "2023-02-20T19:04:32.390000+00:00",
"Status": "Active",
"DocumentVersion": "1",
"Parameters": [
{
"Name": "linuxcmd",
"Type": "String",
"Description": "The command to run on connection...",
"DefaultValue": "if [ -d '/opt/parallelcluster' ]; then source /opt/parallelcluster/cfnconfig; sudo su - $cfn_cluster_user; fi; /bin/bash"
}
],
"PlatformTypes": [
"Windows",
"Linux",
"MacOS"
],
"DocumentType": "Session",
"SchemaVersion": "1.0",
"LatestVersion": "1",
"DefaultVersion": "1",
"DocumentFormat": "JSON",
"Tags": []
}
}
```
La última versión es `1`.
# Crear un clúster con CloudFormation
Aprenda a crear un clúster con un recurso AWS ParallelCluster CloudFormation personalizado. Para obtener más información, consulte [AWS CloudFormation recurso personalizado](cloudformation-v3.md).
Al usarlo AWS ParallelCluster, solo pagas por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos:**
+ AWS CLI [Está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
## Creación de clústeres con una pila de creación CloudFormation rápida
En este tutorial, utilizarás una pila de creación rápida para implementar una CloudFormation plantilla que cree un clúster y los siguientes recursos: AWS
+ Una CloudFormation pila raíz creada mediante una pila de creación CloudFormation rápida.
+ Pilas anidadas CloudFormation que incluyen políticas predeterminadas, configuración de VPC predeterminada y un proveedor de recursos personalizado.
+ Un ejemplo de pila de AWS ParallelCluster clústeres y un clúster en el que puedes iniciar sesión y ejecutar trabajos.
**Cree un clúster con AWS CloudFormation**
1. Inicie sesión en Consola de administración de AWS.
1. Abre el [enlace CloudFormation de creación rápida](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=mycluster&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/parallelcluster/3.15.0/templates/1-click/cluster-example.yaml) para crear los siguientes recursos en la CloudFormation consola:
+ Una CloudFormation pila anidada con una VPC con una subred pública y privada para ejecutar el nodo principal del clúster y los nodos de cómputo, respectivamente.
+ Una CloudFormation pila anidada con un recurso AWS ParallelCluster personalizado para administrar el clúster.
+ Una CloudFormation pila anidada con las políticas predeterminadas para administrar el clúster.
+ Una CloudFormation pila raíz para las pilas anidadas.
+ Un AWS ParallelCluster clúster con el Slurm planificador y un número definido de nodos de procesamiento.
![\[La interfaz de usuario de CloudFormation creación rápida de la consola.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. En la sección **Parámetros** **Creación rápida de pila**, proporcione valores para los parámetros siguientes:
1. Para **KeyName**, introduzca el nombre de su par de claves de Amazon EC2.
1. Para **AvailabilityZone**, elija una zona de disponibilidad para los nodos de su clúster, por ejemplo,`us-east-1a`.
1. Elija las casillas de verificación para confirmar las capacidades de acceso en la parte inferior de la página.
1. Seleccione **Creación de pila**.
1. Espere a que la CloudFormation pila alcance el `CREATE_COMPLETE` estado.
## Creación de clústeres con la interfaz de línea de CloudFormation comandos (CLI)
En este tutorial, utilizará la interfaz de línea de AWS comandos (CLI) CloudFormation para implementar una CloudFormation plantilla que cree un clúster.
**Cree los siguientes AWS recursos:**
+ Una CloudFormation pila raíz creada mediante una pila de CloudFormation creación rápida.
+ Pilas anidadas CloudFormation que incluyen políticas predeterminadas, configuración de VPC predeterminada y un proveedor de recursos personalizado.
+ Un ejemplo de pila de AWS ParallelCluster clústeres y un clúster en los que puedes iniciar sesión y ejecutar trabajos.
Reemplace*inputs highlighted in red*, por ejemplo*keypair*, con sus propios valores.
**Cree un clúster con AWS CloudFormation**
1. Cree una CloudFormation plantilla denominada `cluster_template.yaml` con el siguiente contenido:
```
AWSTemplateFormatVersion: '2010-09-09'
Description: > AWS ParallelCluster CloudFormation Template
Parameters:
KeyName:
Description: KeyPair to login to the head node
Type: AWS::EC2::KeyPair::KeyName
AvailabilityZone:
Description: Availability zone where instances will be launched
Type: AWS::EC2::AvailabilityZone::Name
Default: us-east-2a
Mappings:
ParallelCluster:
Constants:
Version: 3.15.0
Resources:
PclusterClusterProvider:
Type: AWS::CloudFormation::Stack
Properties:
TemplateURL: !Sub
- https://${AWS::Region}-aws-parallelcluster.s3.${AWS::Region}.${AWS::URLSuffix}/parallelcluster/${Version}/templates/custom_resource/cluster.yaml
- { Version: !FindInMap [ParallelCluster, Constants, Version] }
PclusterVpc:
Type: AWS::CloudFormation::Stack
Properties:
Parameters:
PublicCIDR: 10.0.0.0/24
PrivateCIDR: 10.0.16.0/20
AvailabilityZone: !Ref AvailabilityZone
TemplateURL: !Sub
- https://${AWS::Region}-aws-parallelcluster.s3.${AWS::Region}.${AWS::URLSuffix}/parallelcluster/${Version}/templates/networking/public-private-${Version}.cfn.json
- { Version: !FindInMap [ParallelCluster, Constants, Version ] }
PclusterCluster:
Type: Custom::PclusterCluster
Properties:
ServiceToken: !GetAtt [ PclusterClusterProvider , Outputs.ServiceToken ]
ClusterName: !Sub 'c-${AWS::StackName}'
ClusterConfiguration:
Image:
Os: alinux2
HeadNode:
InstanceType: t2.medium
Networking:
SubnetId: !GetAtt [ PclusterVpc , Outputs.PublicSubnetId ]
Ssh:
KeyName: !Ref KeyName
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-cr0
InstanceType: t2.micro
Networking:
SubnetIds:
- !GetAtt [ PclusterVpc , Outputs.PrivateSubnetId ]
Outputs:
HeadNodeIp:
Description: The Public IP address of the HeadNode
Value: !GetAtt [ PclusterCluster, headNode.publicIpAddress ]
```
1. Ejecute el siguiente comando AWS CLI para implementar la CloudFormation pila para la creación y administración del clúster.
```
$ aws cloudformation deploy --template-file ./cluster_template.yaml \
--stack-name mycluster \
--parameter-overrides KeyName=keypair \
AvailabilityZone=us-east-2b \
--capabilities CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND
```
## Vea la salida CloudFormation del clúster
Vea la salida del CloudFormation clúster para obtener detalles útiles sobre el clúster. La propiedad `ValidationMessages` agregada proporciona acceso a los mensajes de validación de las operaciones de creación y actualización del clúster.
1. Ve a la [CloudFormation consola](https://console.aws.amazon.com/cloudformation/home) y selecciona la pila que incluye tu recurso AWS ParallelCluster personalizado.
1. Elija **los detalles de la pila** y a continuación, seleccione la pestaña **Salidas**.
![\[La tabla de CloudFormation resultados de la consola muestra los valores para HeadNodeIp y ValidationMessages.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/cfn-outputs.png)
Es posible que los mensajes de validación queden truncados. Para obtener más información acerca de la recuperación de registros, consulte [AWS ParallelCluster solución de problemas](troubleshooting-v3.md).
## Acceso al clúster
Acceso al clúster
**`ssh` en el nodo principal del clúster.**
1. Una vez completada la implementación de la CloudFormation pila, obtenga la dirección IP del nodo principal con el siguiente comando:
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
También puede recuperar la dirección IP del nodo principal a partir del **HeadNodeIp**parámetro de la pestaña **Salidas** de la pila de clústeres de la CloudFormation consola.
Puede encontrar la dirección IP del nodo principal aquí porque se agregó en la `Outputs` sección de la CloudFormation plantilla de clúster, específicamente para este clúster de ejemplo.
1. Conéctese al nodo principal del clúster ejecutando el siguiente comando:
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## Limpieza
Elimine el clúster.
1. Ejecute el siguiente comando AWS CLI para eliminar la CloudFormation pila y el clúster.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. Ejecute el siguiente comando para comprobar el estado de la eliminación de la pila.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# Implemente ParallelCluster la API con Terraform
En este tutorial, definirá un proyecto simple de Terraform para implementar una ParallelCluster API.
**Requisitos previos**
+ Está instalado Terraform v1.5.7\$1.
+ Función de IAM con los permisos para implementar la ParallelCluster API. Consulte [Permisos necesarios](tutorial-deploy-terraform-permissions.md).
# Definición de un proyecto de Terraform
En este tutorial, definirá un proyecto de Terraform.
1. Cree un directorio denominado `my-pcluster-api`.
Todos los archivos que cree estarán dentro de este directorio.
1. Cree el archivo `provider.tf` para configurar el AWS proveedor.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. Cree el archivo `main.tf` para definir los recursos mediante el ParallelCluster módulo.
```
module "parallelcluster_pcluster_api" {
source = "aws-tf/parallelcluster/aws//modules/pcluster_api"
version = "1.1.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
parameters = {
EnableIamAdminAccess = "true"
}
}
```
1. Cree el archivo `variables.tf` para definir las variables que se pueden inyectar en este proyecto.
```
variable "region" {
description = "The region the ParallelCluster API is deployed in."
type = string
default = "us-east-1"
}
variable "profile" {
type = string
description = "The AWS profile used to deploy the clusters."
default = null
}
variable "api_stack_name" {
type = string
description = "The name of the CloudFormation stack used to deploy the ParallelCluster API."
default = "ParallelCluster"
}
variable "api_version" {
type = string
description = "The version of the ParallelCluster API."
}
```
1. Cree el archivo `terraform.tfvars` para establecer valores arbitrarios para las variables.
El siguiente archivo implementa una ParallelCluster API 3.11.1 `us-east-1` con el nombre de la pila. `MyParallelClusterAPI-3111` Podrás hacer referencia a esta implementación de ParallelCluster API usando su nombre de pila.
**nota**
La `api_version` asignación del siguiente código se puede reemplazar por cualquier AWS ParallelCluster versión compatible.
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. Cree el archivo `outputs.tf` para definir los resultados devueltos por este proyecto.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
El directorio del proyecto es el siguiente:
```
my-pcluster-api
├── main.tf - Terraform entrypoint to define the resources using the ParallelCluster module.
├── outputs.tf - Defines the outputs returned by Terraform.
├── providers.tf - Configures the AWS provider.
├── terraform.tfvars - Set the arbitrary values for the variables, i.e. region, PCAPI version, PCAPI stack name
└── variables.tf - Defines the variables, e.g. region, PCAPI version, PCAPI stack name.
```
# Implemente la API.
Para implementar la API, ejecute los comandos estándar de Terraform en orden.
1. Compile el proyecto:
```
terraform init
```
1. Defina el plan de implementación:
```
terraform plan -out tfplan
```
1. Implemente el plan:
```
terraform apply tfplan
```
# Permisos necesarios
Necesita los siguientes permisos para implementar la ParallelCluster API con Terraform:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudformation:DescribeStacks",
"cloudformation:GetTemplate"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormationRead"
},
{
"Action": [
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"cloudformation:CreateChangeSet"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/MyParallelClusterAPI*",
"Effect": "Allow",
"Sid": "CloudFormationWrite"
},
{
"Action": [
"cloudformation:CreateChangeSet"
],
"Resource": [
"arn:aws:cloudformation:us-east-1:111122223333:aws:transform/Include",
"arn:aws:cloudformation:us-east-1:111122223333:aws:transform/Serverless-2016-10-31"
],
"Effect": "Allow",
"Sid": "CloudFormationTransformWrite"
},
{
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:*-aws-parallelcluster/parallelcluster/*/api/ParallelCluster.openapi.yaml",
"arn:aws:s3:us-east-1:111122223333:*-aws-parallelcluster/parallelcluster/*/layers/aws-parallelcluster/lambda-layer.zip"
],
"Effect": "Allow",
"Sid": "S3ParallelClusterArtifacts"
},
{
"Action": [
"iam:CreateRole",
"iam:DeleteRole",
"iam:GetRole",
"iam:CreatePolicy",
"iam:DeletePolicy",
"iam:GetPolicy",
"iam:GetRolePolicy",
"iam:AttachRolePolicy",
"iam:DetachRolePolicy",
"iam:PutRolePolicy",
"iam:DeleteRolePolicy",
"iam:ListPolicyVersions"
],
"Resource": [
"arn:aws:iam::111122223333:role/*",
"arn:aws:iam::111122223333:policy/*"
],
"Effect": "Allow",
"Sid": "IAM"
},
{
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/ParallelClusterLambdaRole-*",
"arn:aws:iam::111122223333:role/APIGatewayExecutionRole-*"
],
"Effect": "Allow",
"Sid": "IAMPassRole"
},
{
"Action": [
"lambda:CreateFunction",
"lambda:DeleteFunction",
"lambda:GetFunction",
"lambda:PublishLayerVersion",
"lambda:DeleteLayerVersion",
"lambda:GetLayerVersion",
"lambda:TagResource",
"lambda:UntagResource"
],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:layer:PCLayer-*",
"arn:aws:lambda:us-east-1:111122223333:function:*-ParallelClusterFunction-*"
],
"Effect": "Allow",
"Sid": "Lambda"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:DeleteLogGroup",
"logs:DescribeLogGroups",
"logs:PutRetentionPolicy",
"logs:TagLogGroup",
"logs:UntagLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/lambda/*-ParallelClusterFunction-*"
],
"Effect": "Allow",
"Sid": "Logs"
},
{
"Action": [
"apigateway:DELETE",
"apigateway:GET",
"apigateway:PATCH",
"apigateway:POST",
"apigateway:PUT",
"apigateway:UpdateRestApiPolicy"
],
"Resource": [
"arn:aws:apigateway:us-east-1::/restapis",
"arn:aws:apigateway:us-east-1::/restapis/*",
"arn:aws:apigateway:us-east-1::/tags/*"
],
"Effect": "Allow",
"Sid": "APIGateway"
}
]
}
```
------
# Creación de un clúster con Terraform
Al usarlo AWS ParallelCluster, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos**
+ Está instalado Terraform v1.5.7\$1.
+ [AWS ParallelCluster API](api-reference-v3.md) v3.8.0\$1 está implementada en su cuenta. Consulte [Implemente ParallelCluster la API con Terraform](tutorial-deploy-terraform.md).
+ Función de IAM con los permisos para invocar la ParallelCluster API. Consulte [Permisos necesarios]
# Definición de un proyecto de Terraform
En este tutorial, definirá un proyecto sencillo de Terraform para implementar un clúster.
1. Cree un directorio denominado `my-clusters`.
Todos los archivos que cree estarán dentro de este directorio.
1. Cree el archivo `terraform.tf` para importar el ParallelCluster proveedor.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Cree el archivo `providers.tf` para configurar los AWS proveedores ParallelCluster y.
```
provider "aws" {
region = var.region
profile = var.profile
}
provider "aws-parallelcluster" {
region = var.region
profile = var.profile
api_stack_name = var.api_stack_name
use_user_role = true
}
```
1. Cree el archivo `main.tf` para definir los recursos mediante el ParallelCluster módulo.
```
module "pcluster" {
source = "aws-tf/parallelcluster/aws"
version = "1.1.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
deploy_pcluster_api = false
template_vars = local.config_vars
cluster_configs = local.cluster_configs
config_path = "config/clusters.yaml"
}
```
1. Cree el archivo `clusters.tf` para definir varios clústeres como variables locales de Terraform.
**nota**
Puede definir varios clústeres dentro del elemento `cluster_config`. Para cada clúster, puede definir explícitamente las propiedades del clúster dentro de las variables locales (consulte `DemoCluster01`) o hacer referencia a un archivo externo (consulte `DemoCluster02`).
Para revisar las propiedades del clúster que puede establecer en el elemento de configuración, consulte [Configuración del clúster](cluster-configuration-file-v3.md).
Para revisar las opciones que puede configurar para la creación de clústeres, consulte [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
```
locals {
cluster_configs = {
DemoCluster01 : {
region : local.config_vars.region
rollbackOnFailure : false
validationFailureLevel : "WARNING"
suppressValidators : [
"type:KeyPairValidator"
]
configuration : {
Region : local.config_vars.region
Image : {
Os : "alinux2"
}
HeadNode : {
InstanceType : "t3.small"
Networking : {
SubnetId : local.config_vars.subnet
}
Iam : {
AdditionalIamPolicies : [
{ Policy : "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" }
]
}
}
Scheduling : {
Scheduler : "slurm"
SlurmQueues : [{
Name : "queue1"
CapacityType : "ONDEMAND"
Networking : {
SubnetIds : [local.config_vars.subnet]
}
Iam : {
AdditionalIamPolicies : [
{ Policy : "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" }
]
}
ComputeResources : [{
Name : "compute"
InstanceType : "t3.small"
MinCount : "1"
MaxCount : "4"
}]
}]
SlurmSettings : {
QueueUpdateStrategy : "TERMINATE"
}
}
}
}
DemoCluster02 : {
configuration : "config/cluster_config.yaml"
}
}
}
```
1. Cree el archivo `config/clusters.yaml` para definir varios clústeres como configuración de YAML.
```
DemoCluster03:
region: ${region}
rollbackOnFailure: true
validationFailureLevel: WARNING
suppressValidators:
- type:KeyPairValidator
configuration: config/cluster_config.yaml
DemoCluster04:
region: ${region}
rollbackOnFailure: false
configuration: config/cluster_config.yaml
```
1. Cree el archivo`config/cluster_config.yaml`, que es un archivo de ParallelCluster configuración estándar en el que se pueden insertar variables de Terraform.
Para revisar las propiedades del clúster que puede establecer en el elemento de configuración, consulte [Configuración del clúster](cluster-configuration-file-v3.md).
```
Region: ${region}
Image:
Os: alinux2
HeadNode:
InstanceType: t3.small
Networking:
SubnetId: ${subnet}
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue1
CapacityType: ONDEMAND
Networking:
SubnetIds:
- ${subnet}
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
ComputeResources:
- Name: compute
InstanceType: t3.small
MinCount: 1
MaxCount: 5
SlurmSettings:
QueueUpdateStrategy: TERMINATE
```
1. Cree el archivo `clusters_vars.tf` para definir las variables que se pueden inyectar en las configuraciones del clúster.
Este archivo le permite definir valores dinámicos que se pueden usar en las configuraciones de clúster, como la región y la subred.
En este ejemplo, los valores se recuperan directamente de las variables del proyecto, pero es posible que necesite utilizar una lógica personalizada para determinarlos.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. Cree el archivo `variables.tf` para definir las variables que se pueden inyectar en este proyecto.
```
variable "region" {
description = "The region the ParallelCluster API is deployed in."
type = string
default = "us-east-1"
}
variable "cluster_region" {
description = "The region the clusters will be deployed in."
type = string
default = "us-east-1"
}
variable "profile" {
type = string
description = "The AWS profile used to deploy the clusters."
default = null
}
variable "subnet_id" {
type = string
description = "The id of the subnet to be used for the ParallelCluster instances."
}
variable "api_stack_name" {
type = string
description = "The name of the CloudFormation stack used to deploy the ParallelCluster API."
default = "ParallelCluster"
}
variable "api_version" {
type = string
description = "The version of the ParallelCluster API."
}
```
1. Cree el archivo `terraform.tfvars` para establecer valores arbitrarios para las variables.
El siguiente archivo despliega los clústeres `eu-west-1` dentro de la subred`subnet-123456789`, utilizando la ParallelCluster API 3.11.1 existente, que ya está implementada con el nombre de la pila. `us-east-1` `MyParallelClusterAPI-3111`
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
cluster_region = "eu-west-1"
subnet_id = "subnet-123456789"
```
1. Cree el archivo `outputs.tf` para definir los resultados devueltos por este proyecto.
```
output "clusters" {
value = module.pcluster.clusters
}
```
El directorio del proyecto es el siguiente:
```
my-clusters
├── config
│ ├── cluster_config.yaml - Cluster configuration, where terraform variables can be injected..
│ └── clusters.yaml - File listing all the clusters to deploy.
├── clusters.tf - Clusters defined as Terraform local variables.
├── clusters_vars.tf - Variables that can be injected into cluster configurations.
├── main.tf - Terraform entrypoint where the ParallelCluster module is configured.
├── outputs.tf - Defines the cluster as a Terraform output.
├── providers.tf - Configures the providers: ParallelCluster and AWS.
├── terraform.tf - Import the ParallelCluster provider.
├── terraform.tfvars - Defines values for variables, e.g. region, PCAPI stack name.
└── variables.tf - Defines the variables, e.g. region, PCAPI stack name.
```
# Implementación del clúster
Para implementar el clúster, ejecute los comandos estándar de Terraform en orden.
**nota**
En este ejemplo, se supone que ya has implementado la ParallelCluster API en tu cuenta.
1. Compile el proyecto:
```
terraform init
```
1. Defina el plan de implementación:
```
terraform plan -out tfplan
```
1. Implemente el plan:
```
terraform apply tfplan
```
## Implementa la ParallelCluster API con clústeres
Si no has implementado la ParallelCluster API y quieres implementarla con los clústeres, cambia los siguientes archivos:
+ `main.tf`
```
module "pcluster" {
source = "aws-tf/aws/parallelcluster"
version = "1.0.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
deploy_pcluster_api = true
parameters = {
EnableIamAdminAccess = "true"
}
template_vars = local.config_vars
cluster_configs = local.cluster_configs
config_path = "config/clusters.yaml"
}
```
+ `providers.tf`
```
provider "aws-parallelcluster" {
region = var.region
profile = var.profile
endpoint = module.pcluster.pcluster_api_stack_outputs.ParallelClusterApiInvokeUrl
role_arn = module.pcluster.pcluster_api_stack_outputs.ParallelClusterApiUserRole
}
```
# Permisos necesarios
Necesita los siguientes permisos para implementar un clúster con Terraform:
+ asuma la función de ParallelCluster API, que se encarga de interactuar con la ParallelCluster API
+ describa la CloudFormation pila de la ParallelCluster API para verificar su existencia y recuperar sus parámetros y resultados
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Resource": "arn:aws:sts::111122223333:role/PCAPIUserRole-*",
"Effect": "Allow",
"Sid": "AssumePCAPIUserRole"
},
{
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormation"
}
]
}
```
------
# Creación de una AMI personalizada con Terraform
Al usarlo AWS ParallelCluster, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos**
+ Está instalado Terraform v1.5.7\$1.
+ [AWS ParallelCluster API](api-reference-v3.md) v3.8.0\$1 está implementada en su cuenta. Consulte [Creación de un clúster con Terraform](tutorial-create-cluster-terraform.md).
+ Función de IAM con los permisos para invocar la ParallelCluster API. Consulte [Permisos necesarios](tutorial-create-ami-terraform-permissions.md).
# Definición de un proyecto de Terraform
En este tutorial, definirá un proyecto sencillo de Terraform para implementar una AMI ParallelCluster personalizada.
1. Cree un directorio denominado `my-amis`.
Todos los archivos que cree estarán dentro de este directorio.
1. Cree el archivo `terraform.tf` para importar el ParallelCluster proveedor.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Cree el archivo `providers.tf` para configurar los AWS proveedores ParallelCluster y.
```
provider "aws" {
region = var.region
profile = var.profile
}
provider "aws-parallelcluster" {
region = var.region
profile = var.profile
api_stack_name = var.api_stack_name
use_user_role = true
}
```
1. Cree el archivo `main.tf` para definir los recursos mediante el ParallelCluster módulo.
Para revisar las propiedades de la imagen que puede establecer en el elemento `image_configuration`, consulte [Cree archivos de configuración de imágenes](image-builder-configuration-file-v3.md).
Para revisar las opciones que puede configurar para la creación de imágenes, por ejemplo `image_id` y `rollback_on_failure`, consulte [`pcluster build-image`](pcluster.build-image-v3.md).
```
data "aws-parallelcluster_list_official_images" "parent_image" {
region = var.region
os = var.os
architecture = var.architecture
}
resource "aws-parallelcluster_image" "demo01" {
image_id = "demo01"
image_configuration = yamlencode({
"Build":{
"InstanceType": "c5.2xlarge",
"ParentImage": data.aws-parallelcluster_list_official_images.parent_image.official_images[0].amiId,
"UpdateOsPackages": {"Enabled": false}
}
})
rollback_on_failure = false
}
```
1. Cree el archivo `variables.tf` para definir las variables que se pueden inyectar en este proyecto.
```
variable "region" {
description = "The region the ParallelCluster API is deployed in."
type = string
default = "us-east-1"
}
variable "profile" {
type = string
description = "The AWS profile used to deploy the clusters."
default = null
}
variable "api_stack_name" {
type = string
description = "The name of the CloudFormation stack used to deploy the ParallelCluster API."
default = "ParallelCluster"
}
variable "api_version" {
type = string
description = "The version of the ParallelCluster API."
}
variable "os" {
type = string
description = "The OS of the ParallelCluster image."
}
variable "architecture" {
type = string
description = "The architecture of the ParallelCluster image."
}
```
1. Cree el archivo `terraform.tfvars` para establecer los valores arbitrarios de las variables.
Con el siguiente archivo, implemente la AMI personalizada `us-east-1` basada en la arquitectura Amazon Linux 2 para x86\$164, utilizando la ParallelCluster API 3.11.1 existente que ya está implementada con el nombre de la pila. `us-east-1` `MyParallelClusterAPI-3111`
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
os = "alinux2"
architecture = "x86_64"
```
1. Cree el archivo `outputs.tf` para definir los resultados devueltos por este proyecto.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
El directorio del proyecto es el siguiente:
```
my-amis
├── main.tf - Terraform entrypoint where the ParallelCluster module is configured.
├── outputs.tf - Defines the cluster as a Terraform output.
├── providers.tf - Configures the providers: ParallelCluster and AWS.
├── terraform.tf - Import the ParallelCluster provider.
├── terraform.tfvars - Defines values for variables, e.g. region, PCAPI stack name.
└── variables.tf - Defines the variables, e.g. region, PCAPI stack name.
```
# Implementación de la API
Para implementar la AMI, ejecute los comandos estándar de Terraform en orden.
1. Compile el proyecto:
```
terraform init
```
1. Defina el plan de implementación:
```
terraform plan -out tfplan
```
1. Implemente el plan:
```
terraform apply tfplan
```
# Permisos necesarios
Necesita los siguientes permisos para implementar una AMI personalizada con Terraform:
+ asuma la función de ParallelCluster API, que se encarga de interactuar con la ParallelCluster API
+ describa la CloudFormation pila de la ParallelCluster API para verificar su existencia y recuperar sus parámetros y resultados
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Resource": "arn:aws:sts::111122223333:role/PCAPIUserRole-*",
"Effect": "Allow",
"Sid": "AssumePCAPIUserRole"
},
{
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormation"
}
]
}
```
------
# AWS ParallelCluster Integración de la interfaz de usuario con Identity Center
El objetivo de este tutorial es demostrar cómo integrar la AWS ParallelCluster interfaz de usuario con el IAM Identity Center para obtener una solución de inicio de sesión único que unifique a los usuarios de Active Directory y que pueda compartirse con clústeres. AWS ParallelCluster
Al utilizarla AWS ParallelCluster, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos:**
+ Una interfaz de usuario de AWS ParallelCluster existente que se pueda instalar siguiendo [estas instrucciones](install-pcui-v3.md).
+ Un Active Directory administrado existente, preferiblemente uno [con el que también se pueda integrar AWS ParallelCluster](tutorials_05_multi-user-ad.md).
## Activar IAM Identity Center
Si ya tiene un centro de identidad conectado a su AWS Managed Microsoft AD (Active Directory), puede utilizarlo y pasar a la sección **Añadir su aplicación al Centro de identidades de IAM**.
Si aún no tiene un centro de identidad conectado a uno AWS Managed Microsoft AD, siga los pasos que se indican a continuación para configurarlo.
**Habilitación de un centro de identidad**
1. Navegue hasta la consola de IAM Identity Center. (Asegúrese de estar en la región en la que tiene el suyo) AWS Managed Microsoft AD.
1. Haga clic en el botón **Habilitado**. Es posible que se le pregunte si desea activar las organizaciones. Se trata de un requisito para poder activar esta opción. **Nota**: Esta acción enviará al administrador de su cuenta un correo electrónico de confirmación con un enlace que deberá seguir para confirmarla.
**Conexión entre Identity Center y un AD administrado**
1. En la página siguiente, después de habilitar el centro de identidad, debería ver los pasos de configuración recomendados. En el paso 1, seleccione **Elija la fuente de identidad**.
1. En la sección Origen de identidad, haga clic en el menú desplegable **Acciones** (en la parte superior derecha) y, a continuación, seleccione **Cambiar el origen de identidad**.
1. Seleccione **Active Directory**.
1. En **Directorios existentes**, elija su directorio.
1. Haga clic en Next (Siguiente).
1. Revise los cambios, desplácese hasta el final, escriba ACEPTAR en el cuadro de texto para confirmarlos y, a continuación, haga clic en **Cambiar el origen de identidad**.
1. Espere a que se completen los cambios y aparecerá un banner verde en la parte superior.
**Sincronización de usuarios y grupos en Identity Center**
1. En el banner verde, haga clic en **Iniciar la configuración guiada** (botón situado en la parte superior derecha).
![\[Captura de pantalla en la que se muestra el botón Iniciar la configuración guiada.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. En la sección **Configurar los mapeos de atributos**, haga clic en **Siguiente**
1. En la sección Configurar el ámbito de sincronización, escriba el nombre de los usuarios que desea sincronizar con el centro de identidades y, a continuación, haga clic en **Agregar**.
1. Cuando termine de agregar usuarios y grupos, haga clic en **Siguiente**.
![\[Captura de pantalla que resalta el botón Siguiente.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. Revise los cambios y, a continuación, haga clic en **Guardar configuración**.
1. Si ve una advertencia en la siguiente pantalla sobre los usuarios que no se están sincronizando, seleccione el **botón Reanudar la sincronización** en la esquina superior derecha.
1. A continuación, para activar los usuarios, en la pestaña **Usuarios** de la izquierda, seleccione un usuario y, a continuación, haga clic en **Habilitar el acceso de usuarios** > **Habilitar el acceso de usuarios**.
**Nota**: Puede que tenga que seleccionar Reanudar la sincronización si aparece un banner de advertencia en la parte superior y esperar a que los usuarios se sincronicen (pruebe con el botón de actualización para comprobar si ya se han sincronizado).
![\[Captura de pantalla que resalta la pestaña Usuarios.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## Adición de su aplicación al IAM Identity Center
Una vez que haya sincronizado sus usuarios con IAM Identity Center, deberá añadir una nueva aplicación. Esto configura qué aplicaciones habilitadas para SSO estarán disponibles en su portal de IAM Identity Center. En este caso, añadiremos la interfaz de usuario de AWS ParallelCluster como aplicación, mientras que el IAM Identity Center será el proveedor de identidad.
El siguiente paso será añadir la AWS ParallelCluster interfaz de usuario como una aplicación en el IAM Identity Center. AWS ParallelCluster La interfaz de usuario es un portal web que ayuda al usuario a gestionar sus clústeres. Para obtener más información, consulte [Interfaz de usuario de AWS ParallelCluster](pcui-using-v3.md).
**Configuración de la aplicación en Identity Center**
1. En **IAM Identity Center** > **Aplicaciones** (en la barra de menú de la izquierda), haga clic en Aplicaciones.
1. Haga clic en **Agregar aplicación**.
1. Seleccione **Agregar aplicación de SAML 2.0 personalizada**.
1. Haga clic en **Siguiente**.
1. Seleccione el nombre para mostrar y la descripción que desee utilizar (p. ej., la interfaz de usuario y AWS ParallelCluster la interfaz de usuario)
1. En la sección **Metadatos del IAM Identity Center**, copie el enlace al archivo de metadatos SAML de IAM Identity Center y guárdelo para más adelante, ya que se utilizará al configurar el SSO en la aplicación web.
1. En **Propiedades de la aplicación**, en la URL de inicio de la aplicación, introduzca su dirección de PCUI. **Para encontrarlo, ve a la CloudFormation consola, selecciona la pila que corresponde a la PCUI (por ejemplo, parallelcluster-ui) y ve a la pestaña Salidas para buscar** ParallelCluster UIUrl
p. ej. https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. En **Metadatos de la aplicación**, elija **Escribir manualmente los valores de los metadatos**. A continuación, proporcione los siguientes valores.
1. **Importante**: asegúrese de reemplazar los valores del prefijo de dominio (domain-prefix), la región y el identificador del grupo de usuarios (userpool-id) por información específica de su entorno.
1. El prefijo de dominio, la región y el identificador del grupo de usuarios se pueden obtener desde la consola de **Amazon Cognito** > **Grupos de usuarios**
![\[Captura de pantalla que resalta el nombre del grupo de usuarios en los grupos de usuarios de Cognito\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. Seleccione el grupo de usuarios que corresponda a la PCUI (que tendrá un nombre de grupo de usuarios como EK3 TO45 PCUI-CD8A2-Cognito-153 S98-UserPool)
1. Navegue hasta **Integración de aplicaciones**
![\[Captura de pantalla donde se destaca el dominio de Cognito en la pestaña Integración de aplicaciones\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. URL del Application Assertion Consumer Service (ACS): https://.auth. .amazoncognito. com/saml2/idpresponse
Audiencia SAML de la aplicación: urn:amazon:cognito:sp:
1. Seleccione **Enviar**. A continuación, vaya a la página **Detalles** de la aplicación que ha agregado.
1. Seleccione la lista desplegable **Acciones** y elija **Editar las asignaciones de atributos**. A continuación, proporcione los siguientes atributos:
1. Atributo de usuario en la aplicación: **asunto** (Nota: **Asunto** viene rellenado previamente). → Se asigna a este valor de cadena o atributo de usuario en IAM Identity Center: **\$1\$1user:email\$1**, formato: **emailAddress**
1. Atributo de usuario de la aplicación: **correo electrónico** → Se asigna a este valor de cadena o atributo de usuario de IAM Identity Center: **\$1\$1user:email\$1**, formato: **sin especificar**
![\[Captura de pantalla en la que se destaca la sección Asignaciones de atributos para la PCUI\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. Guarde los cambios.
1. Pulse el botón **Asignar usuarios** y, a continuación, asigne su usuario a la aplicación. Estos son los usuarios de su Active Directory que tendrán acceso a la interfaz de la PCUI.
![\[Captura de pantalla en la que se destaca Asignar usuarios para la aplicación.\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**Configuración de IAM Identity Center como IdP de SAML en el grupo de usuarios**
1. En la configuración de su grupo de usuarios, seleccione **Experiencia de inicio de sesión** > **Agregar proveedor de identidad**
![\[Captura de pantalla que resalta la pestaña de experiencia de inicio\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. Elija un IdP de SAML.
1. Para el **nombre del proveedor**, proporcione **IdentityCenter**
1. En **Origen del documento de metadatos**, seleccione **Ingrese la URL del punto de conexión del documento de metadatos** e introduzca la URL copiada durante la configuración de la aplicación en Identity Center.
1. En **Atributos**, para correo electrónico, elija un correo electrónico
![\[Captura de pantalla que resalta la pestaña de experiencia de inicio\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. Seleccione **Agregar proveedor de identidades**.
**Integración del IdP con el cliente de aplicaciones del grupo de usuarios**
1. A continuación, en la sección **Integración de aplicaciones** de su grupo de usuarios, elija el cliente que aparece en la **lista de clientes de aplicaciones**
![\[Captura de pantalla que resalta la pestaña de experiencia de inicio\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. En **Interfaz de usuario alojada**, seleccione **Editar**.
1. En **Proveedores de identidad**, elige **IdentityCenter**también.
1. Elija **Guardar cambios**.
**Validación de su configuración**
1. A continuación, validaremos la configuración que acabamos de crear iniciando la sesión en la PCUI. Inicie sesión en el portal de la PCUI y verá una opción para iniciar sesión con su identificador corporativo:
![\[Captura de pantalla que resalta la pestaña de experiencia de inicio\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. Al hacer clic en el **IdentityCenter**botón, accederá al inicio de sesión del IdP del IAM Identity Center, seguido de una página con sus aplicaciones que incluye la PCUI. Abra esa aplicación.
1. Cuando llegue a la siguiente pantalla, su usuario se habrá agregado al grupo de usuarios de Cognito.
![\[Captura de pantalla donde se muestra la pestaña de experiencia de inicio\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**Convierta su usuario en administrador**
1. Ahora vaya a la consola de **Amazon Cognito** > **Grupos de usuarios** y seleccione el usuario recién creado, que debe tener el prefijo identitycenter.
![\[Captura de pantalla que resalta la pestaña de experiencia de inicio\]](http://docs.aws.amazon.com/es_es/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. En **Miembros de grupos,** seleccione **Añadir usuario al grupo**, seleccione **admin** y haga clic en **Añadir**.
1. Ahora, al hacer clic en **Continuar**, IdentityCenter accederás a la página de la AWS ParallelCluster interfaz de usuario.
# Ejecución de trabajos en contenedores con Pyxis
Aprenda a crear un clúster que pueda ejecutar trabajos en contenedores con Pyxis, que es un complemento de SPANK para administrar trabajos en contenedores en SLURM. Los contenedores de Pyxis son gestionados por Enroot, una herramienta que convierte las container/OS imágenes tradicionales en entornos aislados sin privilegios. Para obtener más información, consulte [NVIDIA Pyxis](https://github.com/NVIDIA/pyxis) y [NVIDIA Enroot](https://github.com/NVIDIA/enroot).
**nota**
Esta función está disponible en la versión 3.11.1 AWS ParallelCluster
Los scripts de este tutorial mueven (`mv`) algunos archivos, lo que los elimina de sus ubicaciones originales. Si desea conservar copias de estos archivos en sus ubicaciones originales, cambie los scripts y utilice el comando copy (`cp`) en su lugar.
Al AWS ParallelCluster utilizarlos, solo paga por los AWS recursos que se crean al crear o actualizar AWS ParallelCluster imágenes y clústeres. Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
**Requisitos previos:**
+ AWS CLI Está [instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Un [par de claves de Amazon EC2.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)
+ Un rol de IAM con los [permisos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) necesarios para ejecutar la [CLI de pcluster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
## Cree el clúster
A partir de la AWS ParallelCluster versión 3.11.1, todas las versiones oficiales AMIs vienen con Pyxis y Enroot preinstalados. En concreto, SLURM se recompila con soporte para Pyxis y Enroot se instala como un archivo binario en el sistema. Sin embargo, debe configurarlos en función de sus necesidades específicas. Las carpetas utilizadas por Enroot y Pyxis tendrán un impacto crítico en el rendimiento del clúster. Para obtener más información, consulte la [documentación de Pyxis](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration) y la [documentación de Enroot](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example).
Para su comodidad, en esta página encontrará ejemplos de configuraciones para Pyxis, Enroot y SPANK en `/opt/parallelcluster/examples/`.
Para implementar un clúster con los ejemplos de configuraciones que hemos proporcionado, complete el siguiente tutorial.
**Para crear un clúster con la configuración de ejemplo**
Pyxis y Enroot deben configurarse en el nodo principal creando primero los directorios persistentes y volátiles para Enroot, luego creando el directorio de tiempo de ejecución para Pyxis y, por último, habilitando Pyxis como complemento SPANK en todo el clúster.
1. Ejecute el siguiente script como acción [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured)personalizada en el nodo principal para configurar Pyxis y Enroot en el nodo principal.
```
#!/bin/bash
set -e
echo "Executing $0"
# Configure Enroot
ENROOT_PERSISTENT_DIR="/var/enroot"
ENROOT_VOLATILE_DIR="/run/enroot"
sudo mkdir -p $ENROOT_PERSISTENT_DIR
sudo chmod 1777 $ENROOT_PERSISTENT_DIR
sudo mkdir -p $ENROOT_VOLATILE_DIR
sudo chmod 1777 $ENROOT_VOLATILE_DIR
sudo mv /opt/parallelcluster/examples/enroot/enroot.conf /etc/enroot/enroot.conf
sudo chmod 0644 /etc/enroot/enroot.conf
# Configure Pyxis
PYXIS_RUNTIME_DIR="/run/pyxis"
sudo mkdir -p $PYXIS_RUNTIME_DIR
sudo chmod 1777 $PYXIS_RUNTIME_DIR
sudo mkdir -p /opt/slurm/etc/plugstack.conf.d/
sudo mv /opt/parallelcluster/examples/spank/plugstack.conf /opt/slurm/etc/
sudo mv /opt/parallelcluster/examples/pyxis/pyxis.conf /opt/slurm/etc/plugstack.conf.d/
sudo -i scontrol reconfigure
```
1. Pyxis y Enroot deben configurarse en la flota de computación mediante la creación de los directorios persistentes y volátiles para Enroot y el directorio de tiempo de ejecución para Pyxis. Ejecute el siguiente script como acción [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personalizada en los nodos de procesamiento para configurar Pyxis y Enroot en la flota de procesamiento.
```
#!/bin/bash
set -e
echo "Executing $0"
# Configure Enroot
ENROOT_PERSISTENT_DIR="/var/enroot"
ENROOT_VOLATILE_DIR="/run/enroot"
ENROOT_CONF_DIR="/etc/enroot"
sudo mkdir -p $ENROOT_PERSISTENT_DIR
sudo chmod 1777 $ENROOT_PERSISTENT_DIR
sudo mkdir -p $ENROOT_VOLATILE_DIR
sudo chmod 1777 $ENROOT_VOLATILE_DIR
sudo mkdir -p $ENROOT_CONF_DIR
sudo chmod 1777 $ENROOT_CONF_DIR
sudo mv /opt/parallelcluster/examples/enroot/enroot.conf /etc/enroot/enroot.conf
sudo chmod 0644 /etc/enroot/enroot.conf
# Configure Pyxis
PYXIS_RUNTIME_DIR="/run/pyxis"
sudo mkdir -p $PYXIS_RUNTIME_DIR
sudo chmod 1777 $PYXIS_RUNTIME_DIR
# In Ubuntu24.04 Apparmor blocks the creation of unprivileged user namespaces,
# which is required by Enroot. So to run Enroot, it is required to disable this restriction.
# See https://ubuntu.com/blog/ubuntu-23-10-restricted-unprivileged-user-namespaces
source /etc/os-release
if [ "${ID}${VERSION_ID}" == "ubuntu24.04" ]; then
echo "kernel.apparmor_restrict_unprivileged_userns = 0" | sudo tee /etc/sysctl.d/99-pcluster-disable-apparmor-restrict-unprivileged-userns.conf
sudo sysctl --system
fi
```
## Envío de trabajos
Ahora que Pyxis está configurado en su clúster, puede enviar trabajos en contenedores mediante los comandos sbatch y srun, que ahora están enriquecidos con opciones específicas para contenedores.
```
# Submitting an interactive job
srun -N 2 --container-image docker://ubuntu:22.04 hostname
# Submitting a batch job
sbatch -N 2 --wrap='srun --container-image docker://ubuntu:22.04 hostname'
```
# Creación de un clúster con un Lustre habilitado para EFA FSx
En este tutorial, creará un clúster que utilice un sistema de archivos FSx Lustre compatible con EFA como almacenamiento compartido. El uso de un sistema de archivos FSx Lustre con EFA habilitado puede aumentar el rendimiento hasta 8 veces. *Para comprobar si lo que necesita es un sistema de archivos compatible con EFA, consulte [Trabajar con sistemas de archivos compatibles con EFA en la Guía del usuario](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html) de Lustre. FSx *
Cuando lo usa AWS ParallelCluster, solo paga por AWS los recursos que se crean al crear o actualizar imágenes y clústeres. AWS ParallelCluster Para obtener más información, consulte [AWS servicios utilizados por AWS ParallelCluster](aws-services-v3.md).
## Requisitos
+ La AWS CLI está [instalada y configurada](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ La ParallelCluster CLI está [instalada y configurada](install-v3-parallelcluster.md).
+ Un [par de claves de Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) para iniciar sesión en el clúster.
+ Un rol de IAM con los [permisos](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) necesarios para ejecutar la ParallelCluster CLI.
## Creación de los grupos de seguridad
Cree dos grupos de seguridad en la misma VPC donde se implementarán el clúster y el sistema de archivos: uno para el cliente que se ejecuta en los nodos del clúster y otro para el sistema de archivos.
```
# Create security group for the FSx client
aws ec2 create-security-group \
--group-name Fsx-Client-SecurityGroup \
--description "Allow traffic for the FSx Lustre client" \
--vpc-id vpc-cluster \
--region region
# Create security group for the FSx file system
aws ec2 create-security-group \
--group-name Fsx-FileSystem-SecurityGroup \
--description "Allow traffic for the FSx Lustre File System" \
--vpc-id vpc-cluster \
--region region
```
En el resto del tutorial, `sg-client` asumiremos que `sg-file-system` son los identificadores de los grupos de seguridad del cliente y del sistema de archivos, respectivamente.
Configure el grupo de seguridad del cliente para permitir que todo el tráfico saliente llegue al sistema de archivos, según lo [exige la EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security).
```
# Allow all outbound traffic from the client to the file system
aws ec2 authorize-security-group-egress \
--group-id sg-client \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
```
Configure el grupo de seguridad del sistema de archivos para permitir todo el inbound/outbound tráfico interno y todo el tráfico entrante del cliente, según lo [exija](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) la EFA.
```
# Allow all inbound traffic within this security group
aws ec2 authorize-security-group-ingress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
# Allow all outbound traffic within this security group
aws ec2 authorize-security-group-egress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
# Allow all inbound traffic from the client
aws ec2 authorize-security-group-ingress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-client \
--region region
# Allow all outbound traffic to the client
aws ec2 authorize-security-group-egress \
--group-id sg-file-system \
--protocol -1 \
--port -1 \
--source-group sg-client \
--region region
```
## Cree el sistema de archivos
Cree el sistema de archivos en la misma zona de disponibilidad (AZ) en la que estarán los nodos de procesamiento y `subnet-compute-nodes` sustitúyalo por su ID en el código siguiente. Esto es necesario para permitir que la EFA funcione con su sistema de archivos. Tenga en cuenta que, como parte de la creación del sistema de archivos, habilitamos el EFA mediante la EfaEnable propiedad.
```
aws fsx create-file-system \
--file-system-type LUSTRE \
--storage-capacity 38400 \
--storage-type SSD \
--subnet-ids subnet-compute-nodes \
--security-group-ids sg-file-system \
--lustre-configuration DeploymentType=PERSISTENT_2,PerUnitStorageThroughput=125,EfaEnabled=true,MetadataConfiguration={Mode=AUTOMATIC} \
--region region
```
Tome nota del identificador del sistema de archivos devuelto por el comando anterior. En el resto del tutorial, `fs-id` sustitúyalo por este identificador del sistema de archivos.
## Cree el clúster
1. Cree el clúster con las siguientes configuraciones establecidas en el archivo de configuración AWS ParallelCluster YAML:
1. AMI basada en un sistema operativo compatible, como Ubuntu 22.04.
1. Los nodos de cómputo deben usar un [tipo de instancia compatible con EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) que tenga [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), como la g6.16xlarge.
+ Los nodos de cómputo deben estar en la misma zona de disponibilidad en la que se encuentra el sistema de archivos.
+ Los nodos de cómputo deben tener el valor [Efa/Enabled](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled) establecido en true.
+ Los nodos de cómputo deben ejecutar el script de configuración `configure-efa-fsx-lustre-client.sh` como una acción [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personalizada. El script, que se incluye en la [documentación FSx oficial](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) y se ofrece en nuestra sección pública para su comodidad, tiene por objeto configurar el cliente FSx Lustre en los nodos de cómputo para que puedan utilizar EFA.
1. Cree un archivo de configuración de clústeres: `config.yaml`
```
Region: region
Image:
Os: ubuntu2204
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-xxxxxxxxxx
AdditionalSecurityGroups:
- sg-client
Ssh:
KeyName: my-ssh-key
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: q1
ComputeResources:
- Name: cr1
Instances:
- InstanceType: g6.16xlarge
MinCount: 1
MaxCount: 3
Efa:
Enabled: true
Networking:
SubnetIds:
- subnet-xxxxxxxxxx # Subnet in the same AZ where the file system is
AdditionalSecurityGroups:
- sg-client
PlacementGroup:
Enabled: false
CustomActions:
OnNodeStart:
Script: https://us-east-1-aws-parallelcluster.s3.us-east-1.amazonaws.com/scripts/fsx-lustre-efa/configure-efa-fsx-lustre-client.sh
SharedStorage:
- MountDir: /fsx
Name: my-fsxlustre-efa-external
StorageType: FsxLustre
FsxLustreSettings:
FileSystemId: fs-id
```
A continuación, cree un clúster con esa configuración:
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## Validar FSx con EFA funciona
Para comprobar que el tráfico de red de Lustre utiliza EFA, utilice la `lnetctl` herramienta Lustre, que puede mostrar el tráfico de red de una interfaz de red determinada. Para ello, ejecute los siguientes comandos en un nodo de cómputo:
```
# Take note of the number of packets flowing through the interface,
# which are specified in statistics:send_count and statistics:recv_count
sudo lnetctl net show --net efa -v
# Generate traffic to the file system
echo 'Hello World' > /fsx/hello-world.txt
# Take note of the number of packets flowing through the interface,
# which are specified in statistics:send_count and statistics:recv_count
sudo lnetctl net show --net efa -v
```
Si la función funciona, se espera que aumente la cantidad de paquetes que fluyen a través de la interfaz.
# Support nVidia-IMEX con instancia p6e-gb200
En este tutorial, se muestra cómo empezar a utilizar AWS ParallelCluster el P6e- GB200 para aprovechar el máximo rendimiento de la GPU para el entrenamiento y la inferencia de la IA. [Las instancias p6e-gb200.36xlarge solo están disponibles a través de P6e, GB200 UltraServers donde el tamaño es Ultraserver y es el que forma el Ultraserver](https://aws.amazon.com/ec2/instance-types/p6/). `u-p6e-gb200x72` `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) [Al comprar un Ultraserver, estará disponible a través de un EC2 Capacity Blocks for ML`u-p6e-gb200x72`, que tendrá 18 instancias.](https://aws.amazon.com/ec2/capacityblocks/) `p6e-gb200.36xlarge` [Para obtener más información, consulte P6e-. GB200](https://aws.amazon.com/ec2/instance-types/p6/)
AWS ParallelCluster versión 3.14.0:
+ proporciona el paquete completo de software de NVIDIA (controladores, CUDA, EFA, NVIDIA-IMEX) que requiere este tipo de instancia
+ crea configuraciones nvidia-imex para el ultra servidor P6e GB200
+ habilita e inicia el servicio para el ultraserver P6e `nvidia-imex` GB200
+ configura el complemento de topología Slurm Block para que cada Ultraserver P6e-GB200 (un bloque de capacidad EC2) sea un bloque Slurm con el tamaño correcto (consulte la entrada correspondiente a la versión 3.14.0). [Notas de la versión e historial de revisión](document_history.md)
Sin embargo, GPU-to-GPU la comunicación NVLink requiere configuraciones adicionales, específicamente un [https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location)archivo que contenga las direcciones IP de los nodos de cómputo de un dominio IMEX y que no se genere automáticamente. ParallelCluster Para ayudar a generar este archivo, proporcionamos un script de prólogo que descubre automáticamente el nodo de cómputo IPs y configura las [https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/config.html#imex-service-node-configuration-file-location)siguientes recomendaciones de integración del programador de [tareas con NVIDIA IMEX Slurm](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration). En este tutorial, se explica cómo crear el script de prólogo, implementarlo mediante una acción HeadNode personalizada y validar la configuración de IMEX.
**nota**
P6e- GB200 es compatible a partir de la versión AWS ParallelCluster 3.14.0 en Amazon Linux 2023, Ubuntu 22.04 y Ubuntu 24.04. [Para obtener versiones de software detalladas y una lista actualizada de las distribuciones compatibles, consulte el registro de cambios.AWS ParallelCluster](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md)
## Cree un script Prolog para administrar NVIDIA-IMEX
**Limitación:**
+ Este guion de prólogo se ejecutará al enviar un trabajo exclusivo. Esto es para garantizar que el reinicio de IMEX no interrumpa ninguna tarea en ejecución en los nodos del P6e-GB200 que pertenecen a un dominio IMEX.
A continuación se muestra el `91_nvidia_imex_prolog.sh` script que debe configurar como prólogo en Slurm. Se utiliza para actualizar automáticamente la configuración de nvidia-imex en los nodos de cómputo. [El nombre del script tiene el prefijo de `91` para cumplir con la convención de nomenclatura de SchedMD.](https://slurm.schedmd.com/prolog_epilog.html) Esto garantiza que se ejecute antes que cualquier otro script de prólogo de la secuencia. El script reconfigura la configuración del nodo Imex de NVIDIA cuando se inicia un trabajo y vuelve a cargar los daemons de NVIDIA necesarios.
**nota**
Este script no se ejecutará en caso de que se inicien varios trabajos simultáneamente en los mismos nodos, por lo que le sugerimos que utilice la marca al enviarlos. `--exclusive`
```
#!/usr/bin/env bash
# This prolog script configures the NVIDIA IMEX on compute nodes involved in the job execution.
#
# In particular:
# - Checks whether the job is executed exclusively.
# If not, it exits immediately because it requires jobs to be executed exclusively.
# - Checks if it is running on a p6e-gb200 instance type.
# If not, it exits immediately because IMEX must be configured only on that instance type.
# - Checks if the IMEX service is enabled.
# If not, it exits immediately because IMEX must be enabled to get configured.
# - Creates the IMEX default channel.
# For more information about IMEX channels, see https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/imexchannels.html
# - Writes the private IP addresses of compute nodes into /etc/nvidia-imex/nodes_config.cfg.
# - Restarts the IMEX system service.
#
# REQUIREMENTS:
# - This prolog assumes to be run only with exclusive jobs.
LOG_FILE_PATH="/var/log/parallelcluster/nvidia-imex-prolog.log"
SCONTROL_CMD="/opt/slurm/bin/scontrol"
IMEX_START_TIMEOUT=60
IMEX_STOP_TIMEOUT=15
ALLOWED_INSTANCE_TYPES="^(p6e-gb200)"
IMEX_SERVICE="nvidia-imex"
IMEX_NODES_CONFIG="/etc/nvidia-imex/nodes_config.cfg"
function info() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [INFO] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function warn() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [WARN] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function error() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [ERROR] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function error_exit() {
error "$1" && exit 1
}
function prolog_end() {
info "PROLOG End JobId=${SLURM_JOB_ID}: $0"
info "----------------"
exit 0
}
function get_instance_type() {
local token=$(curl -X PUT -s "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -s -H "X-aws-ec2-metadata-token: ${token}" http://169.254.169.254/latest/meta-data/instance-type
}
function return_if_unsupported_instance_type() {
local instance_type=$(get_instance_type)
if [[ ! ${instance_type} =~ ${ALLOWED_INSTANCE_TYPES} ]]; then
info "Skipping IMEX configuration because instance type ${instance_type} does not support it"
prolog_end
fi
}
function return_if_imex_disabled() {
if ! systemctl is-enabled "${IMEX_SERVICE}" &>/dev/null; then
warn "Skipping IMEX configuration because system service ${IMEX_SERVICE} is not enabled"
prolog_end
fi
}
function return_if_job_is_not_exclusive() {
if [[ "${SLURM_JOB_OVERSUBSCRIBE}" =~ ^(NO|TOPO)$ ]]; then
info "Job is exclusive, proceeding with IMEX configuration"
else
info "Skipping IMEX configuration because the job is not exclusive"
prolog_end
fi
}
function get_ips_from_node_names() {
local _nodes=$1
${SCONTROL_CMD} -ao show node "${_nodes}" | sed 's/^.* NodeAddr=\([^ ]*\).*/\1/'
}
function get_compute_resource_name() {
local _queue_name_prefix=$1
local _slurmd_node_name=$2
echo "${_slurmd_node_name}" | sed -E "s/${_queue_name_prefix}(.+)-[0-9]+$/\1/"
}
function reload_imex() {
info "Stopping IMEX"
timeout ${IMEX_STOP_TIMEOUT} systemctl stop ${IMEX_SERVICE}
pkill -9 ${IMEX_SERVICE}
info "Restarting IMEX"
timeout ${IMEX_START_TIMEOUT} systemctl start ${IMEX_SERVICE}
}
function create_default_imex_channel() {
info "Creating IMEX default channel"
MAJOR_NUMBER=$(cat /proc/devices | grep nvidia-caps-imex-channels | cut -d' ' -f1)
if [ ! -d "/dev/nvidia-caps-imex-channels" ]; then
sudo mkdir /dev/nvidia-caps-imex-channels
fi
# Then check and create device node
if [ ! -e "/dev/nvidia-caps-imex-channels/channel0" ]; then
sudo mknod /dev/nvidia-caps-imex-channels/channel0 c $MAJOR_NUMBER 0
info "IMEX default channel created"
else
info "IMEX default channel already exists"
fi
}
{
info "PROLOG Start JobId=${SLURM_JOB_ID}: $0"
return_if_job_is_not_exclusive
return_if_unsupported_instance_type
return_if_imex_disabled
create_default_imex_channel
IPS_FROM_CR=$(get_ips_from_node_names "${SLURM_NODELIST}")
info "Node Names: ${SLURM_NODELIST}"
info "Node IPs: ${IPS_FROM_CR}"
info "IMEX Nodes Config: ${IMEX_NODES_CONFIG}"
info "Updating IMEX nodes config ${IMEX_NODES_CONFIG}"
echo "${IPS_FROM_CR}" > "${IMEX_NODES_CONFIG}"
reload_imex
prolog_end
} 2>&1 | tee -a "${LOG_FILE_PATH}" | logger -t "91_nvidia_imex_prolog"
```
## Cree el script de acción HeadNode OnNodeStart personalizado
Cree una acción `install_custom_action.sh` personalizada que descargue el script de prólogo mencionado anteriormente en un directorio compartido al `/opt/slurm/etc/scripts/prolog.d/` que accedan los nodos de cómputo y establezca los permisos adecuados para su ejecución.
```
#!/bin/bash
set -e
echo "Executing $0"
PROLOG_NVIDIA_IMEX=/opt/slurm/etc/scripts/prolog.d/91_nvidia_imex_prolog.sh
aws s3 cp "s3:///91_nvidia_imex_prolog.sh" "${PROLOG_NVIDIA_IMEX}"
chmod 0755 "${PROLOG_NVIDIA_IMEX}"
```
## Cree el clúster
Cree un clúster que incluya instancias P6e. GB200 A continuación, encontrará un ejemplo de configuración del tipo SlurmQueues Ultraserver. `u-p6e-gb200x72`
Actualmente, P6e- solo GB200 está disponible en las Zonas Locales. Algunas [zonas locales no admiten una puerta de enlace NAT](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html), así que siga las [opciones de conectividad de las zonas locales](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html) según sea ParallelCluster necesario [Configuración de grupos de seguridad para entornos restringidos](security-groups-configuration.md) para conectarse a AWS los servicios. Siga las instrucciones [Lanzamiento de instancias con bloques de capacidad (CB)](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch), ya que los Ultraservers solo están disponibles como bloques de capacidad.
```
HeadNode:
CustomActions:
OnNodeStart:
Script: s3:///install_custom_action.sh
S3Access:
- BucketName:
InstanceType:
Networking:
SubnetId:
Ssh:
KeyName:
Image:
Os: ubuntu2404
Scheduling:
Scheduler: slurm
SlurmSettings:
CustomSlurmSettings:
- PrologFlags: "Alloc,NoHold"
- MessageTimeout: 240
SlurmQueues:
- CapacityReservationTarget:
CapacityReservationId:
CapacityType: CAPACITY_BLOCK
ComputeResources: ### u-p6e-gb200x72
- DisableSimultaneousMultithreading: true
Efa:
Enabled: true
InstanceType: p6e-gb200.36xlarge
MaxCount: 18
MinCount: 18
Name: cr1
Name: q1
Networking:
SubnetIds:
-
```
## Valide la configuración de IMEX
El `91_nvidia_imex_prolog.sh` prólogo se ejecutará cuando envíes un trabajo de Slurm. A continuación se muestra un ejemplo de trabajo para comprobar el estado del dominio NVIDIA-IMEX.
```
#!/bin/bash
#SBATCH --job-name=nvidia-imex-status-job
#SBATCH --ntasks-per-node=1
#SBATCH --output=slurm-%j.out
#SBATCH --error=slurm-%j.err
QUEUE_NAME="q1"
COMPUTE_RES_NAME="cr1"
IMEX_CONFIG_FILE="/opt/parallelcluster/shared/nvidia-imex/config_${QUEUE_NAME}_${COMPUTE_RES_NAME}.cfg"
srun bash -c "/usr/bin/nvidia-imex-ctl -N -c ${IMEX_CONFIG_FILE} > result_\${SLURM_JOB_ID}_\$(hostname).out 2> result_\${SLURM_JOB_ID}_\$(hostname).err"
```
Compruebe el resultado del Job:
```
Connectivity Table Legend:
I - Invalid - Node wasn't reachable, no connection status available
N - Never Connected
R - Recovering - Connection was lost, but clean up has not yet been triggered.
D - Disconnected - Connection was lost, and clean up has been triggreed.
A - Authenticating - If GSSAPI enabled, client has initiated mutual authentication.
!V! - Version mismatch, communication disabled.
!M! - Node map mismatch, communication disabled.
C - Connected - Ready for operation
5/12/2025 06:08:10.580
Nodes:
Node #0 - 172.31.48.81 - READY - Version: 570.172
Node #1 - 172.31.48.98 - READY - Version: 570.172
Node #2 - 172.31.48.221 - READY - Version: 570.172
Node #3 - 172.31.49.228 - READY - Version: 570.172
Node #4 - 172.31.50.39 - READY - Version: 570.172
Node #5 - 172.31.50.44 - READY - Version: 570.172
Node #6 - 172.31.51.66 - READY - Version: 570.172
Node #7 - 172.31.51.157 - READY - Version: 570.172
Node #8 - 172.31.52.239 - READY - Version: 570.172
Node #9 - 172.31.53.80 - READY - Version: 570.172
Node #10 - 172.31.54.95 - READY - Version: 570.172
Node #11 - 172.31.54.183 - READY - Version: 570.172
Node #12 - 172.31.54.203 - READY - Version: 570.172
Node #13 - 172.31.54.241 - READY - Version: 570.172
Node #14 - 172.31.55.59 - READY - Version: 570.172
Node #15 - 172.31.55.187 - READY - Version: 570.172
Node #16 - 172.31.55.197 - READY - Version: 570.172
Node #17 - 172.31.56.47 - READY - Version: 570.172
Nodes From\To 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0 C C C C C C C C C C C C C C C C C C
1 C C C C C C C C C C C C C C C C C C
2 C C C C C C C C C C C C C C C C C C
3 C C C C C C C C C C C C C C C C C C
4 C C C C C C C C C C C C C C C C C C
5 C C C C C C C C C C C C C C C C C C
6 C C C C C C C C C C C C C C C C C C
7 C C C C C C C C C C C C C C C C C C
8 C C C C C C C C C C C C C C C C C C
9 C C C C C C C C C C C C C C C C C C
10 C C C C C C C C C C C C C C C C C C
11 C C C C C C C C C C C C C C C C C C
12 C C C C C C C C C C C C C C C C C C
13 C C C C C C C C C C C C C C C C C C
14 C C C C C C C C C C C C C C C C C C
15 C C C C C C C C C C C C C C C C C C
16 C C C C C C C C C C C C C C C C C C
17 C C C C C C C C C C C C C C C C C C
Domain State: UP
```
# Personalice las interfaces de red de nodos de cómputo con anulaciones de plantillas de lanzamiento
A partir de la AWS ParallelCluster versión 3.15.0, el `LaunchTemplateOverrides` parámetro permite personalizar las interfaces de red de los nodos de procesamiento sustituyendo la configuración de la interfaz de red predeterminada por la configuración de una plantilla de lanzamiento a la que se hace referencia. La sección de interfaz de red de la plantilla de lanzamiento utilizada para la anulación sobrescribe toda la sección de interfaz de red de los nodos de cómputo.
En este tutorial, se muestra un ejemplo de cómo anular la configuración de red predeterminada de los nodos de `p6-b300.48xlarge` procesamiento. Esta personalización resulta útil cuando se necesita una configuración de interfaz de red específica que difiera de la que se AWS ParallelCluster configura de forma predeterminada. En este ejemplo, configuramos el caso de uso 2 para las instancias P6-B300, tal y como se describe en la documentación de tipos de instancias compatibles con [Amazon EC2 EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html).
**nota**
Se recomienda utilizar la plantilla de lanzamiento AWS CLI para crear la plantilla de lanzamiento en lugar de la consola para obtener la máxima flexibilidad.
**nota**
La plantilla de lanzamiento solo debe contener anulaciones de interfaces de red. AWS ParallelCluster tiene una validación que impide anular otros parámetros.
**aviso**
Si utilizas la anulación para configurar las interfaces de red de una forma que no sea compatible con el tipo de instancia que se está utilizando, las instancias no se lanzarán.
**Requisitos previos**
+ AWS ParallelCluster [está instalada la versión 3.15.0 o posterior.](install-v3-parallelcluster.md)
+ AWS CLI [Está instalado y configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Tiene un rol de IAM con los [permisos](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necesarios para ejecutar el CLI [`pcluster`](pcluster-v3.md).
## Paso 1: Crear grupos de seguridad
Al crear la plantilla de lanzamiento para utilizarla en la anulación, debe hacer referencia a un grupo de seguridad. El grupo AWS ParallelCluster de seguridad predeterminado para el recurso informático no existe hasta que se crea el clúster, por lo que debe crear un grupo de seguridad personalizado. A continuación, el grupo de seguridad del nodo principal debe hacer referencia a este grupo de seguridad para permitir el tráfico entre el nodo principal y los nodos de procesamiento.
Si va a actualizar un clúster existente para personalizar la nueva capacidad, puede usar el grupo de seguridad de AWS ParallelCluster nodos de procesamiento predeterminado en la plantilla de lanzamiento en lugar de crear uno personalizado.
Cree los dos grupos de seguridad siguientes:
+ **Grupo de seguridad adicional del nodo principal** (`sg-1234abcd`):
+ Entrada: todo el tráfico del grupo de seguridad informática
+ **Grupo de seguridad informática** (`sg-abcd1234`):
+ Entrada: todo el tráfico del grupo de seguridad del nodo principal
+ Entrada: todo el tráfico procedente de self () compute-to-compute
+ Salida: permitido todo por defecto
## Paso 2: Crea la plantilla de lanzamiento
Cree una plantilla de lanzamiento que defina la configuración de la interfaz de red para los `p6-b300.48xlarge` nodos de procesamiento. Para la interfaz de red principal (índice de tarjeta de red 0, índice de dispositivo 0), utilice una interfaz de red ENA (predeterminada). Para el resto de las tarjetas de red, cree una interfaz exclusiva para EFA (índices de tarjetas de red del 1 al 16, índice de dispositivos 0) y una interfaz ENA (predeterminada) (índices de tarjetas de red del 1 al 16, índice de dispositivos 1).
Ejecute el siguiente AWS CLI comando para crear la plantilla de lanzamiento (): `lt-123456789`
```
aws ec2 create-launch-template \
--region us-east-1 \
--launch-template-name override-lt \
--launch-template-data '{
"NetworkInterfaces": [
{"NetworkCardIndex":0, "DeviceIndex":0, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":1, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":1, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":2, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":2, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":3, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":3, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":4, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":4, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":5, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":5, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":6, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":6, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":7, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":7, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":8, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":8, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":9, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":9, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":10, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":10, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":11, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":11, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":12, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":12, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":13, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":13, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":14, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":14, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":15, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":15, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":16, "DeviceIndex":0, "InterfaceType":"efa-only", "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"},
{"NetworkCardIndex":16, "DeviceIndex":1, "Groups":["sg-abcd1234"], "SubnetId":"subnet-123456789"}
]
}'
```
## Paso 3: Cree el clúster con las sustituciones de la plantilla de lanzamiento
Cree una configuración de clúster que utilice el `LaunchTemplateOverrides` parámetro como referencia a la plantilla de lanzamiento que creó.
```
Region: us-east-1
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-abcdefghi
AdditionalSecurityGroups:
# Add the head node SG that allows traffic from the compute node SG
- sg-1234abcd
...
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
Networking:
SubnetIds:
- subnet-123456789
ComputeResources:
- Name: compute-resource1
InstanceType: p6-b300.48xlarge
Efa:
Enabled: false # The override replaces all network interface configuration, so this setting is ignored
LaunchTemplateOverrides:
LaunchTemplateId: lt-123456789
Version: 1 # If the launch template is updated, then the new version should be specified here.
```