Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Tutoriels d'utilisation AWS ParallelCluster
Les didacticiels suivants vous montrent comment démarrer avec AWS ParallelCluster la version 3 et fournissent des conseils sur les meilleures pratiques pour certaines tâches courantes.
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Topics**
+ [Exécution de votre premier job sur AWS ParallelCluster](tutorials-running-your-first-job-on-version-3.md)
+ [Création d'une AWS ParallelCluster AMI personnalisée](building-custom-ami-v3.md)
+ [Intégration d'Active Directory](tutorials_05_multi-user-ad.md)
+ [Configuration du chiffrement du stockage partagé à l'aide d'une AWS KMS clé](tutorials_04_encrypted_kms_fs-v3.md)
+ [Exécution de tâches dans un cluster en mode de files d'attente multiples](multi-queue-tutorial-v3.md)
+ [Utilisation de l' AWS ParallelCluster API](tutorials_06_API_use.md)
+ [Création d'un cluster avec Slurm comptabilité](tutorials_07_slurm-accounting-v3.md)
+ [Création d'un cluster avec un module externe Slurmdbd comptabilité](external-slurmdb-accounting.md)
+ [Revenir à une version précédente du document AWS Systems Manager](tutorials_08_ssm-document-version-rev-v3.md)
+ [Création d'un cluster avec CloudFormation](tutorials_09_cfn-custom-resource-v3.md)
+ [Déployer une ParallelCluster API avec Terraform](tutorial-deploy-terraform.md)
+ [Création d'un cluster avec Terraform](tutorial-create-cluster-terraform.md)
+ [Création d'une AMI personnalisée avec Terraform](tutorial-create-ami-terraform.md)
+ [AWS ParallelCluster Intégration de l'interface utilisateur à Identity Center](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Exécution de tâches conteneurisées avec Pyxis](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [Création d'un cluster avec un Lustre compatible EFA FSx](tutorial-efa-enabled-fsx-lustre.md)
+ [Support de Nvidia-IMEX avec l'instance p6e-gb200](support-nvidia-imex-p6e-gb200-instance.md)
+ [Personnalisez les interfaces réseau des nœuds de calcul avec des remplacements de modèles de lancement](tutorial-network-customization-v3.md)
# Exécution de votre premier job sur AWS ParallelCluster
Ce didacticiel vous explique comment exécuter votre première tâche Hello World sur AWS ParallelCluster
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Conditions préalables**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une paire de [clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
## Vérification de votre installation
Tout d'abord, nous vérifions que AWS ParallelCluster c'est correctement installé et configuré, y compris la dépendance Node.js.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
Cela renvoie la version en cours d'exécution de AWS ParallelCluster.
## Création de votre premier cluster
Il est temps de créer votre premier cluster. Comme la charge de travail pour ce didacticiel n'est pas exigeante, nous pouvons utiliser la taille d'instance par défaut, à savoir `t2.micro`. (Pour les charges de travail en production, vous choisissez une taille d'instance qui répond le mieux à vos besoins.) Appelons votre cluster`hello-world`.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**Note**
Le Région AWS à utiliser doit être spécifié pour la plupart des `pcluster` commandes. S'il n'est pas spécifié dans la variable d'`AWS_DEFAULT_REGION`environnement ou dans le `region` paramètre dans la `[default]` section du `~/.aws/config` fichier, le `--region` paramètre doit être fourni sur la ligne de `pcluster` commande.
Si le résultat affiche un message concernant la configuration, vous devez exécuter ce qui suit pour configurer AWS ParallelCluster :
```
$ pcluster configure --config hello-world.yaml
```
Si la [`pcluster create-cluster`](pcluster.create-cluster-v3.md) commande aboutit, vous obtenez un résultat similaire à ce qui suit :
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Vous surveillez la création du cluster à l'aide de :
```
$ pcluster describe-cluster --cluster-name hello-world
```
Les `clusterStatus` rapports « `CREATE_IN_PROGRESS` » lors de la création du cluster. Il `clusterStatus` passe à « `CREATE_COMPLETE` » lorsque le cluster est créé avec succès. La sortie nous fournit également la `publicIpAddress` fin `privateIpAddress` de notre nœud principal.
## Connexion à votre nœud principal
Utilisez votre fichier pem OpenSSH pour vous connecter à votre nœud principal.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
Une fois connecté, exécutez la commande `sinfo` pour vérifier que vos nœuds de calcul sont créés et configurés.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
Le résultat indique que nous avons une file d'attente dans notre cluster, avec jusqu'à dix nœuds.
## Exécution de votre première tâche avec Slurm
Ensuite, nous créons une tâche qui dort pendant un certain temps, puis génère son propre nom d'hôte. Créez un fichier nommé `hellojob.sh` avec le contenu suivant :
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
Ensuite, soumettez la tâche avec `sbatch`, et vérifiez qu'elle s'exécute.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
Maintenant, vous pouvez afficher votre file d'attente et vérifier le statut de la tâche. Le provisionnement d'une nouvelle instance Amazon EC2 démarre en arrière-plan. Vous pouvez surveiller l'état des instances de cluster à l'aide de la `sinfo` commande.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
La sortie indique que le travail a été soumis à`queue1`. Attendez 30 secondes que la tâche se termine et exécutez `squeue` à nouveau.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
Maintenant qu'il n'y a pas de tâche dans la file d'attente, nous pouvons rechercher la sortie dans notre répertoire actuel.
```
$ 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
```
Dans le résultat, nous voyons un fichier `out` « ». Nous pouvons voir les résultats de notre travail :
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
La sortie indique également que notre tâche a été exécutée avec succès sur l'instance `queue1-dy-queue1t2micro-1`.
Dans le cluster que vous venez de créer, seul le répertoire de base est partagé entre tous les nœuds du cluster.
Pour en savoir plus sur la création et l'utilisation de clusters, consultez[Bonnes pratiques](best-practices-v3.md).
Si votre application nécessite le partage de logiciels, de bibliothèques ou de données, envisagez les options suivantes :
+ Créez une AMI personnalisée AWS ParallelCluster activée qui inclut votre logiciel, comme décrit dans[Création d'une AWS ParallelCluster AMI personnalisée](building-custom-ami-v3.md).
+ Utilisez l'[StorageSettings](SharedStorage-v3.md)option du fichier AWS ParallelCluster de configuration pour spécifier un système de fichiers partagé et stocker le logiciel installé dans l'emplacement de montage indiqué.
+ [Actions de bootstrap personnalisées](custom-bootstrap-actions-v3.md)À utiliser pour automatiser la procédure d'amorçage de chaque nœud de votre cluster.
# Création d'une AWS ParallelCluster AMI personnalisée
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Important**
Si vous créez une AMI personnalisée, vous devez répéter les étapes que vous avez utilisées pour créer votre AMI personnalisée à chaque nouvelle AWS ParallelCluster version.
Avant de poursuivre votre lecture, nous vous recommandons de consulter d'abord [Actions de bootstrap personnalisées](custom-bootstrap-actions-v3.md) cette section. Déterminez si les modifications que vous souhaitez apporter peuvent être scriptées et prises en charge dans les AWS ParallelCluster versions futures.
Même si la création d'une AMI personnalisée n'est généralement pas idéale, il existe des scénarios spécifiques dans lesquels il AWS ParallelCluster est nécessaire de créer une AMI personnalisée pour. Ce didacticiel explique comment créer une AMI personnalisée pour ces scénarios.
**Conditions préalables**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une paire de [clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM avec les [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI et créer des images.
## Comment personnaliser l' AWS ParallelCluster AMI
Il existe deux manières de créer une AWS ParallelCluster AMI personnalisée. L'une de ces deux méthodes consiste à créer une nouvelle AMI à l'aide de la AWS ParallelCluster CLI. Une autre méthode nécessite que vous apportiez des modifications manuelles pour créer une nouvelle AMI disponible sous votre Compte AWS.
## Créez une AWS ParallelCluster AMI personnalisée
Si vous disposez d'une AMI et d'un logiciel personnalisés, vous pouvez appliquer les modifications nécessaires par-dessus. AWS ParallelCluster AWS ParallelCluster s'appuie sur le service EC2 Image Builder pour créer AMIs des produits personnalisés. Pour plus d'informations, consultez le [guide de l'utilisateur d'Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
Points clés :
+ Le processus dure environ 1 heure. Cette durée peut varier s'il y a un [`Build`](Build-v3.md)/supplémentaire [`Components`](Build-v3.md#Build-v3-Components)à installer au moment de la construction.
+ L'AMI est étiquetée avec les versions des principaux composants. Il s'agit notamment du noyau, du planificateur et du pilote [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). Un sous-ensemble des versions des composants est également indiqué dans la description de l'AMI.
+ À partir de la AWS ParallelCluster version 3.0.0, un nouvel ensemble de commandes CLI peut être utilisé pour gérer le cycle de vie des images. Cela inclut [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md) et [`delete-image`](pcluster.delete-image-v3.md).
+ Cette méthode est reproductible. Vous pouvez le réexécuter pour rester à AMIs jour (par exemple, les mises à jour du système d'exploitation), puis les utiliser lorsque vous mettez à jour un cluster existant.
**Note**
Si vous utilisez cette méthode dans la partition AWS Chine, vous risquez de rencontrer des erreurs réseau. Par exemple, ces erreurs peuvent apparaître dans la `pcluster build-image` commande lorsqu'elle télécharge des packages depuis GitHub ou depuis un référentiel du système d'exploitation. Dans ce cas, nous vous recommandons d'utiliser l'une des méthodes alternatives suivantes :
Suivez l'[Modifier une AWS ParallelCluster AMI](#modify-an-aws-parallelcluster-ami-v3)approche qui contourne cette commande.
Créez l'image dans une autre partition ou région, par exemple`us-east-1`, puis store/restore déplacez-la vers la région de Chine. Pour plus d’informations, consultez [Stockage et restauration d’une AMI à l’aide de S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) dans le *Guide de l’utilisateur Amazon EC2*.
Étapes :
1. Configurez vos Compte AWS informations d'identification afin que le AWS ParallelCluster client puisse appeler les opérations d' AWS API en votre nom. Pour obtenir la liste des autorisations requises, consultez [Gestion des identités et des accès AWS autorisations dans AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md).
1. Créez un fichier de configuration *d'image de construction* de base. Pour ce faire, spécifiez le [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType)à utiliser pour créer l'image et le [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage). Ils sont utilisés comme point de départ pour créer l'AMI. Pour plus d'informations sur les paramètres de construction facultatifs, consultez la section [Configuration de l'image](image-builder-configuration-file-v3.md).
```
Build:
InstanceType:
ParentImage:
```
1. Utilisez la commande CLI [`pcluster build-image`](pcluster.build-image-v3.md)pour créer une AWS ParallelCluster AMI à partir de l'AMI que vous fournissez comme 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"
}
}
```
**Avertissement**
`pcluster build-image`utilise le VPC par défaut. Si vous supprimez le VPC par défaut en utilisant AWS Control Tower ou AWS Landing Zone, l'ID de sous-réseau doit être spécifié dans le fichier de configuration de l'image. Pour de plus amples informations, veuillez consulter [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId).
Pour obtenir la liste des autres paramètres, consultez la page de référence des [`pcluster build-image`](pcluster.build-image-v3.md)commandes. Les résultats de la commande précédente sont les suivants :
+ Une CloudFormation pile est créée en fonction de la configuration de l'image. La pile inclut toutes les ressources EC2 Image Builder requises pour le build.
+ Les ressources créées incluent les AWS ParallelCluster composants officiels d'Image Builder auxquels des composants Image Builder personnalisés peuvent être ajoutés. Pour plus d'informations, consultez la section [Création d'un composant personnalisé avec Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) dans le guide de l'*utilisateur d'EC2 Image Builder*.
+ EC2 Image Builder lance une instance de build, applique AWS ParallelCluster le livre de recettes, installe AWS ParallelCluster la pile logicielle et effectue les tâches de configuration nécessaires. Le AWS ParallelCluster livre de recettes est utilisé pour construire et démarrer. AWS ParallelCluster
+ L'instance est arrêtée et une nouvelle AMI est créée à partir de celle-ci.
+ Une autre instance est lancée à partir de l'AMI nouvellement créée. Pendant la phase de test, EC2 Image Builder exécute des tests définis dans les composants Image Builder.
+ Si la construction est réussie, la pile est supprimée. Si la construction échoue, la pile est conservée et disponible pour inspection.
1. Vous pouvez surveiller l'état du processus de génération en exécutant la commande suivante. Une fois la compilation terminée, vous pouvez l'exécuter pour récupérer l'ID d'AMI indiqué dans la réponse.
```
$ 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. Pour créer votre cluster, entrez l'ID de l'AMI dans le [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)champ de configuration de votre cluster.
**Résolution des problèmes et surveillance du processus de création d'AMI**
La création de l'image se termine en une heure environ. Vous pouvez surveiller le processus en exécutant la [`pcluster describe-image`](pcluster.describe-image-v3.md)commande ou les commandes de récupération du journal.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
La [`build-image`](pcluster.build-image-v3.md)commande crée une CloudFormation pile contenant toutes les ressources Amazon EC2 nécessaires à la création de l'image et lance le processus EC2 Image Builder.
Après avoir exécuté la [`build-image`](pcluster.build-image-v3.md)commande, il est possible de récupérer les événements de la CloudFormation pile en utilisant [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md). Vous pouvez filtrer les résultats à l'aide du `--query` paramètre pour voir les derniers événements. Pour plus d'informations, consultez la section [Filtrage AWS CLI de la sortie](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html) dans le *guide de AWS Command Line Interface l'utilisateur*.
```
$ 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"
}
```
Après environ 15 minutes, les événements de la pile apparaissent dans l'entrée du journal des événements liés à la création d'Image Builder. Vous pouvez désormais répertorier les flux de journaux d'images et suivre les étapes de l'Image Builder à l'aide [`pcluster list-image-log-streams`](pcluster.list-image-log-streams-v3.md)des [`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md)commandes and.
```
$ 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"
}
]
}
```
Continuez à vérifier la [`describe-image`](pcluster.describe-image-v3.md)commande jusqu'à ce que vous voyiez le `BUILD_COMPLETE` statut.
```
$ 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 vous devez résoudre un problème de création d'AMI personnalisée, créez une archive des journaux d'images comme décrit dans les étapes suivantes.
Il est possible d'archiver les journaux dans un compartiment Amazon S3 ou dans un fichier local, selon le `--output` paramètre.
```
$ 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"
}
```
L'archive contient les flux de CloudWatch logs liés au processus Image Builder et aux événements de CloudFormation stack. L'exécution de la commande peut prendre plusieurs minutes.
**Gestion personnalisée AMIs**
À partir de la AWS ParallelCluster version 3.0.0, un nouvel ensemble de commandes a été ajouté à la CLI pour créer, surveiller et gérer le cycle de vie des images. Pour plus d'informations sur les commandes, consultez la section [commandes pcluster](pcluster-v3.md).
## Modifier une AWS ParallelCluster AMI
Cette méthode consiste à modifier une AWS ParallelCluster AMI officielle en y ajoutant une personnalisation. La base AWS ParallelCluster AMIs est mise à jour avec les nouvelles versions. Ils AMIs contiennent tous les composants nécessaires AWS ParallelCluster au fonctionnement lors de leur installation et de leur configuration. Vous pouvez commencer par l'un d'entre eux comme base.
Points clés :
+ Cette méthode est plus rapide que la [`build-image`](pcluster.build-image-v3.md)commande. Cependant, il s'agit d'un processus manuel qui ne se répète pas automatiquement.
+ Avec cette méthode, vous n'avez pas accès aux commandes de récupération des journaux et de gestion du cycle de vie des images disponibles via la CLI.
Étapes :
------
#### [ New Amazon EC2 console ]
1. Trouvez l'AMI qui correspond à l'AMI spécifique Région AWS que vous utilisez. Pour le trouver, utilisez la [`pcluster list-official-images`](pcluster.list-official-images-v3.md)commande avec le `--region` paramètre pour sélectionner les `--architecture` paramètres spécifiques Région AWS `--os` et à filtrer pour l'AMI souhaitée avec le système d'exploitation et l'architecture que vous souhaitez utiliser. À partir de la sortie, récupérez l'identifiant de l'image Amazon EC2.
1. Connectez-vous à la console Amazon EC2 AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Dans le volet de navigation, choisissez **Images**, puis **AMIs**. Recherchez l'ID d'image EC2 récupéré, sélectionnez l'AMI, puis choisissez **Launch instance from AMI**.
1. Faites défiler la page vers le bas et choisissez votre **type d'instance**.
1. Choisissez votre **paire de clés** et **lancez votre instance**.
1. Connectez-vous à votre instance à l'aide de l'utilisateur du système d'exploitation et de votre SSH clé.
1. Personnalisez manuellement votre instance pour répondre à vos besoins.
1. Exécutez la commande suivante pour préparer votre instance pour la création d'AMI.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Dans la console, choisissez **Instance state** et **Stop instance**.
Accédez à **Instances**, choisissez la nouvelle instance, sélectionnez **État de l'instance** et **Arrêtez l'instance**.
1. [Créez une nouvelle AMI à partir de l'instance à l'aide de la console Amazon EC2 ou AWS CLI de la commande create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Depuis la console Amazon EC2**
1. Choisissez **Instances** dans le volet de navigation.
1. Choisissez l'instance que vous avez créée et modifiée.
1. Dans **Actions**, choisissez **Image**, puis **Créer une image**.
1. Choisissez **Créer une image**.
1. Entrez le nouvel ID AMI dans le [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)champ de configuration de votre cluster et créez un cluster.
------
#### [ Old Amazon EC2 console ]
1. Trouvez l' AWS ParallelCluster AMI qui correspond à l'AMI spécifique Région AWS que vous utilisez. Pour le trouver, vous pouvez utiliser la [`pcluster list-official-images`](pcluster.list-official-images-v3.md)commande avec le `--region` paramètre pour sélectionner les `--architecture` paramètres spécifiques Région AWS `--os` et à filtrer pour l'AMI souhaitée avec le système d'exploitation et l'architecture que vous souhaitez utiliser. À partir de la sortie, vous pouvez récupérer l'identifiant de l'image Amazon EC2.
1. Connectez-vous à la console Amazon EC2 AWS Management Console et ouvrez-la à l'adresse. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Dans le volet de navigation, choisissez **Images**, puis **AMIs**. Définissez le filtre pour les **images publiques** et recherchez l'ID d'image EC2 récupéré, sélectionnez l'AMI, puis choisissez **Launch**.
1. Choisissez votre type d'instance et sélectionnez **Suivant : Configurer les détails de l'instance** ou **Vérifier et lancer** pour lancer votre instance.
1. Choisissez **Launch**, sélectionnez votre **paire de clés** et **lancez les instances**.
1. Connectez-vous à votre instance à l'aide de l'utilisateur du système d'exploitation et de votre clé SSH. Pour plus d'informations, accédez à **Instances**, sélectionnez la nouvelle instance et **Connect**.
1. Personnalisez manuellement votre instance pour répondre à vos besoins.
1. Exécutez la commande suivante pour préparer votre instance pour la création d'une AMI :
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. **Depuis la console Amazon EC2, choisissez **Instances** dans le volet de navigation, sélectionnez votre nouvelle instance et choisissez **Actions**, **Instance State** et Stop.**
1. [Créez une nouvelle AMI à partir de l'instance à l'aide de la console Amazon EC2 ou AWS CLI de la commande create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Depuis la console Amazon EC2**
1. Choisissez **Instances** dans le volet de navigation.
1. Choisissez l'instance que vous avez créée et modifiée.
1. Dans **Actions**, choisissez **Image**, puis **Créer une image**.
1. Choisissez **Créer une image**.
1. Entrez le nouvel ID AMI dans le [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)champ de configuration de votre cluster et créez un cluster.
------
# Intégration d'Active Directory
Dans ce didacticiel, vous allez créer un environnement multi-utilisateurs. Cet environnement inclut un AWS ParallelCluster qui est intégré à un AWS Managed Microsoft AD (Active Directory) à`corp.example.com`. Vous configurez un `Admin` utilisateur pour gérer le répertoire, un `ReadOnly` utilisateur pour lire le répertoire et un `user000` utilisateur pour se connecter au cluster. Vous pouvez utiliser le chemin automatique ou le chemin manuel pour créer les ressources réseau, un Active Directory (AD) et l'instance Amazon EC2 que vous utilisez pour configurer l'AD. Quel que soit le chemin, l'infrastructure que vous créez est préconfigurée pour s'intégrer à AWS ParallelCluster l'aide de l'une des méthodes suivantes :
+ LDAPS avec vérification des certificats (recommandé comme option la plus sûre)
+ LDAPS sans vérification du certificat
+ LDAP
Le protocole LDAP en lui-même *ne fournit pas* de chiffrement. Pour garantir la transmission sécurisée d'informations potentiellement sensibles, nous vous recommandons vivement d'utiliser LDAPS (LDAP over TLS/SSL) pour les clusters intégrés à. ADs *Pour plus d'informations, voir [Activer le protocole LDAPS côté serveur à l'aide](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html) du Directory Service guide d' AWS Managed Microsoft AD administration.*
Après avoir créé ces ressources, configurez et créez votre cluster intégré à votre Active Directory (AD). Une fois le cluster créé, connectez-vous en tant qu'utilisateur que vous avez créé. Pour plus d'informations sur la configuration que vous créez dans ce didacticiel, consultez [Accès de plusieurs utilisateurs aux clusters](multi-user-v3.md) la section relative à la [`DirectoryService`](DirectoryService-v3.md)configuration.
Ce didacticiel explique comment créer un environnement prenant en charge l'accès de plusieurs utilisateurs aux clusters. Ce didacticiel n'explique pas comment créer et utiliser un Directory Service AD. Les étapes que vous suivez pour configurer un AWS Managed Microsoft AD dans ce didacticiel sont fournies à des fins de test uniquement. Ils *ne sont pas* fournis pour remplacer la documentation officielle et les meilleures pratiques que vous pouvez trouver sur [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) dans le *Guide d'Directory Service administration*.
**Note**
Les mots de passe des utilisateurs de l'annuaire expirent conformément aux définitions des propriétés de la politique de mot de passe d'annuaire. Pour réinitialiser les mots de passe des annuaires avec AWS ParallelCluster, voir[Comment réinitialiser le mot de passe d'un utilisateur et les mots de passe expirés](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd).
**Note**
Les adresses IP du contrôleur de domaine de l'annuaire peuvent changer en raison des modifications du contrôleur de domaine et de la maintenance de l'annuaire. Si vous avez choisi la méthode de création rapide automatisée pour créer l'infrastructure d'annuaire, vous devez aligner manuellement l'équilibreur de charge devant les contrôleurs d'annuaire lorsque les adresses IP des répertoires changent. Si vous utilisez la méthode de création rapide, les adresses IP du répertoire ne sont pas automatiquement alignées avec les équilibreurs de charge.
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Conditions préalables**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une paire de [clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
Au fur et à mesure que vous parcourez le didacticiel`inputs highlighted in red`, remplacez, tels que `region-id` et`d-abcdef01234567890`, par vos propres noms et IDs. Remplacez `0123456789012` par votre Compte AWS numéro.
# Création de l'infrastructure AD
Choisissez l'onglet *Automatisé* pour créer l'infrastructure Active Directory (AD) à l'aide d'un modèle de création CloudFormation rapide.
Choisissez l'onglet *Manuel* pour créer manuellement l'infrastructure AD.
## Automatisé
1. Connectez-vous au AWS Management Console.
1. Ouvrez [CloudFormation Quick Create (région 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)) pour créer les ressources suivantes dans la console : CloudFormation
+ Un VPC avec deux sous-réseaux et un routage pour un accès public, si aucun VPC n'est spécifié.
+ Un AWS Managed Microsoft AD.
+ Une instance Amazon EC2 jointe à l'AD que vous pouvez utiliser pour gérer l'annuaire.
1. Dans la section **Paramètres** de la page de **création rapide d'une pile**, entrez des mots de passe pour les paramètres suivants :
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Prenez note des mots de passe. Vous les utiliserez plus tard dans ce didacticiel.
1. Pour **DomainName**, entrez **corp.example.com**.
1. Pour **Keypair**, entrez le nom d'une paire de clés Amazon EC2.
1. Cochez les cases correspondant à chacune des fonctionnalités d'accès au bas de la page.
1. Sélectionnez **Créer la pile**.
1. Une fois que la CloudFormation pile a atteint son `CREATE_COMPLETE` état, choisissez l'onglet **Sorties** de la pile. Notez les noms des ressources de sortie et les IDs raisons pour lesquelles vous devrez les utiliser ultérieurement. Les sorties fournissent les informations nécessaires à la création du cluster.
![\[Un diagramme qui montre les sorties de pile créées dans le AWS Management Console.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/ad-cfn.png)
1. Pour terminer les exercices[(Facultatif) Gérer les utilisateurs et les groupes AD](tutorials_05_multi-user-ad-step2.md), vous avez besoin de l'ID du répertoire. Choisissez **Ressources** et faites défiler l'écran vers le bas pour prendre note de l'ID du répertoire.
1. Continuez sur [(Facultatif) Gérer les utilisateurs et les groupes AD](tutorials_05_multi-user-ad-step2.md) ou[Créer le cluster](tutorials_05_multi-user-ad-step3.md).
## Manuelle
Créez un VPC pour le service d'annuaire avec deux sous-réseaux dans différentes zones de disponibilité et un. AWS Managed Microsoft AD
### Créez l'AD
**Note**
Le répertoire et le nom de domaine sont`corp.example.com`. Le nom abrégé est`CORP`.
Modifiez le `Admin` mot de passe dans le script.
La création de l'Active Directory (AD) prend au moins 15 minutes.
Utilisez le script Python suivant pour créer le VPC, les sous-réseaux et les ressources AD dans votre environnement local. Région AWS Enregistrez ce fichier sous `ad.py` et exécutez-le.
```
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})
```
Voici un exemple de sortie du script Python.
```
{
"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"
}
```
Notez les noms des ressources de sortie et IDs. Vous les utiliserez ultérieurement.
Une fois le script terminé, passez à l'étape suivante.
### Création d'une instance Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Connectez-vous au AWS Management Console.
1. Si aucun rôle n'est associé aux politiques répertoriées à l'étape 4 ci-jointe, ouvrez la console IAM à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse. Sinon, passez à l'étape 5.
1. Créez la `ResetUserPassword` politique en remplaçant le contenu surligné en rouge par votre Région AWS identifiant, votre identifiant de compte et l'identifiant du répertoire à partir de la sortie du script que vous avez exécuté pour créer l'AD.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Créez un rôle IAM avec les politiques suivantes associées.
+ AWS politique gérée [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politique gérée [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword politique
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le tableau de **bord Amazon EC2**, choisissez **Launch** Instance.
1. Dans **Images d'applications et de systèmes d'exploitation**, sélectionnez une AMI Amazon Linux 2 récente.
1. Pour **Type d'instance**, choisissez t2.micro.
1. Pour **Key pair**, choisissez une paire de clés.
1. Sous **Paramètres réseau**, choisissez **Modifier**.
1. Pour **VPC**, sélectionnez le répertoire VPC.
1. Faites défiler l'écran vers le bas et sélectionnez **Détails avancés**.
1. Dans **Détails avancés**, **Répertoire des jointures de domaines**, sélectionnez**corp.example.com**.
1. Pour le **profil d'instance IAM**, choisissez le rôle que vous avez créé à l'étape 1 ou un rôle dont les politiques sont répertoriées à l'étape 4 ci-jointes.
1. Dans **Résumé**, choisissez **Launch instance**.
1. Notez l'ID de l'instance (par exemple, i-1234567890abcdef0) et attendez que le lancement de l'instance soit terminé.
1. Une fois l'instance lancée, passez à l'étape suivante.
------
#### [ Old Amazon EC2 console ]
1. Connectez-vous au AWS Management Console.
1. Si aucun rôle n'est associé aux politiques répertoriées à l'étape 4 ci-jointe, ouvrez la console IAM à [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)l'adresse. Sinon, passez à l'étape 5.
1. Créez la `ResetUserPassword` politique. Remplacez le contenu surligné en rouge par votre Région AWS Compte AWS identifiant, votre identifiant et l'identifiant du répertoire figurant dans le résultat du script que vous avez exécuté pour créer l'Active Directory (AD).
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Créez un rôle IAM avec les politiques suivantes associées.
+ AWS politique gérée [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS politique gérée [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ Stratégie ResetUserPassword
1. Ouvrez la console Amazon EC2 à l’adresse [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Dans le tableau de **bord Amazon EC2**, choisissez **Launch** Instance.
1. Dans **Images d'applications et de systèmes d'exploitation**, sélectionnez une AMI Amazon Linux 2 récente.
1. Concernant l'option **Instance type (Type d'instance)**, choisissez t2.micro.
1. Pour **Key pair**, choisissez une paire de clés.
1. Dans **Paramètres réseau**, choisissez **Modifier**.
1. Dans **Paramètres réseau**, **VPC**, sélectionnez le répertoire VPC.
1. Faites défiler l'écran vers le bas et sélectionnez **Détails avancés**.
1. Dans **Détails avancés**, **Répertoire des jointures de domaines**, sélectionnez**corp.example.com**.
1. Dans **Détails avancés**, **Profil d'instance**, choisissez le rôle que vous avez créé à l'étape 1 ou un rôle auquel sont jointes les politiques répertoriées à l'étape 4.
1. Dans **Résumé**, choisissez **Launch instance**.
1. Notez l'ID de l'instance (par exemple,i-1234567890abcdef0) et attendez que le lancement de l'instance soit terminé.
1. Une fois l'instance lancée, passez à l'étape suivante.
------
### Joignez votre instance à l'AD
1.
**Connectez-vous à votre instance et rejoignez le domaine AD en tant que`admin`.**
Exécutez les commandes suivantes pour vous connecter à l'instance.
```
$ 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.
**Installez le logiciel nécessaire et rejoignez le royaume.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Remplacez le mot de passe administrateur par votre `admin` mot de passe.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Si la procédure précédente a réussi, vous êtes rattaché au royaume et pouvez passer à l'étape suivante.
### Ajouter des utilisateurs à l'AD
1.
**Créez le ReadOnlyUser et un utilisateur supplémentaire.**
Dans cette étape, vous utiliserez les outils [adcli](https://www.mankier.com/package/adcli) et [openldap-clients](https://www.mankier.com/package/openldap-clients) que vous avez installés lors d'une étape précédente.
```
$ 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. **Vérifiez que les utilisateurs ont été créés :**
Les adresses IP DNS du répertoire sont des sorties du script 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"
```
Par défaut, lorsque vous créez un utilisateur avec le`ad-cli`, l'utilisateur est désactivé.
1.
****Réinitialisez et activez les mots de passe utilisateur depuis votre ordinateur local :****
Déconnectez-vous de votre instance Amazon EC2.
**Note**
`ro-p@ssw0rd`est le mot de passe de`ReadOnlyUser`, extrait de AWS Secrets Manager.
`user-p@ssw0rd`est le mot de passe d'un utilisateur du cluster fourni lorsque vous vous connectez (`ssh`) au cluster.
`directory-id`Il s'agit d'une sortie du script 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. **Ajoutez le mot de passe à un secret du Gestionnaire de Secrets.**
Maintenant que vous avez créé `ReadOnlyUser` et défini le mot de passe, stockez-le dans un secret qui AWS ParallelCluster servira à valider les connexions.
Utilisez Secrets Manager pour créer un nouveau secret contenant le mot de passe correspondant `ReadOnlyUser` à la valeur. Le format de la valeur secrète doit être uniquement en texte brut (pas au format JSON). Prenez note de l'ARN secret pour les étapes futures.
```
$ 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
```
### Configuration de LDAPS avec vérification des certificats (recommandée)
Prenez note de la ressource IDs. Vous les utiliserez par étapes ultérieures.
1.
**Générez un certificat de domaine, localement.**
```
$ 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.
**Stockez le certificat dans Secrets Manager pour qu'il puisse être récupéré ultérieurement dans le cluster.**
```
$ 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. Ajoutez la politique suivante au rôle IAM que vous avez créé pour joindre l'instance Amazon EC2 au domaine AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Importez le certificat dans 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.
**Créez et l'équilibreur de charge placé devant les points de terminaison 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.
**Créez le groupe cible qui cible les points de terminaison 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.
**Enregistrez les points de terminaison Active Directory (AD) dans le groupe cible.**
```
$ 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.
**Créez l'écouteur LB avec le certificat.**
```
$ 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.
**Créez la zone hébergée pour rendre le domaine détectable dans le VPC du cluster.**
```
$ 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.
**Créez un fichier nommé `recordset-change.json` avec le contenu suivant. `HostedZoneId`est l'ID de zone hébergée canonique de l'équilibreur de charge.**
```
{
"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.
**Soumettez la modification du jeu d'enregistrements à la zone hébergée, cette fois en utilisant l'ID de zone hébergée.**
```
$ 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.
**Créez un document de politique `policy.json` avec le contenu suivant.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Créez un document de politique nommé `policy.json` avec le contenu suivant.**
```
$ 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. Continuez à suivre les étapes indiquées dans [(Facultatif) Gérer les utilisateurs et les groupes AD](tutorials_05_multi-user-ad-step2.md) ou[Créer le cluster](tutorials_05_multi-user-ad-step3.md).
# (Facultatif) Gérer les utilisateurs et les groupes AD
Au cours de cette étape, vous gérez les utilisateurs et les groupes à partir d'une instance Amazon EC2 Amazon Linux 2 jointe au domaine Active Delivery (AD).
Si vous avez suivi le chemin *automatique*, redémarrez et connectez-vous à l'instance jointe à AD créée dans le cadre de l'automatisation.
Si vous avez suivi le chemin *manuel*, redémarrez et connectez-vous à l'instance que vous avez créée et jointe à AD lors des étapes précédentes.
Au cours de ces étapes, vous utilisez les outils [adcli](https://www.mankier.com/package/adcli) et [openldap-clients](https://www.mankier.com/package/openldap-clients) qui ont été installés dans l'instance lors d'une étape précédente.
**Connectez-vous à une instance Amazon EC2 jointe au domaine AD**
1. Depuis la console Amazon EC2, sélectionnez l'instance Amazon EC2 sans titre créée lors des étapes précédentes. L'état de l'instance **est peut-être Arrêté**.
1. Si l'état de l'instance est **Arrêté**, choisissez **État de l'instance**, puis **Démarrer l'instance**.
1. Une fois les vérifications d'état terminées, sélectionnez l'instance, puis choisissez **Connect** and SSH in to the instance.
**Gérez les utilisateurs et les groupes lorsque vous êtes connecté à une instance Amazon EC2 Amazon Linux 2 qui a rejoint l'AD**
Lorsque vous exécutez les `adcli` commandes avec l'` -U "Admin"`option, vous êtes invité à saisir le mot de `Admin` passe AD. Vous incluez le `Admin` mot de passe AD dans les `ldapsearch` commandes.
1.
**Créez un utilisateur.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Définissez un mot de passe utilisateur.**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**Créez un groupe.**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**Ajoutez un utilisateur à un groupe.**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Décrivez les utilisateurs et les groupes.**
Décrivez tous les utilisateurs.
```
$ 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"
```
Décrivez un utilisateur spécifique.
```
$ 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"
```
Décrivez tous les utilisateurs à l'aide d'un modèle de nom.
```
$ 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"
```
Décrivez tous les utilisateurs qui font partie d'un groupe spécifique.
```
$ 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"
```
Décrire tous les groupes
```
$ 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"
```
Décrire un groupe spécifique
```
$ 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.
**Supprimer un utilisateur d'un groupe.**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Supprime un utilisateur.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Supprimez un groupe.**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# Créer le cluster
Si vous n'avez pas quitté l'instance Amazon EC2, faites-le maintenant.
L'environnement est configuré pour créer un cluster capable d'authentifier les utilisateurs auprès d'Active Directory (AD).
Créez une configuration de cluster simple et fournissez les paramètres nécessaires à la connexion à l'AD. Pour plus d’informations, consultez la section [`DirectoryService`](DirectoryService-v3.md).
Choisissez l'une des configurations de cluster suivantes et copiez-la dans un fichier nommé `ldaps_config.yaml``ldaps_nocert_config.yaml`, ou`ldap_config.yaml`.
Nous vous recommandons de choisir la configuration LDAPS avec vérification des certificats. Si vous choisissez cette configuration, vous devez également copier le script bootstrap dans un fichier nommé`active-directory.head.post.sh`. Vous devez également le stocker dans un compartiment Amazon S3 comme indiqué dans le fichier de configuration.
## LDAPS avec configuration de vérification des certificats (recommandé)
**Note**
`KeyName`: l'une de vos paires de clés Amazon EC2.
`SubnetId / SubnetIds`: l'un des sous-réseaux IDs fournis dans la sortie de la pile de création CloudFormation rapide (didacticiel automatisé) ou du script python (didacticiel manuel).
`Region`: Région dans laquelle vous avez créé l'infrastructure AD.
`DomainAddr`: Cette adresse IP est l'une des adresses DNS de votre service AD.
`PasswordSecretArn`: le nom de ressource Amazon (ARN) du secret qui contient le mot de passe du`DomainReadOnlyUser`.
`BucketName`: nom du compartiment contenant le script bootstrap.
`AdditionalPolicies`/`Policy`: Le nom de ressource Amazon (ARN) de la politique de certification du domaine lu ReadCertExample.
`CustomActions`/`OnNodeConfigured`/`Args`: Le nom de ressource Amazon (ARN) du secret contenant la politique de certification du domaine.
Pour une meilleure sécurité, nous vous suggérons d'utiliser la `AllowedIps` configuration `HeadNode``Ssh`//pour limiter l'accès SSH au nœud principal.
Notez que le certificat spécifié dans `LdapTlsCaCert` doit être accessible à tous les nœuds du cluster.
**Exigences strictes**
Le certificat spécifié dans `LdapTlsCaCert` doit être accessible à tous les nœuds du cluster.
Un nœud n'ayant pas accès au certificat ne sera pas en mesure de résoudre le problème des utilisateurs depuis l'annuaire.
```
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
```
**Script Bootstrap**
Après avoir créé le fichier bootstrap et avant de le télécharger dans votre compartiment S3, exécutez-le `chmod +x active-directory.head.post.sh` pour donner l'autorisation d' AWS ParallelCluster exécution.
```
#!/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 sans configuration de vérification de certificat
**Note**
`KeyName`: l'une de vos paires de clés Amazon EC2.
`SubnetId / SubnetIds`: l'un des sous-réseaux figurant IDs dans la sortie de la pile de création CloudFormation rapide (didacticiel automatisé) ou du script python (didacticiel manuel).
`Region`: Région dans laquelle vous avez créé l'infrastructure AD.
`DomainAddr`: Cette adresse IP est l'une des adresses DNS de votre service AD.
`PasswordSecretArn`: le nom de ressource Amazon (ARN) du secret qui contient le mot de passe du`DomainReadOnlyUser`.
Pour une meilleure sécurité, nous vous suggérons d'utiliser la AllowedIps configuration HeadNode /Ssh/ pour limiter l'accès SSH au nœud 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
```
## Configuration du protocole LDAP
**Note**
`KeyName`: l'une de vos paires de clés Amazon EC2.
`SubnetId / SubnetIds`: l'un des sous-réseaux IDs fournis dans la sortie de la pile de création CloudFormation rapide (didacticiel automatisé) ou du script python (didacticiel manuel).
`Region`: Région dans laquelle vous avez créé l'infrastructure AD.
`DomainAddr`: Cette adresse IP est l'une des adresses DNS de votre service AD.
`PasswordSecretArn`: le nom de ressource Amazon (ARN) du secret qui contient le mot de passe du`DomainReadOnlyUser`.
Pour une meilleure sécurité, nous vous suggérons d'utiliser la AllowedIps configuration HeadNode /Ssh/ pour limiter l'accès SSH au nœud 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
```
Créez votre cluster à l'aide de la commande suivante.
```
$ 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"
}
}
```
# Connectez-vous au cluster en tant qu'utilisateur
Vous pouvez déterminer l'état du cluster à l'aide des commandes suivantes.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
La sortie est la suivante.
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
Lorsque le statut atteint`"CREATE_COMPLETE"`, connectez-vous avec le nom d'utilisateur et le mot de passe créés.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
Vous pouvez vous connecter sans mot de passe en fournissant la SSH clé créée pour le nouvel utilisateur sur`/home/user000@HEAD_NODE_IP/.ssh/id_rsa`.
Si la `ssh` commande a réussi, vous vous êtes connecté avec succès au cluster en tant qu'utilisateur authentifié pour utiliser Active Directory (AD).
# Nettoyage
1.
**Depuis votre ordinateur local, supprimez le cluster.**
```
$ 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.
**Vérifiez la progression du cluster en cours de suppression.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Une fois le cluster supprimé avec succès, passez à l'étape suivante.
## Automatisé
**Supprimer les ressources Active Directory**
1. À partir de [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/).
1. Dans le volet de navigation, choisissez **Stack (Piles)**.
1. Dans la liste des piles, choisissez la pile AD (par exemple,`pcluster-ad`).
1. Sélectionnez **Delete (Supprimer)**.
## Manuelle
1.
**Supprimez l'instance Amazon EC2.**
1. Dans [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/), choisissez **Instances** dans le volet de navigation.
1. Dans la liste des instances, choisissez l'instance que vous avez créée pour ajouter des utilisateurs à l'annuaire.
1. Choisissez **État de l'instance**, puis **Terminate instance**.
1.
**Supprimez la zone hébergée.**
1. Créez un `recordset-delete.json` avec le contenu suivant. Dans cet exemple, HostedZoneId il s'agit de l'ID de zone hébergée canonique de l'équilibreur de charge.
```
{
"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. Soumettez la modification du jeu d'enregistrements à la zone hébergée à l'aide de l'ID de zone hébergée.
```
$ 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. Supprimez la zone hébergée.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**Supprimez l'écouteur LB.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**Supprimez le groupe cible.**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**Supprimez l'équilibreur de charge.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**Supprimez la politique utilisée par le cluster pour lire le certificat depuis Secrets Manager.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**Supprimez le secret qui contient le certificat de domaine.**
```
$ 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.
**Supprimez le certificat d'ACM.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Supprimez les ressources Active Directory (AD).**
1. Obtenez la ressource suivante IDs à partir de la sortie du script python `ad.py` :
+ IDENTIFIANT DE L'ANNONCE
+ sous-réseau AD IDs
+ AJOUTER UN IDENTIFIANT VPC
1. Supprimez le répertoire en exécutant la commande suivante.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. Répertoriez les groupes de sécurité du VPC.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. Supprimez le groupe de sécurité personnalisé.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. Supprimer les sous-réseaux.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. Décrivez la passerelle 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. Détachez la passerelle Internet.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Supprimez la passerelle Internet.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. Supprimer le VPC.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Supprimez le secret qui contient le `ReadOnlyUser` mot de passe.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# Configuration du chiffrement du stockage partagé à l'aide d'une AWS KMS clé
Découvrez comment configurer une AWS KMS clé gérée par le client pour chiffrer et protéger vos données dans les systèmes de stockage de fichiers en cluster configurés pour AWS ParallelCluster.
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster prend en charge les options de configuration de stockage partagé suivantes :
+ [`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)
Vous pouvez utiliser ces options pour fournir une AWS KMS clé gérée par le client pour le chiffrement des systèmes de stockage partagé Amazon EBS, Amazon EFS et FSx Lustre. Pour les utiliser, vous devez créer et configurer une politique IAM pour les éléments suivants :
+ [`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)
**Conditions préalables**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une paire de [clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
**Topics**
+ [Création de la stratégie](creating-the-role-v3.md)
+ [Configuration et création du cluster](creating-the-cluster-v3.md)
# Création de la stratégie
Dans ce didacticiel, vous allez créer une politique pour configurer le chiffrement du stockage partagé à l'aide d'une AWS KMS clé.
**Créez une stratégie.**
1. Accédez à la console IAM : [https://console.aws.amazon.com/iam/accueil](https://console.aws.amazon.com/iam/home).
1. Choisissez **Policies** (Politiques).
1. Choisissez **Create Policy** (Créer une politique).
1. Choisissez l'onglet **JSON** et collez la politique suivante. Assurez-vous de remplacer toutes les occurrences de `123456789012` par votre Compte AWS identifiant et la clé Amazon Resource Name (ARN) et Région AWS par votre propre identifiant.
------
#### [ 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. Pour ce didacticiel, nommez la politique`ParallelClusterKmsPolicy`, puis choisissez **Create Policy**.
1. Prenez note de l'ARN de la politique. Vous en avez besoin pour configurer votre cluster.
# Configuration et création du cluster
Voici un exemple de configuration de cluster qui inclut un système de fichiers partagé Amazon Elastic Block Store avec chiffrement.
```
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
```
Remplacez les éléments en rouge par vos propres valeurs. Créez ensuite un cluster qui utilise votre AWS KMS clé pour chiffrer vos données dans Amazon EBS.
La configuration est similaire pour Amazon EFS et FSx pour les systèmes de fichiers Lustre.
La `SharedStorage` configuration d'Amazon EFS est la suivante.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
La `SharedStorage` configuration FSx pour Lustre est la suivante.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# Exécution de tâches dans un cluster en mode de files d'attente multiples
Ce didacticiel explique comment exécuter votre premier « Hello World » job en AWS ParallelCluster [mode file d'attente multiple](configuration-of-multiple-queues-v3.md).
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Conditions préalables**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une paire de [clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
## Configurez votre cluster
Tout d'abord, vérifiez qu' AWS ParallelCluster il est correctement installé en exécutant la commande suivante.
```
$ pcluster version
```
Pour plus d’informations sur `pcluster version`, consultez [`pcluster version`](pcluster.version-v3.md).
Cette commande renvoie la version en cours d'exécution de AWS ParallelCluster.
Exécutez ensuite `pcluster configure` pour générer un fichier de configuration de base. Suivez toutes les instructions qui suivent cette commande.
```
$ pcluster configure --config multi-queue-mode.yaml
```
Pour plus d'informations sur la commande `pcluster configure`, consultez [`pcluster configure`](pcluster.configure-v3.md).
Une fois cette étape terminée, un fichier de configuration de base nommé `multi-queue-mode.yaml` apparaît. Ce fichier contient une configuration de base du cluster.
À l'étape suivante, vous modifiez votre nouveau fichier de configuration et lancez un cluster avec plusieurs files d'attente.
**Note**
Certaines instances utilisées dans ce didacticiel ne sont pas éligibles au niveau gratuit.
Pour ce didacticiel, modifiez votre fichier de configuration pour qu'il corresponde à la configuration suivante. Les éléments surlignés en rouge représentent les valeurs de votre fichier de configuration. Gardez vos propres valeurs.
```
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
```
## Créer votre cluster
Créez un cluster nommé en `multi-queue-cluster` fonction de votre fichier de configuration.
```
$ 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"
}
}
```
Pour plus d'informations sur la commande `pcluster create-cluster`, consultez [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
Pour vérifier l'état du cluster, exécutez la commande suivante.
```
$ 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"
}
}
```
Lorsque le cluster est créé, le `clusterStatus` champ s'affiche`CREATE_COMPLETE`.
## Connectez-vous au nœud principal
Utilisez votre fichier de clé SSH privée pour vous connecter au nœud principal.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
Pour plus d’informations sur `pcluster ssh`, consultez [`pcluster ssh`](pcluster.ssh-v3.md).
Une fois connecté, exécutez la `sinfo` commande pour vérifier que les files d'attente de votre planificateur sont installées et configurées.
Pour plus d'informations`sinfo`, consultez [sinfo](https://slurm.schedmd.com/sinfo.html) dans la *Slurmdocumentation*.
```
$ 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]
```
La sortie indique que vous disposez d'un `t2.micro` et d'un nœud de `c5.xlarge` calcul dans l'`idle`état qui sont disponibles dans votre cluster.
Les autres nœuds sont tous en état d'économie d'énergie, indiqué par le `~` suffixe dans l'état du nœud, et aucune instance Amazon EC2 ne les prend en charge. La file d'attente par défaut est indiquée par un `*` suffixe après son nom. `spot`est votre file d'attente de tâches par défaut.
## Exécuter le job en mode file d'attente multiple
Ensuite, essayez d'exécuter une tâche pour dormir pendant un moment. La tâche génère ensuite son propre nom d'hôte. Assurez-vous que ce script peut être exécuté par l'utilisateur actuel.
```
$ tee <
Dans ce didacticiel, vous allez créer et tester l'API avec [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) et un AWS ParallelCluster CloudFormation modèle. Ensuite, vous utilisez l'exemple de client disponible sur GitHub pour utiliser l'API. Pour en savoir plus sur l'utilisation de l'API, consultez le document [AWS ParallelCluster API](api-reference-v3.md).
Pour plus d'informations, consultez la section [Création d'un composant personnalisé avec Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) dans le *guide de l'utilisateur d'EC2 Image Builder*.
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Prérequis**
+ AWS CLI Il est [installé](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) et configuré dans votre environnement informatique.
+ AWS ParallelCluster est installé dans un environnement virtuel. Pour de plus amples informations, veuillez consulter [Installation AWS ParallelCluster dans un environnement virtuel (recommandé)](install-v3-virtual-environment.md).
+ Vous possédez une [paire de EC2 clés Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
## Étape 1 : créer l'API avec Amazon API Gateway
**Restez dans votre répertoire d'utilisateurs personnel et activez votre environnement virtuel :**
1. Installez un processeur de ligne de commande JSON utile.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. Exécutez la commande suivante pour obtenir votre AWS ParallelCluster version et l'affecter à une variable d'environnement.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. Créez une variable d'environnement et attribuez-lui votre identifiant de région.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. Exécutez les commandes suivantes pour déployer l'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"
}
```
Une fois le processus terminé, passez à l'étape suivante.
## Étape 2 : tester l'API dans la console Amazon API Gateway
1. Connectez-vous au AWS Management Console.
1. Accédez à la console [Amazon API Gateway](https://console.aws.amazon.com/apigateway/home).
1. Choisissez le déploiement de votre API.
![\[Console Amazon API Gateway avec la liste de vos passerelles parmi lesquelles vous pouvez choisir.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/gateway_choose.png)
1. Choisissez **Stages**, puis sélectionnez un stage.
![\[Une vue sur console des niveaux parmi lesquels vous pouvez choisir. Vous pouvez également consulter l'URL fournie par API Gateway pour votre API.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/gateway_address.png)
1. Notez l'URL fournie par API Gateway pour accéder à votre API ou pour l'appeler. Il est surligné en bleu.
1. Choisissez **Ressources**, puis sélectionnez **`GET`**sous **`/clusters`**.
1. Choisissez l'icône **TEST**, puis faites défiler l'écran vers le bas et choisissez l'icône **TEST**.
![\[Vue de console des ressources de l'API et des mécanismes de test.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/gateway_test.png)
La réponse à votre message `/clusters GET` s'affiche.
![\[Vue de console des ressources de l'API, des mécanismes de test et de la réponse à votre demande de test.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/gateway.png)
## Étape 3 : préparer et tester un exemple de client pour appeler l'API
Clonez le code AWS ParallelCluster source `api` dans le répertoire et installez les bibliothèques clientes 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. Retournez à votre répertoire d'utilisateurs personnel.
1. Exportez l'URL de base d'API Gateway que le client utilise lors de l'exécution.
```
$ 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. Exportez un nom de cluster que le client utilise pour créer un cluster.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. Exécutez les commandes suivantes pour stocker les informations d'identification utilisées par le client d'exemple pour accéder à l'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
```
## Étape 4 : Copier le script de code client et exécuter des tests de cluster
1. Copiez l'exemple de code client suivant `test_pcluster_client.py` dans votre répertoire utilisateur personnel. Le code client demande d'effectuer les opérations suivantes :
+ Créez le cluster .
+ Décrivez le cluster.
+ Répertoriez les clusters.
+ Décrivez le parc informatique.
+ Décrivez les instances de cluster.
```
# 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. Créez une configuration de cluster.
```
$ pcluster configure --config cluster-config.yaml
```
1. La bibliothèque du client API détecte automatiquement les détails de configuration à partir de vos variables d'environnement (par exemple `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`,, ou`AWS_SESSION_TOKEN`) ou`$HOME/.aws`. La commande suivante fait passer votre rôle IAM actuel au rôle désignéParallelClusterApiUserRole.
```
$ 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"')
```
**Erreur à surveiller :**
Si vous voyez un message d'erreur similaire à ce qui suit, c'est que vous avez déjà supposé que le ParallelClusterApiUserRole vôtre `AWS_SESSION_TOKEN` a expiré.
```
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
```
Supprimez le rôle, puis réexécutez la `aws sts assume-role` commande pour utiliser leParallelClusterApiUserRole.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
Pour fournir à vos utilisateurs actuels les autorisations d'accès à l'API, vous devez [développer la politique de ressources](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html).
1. Exécutez la commande suivante pour tester l'exemple de client.
```
$ 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!
```
## Étape 5 : Copier le script de code client et supprimer le cluster
1. Copiez l'exemple de code client suivant dans`delete_cluster_client.py`. Le code client fait une demande de suppression du cluster.
```
# 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. Exécutez la commande suivante pour supprimer le cluster.
```
$ 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. Une fois les tests terminés, désactivez les variables d'environnement.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## Étape 6 : Nettoyer
Vous pouvez utiliser le AWS Management Console ou AWS CLI pour supprimer votre API.
1. Dans la CloudFormation console, choisissez la pile d'API, puis choisissez **Supprimer**.
1. Exécutez la commande suivante si vous utilisez le AWS CLI.
En utilisant CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Création d'un cluster avec Slurm comptabilité
Découvrez comment configurer et créer un cluster avec Slurm comptabilité. Pour de plus amples informations, veuillez consulter [Slurmcomptabilité avec AWS ParallelCluster](slurm-accounting-v3.md).
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
Dans ce didacticiel, vous allez utiliser un [modèle de création CloudFormation rapide (us-east-1) pour créer une base de données sans serveur pour MySQL](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). [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) Le modèle indique de CloudFormation créer tous les composants nécessaires pour déployer une base de données Amazon Aurora sans serveur sur le même VPC que le cluster. Le modèle crée également une configuration réseau et de sécurité de base pour la connexion entre le cluster et la base de données.
**Note**
À partir de la version 3.3.0, prend en charge AWS ParallelCluster Slurm comptabilité avec le paramètre de configuration du cluster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[Database](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database).
**Note**
Le modèle de création rapide sert d'exemple. Ce modèle ne couvre pas tous les cas d'utilisation possibles pour un Slurm serveur de base de données de comptabilité. Il est de votre responsabilité de créer un serveur de base de données dont la configuration et la capacité sont adaptées à vos charges de travail de production.
**Prérequis :**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une [paire de EC2 clés Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
+ La région dans laquelle vous déployez le modèle de création rapide prend en charge Amazon Aurora MySQL serverless v2. Pour plus d'informations, consultez [Aurora Serverless v2 avec 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).
## Étape 1 : créer le VPC et les sous-réseaux pour AWS ParallelCluster
Pour utiliser le CloudFormation modèle fourni pour Slurm base de données de comptabilité, le VPC du cluster doit être prêt. Vous pouvez le faire manuellement ou dans le cadre de la [Configuration et création d'un cluster à l'aide de l'interface de ligne de AWS ParallelCluster commande](install-v3-configuring.md) procédure. Si vous l'avez déjà utilisé AWS ParallelCluster, vous disposez peut-être d'un VPC prêt pour le déploiement du cluster et du serveur de base de données.
## Étape 2 : Création de la pile de base de données
Utilisez le [modèle de création CloudFormation rapide (us-east-1) pour créer une pile de base de données pour](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) Slurm comptabilité. Le modèle nécessite les entrées suivantes :
+ Informations d'identification du serveur de base de données, en particulier le nom d'utilisateur et le mot de passe de l'administrateur.
+ Dimensionnement du cluster Amazon Aurora sans serveur. Cela dépend du chargement attendu du cluster.
+ Les paramètres réseau, en particulier le VPC cible et les sous-réseaux ou blocs CIDR pour la création des sous-réseaux.
Sélectionnez les informations d'identification et la taille appropriées pour votre serveur de base de données. Pour les options de mise en réseau, vous devez utiliser le même VPC sur lequel le AWS ParallelCluster cluster est déployé. Vous pouvez créer les sous-réseaux de la base de données et les transmettre en entrée au modèle. Vous pouvez également fournir deux blocs d'adresse CIDR disjoints pour les deux sous-réseaux et laisser le CloudFormation modèle créer les deux sous-réseaux pour les blocs d'adresse CIDR. Assurez-vous que les blocs CIDR ne se chevauchent pas avec les sous-réseaux existants. Si les blocs CIDR se chevauchent avec des sous-réseaux existants, la pile ne peut pas être créée.
La création du serveur de base de données prend plusieurs minutes.
## Étape 3 : créer un cluster avec Slurm comptabilité activée
Le CloudFormation modèle fourni génère une CloudFormation pile avec certaines sorties définies. À partir du AWS Management Console, vous pouvez afficher les sorties dans l'onglet **Sorties** de la vue en CloudFormation pile. Pour activer le Slurm comptabilité, certaines de ces sorties doivent être utilisées dans le fichier de configuration du AWS ParallelCluster cluster :
+ `DatabaseHost`: utilisé pour le paramètre de configuration [`Uri`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-Uri)du cluster [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//.
+ `DatabaseAdminUser`: utilisé pour la valeur du paramètre de configuration [`UserName`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-UserName)du cluster [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//.
+ `DatabaseSecretArn`: utilisé pour le paramètre de configuration [`PasswordSecretArn`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-PasswordSecretArn)du cluster [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//.
+ `DatabaseClientSecurityGroup`: il s'agit du groupe de sécurité attaché au nœud principal du cluster défini dans le paramètre de [`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups)configuration [`HeadNode`[`Networking`](HeadNode-v3.md#HeadNode-v3-Networking)](HeadNode-v3.md)//.
Mettez à jour les `Database` paramètres du fichier de configuration de votre cluster avec les valeurs de sortie. Utilisez la [`pcluster`](pcluster-v3.md) CLI pour créer le cluster.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
Une fois le cluster créé, vous pouvez commencer à utiliser Slurm des commandes de comptabilité telles que `sacctmgr` ou`sacct`.
# Création d'un cluster avec un module externe Slurmdbd comptabilité
Apprenez à configurer et à créer un cluster avec des outils externes Slurmdbd comptabilité. Pour de plus amples informations, consultez [.Slurm comptabilité avec AWS ParallelCluster](slurm-accounting-v3.md).
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour plus d'informations, consultez la section [AWS Services utilisés par AWS ParallelCluster](aws-services-v3.md).
L' AWS ParallelCluster interface utilisateur repose sur une architecture sans serveur et vous pouvez l'utiliser dans AWS Free Tier catégorie dans la plupart des cas. Pour plus d'informations, consultez la section [Coûts de l'AWS ParallelCluster interface utilisateur](install-pcui-costs-v3.md).
Dans ce didacticiel, vous allez utiliser un modèle de AWS CloudFormation création rapide pour créer les composants nécessaires au déploiement d'une instance de Slurmdbd sur le même VPC que le cluster. Le modèle crée une configuration réseau et de sécurité de base pour la connexion entre le cluster et la base de données.
**Note**
En commençant par`version 3.10.0`, AWS ParallelCluster prend en charge le Slurmdbd externe avec le paramètre de configuration du cluster. `SlurmSettings / ExternelSlurmdbd`
**Note**
Le modèle de création rapide sert d'exemple. Ce modèle ne couvre pas tous les cas d'utilisation possibles. Il est de votre responsabilité de créer un Slurmdbd externe avec la configuration et la capacité adaptées à vos charges de travail de production.
**Prérequis :**
+ AWS ParallelCluster [est installé](install-v3-parallelcluster.md).
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous possédez une [paire de clés Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Vous avez un Gestion des identités et des accès AWS rôle doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
+ Vous avez un Slurm base de données de comptabilité. Pour suivre un didacticiel de création Slurm base de données de comptabilité, suivez les étapes 1 et 2 de la section [Création de la pile de base de données de comptabilité Slurm](tutorials_07_slurm-accounting-v3.md).
## Étape 1 : Création de la pile Slurmdbd
Dans ce didacticiel, utilisez un [modèle de CloudFormation création rapide (`us-east-1`) pour créer](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) une pile Slurmdbd. Le modèle nécessite les entrées suivantes :
**Réseaux**
+ **VPCId**: ID VPC pour lancer l'instance Slurmdbd.
+ **SubnetId**: ID de sous-réseau pour lancer l'instance Slurmdbd.
+ **PrivatePrefix**: le préfixe CIDR du VPC.
+ **PrivateIp**: adresse IP privée secondaire à attribuer à l'instance de Slurmdbd.
**Connexion de la base de données**
+ **DBMSClientSG** : Le groupe de sécurité à associer à l'instance de Slurmdbd. Ce groupe de sécurité doit autoriser les connexions entre le serveur de base de données et l'instance de Slurmdbd.
+ **DBMSDatabaseNom** : nom de la base de données.
+ **DBMSUsername**: nom d'utilisateur de la base de données.
+ **DBMSPasswordSecretArn**: le secret contenant le mot de passe de la base de données.
+ **DBMSUri**: URI du serveur de base de données.
**Paramètres des instances**
+ **InstanceType**: type d'instance à utiliser pour l'instance de slurmdbd.
+ **KeyName**: une paire de EC2 clés Amazon à utiliser pour l'instance slurmdbd.
**Paramètres de Slurmdbd**
+ **AMIID** : AMI de l'instance de Slurmdbd. L'AMI doit être une ParallelCluster AMI. La version de l' ParallelCluster AMI détermine la version de Slurmdbd.
+ **MungeKeySecretArn**: Le secret contenant la clé munge à utiliser pour authentifier les communications entre Slurmdbd et les clusters.
+ **SlurmdbdPort**: numéro de port utilisé par le slurmdbd.
+ **EnableSlurmdbdSystemService**: active slurmdbd en tant que service système et le fait fonctionner au lancement d'une instance.
**Avertissement**
Si la base de données a été créée par une version différente de SlurmDB, ne pas utiliser Slurmdbd en tant que service système.
Si la base de données contient un grand nombre d'entrées, Slurm Database Daemon (SlurmDBD) peut nécessiter des dizaines de minutes pour mettre à jour la base de données et ne pas répondre pendant cet intervalle de temps.
Avant la mise à niveau SlurmDB, effectuez une sauvegarde de la base de données. Pour de plus amples informations, veuillez consulter le [.Slurm documentation](https://slurm.schedmd.com/quickstart_admin.html#upgrade).
## Étape 2 : Création d'un cluster avec des composants externes Slurmdbd activé
Le CloudFormation modèle fourni génère une CloudFormation pile avec certaines sorties définies.
À partir du AWS Management Console, consultez l'onglet **Sorties** de la CloudFormation pile pour passer en revue les entités créées. Pour activer le Slurm en comptabilité, certaines de ces sorties doivent être utilisées dans le fichier de AWS ParallelCluster configuration :
+ **SlurmdbdPrivateIp**: Utilisé pour le paramètre de configuration du [cluster [SlurmSettings[ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//Host.](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Host)
+ **SlurmdbdPort**: Utilisé pour la valeur du paramètre de configuration du cluster [ SlurmSettings[ ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//[Port](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Port).
+ **AccountingClientSecurityGroup**: il s'agit du groupe de sécurité attaché au nœud principal du cluster défini dans le paramètre de configuration [HeadNode](HeadNode-v3.md)/[Networking](HeadNode-v3.md#HeadNode-v3-Networking)/[AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups).
De plus, depuis l'onglet **Paramètres** de la vue de la CloudFormation pile :
+ **MungeKeySecretArn**: Utilisé pour la valeur du paramètre de configuration [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn)cluster.
Mettez à jour les paramètres de la base de données du fichier de configuration de votre cluster avec les valeurs de sortie. Utilisez le pcluster AWS CLI pour créer le cluster.
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
Une fois le cluster créé, vous pouvez commencer à utiliser Slurm des commandes de comptabilité telles que `sacctmgr` ou`sacct`.
**Avertissement**
Trafic entre `ParallelCluster` et vers l'extérieur SlurmDB n'est pas crypté. Il est recommandé d'exécuter le cluster et le module externe SlurmDB dans un réseau fiable.
# Revenir à une version précédente du document AWS Systems Manager
Découvrez comment revenir à une version précédente du document AWS Systems Manager. Pour plus d'informations sur les documents SSM, consultez la section [Documents de AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html) dans le *Guide de l'utilisateur de AWS Systems Manager*.
Lorsque vous utilisez l'interface de ligne de AWS ParallelCluster commande (CLI) ou l'API, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Prérequis :**
+ Et Compte AWS avec les autorisations nécessaires pour gérer les documents SSM.
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
## Revenir à une version précédente du document SSM
1. Dans votre terminal, exécutez la commande suivante pour obtenir la liste des documents SSM existants que vous possédez.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. Rétablissez une version précédente d'un document SSM. Dans cet exemple, nous revenons à une version précédente du `SessionManagerRunShell` document. Vous pouvez utiliser le `SessionManagerRunShell` document SSM pour personnaliser chaque session du shell SSM que vous lancez.
1. Trouvez le `DocumentVersion` paramètre pour `SessionManagerRunShell` en exécutant la commande suivante :
```
$ 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 dernière version est `2`.
1. Revenez à la version précédente en exécutant la commande suivante :
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. Vérifiez que la version du document a été rétablie en exécutant à nouveau la `describe-document` commande :
```
$ 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 dernière version est `1`.
# Création d'un cluster avec CloudFormation
Découvrez comment créer un cluster avec une ressource AWS ParallelCluster CloudFormation personnalisée. Pour de plus amples informations, veuillez consulter [AWS CloudFormation ressource personnalisée](cloudformation-v3.md).
Lors de l'utilisation AWS ParallelCluster, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Prérequis :**
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Une [paire de clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
## Création de clusters à l'aide d'une pile CloudFormation à création rapide
Dans ce didacticiel, vous allez utiliser une pile de création rapide pour déployer un CloudFormation modèle qui crée un cluster et les ressources suivantes : AWS
+ Une CloudFormation pile racine créée à l'aide d'une pile de CloudFormation création rapide.
+ CloudFormation Des piles imbriquées qui incluent des politiques par défaut, une configuration VPC par défaut et un fournisseur de ressources personnalisé.
+ Exemple de pile de AWS ParallelCluster clusters et de cluster auxquels vous pouvez vous connecter et exécuter des tâches.
**Créez un cluster avec AWS CloudFormation**
1. Connectez-vous au AWS Management Console.
1. Ouvrez le [lien de CloudFormation création rapide](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) pour créer les ressources suivantes dans la CloudFormation console :
+ Une CloudFormation pile imbriquée avec un VPC doté d'un sous-réseau public et privé pour exécuter le nœud principal du cluster et les nœuds de calcul, respectivement.
+ Une CloudFormation pile imbriquée avec une ressource AWS ParallelCluster personnalisée pour gérer le cluster.
+ Une CloudFormation pile imbriquée avec les politiques par défaut pour gérer le cluster.
+ Une CloudFormation pile racine pour les piles imbriquées.
+ Un AWS ParallelCluster cluster avec le Slurm planificateur et un nombre défini de nœuds de calcul.
![\[L'interface utilisateur de CloudFormation création rapide de la console.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. Dans la section **Paramètres** de **création rapide de la pile**, entrez les valeurs des paramètres suivants :
1. Pour **KeyName**, entrez le nom de votre paire de clés Amazon EC2.
1. Pour **AvailabilityZone**, choisissez un AZ pour les nœuds de votre cluster, par exemple,`us-east-1a`.
1. Cochez les cases correspondant à chacune des fonctionnalités d'accès au bas de la page.
1. Sélectionnez **Créer la pile**.
1. Attendez que la CloudFormation pile atteigne son `CREATE_COMPLETE` état.
## Création de clusters avec l'interface de ligne de CloudFormation commande (CLI)
Dans ce didacticiel, vous allez utiliser l'interface de ligne de AWS commande (CLI) CloudFormation pour déployer un CloudFormation modèle qui crée un cluster.
**Créez les AWS ressources suivantes :**
+ Une CloudFormation pile racine créée à l'aide d'une pile de CloudFormation création rapide.
+ CloudFormation Des piles imbriquées qui incluent des politiques par défaut, une configuration VPC par défaut et un fournisseur de ressources personnalisé.
+ Exemple de pile de AWS ParallelCluster clusters et de cluster auxquels vous pouvez vous connecter et exécuter des tâches.
*inputs highlighted in red*Remplacez-les, par exemple*keypair*, par vos propres valeurs.
**Créez un cluster avec AWS CloudFormation**
1. Créez un CloudFormation modèle nommé `cluster_template.yaml` avec le contenu suivant :
```
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. Exécutez la commande AWS CLI suivante pour déployer la CloudFormation pile à des fins de création et de gestion de clusters.
```
$ 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
```
## Afficher la sortie CloudFormation du cluster
Consultez la sortie du CloudFormation cluster pour obtenir des informations utiles sur le cluster. La `ValidationMessages` propriété ajoutée permet d'accéder aux messages de validation issus des opérations de création et de mise à jour du cluster.
1. Accédez à la [CloudFormation console](https://console.aws.amazon.com/cloudformation/home) et sélectionnez la pile qui inclut votre ressource AWS ParallelCluster personnalisée.
1. Choisissez **Stack details**, puis sélectionnez l'onglet **Outputs**.
![\[La console CloudFormation affiche un tableau indiquant les valeurs pour HeadNodeIp et ValidationMessages.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/cfn-outputs.png)
Les messages de validation peuvent être tronqués. Pour plus d'informations sur la façon de récupérer les journaux, consultez[AWS ParallelCluster résolution des problèmes](troubleshooting-v3.md).
## Accédez à votre cluster
Accédez au cluster.
**`ssh`dans le nœud principal du cluster**
1. Une fois le déploiement de la CloudFormation pile terminé, obtenez l'adresse IP du nœud principal à l'aide de la commande suivante :
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
Vous pouvez également récupérer l'adresse IP du nœud principal à partir du **HeadNodeIp**paramètre de l'onglet Cluster Stack **Outputs** de la CloudFormation console.
Vous pouvez trouver l'adresse IP du nœud principal ici car elle a été ajoutée dans la `Outputs` section du CloudFormation modèle de cluster, spécifiquement pour cet exemple de cluster.
1. Connectez-vous au nœud principal du cluster en exécutant la commande suivante :
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## Nettoyage
Supprimez le cluster.
1. Exécutez la commande AWS CLI suivante pour supprimer la CloudFormation pile et le cluster.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. Vérifiez l'état de suppression de la pile en exécutant la commande suivante.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# Déployer une ParallelCluster API avec Terraform
Dans ce didacticiel, vous allez définir un projet Terraform simple pour déployer une ParallelCluster API.
**Conditions préalables**
+ Terraform v1.5.7\$1 est installé.
+ Rôle IAM autorisé à déployer l' ParallelCluster API. Consultez [Autorisations requises](tutorial-deploy-terraform-permissions.md).
# Définir un projet Terraform
Dans ce didacticiel, vous allez définir un projet Terraform.
1. Créez un répertoire appelé`my-pcluster-api`.
Tous les fichiers que vous créez se trouveront dans ce répertoire.
1. Créez le fichier `provider.tf` pour configurer le AWS fournisseur.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. Créez le fichier `main.tf` pour définir les ressources à l'aide du ParallelCluster module.
```
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. Créez le fichier `variables.tf` pour définir les variables qui peuvent être injectées pour ce projet.
```
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. Créez le fichier `terraform.tfvars` pour définir des valeurs arbitraires pour les variables.
Le fichier ci-dessous déploie une ParallelCluster API 3.11.1 en `us-east-1` utilisant le nom de la pile. `MyParallelClusterAPI-3111` Vous pourrez référencer ce déploiement d' ParallelCluster API à l'aide de son nom de pile.
**Note**
L'`api_version`attribution du code suivant peut être remplacée par n'importe quelle AWS ParallelCluster version prise en charge.
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. Créez le fichier `outputs.tf` pour définir les sorties renvoyées par ce projet.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
Le répertoire du projet est le suivant :
```
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.
```
# Déploiement de l’API
Pour déployer l'API, exécutez les commandes Terraform standard dans l'ordre.
1. Générez le projet :
```
terraform init
```
1. Définissez le plan de déploiement :
```
terraform plan -out tfplan
```
1. Déployez le plan :
```
terraform apply tfplan
```
# Autorisations requises
Vous avez besoin des autorisations suivantes pour déployer l' ParallelCluster API avec 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"
}
]
}
```
------
# Création d'un cluster avec Terraform
Lors de l'utilisation AWS ParallelCluster, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Conditions préalables**
+ Terraform v1.5.7\$1 est installé.
+ [AWS ParallelCluster API](api-reference-v3.md)La version 3.8.0\$1 est déployée sur votre compte. Consultez [Déployer une ParallelCluster API avec Terraform](tutorial-deploy-terraform.md).
+ Rôle IAM autorisé à invoquer l' ParallelCluster API. Voir [Autorisations requises]
# Définir un projet Terraform
Dans ce didacticiel, vous allez définir un projet Terraform simple pour déployer un cluster.
1. Créez un répertoire appelé`my-clusters`.
Tous les fichiers que vous créez se trouveront dans ce répertoire.
1. Créez le fichier `terraform.tf` pour importer le ParallelCluster fournisseur.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Créez le fichier `providers.tf` pour configurer les AWS fournisseurs ParallelCluster et.
```
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. Créez le fichier `main.tf` pour définir les ressources à l'aide du ParallelCluster module.
```
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. Créez le fichier `clusters.tf` pour définir plusieurs clusters en tant que variables locales Terraform.
**Note**
Vous pouvez définir plusieurs clusters au sein de l'`cluster_config`élément. Pour chaque cluster, vous pouvez définir explicitement les propriétés du cluster dans les variables locales (voir`DemoCluster01`) ou référencer un fichier externe (voir`DemoCluster02`).
Pour consulter les propriétés du cluster que vous pouvez définir dans l'élément de configuration, consultez[Fichier de configuration du cluster](cluster-configuration-file-v3.md).
Pour consulter les options que vous pouvez définir pour la création de clusters, consultez[`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. Créez le fichier `config/clusters.yaml` pour définir plusieurs clusters en tant que configuration 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. Créez le fichier`config/cluster_config.yaml`, qui est un fichier de ParallelCluster configuration standard dans lequel les variables Terraform peuvent être injectées.
Pour consulter les propriétés du cluster que vous pouvez définir dans l'élément de configuration, consultez[Fichier de configuration du cluster](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. Créez le fichier `clusters_vars.tf` pour définir les variables qui peuvent être injectées dans les configurations de cluster.
Ce fichier vous permet de définir des valeurs dynamiques qui peuvent être utilisées dans les configurations de cluster, telles que la région et le sous-réseau.
Cet exemple extrait des valeurs directement à partir des variables du projet, mais vous devrez peut-être utiliser une logique personnalisée pour les déterminer.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. Créez le fichier `variables.tf` pour définir les variables qui peuvent être injectées pour ce projet.
```
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. Créez le fichier `terraform.tfvars` pour définir des valeurs arbitraires pour les variables.
Le fichier ci-dessous déploie les clusters `eu-west-1` au sein du sous-réseau`subnet-123456789`, en utilisant l' ParallelCluster API 3.11.1 existante, qui est déjà déployée avec le nom de la pile. `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. Créez le fichier `outputs.tf` pour définir les sorties renvoyées par ce projet.
```
output "clusters" {
value = module.pcluster.clusters
}
```
Le répertoire du projet est le suivant :
```
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.
```
# Déploiement du cluster
Pour déployer le cluster, exécutez les commandes Terraform standard dans l'ordre.
**Note**
Cet exemple suppose que vous avez déjà déployé l' ParallelCluster API dans votre compte.
1. Générez le projet :
```
terraform init
```
1. Définissez le plan de déploiement :
```
terraform plan -out tfplan
```
1. Déployez le plan :
```
terraform apply tfplan
```
## Déployez l' ParallelCluster API avec des clusters
Si vous n'avez pas déployé l' ParallelCluster API et que vous souhaitez la déployer avec les clusters, modifiez les fichiers suivants :
+ `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
}
```
# Autorisations requises
Vous avez besoin des autorisations suivantes pour déployer un cluster avec Terraform :
+ assumer le rôle d' ParallelCluster API, qui est chargé d'interagir avec l' ParallelCluster API
+ décrire la CloudFormation pile de l' ParallelCluster API pour vérifier son existence et récupérer ses paramètres et ses sorties
------
#### [ 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"
}
]
}
```
------
# Création d'une AMI personnalisée avec Terraform
Lors de l'utilisation AWS ParallelCluster, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Conditions préalables**
+ Terraform v1.5.7\$1 est installé.
+ [AWS ParallelCluster API](api-reference-v3.md)La version 3.8.0\$1 est déployée sur votre compte. Consultez [Création d'un cluster avec Terraform](tutorial-create-cluster-terraform.md).
+ Rôle IAM autorisé à invoquer l' ParallelCluster API. Consultez [Autorisations requises](tutorial-create-ami-terraform-permissions.md).
# Définir un projet Terraform
Dans ce didacticiel, vous allez définir un projet Terraform simple pour déployer une ParallelCluster AMI personnalisée.
1. Créez un répertoire appelé`my-amis`.
Tous les fichiers que vous créez se trouveront dans ce répertoire.
1. Créez le fichier `terraform.tf` pour importer le ParallelCluster fournisseur.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Créez le fichier `providers.tf` pour configurer les AWS fournisseurs ParallelCluster et.
```
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. Créez le fichier `main.tf` pour définir les ressources à l'aide du ParallelCluster module.
Pour consulter les propriétés de l'image que vous pouvez définir au sein de l'`image_configuration`élément, voir[Créez des fichiers de configuration d'image](image-builder-configuration-file-v3.md).
Pour consulter les options que vous pouvez définir pour la création d'images, par exemple`rollback_on_failure`, `image_id` et voir[`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. Créez le fichier `variables.tf` pour définir les variables qui peuvent être injectées pour ce projet.
```
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. Créez le fichier `terraform.tfvars` pour définir vos valeurs arbitraires pour les variables.
Dans le fichier ci-dessous, déployez l'AMI personnalisée `us-east-1` basée sur l'architecture Amazon Linux 2 pour x86\$164, en utilisant l' ParallelCluster API 3.11.1 existante qui est déjà déployée avec le nom de la pile. `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. Créez le fichier `outputs.tf` pour définir les sorties renvoyées par ce projet.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
Le répertoire du projet est le suivant :
```
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.
```
# Déployer l'AMI
Pour déployer l'AMI, exécutez les commandes Terraform standard dans l'ordre.
1. Générez le projet :
```
terraform init
```
1. Définissez le plan de déploiement :
```
terraform plan -out tfplan
```
1. Déployez le plan :
```
terraform apply tfplan
```
# Autorisations requises
Vous avez besoin des autorisations suivantes pour déployer une AMI personnalisée avec Terraform :
+ assumer le rôle d' ParallelCluster API, qui est chargé d'interagir avec l' ParallelCluster API
+ décrire la CloudFormation pile de l' ParallelCluster API, pour vérifier son existence et récupérer ses paramètres et ses sorties
------
#### [ 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 Intégration de l'interface utilisateur à Identity Center
L'objectif de ce didacticiel est de montrer comment intégrer l' AWS ParallelCluster interface utilisateur à IAM Identity Center pour créer une solution d'authentification unique qui unifie les utilisateurs dans Active Directory et qui peut être partagée avec des clusters. AWS ParallelCluster
Lors de l'utilisation AWS ParallelCluster, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Prérequis :**
+ Une AWS ParallelCluster interface utilisateur existante qui peut être installée en suivant les instructions [ici.](install-pcui-v3.md)
+ Un Active Directory géré existant, de préférence un annuaire que vous utiliserez également pour [l'intégration AWS ParallelCluster](tutorials_05_multi-user-ad.md).
## Activer IAM Identity Center
Si vous avez déjà un centre d'identité connecté à votre AWS Managed Microsoft AD (Active Directory), il peut être utilisé et vous pouvez passer à la section **Ajouter votre application à IAM Identity Center**.
Si aucun centre d'identité n'est déjà connecté à un AWS Managed Microsoft AD, suivez les étapes ci-dessous pour le configurer.
**Activation du centre d'identité**
1. Dans la console, accédez à IAM Identity Center. (Assurez-vous que vous vous trouvez dans la région dans laquelle vous avez votre AWS Managed Microsoft AD.)
1. Cliquez sur le bouton **Activer**. Cela peut vous demander si vous souhaitez activer les organisations. C'est une obligation pour que vous puissiez choisir de l'activer. **Remarque** : Cela enverra à l'administrateur de votre compte un e-mail de confirmation vous demandant de suivre le lien pour confirmer.
**Connexion d'Identity Center à Managed AD**
1. Sur la page suivante, après avoir activé le centre d'identité, vous devriez voir les étapes de configuration recommandées. À l'étape 1, sélectionnez **Choisissez votre source d'identité**.
1. Dans la section Source d'identité, cliquez sur le menu déroulant **Actions** (en haut à droite), puis sélectionnez **Modifier la source d'identité**.
1. Sélectionnez **Active Directory**.
1. Sous **Répertoires existants**, choisissez votre répertoire.
1. Cliquez sur Suivant.
1. Passez en revue vos modifications, faites défiler l'écran vers le bas, tapez ACCEPT dans la zone de texte pour confirmer, puis cliquez sur **Modifier la source d'identité**.
1. Attendez que les modifications soient terminées, puis vous devriez voir une bannière verte en haut.
**Synchronisation des utilisateurs et des groupes avec Identity Center**
1. Dans le bandeau vert, cliquez sur **Démarrer la configuration guidée** (bouton en haut à droite)
![\[Capture d'écran mettant en évidence le bouton Démarrer la configuration guidée.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. **Dans la section **Configurer les mappages d'attributs**, cliquez sur Suivant**
1. **Dans la section Configurer l'étendue de synchronisation, saisissez le nom des utilisateurs que vous souhaitez synchroniser avec le centre d'identité, puis cliquez sur Ajouter**
1. Une fois que vous avez terminé d'ajouter des utilisateurs et des groupes, cliquez sur **Suivant**
![\[Capture d'écran mettant en évidence le bouton Suivant.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. Vérifiez vos modifications, puis cliquez sur **Enregistrer la configuration**
1. Si l'écran suivant affiche un avertissement indiquant que les utilisateurs ne sont pas synchronisés, sélectionnez le **bouton Reprendre la synchronisation** en haut à droite.
1. Ensuite, pour activer les utilisateurs, dans l'onglet **Utilisateurs** sur la gauche, sélectionnez un utilisateur, puis cliquez sur **Activer l'accès utilisateur** > **Activer l'accès utilisateur**
**Remarque** : vous devrez peut-être sélectionner Reprendre la synchronisation si une bannière d'avertissement apparaît en haut, puis attendre que les utilisateurs se synchronisent (essayez le bouton d'actualisation pour voir s'ils sont déjà synchronisés).
![\[Capture d'écran mettant en évidence l'onglet Utilisateurs.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## Ajouter votre application à IAM Identity Center
Une fois que vous avez synchronisé vos utilisateurs avec IAM Identity Center, vous devez ajouter une nouvelle application. Cela permet de configurer les applications compatibles SSO qui seront disponibles sur votre portail IAM Identity Center. Dans ce cas, nous ajouterons l' AWS ParallelCluster interface utilisateur en tant qu'application tandis que IAM Identity Center sera le fournisseur d'identité.
L'étape suivante consiste à ajouter l' AWS ParallelCluster interface utilisateur en tant qu'application dans IAM Identity Center. AWS ParallelCluster L'interface utilisateur est un portail Web qui aide l'utilisateur à gérer ses clusters. Pour plus d'informations, voir [AWS ParallelCluster UI](pcui-using-v3.md).
**Configuration de l'application dans Identity Center**
1. Sous **IAM Identity Center** > **Applications** (dans la barre de menu de gauche, cliquez sur Applications)
1. Cliquez sur **Ajouter une application**
1. Sélectionnez **Ajouter une application SAML 2.0 personnalisée**
1. Cliquez sur **Suivant**
1. Sélectionnez le nom d'affichage et la description que vous souhaitez utiliser (par exemple, PCUI et AWS ParallelCluster interface utilisateur)
1. Sous **métadonnées IAM Identity Center**, copiez le lien vers le fichier de métadonnées SAML d'IAM Identity Center et enregistrez-le pour plus tard. Il sera utilisé lors de la configuration de l'authentification unique sur l'application Web
1. Sous **Propriétés de l'application**, dans l'URL de démarrage de l'application, saisissez votre adresse PCUI. **Vous pouvez le trouver en accédant à la CloudFormation console, en sélectionnant la pile correspondant à PCUI (par exemple parallelcluster-ui) et en accédant à l'onglet Outputs pour trouver** ParallelCluster UIUrl
par ex. https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. Sous **Métadonnées de l'application**, choisissez **Tapez manuellement vos valeurs de métadonnées**. Fournissez ensuite les valeurs suivantes.
1. **Important** : assurez-vous de remplacer les valeurs du préfixe de domaine, de la région et de l'identifiant du pool d'utilisateurs par des informations spécifiques à votre environnement.
1. **Le préfixe de domaine, la région et l'identifiant du pool d'utilisateurs peuvent être obtenus en ouvrant la console Amazon Cognito > Groupes **d'**utilisateurs**
![\[Capture d'écran mettant en évidence le nom du groupe d'utilisateurs sous Cognito\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. Sélectionnez le groupe d'utilisateurs correspondant à PCUI (qui aura un nom de groupe d'utilisateurs tel que PCUI-CD8A2-Cognito-153 S98-UserPool) EK3 TO45
1. Accédez à l'**intégration des applications**
![\[Capture d'écran mettant en évidence le domaine Cognito dans l'onglet Intégration des applications\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. URL du service ACS (Application Assertion Consumer Service) : https ://.auth. .amazoncognito. com/saml2/idpresponse
Audience SAML de l'application : urn:amazon:cognito:sp :
1. Sélectionnez **Soumettre**. Accédez ensuite à la page **Détails** de l'application que vous avez ajoutée.
1. Sélectionnez la liste déroulante **Actions** et choisissez **Modifier les mappages d'attributs**. Fournissez ensuite les attributs suivants.
1. Attribut utilisateur dans l'application : **sujet** (Remarque : le **sujet** est prérempli.) **→ Correspond à cette valeur de chaîne ou à cet attribut utilisateur dans IAM Identity Center : **\$1 \$1user:email\$1**, Format : EmailAddress**
1. **Attribut utilisateur dans l'application : **email** → Correspond à cette valeur de chaîne ou à cet attribut utilisateur dans IAM Identity Center : **\$1 \$1user:email\$1**, Format : non spécifié**
![\[Capture d'écran mettant en évidence la section Mappages d'attributs pour PCUI\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. Enregistrez vos modifications.
1. Cliquez sur le bouton **Attribuer des utilisateurs**, puis assignez votre utilisateur à l'application. Il s'agit des utilisateurs de votre Active Directory qui auront accès à l'interface PCUI.
![\[Capture d'écran surlignant Attribuez des utilisateurs à l'application.\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**Configurer IAM Identity Center en tant qu'IdP SAML dans votre groupe d'utilisateurs**
1. Dans les paramètres de votre groupe d'utilisateurs, sélectionnez **Expérience de connexion** > **Ajouter un fournisseur d'identité**
![\[Capture d'écran mettant en évidence l'onglet Expérience de connexion\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. Choisissez un IdP SAML
1. Pour le **nom du fournisseur**, indiquez **IdentityCenter**
1. Sous **Source du document de métadonnées**, choisissez **Entrer l'URL du point de terminaison du document de métadonnées** et fournissez l'URL copiée lors de la configuration de l'application d'Identity Center.
1. Sous **Attributs**, pour e-mail, choisissez e-mail
![\[Capture d'écran mettant en évidence l'onglet Expérience de connexion\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. Sélectionnez **Ajouter un fournisseur d'identité**.
**Intégrer l'IdP au client de l'application du pool d'utilisateurs**
1. Ensuite, dans la section **Intégration des applications** de votre groupe d'utilisateurs, choisissez le client répertorié dans la **liste des clients des applications**
![\[Capture d'écran mettant en évidence l'onglet Expérience de connexion\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. Sous **Interface utilisateur hébergée**, choisissez **Modifier**
1. Sous **Identity, les fournisseurs** choisissent **IdentityCenter**également.
1. Choisissez **Enregistrer les modifications**
**Validez votre configuration**
1. Ensuite, nous allons valider la configuration que nous venons de créer en nous connectant à PCUI. Connectez-vous à votre portail PCUI et vous devriez maintenant voir une option vous permettant de vous connecter avec votre identifiant d'entreprise :
![\[Capture d'écran mettant en évidence l'onglet Expérience de connexion\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. Cliquez sur le **IdentityCenter**bouton pour accéder à la connexion IdP du IAM Identity Center, suivie d'une page contenant vos applications, y compris le PCUI. Ouvrez cette application.
1. Une fois que vous aurez atteint l'écran suivant, votre utilisateur aura été ajouté au groupe d'utilisateurs de Cognito.
![\[Capture d'écran mettant en évidence l'onglet Expérience de connexion\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**Faites de votre utilisateur un administrateur**
1. Accédez maintenant à la **console **Amazon Cognito** > Groupes d'utilisateurs** et sélectionnez le nouvel utilisateur qui doit avoir le préfixe identitycenter.
![\[Capture d'écran mettant en évidence l'onglet Expérience de connexion\]](http://docs.aws.amazon.com/fr_fr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. Sous **Appartenances à des groupes**, sélectionnez **Ajouter un utilisateur au groupe**, choisissez **administrateur** et cliquez sur **Ajouter**.
1. Maintenant, lorsque vous cliquez sur **Continuer**, IdentityCenter vous serez dirigé vers la page de l' AWS ParallelCluster interface utilisateur.
# Exécution de tâches conteneurisées avec Pyxis
Apprenez à créer un cluster capable d'exécuter des tâches conteneurisées à l'aide de Pyxis, un plugin SPANK permettant de gérer des tâches conteneurisées dans SLURM. Les conteneurs de Pyxis sont gérés par Enroot, un outil permettant de transformer des container/OS images traditionnelles en bacs à sable non privilégiés. Pour plus d'informations, consultez [NVIDIA Pyxis](https://github.com/NVIDIA/pyxis) et [NVIDIA](https://github.com/NVIDIA/enroot) Enroot.
**Note**
Cette fonctionnalité est disponible avec la version AWS ParallelCluster 3.11.1
Les scripts de ce didacticiel déplacent (`mv`) certains fichiers, ce qui les supprime de leur emplacement d'origine. Si vous souhaitez conserver des copies de ces fichiers dans leur emplacement d'origine, modifiez les scripts pour utiliser la commande copy (`cp`) à la place.
Lors de l'utilisation AWS ParallelCluster, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
**Prérequis :**
+ Le AWS CLI est [installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Une [paire de clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). .
+ Un rôle IAM doté des [autorisations](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) requises pour exécuter la [CLI pcluster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
## Créer le cluster
À partir de la AWS ParallelCluster version 3.11.1, toutes les versions officielles sont AMIs livrées avec Pyxis et Enroot préinstallés. En particulier, SLURM est recompilé avec le support de Pyxis et Enroot est installé sous forme de binaire dans le système. Cependant, vous devez les configurer en fonction de vos besoins spécifiques. Les dossiers utilisés par Enroot et Pyxis auront un impact critique sur les performances du cluster. Pour plus d'informations, consultez la documentation [Pyxis et la documentation](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration) [Enroot](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example).
Pour votre commodité, vous trouverez ici des exemples de configurations pour Pyxis, Enroot et SPANK. `/opt/parallelcluster/examples/`
Pour déployer un cluster à l'aide des exemples de configurations que nous avons fournis, suivez le didacticiel suivant.
**Pour créer le cluster avec un exemple de configuration**
Pyxis et Enroot doivent être configurés sur le nœud principal en créant d'abord les répertoires persistants et volatils pour Enroot, puis en créant le répertoire d'exécution pour Pyxis, et enfin en activant Pyxis en tant que plugin SPANK dans l'ensemble du cluster.
1. Exécutez le script ci-dessous sous forme d'action [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured)personnalisée dans le nœud principal pour configurer Pyxis et Enroot sur le nœud 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 et Enroot doivent être configurés sur le parc informatique en créant les répertoires persistants et volatils pour Enroot et le répertoire d'exécution pour Pyxis. Exécutez le script ci-dessous sous forme d'action [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personnalisée dans les nœuds de calcul pour configurer Pyxis et Enroot sur le parc informatique.
```
#!/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
```
## Soumettre des emplois
Maintenant que Pyxis est configuré dans votre cluster, vous pouvez soumettre des tâches conteneurisées à l'aide des commandes sbatch et srun, qui sont désormais enrichies d'options spécifiques aux conteneurs.
```
# 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'
```
# Création d'un cluster avec un Lustre compatible EFA FSx
Dans ce didacticiel, vous allez créer un cluster qui utilise un système de fichiers FSx Lustre compatible EFA comme stockage partagé. L'utilisation d'un système de fichiers FSx Lustre avec EFA activé peut augmenter les performances jusqu'à 8 fois. *Pour vérifier si vous avez besoin d'un système de fichiers compatible EFA, consultez la section [Travailler avec des systèmes de fichiers compatibles EFA dans le guide](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html) de l'utilisateur de for Lustre. FSx *
Lorsque vous les utilisez AWS ParallelCluster, vous ne payez que pour les AWS ressources créées lorsque vous créez ou mettez à jour AWS ParallelCluster des images et des clusters. Pour de plus amples informations, veuillez consulter [AWS services utilisés par AWS ParallelCluster](aws-services-v3.md).
## Prérequis
+ La AWS CLI est [installée et configurée](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ La ParallelCluster CLI est [installée et configurée](install-v3-parallelcluster.md).
+ Une [paire de clés Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) pour se connecter au cluster.
+ Un rôle IAM doté des [autorisations](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) requises pour exécuter la ParallelCluster CLI.
## Créer des groupes de sécurité
Créez deux groupes de sécurité dans le même VPC où le cluster et le système de fichiers seront déployés : un pour le client exécuté sur les nœuds du cluster et un pour le système de fichiers.
```
# 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
```
Dans le reste du didacticiel, nous supposerons `sg-client` et `sg-file-system` sommes les identifiants des groupes de sécurité du client et du système de fichiers, respectivement.
Configurez le groupe de sécurité pour le client afin d'autoriser tout le trafic sortant vers le système de fichiers, comme l'[exige 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
```
Configurez le groupe de sécurité du système de fichiers afin d'autoriser tout le inbound/outbound trafic interne et tout le trafic entrant en provenance du client, comme l'[exige EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security).
```
# 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
```
## Création du système de fichiers
Créez le système de fichiers dans la même zone de disponibilité (AZ) où se trouveront les nœuds de calcul ; et remplacez-le `subnet-compute-nodes` par son ID dans le code suivant. Cela est nécessaire pour permettre à EFA de fonctionner avec votre système de fichiers. Notez que, dans le cadre de la création du système de fichiers, nous activons EFA à l'aide de cette EfaEnable propriété.
```
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
```
Prenez note de l'identifiant du système de fichiers renvoyé par la commande précédente. Dans le reste du didacticiel, remplacez-le `fs-id` par cet identifiant de système de fichiers.
## Créer le cluster
1. Créez le cluster avec les configurations suivantes définies dans le fichier de configuration AWS ParallelCluster YAML :
1. AMI basée sur un système d'exploitation compatible, tel qu'Ubuntu 22.04.
1. Les nœuds de calcul doivent utiliser un [type d'instance compatible EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) doté de [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), tel que g6.16xlarge.
+ Les nœuds de calcul doivent se trouver dans la même zone AZ que le système de fichiers.
+ Les nœuds de calcul doivent avoir [Efa/Enabled défini sur true](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled).
+ Les nœuds de calcul doivent exécuter le script de configuration `configure-efa-fsx-lustre-client.sh` en tant qu'action [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personnalisée. Le script, fourni dans la [documentation FSx officielle](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) et proposé dans notre bucket public pour votre commodité, est destiné à configurer le client FSx Lustre sur les nœuds de calcul pour leur permettre d'utiliser EFA.
1. Créez un fichier de configuration de cluster `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
```
Créez ensuite un cluster à l'aide de cette configuration :
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## Valider FSx avec EFA fonctionne
Pour vérifier que le trafic réseau Lustre utilise EFA, utilisez l'`lnetctl`outil Lustre qui peut afficher le trafic réseau pour une interface réseau donnée. Pour ce faire, exécutez les commandes suivantes dans un nœud de calcul :
```
# 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 fonctionnalité fonctionne, le nombre de paquets passant par l'interface devrait augmenter.
# Support de Nvidia-IMEX avec l'instance p6e-gb200
Ce didacticiel vous explique comment démarrer avec AWS ParallelCluster le P6e-GB200, afin de tirer parti des meilleures performances GPU pour l'entraînement et l'inférence liés à l'IA. Les [instances p6e-gb200.36xlarge ne sont disponibles que via P6e](https://aws.amazon.com/ec2/instance-types/p6/), GB200 UltraServers où c'est la taille de l'ultraserver et `u-p6e-gb200x72` c'est ce qui forme l'ultra-serveur. `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) À l'achat d'un Ultraserver, `u-p6e-gb200x72` il sera disponible via un [EC2 Capacity Blocks for ML qui comportera](https://aws.amazon.com/ec2/capacityblocks/) 18 instances. `p6e-gb200.36xlarge` Pour en savoir plus, consultez [P6e- GB200](https://aws.amazon.com/ec2/instance-types/p6/).
AWS ParallelCluster version 3.14.0 :
+ fournit la pile logicielle NVIDIA complète (pilotes, CUDA, EFA, NVIDIA-IMEX) requise par ce type d'instance
+ crée des configurations nvidia-imex pour l'ultra-serveur P6e GB200
+ active et démarre le `nvidia-imex` service pour l'ultraserver P6e GB200
+ configure le plugin de topologie Slurm Block de telle sorte que chaque Ultraserver P6e-GB200 (un bloc de capacité EC2) soit un bloc Slurm de la bonne taille (voir l'entrée pour la version 3.14.0). [Notes de mise à jour et historique du document](document_history.md)
Cependant, GPU-to-GPU la communication NVLink nécessite des configurations supplémentaires, notamment 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)fichier contenant les adresses IP des nœuds de calcul d'un domaine IMEX qui ParallelCluster ne se génère pas automatiquement. Pour faciliter la génération de ce fichier, nous fournissons un script prolog qui découvre automatiquement le nœud de calcul IPs et configure les recommandations d'intégration du planificateur de tâches [NVIDIA IMEX Slurm Job](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration) Scheduler [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)suivantes. Ce didacticiel explique comment créer le script prolog, le déployer via une action HeadNode personnalisée et valider la configuration IMEX.
**Note**
P6e- GB200 est pris en charge à partir de la AWS ParallelCluster version 3.14.0 sur Amazon Linux 2023, Ubuntu 22.04 et Ubuntu 24.04. Pour obtenir des versions logicielles détaillées et une liste actualisée des distributions prises en charge, consultez le [AWS ParallelCluster journal des modifications.](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md)
## Créez un script Prolog pour gérer Nvidia-IMEX
**Limite :**
+ Ce script prologue sera exécuté lors de la soumission d'une tâche exclusive. Cela permet de garantir qu'un redémarrage IMEX ne perturbe aucune tâche en cours d'exécution sur les nœuds P6e-GB200 appartenant à un domaine IMEX.
Vous trouverez ci-dessous le `91_nvidia_imex_prolog.sh` script que vous devez configurer en tant que prologue dans Slurm. Il est utilisé pour mettre à jour automatiquement la configuration nvidia-imex sur les nœuds de calcul. Le nom du script comporte un préfixe « `91` pour respecter la convention de dénomination de [SchedMD](https://slurm.schedmd.com/prolog_epilog.html) ». Cela garantit qu'il s'exécute avant tout autre script prologue de la séquence. Le script reconfigure la configuration du nœud NVIDIA Imex lorsqu'une tâche est démarrée et recharge les daemons NVIDIA nécessaires.
**Note**
Ce script ne sera pas exécuté si plusieurs tâches sont lancées simultanément sur les mêmes nœuds. Nous vous suggérons donc d'utiliser l'`--exclusive`indicateur lors de la soumission.
```
#!/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"
```
## Création du script d'action HeadNode OnNodeStart personnalisé
Créez une action `install_custom_action.sh` personnalisée qui téléchargera le script prologue susmentionné dans un répertoire `/opt/slurm/etc/scripts/prolog.d/` partagé accessible par Compute Nodes et définira les autorisations appropriées à exécuter.
```
#!/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}"
```
## Créer le cluster
Créez un cluster comprenant des GB200 instances P6e-. Vous trouverez ci-dessous un exemple de configuration contenant SlurmQueues pour le type Ultraserver. `u-p6e-gb200x72`
P6e- n'GB200 est actuellement disponible que dans les Zones Locales. Certaines [zones locales ne prennent pas en charge une passerelle NAT](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html). Veuillez donc suivre les [options de connectivité des zones locales selon](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html) les ParallelCluster besoins [Configuration des groupes de sécurité pour les environnements restreints](security-groups-configuration.md) pour vous connecter aux AWS services. Veuillez suivre le [Lancer des instances avec des blocs de capacité (CB)](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch) car les Ultraservers ne sont disponibles que sous forme de blocs de capacité.
```
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:
-
```
## Valider la configuration IMEX
Le `91_nvidia_imex_prolog.sh` prologue s'exécute lorsque vous soumettez une tâche Slurm. Vous trouverez ci-dessous un exemple de tâche pour vérifier l'état du domaine 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"
```
Vérifiez le résultat du 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
```
# Personnalisez les interfaces réseau des nœuds de calcul avec des remplacements de modèles de lancement
À partir de la AWS ParallelCluster version 3.15.0, le `LaunchTemplateOverrides` paramètre vous permet de personnaliser les interfaces réseau des nœuds de calcul en remplaçant la configuration d'interface réseau par défaut par la configuration d'un modèle de lancement référencé. La section d'interface réseau complète des nœuds de calcul est remplacée par la section d'interface réseau du modèle de lancement utilisé pour le remplacement.
Ce didacticiel présente un exemple de remplacement de la configuration réseau par défaut des nœuds de `p6-b300.48xlarge` calcul. Cette personnalisation est utile lorsque vous avez besoin d'une configuration d'interface réseau spécifique différente de celle AWS ParallelCluster configurée par défaut. Dans cet exemple, nous configurons le cas d'utilisation 2 pour les instances P6-B300, comme indiqué dans la documentation sur les types d'instances compatibles avec [Amazon EC2 EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html).
**Note**
Il est recommandé d'utiliser le AWS CLI pour créer le modèle de lancement plutôt que la console pour une flexibilité maximale.
**Note**
Le modèle de lancement ne doit contenir que des remplacements d'interfaces réseau. AWS ParallelCluster possède une validation empêchant le remplacement d'autres paramètres.
**Avertissement**
Si vous utilisez la dérogation pour configurer les interfaces réseau d'une manière qui n'est pas prise en charge par le type d'instance utilisé, les instances ne pourront pas être lancées.
**Conditions préalables**
+ AWS ParallelCluster la version 3.15.0 ou ultérieure [est](install-v3-parallelcluster.md) installée.
+ Le AWS CLI [est installé et configuré.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Vous disposez d'un rôle IAM doté des [autorisations](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) requises pour exécuter la [`pcluster`](pcluster-v3.md) CLI.
## Étape 1 : créer des groupes de sécurité
Lorsque vous créez le modèle de lancement à utiliser dans le cadre de la dérogation, vous devez référencer un groupe de sécurité. Le groupe AWS ParallelCluster de sécurité par défaut pour la ressource de calcul n'existe pas avant la création du cluster. Vous devez donc créer un groupe de sécurité personnalisé. Ce groupe de sécurité doit ensuite être référencé par le groupe de sécurité du nœud principal pour autoriser le trafic entre le nœud principal et les nœuds de calcul.
Si vous mettez à jour un cluster existant pour personnaliser de nouvelles capacités, vous pouvez utiliser le groupe de sécurité des nœuds de AWS ParallelCluster calcul par défaut dans le modèle de lancement au lieu d'en créer un personnalisé.
Créez les deux groupes de sécurité suivants :
+ **Groupe de sécurité supplémentaire du nœud principal** (`sg-1234abcd`) :
+ Entrée : tout le trafic provenant du groupe de sécurité informatique
+ **Groupe de sécurité informatique** (`sg-abcd1234`) :
+ Entrée : tout le trafic provenant du groupe de sécurité du nœud principal
+ Entrée : tout le trafic provenant de self () compute-to-compute
+ Sortie : autorisation de tout par défaut
## Étape 2 : Création du modèle de lancement
Créez un modèle de lancement qui définit la configuration de l'interface réseau pour les nœuds de `p6-b300.48xlarge` calcul. Pour l'interface réseau principale (index de carte réseau 0, indice de périphérique 0), utilisez une interface réseau ENA (par défaut). Pour les autres cartes réseau, créez une interface EFA uniquement (index de carte réseau 1 à 16, index de périphérique 0) et une interface ENA (par défaut) (index de carte réseau 1 à 16, index de périphérique 1).
Exécutez la AWS CLI commande suivante pour créer le modèle de lancement (`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"}
]
}'
```
## Étape 3 : Création du cluster avec des remplacements de modèles de lancement
Créez une configuration de cluster qui utilise le `LaunchTemplateOverrides` paramètre pour référencer le modèle de lancement que vous avez créé.
```
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.
```