

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.

# Commencez avec AWS Parallel Computing Service
<a name="getting-started"></a>

Il s'agit d'un didacticiel pour créer un cluster simple que vous pouvez utiliser pour essayer AWS PCS. La figure suivante montre la conception du cluster.

![\[Schéma d'architecture du cluster du didacticiel : les 2 groupes de nœuds de calcul sont des ressources présentes dans votre environnement Compte AWS et se connectent au contrôleur de cluster Slurm qui s'exécute dans un environnement appartenant à un service. Compte AWS Les EC2 instances des deux groupes de nœuds de calcul se connectent au stockage partagé dans Amazon EFS et Amazon FSx for Lustre.\]](http://docs.aws.amazon.com/fr_fr/pcs/latest/userguide/images/aws-pcs-tutorial-environment-diagram.png)


La conception du cluster du didacticiel comporte les éléments clés suivants :
+ Un VPC et des sous-réseaux qui répondent aux exigences du réseau [AWS PCS.](working-with_networking_vpc-requirements.md)
+ Un système de fichiers Amazon EFS, qui sera utilisé comme répertoire de base partagé.
+ Un système de fichiers Amazon FSx for Lustre, qui fournit un répertoire partagé à hautes performances.
+ Un cluster AWS PCS, qui fournit un contrôleur Slurm.
+ 2 groupes de nœuds de calcul AWS PCS.
  + Le groupe de `login` nœuds, qui fournit un accès interactif au système basé sur le shell.
  + Le groupe de `compute-1` nœuds fournit des instances évolutives de manière élastique pour exécuter des tâches.
+ 1 file d'attente qui envoie des tâches aux EC2 instances du groupe de `compute-1` nœuds.

Le cluster nécessite des AWS ressources supplémentaires, telles que des groupes de sécurité, des rôles IAM et des modèles de EC2 lancement, qui ne sont pas illustrés dans le schéma. 

**Note**  
 Nous vous recommandons de suivre les étapes de ligne de commande décrites dans cette rubrique dans un shell Bash. Si vous n'utilisez pas de shell Bash, certaines commandes de script telles que les caractères de continuation de ligne et la façon dont les variables sont définies et utilisées nécessitent un ajustement pour votre shell. En outre, les règles de votre shell en matière de guillemets peuvent être différentes. Pour plus d'informations, voir [Guillemets et littéraux avec chaînes AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-parameters-quoting-strings.html) *Guide de l'AWS Command Line Interface utilisateur de la version 2*.

**Topics**
+ [Conditions préalables pour démarrer avec PCS AWS](getting-started_prerequisites.md)
+ [Utilisation AWS CloudFormation avec le didacticiel AWS PCS](getting-started_cfn-note.md)
+ [Création d'un VPC et de sous-réseaux pour PCS AWS](getting-started_create-vpc.md)
+ [Création de groupes de sécurité pour AWS PCS](getting-started_create-sg.md)
+ [Création d'un cluster dans AWS PCS](getting-started_create-cluster.md)
+ [Créez un espace de stockage partagé pour les AWS PC dans Amazon Elastic File System](getting-started_create-efs.md)
+ [Créez un espace de stockage partagé pour les AWS PC dans Amazon FSx for Lustre](getting-started_create-fsx.md)
+ [Création de groupes de nœuds de calcul dans AWS PCS](getting-started_create-cng.md)
+ [Créez une file d'attente pour gérer les tâches dans AWS PCS](getting-started_create-queue.md)
+ [Connectez-vous à votre cluster AWS PCS](getting-started_connect.md)
+ [Explorez l'environnement de cluster dans AWS PCS](getting-started_explore.md)
+ [Exécuter une tâche à nœud unique dans AWS PCS](getting-started_run-job.md)
+ [Exécuter une tâche MPI multi-nœuds avec Slurm sur PCS AWS](getting-started_run-mpi-job.md)
+ [Supprimer vos AWS ressources pour AWS PCS](getting-started_delete.md)

# Conditions préalables pour démarrer avec PCS AWS
<a name="getting-started_prerequisites"></a>

Consultez les rubriques suivantes pour préparer votre environnement de développement Compte AWS et celui de votre environnement de développement local pour AWS PCS. 

**Topics**
+ [Inscrivez-vous AWS et créez un utilisateur administratif](setting-up.md)
+ [Installez le AWS CLI pour AWS PC](setting-up_cli.md)
+ [Autorisations IAM requises pour PCS AWS](required-iam-permissions.md)

# Inscrivez-vous AWS et créez un utilisateur administratif
<a name="setting-up"></a>

Effectuez les tâches suivantes pour configurer le service de calcul AWS parallèle (AWS PCS).

**Topics**
+ [Inscrivez-vous pour un Compte AWS](#sign-up-for-aws)
+ [Création d’un utilisateur doté d’un accès administratif](#create-an-admin)

## Inscrivez-vous pour un Compte AWS
<a name="sign-up-for-aws"></a>

Si vous n'en avez pas Compte AWS, procédez comme suit pour en créer un.

**Pour vous inscrire à un Compte AWS**

1. Ouvrez l'[https://portal.aws.amazon.com/billing/inscription.](https://portal.aws.amazon.com/billing/signup)

1. Suivez les instructions en ligne.

   Dans le cadre de la procédure d’inscription, vous recevrez un appel téléphonique ou un SMS et vous saisirez un code de vérification en utilisant le clavier numérique du téléphone.

   Lorsque vous vous inscrivez à un Compte AWS, un *Utilisateur racine d'un compte AWS*est créé. Par défaut, seul l’utilisateur racine a accès à l’ensemble des Services AWS et des ressources de ce compte. La meilleure pratique de sécurité consiste à attribuer un accès administratif à un utilisateur, et à utiliser uniquement l’utilisateur racine pour effectuer les [tâches nécessitant un accès utilisateur racine](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS vous envoie un e-mail de confirmation une fois le processus d'inscription terminé. À tout moment, vous pouvez consulter l'activité actuelle de votre compte et gérer votre compte en accédant à [https://aws.amazon.com/](https://aws.amazon.com/)et en choisissant **Mon compte**.

## Création d’un utilisateur doté d’un accès administratif
<a name="create-an-admin"></a>

Après vous être inscrit à un Compte AWS, sécurisez Utilisateur racine d'un compte AWS AWS IAM Identity Center, activez et créez un utilisateur administratif afin de ne pas utiliser l'utilisateur root pour les tâches quotidiennes.

**Sécurisez votre Utilisateur racine d'un compte AWS**

1.  Connectez-vous en [AWS Management Console](https://console.aws.amazon.com/)tant que propriétaire du compte en choisissant **Utilisateur root** et en saisissant votre adresse Compte AWS e-mail. Sur la page suivante, saisissez votre mot de passe.

   Pour obtenir de l’aide pour vous connecter en utilisant l’utilisateur racine, consultez [Connexion en tant qu’utilisateur racine](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) dans le *Guide de l’utilisateur Connexion à AWS *.

1. Activez l’authentification multifactorielle (MFA) pour votre utilisateur racine.

   Pour obtenir des instructions, voir [Activer un périphérique MFA virtuel pour votre utilisateur Compte AWS root (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) dans le guide de l'utilisateur *IAM*.

**Création d’un utilisateur doté d’un accès administratif**

1. Activez IAM Identity Center.

   Pour obtenir des instructions, consultez [Activation d’ AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.

1. Dans IAM Identity Center, octroyez un accès administratif à un utilisateur.

   Pour un didacticiel sur l'utilisation du Répertoire IAM Identity Center comme source d'identité, voir [Configurer l'accès utilisateur par défaut Répertoire IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) dans le *Guide de AWS IAM Identity Center l'utilisateur*.

**Connexion en tant qu’utilisateur doté d’un accès administratif**
+ Pour vous connecter avec votre utilisateur IAM Identity Center, utilisez l’URL de connexion qui a été envoyée à votre adresse e-mail lorsque vous avez créé l’utilisateur IAM Identity Center.

  Pour obtenir de l'aide pour vous connecter en utilisant un utilisateur d'IAM Identity Center, consultez la section [Connexion au portail AWS d'accès](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) dans le *guide de l'Connexion à AWS utilisateur*.

**Attribution d’un accès à d’autres utilisateurs**

1. Dans IAM Identity Center, créez un ensemble d’autorisations qui respecte la bonne pratique consistant à appliquer les autorisations de moindre privilège.

   Pour obtenir des instructions, consultez [Création d’un ensemble d’autorisations](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.

1. Attribuez des utilisateurs à un groupe, puis attribuez un accès par authentification unique au groupe.

   Pour obtenir des instructions, consultez [Ajout de groupes](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) dans le *Guide de l’utilisateur AWS IAM Identity Center *.

# Installez le AWS CLI pour AWS PC
<a name="setting-up_cli"></a>

Vous devez utiliser la dernière version du AWS CLI. Pour plus d'informations, voir [Installation ou mise à jour vers la dernière version du AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) *guide de AWS Command Line Interface l'utilisateur de la version 2*. 

Vous devez configurer le AWS CLI. Pour plus d'informations, voir [Configurer le AWS CLI dans le](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html) *guide de AWS Command Line Interface l'utilisateur de la version 2*.

Entrez la commande suivante à une invite de commande pour vérifier votre AWS CLI ; elle devrait afficher des informations d'aide.

```
aws pcs help
```

# Autorisations IAM requises pour PCS AWS
<a name="required-iam-permissions"></a>

Le principal de sécurité IAM que vous utilisez doit être autorisé à utiliser les rôles AWS PCS IAM, les rôles liés à un service AWS CloudFormation, un VPC et les ressources associées. Pour plus d'informations[Identity and Access Management pour le service de calcul AWS parallèle](security-iam.md), voir et [Créer un rôle lié à un service](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create-service-linked-role.html) dans le Guide de l'*Gestion des identités et des accès AWS utilisateur*. Vous devez effectuer toutes les étapes de ce guide avec le même utilisateur. Exécutez la commande suivante pour vérifier l'utilisateur actuel : 

```
aws sts get-caller-identity
```

# Utilisation AWS CloudFormation avec le didacticiel AWS PCS
<a name="getting-started_cfn-note"></a>

Le didacticiel AWS PCS comporte de nombreuses étapes et vise à vous aider à comprendre les composants d'un cluster AWS PCS et les procédures requises pour le créer. Nous vous recommandons de suivre les étapes du didacticiel au moins une fois. Une fois que vous aurez bien compris ce que cela implique, vous pouvez l'utiliser AWS CloudFormation pour créer rapidement le cluster d'échantillons grâce à l'automatisation.

CloudFormation est un AWS service qui vous permet de créer et de provisionner des déploiements AWS d'infrastructure de manière prévisible et répétée. Vous pouvez utiliser un CloudFormation modèle pour provisionner automatiquement les AWS ressources du cluster d'échantillons sous la forme d'une unité unique, appelée **pile**. Vous pouvez supprimer la pile lorsque vous en avez terminé.

Pour de plus amples informations, veuillez consulter [Commencez avec CloudFormation AWS PCS](get-started-cfn.md).

# Création d'un VPC et de sous-réseaux pour PCS AWS
<a name="getting-started_create-vpc"></a>

 Vous pouvez créer un VPC et des sous-réseaux à l'aide d'un modèle. CloudFormation Utilisez l'URL suivante pour télécharger le CloudFormation modèle, puis chargez-le dans la [CloudFormation console](https://console.aws.amazon.com/cloudformation/home#/stacks/create) pour créer une nouvelle CloudFormation pile. Pour plus d'informations, consultez la section [Utilisation de la CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-using-console.html) dans le *guide de AWS CloudFormation l'utilisateur*.

```
https://aws-hpc-recipes.s3.amazonaws.com/main/recipes/net/hpc_large_scale/assets/main.yaml
```

 Le modèle étant ouvert dans la CloudFormation console, entrez les options suivantes. Vous pouvez utiliser les valeurs par défaut fournies dans le modèle.
+ Sous **Fournir un nom de pile** :
  + Sous **Nom de la pile**, entrez :

    ```
    hpc-networking
    ```
+ Sous **Paramètres** :
  + Dans le cadre du **VPC** : 
    + Sous **CidrBlock**, entrez :

      ```
      10.3.0.0/16
      ```
  + Sous les **sous-réseaux A** : 
    + Sous **CidrPublicSubnetA**, entrez :

      ```
      10.3.0.0/20
      ```
    + Sous **CidrPrivateSubnetA**, entrez :

      ```
      10.3.128.0/20
      ```
  + Sous les **sous-réseaux B** : 
    + Sous **CidrPublicSubnetB**, entrez :

      ```
      10.3.16.0/20
      ```
    + Sous **CidrPrivateSubnetB**, entrez :

      ```
      10.3.144.0/20
      ```
  + Sous les **sous-réseaux C** : 
    + Pour **ProvisionSubnetsC**, sélectionnez **Vrai**
    + Sous **CidrPublicSubnetC**, entrez :

      ```
      10.3.32.0/20
      ```
    + Sous **CidrPrivateSubnetC**, entrez :

      ```
      10.3.160.0/20
      ```
+ Sous **Capacités** :
  + Cochez la case **Je reconnais que cela AWS CloudFormation pourrait créer des ressources IAM**.

Surveillez l'état de la CloudFormation pile. Lorsqu'il atteint`CREATE_COMPLETE`, trouvez l'ID du groupe de sécurité par défaut dans le nouveau VPC. Vous utiliserez l'identifiant ultérieurement dans le didacticiel.

## Trouvez le groupe de sécurité par défaut pour le VPC du cluster
<a name="getting-started_create-vpc_default-sg"></a>

 Pour trouver l'ID du groupe de sécurité par défaut dans le nouveau VPC, suivez cette procédure : 
+ Accédez à la [console Amazon VPC.](https://console.aws.amazon.com/vpc)
+ Dans le tableau de **bord VPC**, sélectionnez **Filtrer par VPC**. 
  + Choisissez le VPC dont le nom commence par. `hpc-networking`
  + Sous **Sécurité**, sélectionnez **Groupes de sécurité**.
+ Trouvez l'**ID du groupe de sécurité** pour le groupe nommé`default`. Il contient la description`default VPC security group`. Vous utiliserez l'ID ultérieurement pour configurer les modèles de lancement EC2.

# Création de groupes de sécurité pour AWS PCS
<a name="getting-started_create-sg"></a>

 AWS Le PCS s'appuie sur des groupes de sécurité pour gérer le trafic réseau entrant et sortant d'un cluster et de ses groupes de nœuds de calcul. Pour des informations détaillées sur ce sujet, voir[Exigences et considérations relatives aux groupes de sécurité](working-with_networking_sg.md#working-with_networking_sg-requirements). 

Au cours de cette étape, vous allez utiliser un CloudFormation modèle pour créer deux groupes de sécurité. 
+ Un groupe de sécurité du cluster, qui permet les communications entre le contrôleur AWS PCS, les nœuds de calcul et les nœuds de connexion.
+ Un groupe de sécurité SSH entrant, que vous pouvez éventuellement ajouter à vos nœuds de connexion pour prendre en charge l'accès SSH

## Création des groupes de sécurité pour AWS PCS
<a name="getting-started_create-sg_create"></a>

 Vous pouvez utiliser un CloudFormation modèle pour créer les groupes de sécurité. Utilisez l'URL suivante pour télécharger le CloudFormation modèle, puis chargez-le dans la [CloudFormation console](https://console.aws.amazon.com/cloudformation/home#/stacks/create) pour créer une nouvelle CloudFormation pile. Pour plus d'informations, consultez la section [Utilisation de la CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-using-console.html) dans le *guide de AWS CloudFormation l'utilisateur*.

```
https://aws-hpc-recipes.s3.amazonaws.com/main/recipes/pcs/getting_started/assets/pcs-cluster-sg.yaml
```

 Le modèle étant ouvert dans la AWS CloudFormation console, entrez les options suivantes. Notez que certaines options seront préremplies dans le modèle. Vous pouvez simplement les laisser comme valeurs par défaut. 
+ Sous **Fournir un nom de pile**
  + Sous **Nom de la pile**, entrez :

    ```
    getstarted-sg
    ```
+ Sous **Paramètres**
  + Sous **VpcId**, choisissez le VPC dont le nom commence par. `hpc-networking`
  +  (Facultatif) Sous **ClientIpCidr**, entrez une plage d'adresses IP plus restrictive pour le groupe de sécurité SSH entrant. Nous vous recommandons de limiter cela à votre propre adresse IP/sous-réseau (x.x.x.x/32 pour votre propre adresse IP ou x.x.x.x.x/24 pour la plage). Remplacez x.x.x.x par votre propre adresse IP PUBLIQUE. Vous pouvez obtenir votre adresse IP publique à l'aide d'outils tels que [https://ifconfig.co/](https://ifconfig.co/))

 Surveillez l'état de la CloudFormation pile. Lorsqu'il atteint `CREATE_COMPLETE` le groupe de sécurité, les ressources sont prêtes. 

 Deux groupes de sécurité ont été créés, avec les noms suivants : 
+ `cluster-getstarted-sg`— il s'agit du groupe de sécurité du cluster
+ `inbound-ssh-getstarted-sg`— il s'agit d'un groupe de sécurité permettant l'accès SSH entrant

# Création d'un cluster dans AWS PCS
<a name="getting-started_create-cluster"></a>

 Dans AWS PCS, un cluster est une ressource permanente permettant de gérer les ressources et d'exécuter les charges de travail. Vous créez un cluster pour un planificateur spécifique (AWS PCS supporte actuellement Slurm) dans un sous-réseau d'un VPC nouveau ou existant. Le cluster accepte et planifie les tâches, et lance également les nœuds de calcul (EC2 instances) qui traitent ces tâches.

**Pour créer votre cluster**

1. Ouvrez la [console AWS PCS](https://console.aws.amazon.com/pcs/home#/clusters) et choisissez **Create cluster**.

1. Dans la section **Détails du cluster**, entrez les champs suivants :
   + **Nom du cluster** — Entrez `get-started`
   + **Planificateur** — Sélectionnez la version 25.05 de **Slurm**
   + **Taille du contrôleur** — Sélectionnez **Petit**

1.  Dans la section **Mise en réseau**, sélectionnez des valeurs pour les champs suivants : 
   + **VPC** — Choisissez le VPC nommé `hpc-networking:Large-Scale-HPC`
   + **Sous-réseau** : sélectionnez le sous-réseau dont le nom commence par `hpc-networking:PrivateSubnetA`
   + **Groupes de sécurité** : sélectionnez le groupe de sécurité du cluster nommé `cluster-getstarted-sg`

1. Choisissez **Créer un cluster**.

**Note**  
Le champ **État** indique **Création** pendant le provisionnement du cluster. La création d'un cluster peut prendre plusieurs minutes. 

# Créez un espace de stockage partagé pour les AWS PC dans Amazon Elastic File System
<a name="getting-started_create-efs"></a>

Amazon Elastic File System (Amazon EFS) est un AWS service qui fournit un stockage de fichiers entièrement élastique sans serveur afin que vous puissiez partager des données de fichiers sans provisionner ni gérer la capacité et les performances de stockage. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon Elastic File System ?](https://docs.aws.amazon.com/efs/latest/ug/whatisefs.html) dans le *guide de l'utilisateur d'Amazon Elastic File System*. 

 Le cluster de démonstration AWS PCS utilise un système de fichiers EFS pour fournir un répertoire de base partagé entre les nœuds du cluster. Créez un système de fichiers EFS dans le même VPC que votre cluster. 

**Pour créer un système de fichiers Amazon EFS**

1. Accédez à la [console Amazon EFS](https://console.aws.amazon.com/efs).

1. Assurez-vous qu'il est réglé sur le même point que celui Région AWS où vous allez essayer AWS PCS.

1. Choisissez **Create file system** (Créer un système de fichiers).

1. Sur la page **Créer un système de fichiers**, définissez les paramètres suivants :
   + Pour **Nom**, saisissez `getstarted-efs`
   + Sous **Virtual Private Cloud (VPC), choisissez le VPC** nommé `hpc-networking:Large-Scale-HPC`
   + Sélectionnez **Create** (Créer). Cela vous renvoie à la page **Systèmes de fichiers**.

1. Notez l'**ID du système de fichiers** du système de `getstarted-efs` fichiers. Vous aurez besoin de ces informations ultérieurement.

# Créez un espace de stockage partagé pour les AWS PC dans Amazon FSx for Lustre
<a name="getting-started_create-fsx"></a>

Amazon FSx for Lustre permet de lancer et d'exécuter facilement et à moindre coût le système de fichiers Lustre, populaire et performant. Vous utilisez Lustre pour les charges de travail où la rapidité est importante, telles que l'apprentissage automatique, le calcul haute performance (HPC), le traitement vidéo et la modélisation financière. Pour plus d'informations, consultez [Qu'est-ce qu'Amazon FSx pour Lustre ?](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) dans le *guide de l'utilisateur d'Amazon FSx for Lustre*. 

 Le cluster de démonstration AWS PCS peut utiliser un système de fichiers FSx for Lustre pour fournir un répertoire partagé performant entre les nœuds du cluster. Créez un système de fichiers FSx for Lustre dans le même VPC que votre cluster. 

**Pour créer votre système de fichiers FSx for Lustre**

1. Accédez à la [ FSx console Amazon](https://console.aws.amazon.com/fsx).

1. Assurez-vous que la console est configurée pour utiliser la même chose Région AWS que votre cluster.

1. Choisissez **Create file system** (Créer un système de fichiers).
   + Pour **Sélectionner le type de système de fichiers**, choisissez **Amazon FSx pour Lustre**, puis **Next**.

1. Sur la page **Spécifier les détails du système de fichiers**, définissez les paramètres suivants :
   + Sous **Détails du système de fichiers**
     + Pour **Nom**, saisissez `getstarted-fsx`
     + Pour **le type de déploiement et de stockage**, choisissez **Persistent, SSD**
     + Pour le **débit par unité de stockage**, choisissez **125** Mo/s/TiB
     + Pour **Capacité de stockage**, entrez 1,2 TiB
     + Pour la **configuration des métadonnées**, choisissez **Automatique**
     + Pour le **type de compression des données**, sélectionnez **LZ4**
   + Sous **Réseau et sécurité**
     + Pour **Virtual Private Cloud (VPC), choisissez le VPC** nommé `hpc-networking:Large-Scale-HPC`
     + Pour les **groupes de sécurité VPC**, laissez le groupe de sécurité nommé `default`
     + Pour **Sous-réseau**, choisissez le sous-réseau dont le nom commence par `hpc-networking:PrivateSubnetA`
   + Conservez les valeurs par défaut des autres options.
   + Choisissez **Suivant**.

1. Sur la page **Réviser et créer**, choisissez **Créer un système de fichiers**. Cela vous renvoie à la page **Systèmes de fichiers**.

1.  Accédez à la page de détails du système de fichiers FSx for Lustre que vous avez créé. 

1. Notez l'**ID du système de fichiers** et le **nom du montage**. Vous aurez besoin de ces informations ultérieurement.

**Note**  
 Le champ **État** indique **Création** pendant le provisionnement du système de fichiers. La création du système de fichiers peut prendre plusieurs minutes. Attendez qu'il soit terminé avant de poursuivre le reste du didacticiel. 

# Création de groupes de nœuds de calcul dans AWS PCS
<a name="getting-started_create-cng"></a>

 Un groupe de nœuds de calcul est un ensemble virtuel de nœuds de calcul (instances EC2) que AWS PCS lance et gère. Lorsque vous définissez un groupe de nœuds de calcul, vous spécifiez des caractéristiques communes telles que les types d'instances EC2, le nombre d'instances minimal et maximal, les sous-réseaux VPC cibles, l'option d'achat préférée et la configuration de lancement personnalisée. AWS Le PCS lance, gère et arrête efficacement les nœuds de calcul d'un groupe de nœuds de calcul, conformément à ces paramètres. Le cluster de démonstration utilise un groupe de nœuds de calcul pour fournir des nœuds de connexion pour l'accès des utilisateurs, et un groupe de nœuds de calcul distinct pour traiter les tâches. Les rubriques suivantes décrivent les procédures permettant de configurer ces groupes de nœuds de calcul dans votre cluster. 

**Topics**
+ [Création d'un profil d'instance pour AWS PCS](getting-started_create-cng_instance-profile.md)
+ [Création de modèles de lancement pour AWS PCS](getting-started_create-cng_launch-templates.md)
+ [Création d'un groupe de nœuds de calcul pour les nœuds de connexion dans AWS PCS](getting-started_create-cng_login-nodes.md)
+ [Création d'un groupe de nœuds de calcul pour exécuter des tâches de calcul dans AWS PCS](getting-started_create-cng_workers.md)

# Création d'un profil d'instance pour AWS PCS
<a name="getting-started_create-cng_instance-profile"></a>

Les groupes de nœuds de calcul nécessitent un profil d'instance lors de leur création. Si vous utilisez AWS Management Console pour créer un rôle pour Amazon EC2, la console crée automatiquement un profil d'instance et lui attribue le même nom que le rôle. Pour plus d'informations, consultez la section [Utilisation des profils d'instance](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_use_switch-role-ec2_instance-profiles.html) dans le *Guide de Gestion des identités et des accès AWS l'utilisateur*.

 Dans la procédure suivante, vous utiliserez le AWS Management Console pour créer un rôle pour Amazon EC2, qui crée également le profil d'instance pour vos groupes de nœuds de calcul. 

**Pour créer le profil de rôle et d'instance**
+ Accédez à la [Console IAM](https://console.aws.amazon.com/iam).
+ Sous **Access Management (Gestion des accès)**, choisissez **Policies (politiques)**.
  + Choisissez **Create Policy** (Créer une politique).
  + Sous **Spécifier les autorisations**, dans **Éditeur de politiques**, sélectionnez **JSON**.
  + Remplacez le contenu de l'éditeur de texte par le suivant :

------
#### [ JSON ]

****  

    ```
    {
        "Version":"2012-10-17",		 	 	 
        "Statement": [
            {
                "Action": [
                    "pcs:RegisterComputeNodeGroupInstance"
                ],
                "Resource": "*",
                "Effect": "Allow"
            }
        ]
    }
    ```

------
  + Choisissez **Suivant**.
  + Sous **Vérifier et créer**, dans le champ **Nom de la politique**, entrez`AWSPCS-getstarted-policy`.
  + Choisissez **Create Policy** (Créer une politique).
+ Sous **Access Management** (Gestion des accès), choisissez **Roles** (Rôles).
+ Choisissez **Créer un rôle**.
+ Sous **Sélectionner une entité de confiance** :
  + Pour le **type d'entité de confiance**, sélectionnez **AWS service**
  + Sous **Cas d'utilisation**, sélectionnez **EC2.**
    + Ensuite, sous **Choisir un cas d'utilisation** pour le service spécifié, choisissez **EC2.**
  + Choisissez **Suivant**.
+ Sous **Ajouter des autorisations** :
  + Dans **Politiques d'autorisations**, recherchez **AWSPCS-getstarted-policy**.
  + Cochez la case à côté **AWSPCS-getstartedde -policy** pour l'ajouter au rôle.
  + Dans **Politiques d'autorisations**, recherchez **Amazon SSMManaged InstanceCore**.
  + Cochez la case à côté SSMManaged InstanceCore d'**Amazon** pour l'ajouter au rôle.
  + Choisissez **Suivant**.
+ Sous **Nom, passez en revue et créez** :
  + Sous **Détails du rôle** :
    + Pour le **Nom du rôle**, saisissez `AWSPCS-getstarted-role`.
  + Choisissez **Créer un rôle**.

# Création de modèles de lancement pour AWS PCS
<a name="getting-started_create-cng_launch-templates"></a>

 Lorsque vous créez un groupe de nœuds de calcul, vous fournissez un modèle de lancement EC2 que AWS PCS utilise pour configurer les instances EC2 qu'il lance. Cela inclut les paramètres tels que les groupes de sécurité et les scripts qui s'exécutent au lancement de l'instance. 

 Au cours de cette étape, un CloudFormation modèle sera utilisé pour créer deux modèles de lancement EC2. Un modèle sera utilisé pour créer des nœuds de connexion et l'autre pour créer des nœuds de calcul. La principale différence entre eux est que les nœuds de connexion peuvent être configurés pour autoriser l'accès SSH entrant. 

## Accédez au CloudFormation modèle
<a name="getting-started_create-cng_launch-templates_get-cfn-template"></a>

 Utilisez l'URL suivante pour télécharger le CloudFormation modèle, puis chargez-le dans la [CloudFormation console](https://console.aws.amazon.com/cloudformation/home#/stacks/create) pour créer une nouvelle CloudFormation pile. Pour plus d'informations, consultez la section [Utilisation de la CloudFormation console](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cfn-using-console.html) dans le *guide de AWS CloudFormation l'utilisateur*.

```
https://aws-hpc-recipes.s3.amazonaws.com/main/recipes/pcs/getting_started/assets/pcs-lt-efs-fsxl.yaml
```

## Utiliser le CloudFormation modèle pour créer des modèles de lancement EC2
<a name="getting-started_create-cng_launch-templates_use-cfn-template"></a>

 Pour compléter le CloudFormation modèle dans la CloudFormation console, procédez comme suit : 
+ Sous **Fournir un nom de pile** :
  + Sous **Nom de la pile**, entrez`getstarted-lt`.
+ Sous **Paramètres** :
  + Sous **Sécurité**
    + Pour **VpcSecurityGroupId**, sélectionnez le groupe de sécurité nommé `default` dans le VPC de votre cluster.
    + Pour **ClusterSecurityGroupId**, sélectionnez le groupe nommé `cluster-getstarted-sg`
    + Pour **SshSecurityGroupId**, sélectionnez le groupe nommé `inbound-ssh-getstarted-sg`
    + Pour **SshKeyName**, sélectionnez votre paire de clés SSH préférée.
  + Sous **Systèmes de fichiers**
    + Pour **EfsFilesystemId**, entrez l'ID du système de fichiers à partir du système de fichiers EFS que vous avez créé plus tôt dans le didacticiel.
    + Pour **FSxLustreFilesystemId**, entrez l'ID du système de fichiers à partir du système de fichiers FSx for Lustre que vous avez créé plus tôt dans le didacticiel.
    + Pour **FSxLustreFilesystemMountName**, entrez le même FSx nom de montage pour le système de fichiers Lustre.
+ Choisissez **Next**, puis de nouveau **Next**.
+ Sélectionnez **Soumettre**.

 Surveillez l'état de la CloudFormation pile. Lorsqu'il atteint, `CREATE_COMPLETE` le modèle de lancement est prêt à être utilisé. 

**Note**  
Pour voir toutes les ressources créées par le CloudFormation modèle, ouvrez la [CloudFormation console](https://console.aws.amazon.com/cloudformation). Choisissez la pile `getstarted-lt`, puis choisissez l'onglet **Ressources**.

# Création d'un groupe de nœuds de calcul pour les nœuds de connexion dans AWS PCS
<a name="getting-started_create-cng_login-nodes"></a>

 Un groupe de nœuds de calcul est un ensemble virtuel de nœuds de calcul (instances EC2) que AWS PCS lance et gère. Lorsque vous définissez un groupe de nœuds de calcul, vous spécifiez des caractéristiques communes telles que les types d'instances EC2, le nombre d'instances minimal et maximal, les sous-réseaux VPC cibles, l'option d'achat préférée et la configuration de lancement personnalisée. AWS Le PCS lance, gère et arrête efficacement les nœuds de calcul d'un groupe de nœuds de calcul, conformément à ces paramètres. 

 Au cours de cette étape, vous allez lancer un groupe de nœuds de calcul statique qui fournit un accès interactif au cluster. Vous pouvez utiliser SSH ou Amazon EC2 Systems Manager (SSM) pour vous y connecter, puis exécuter des commandes shell et gérer les tâches Slurm. 

**Pour créer le groupe de nœuds de calcul**
+ Ouvrez la [console AWS PCS](https://console.aws.amazon.com/pcs) et accédez à **Clusters**.
+ Sélectionnez le cluster nommé `get-started`
+ Accédez à **Compute node groups** et choisissez **Create**.
+ Dans la section **Configuration du groupe de nœuds de calcul**, fournissez les informations suivantes :
  + **Nom du groupe de nœuds de calcul** — Entrez`login`.
+ Sous **Configuration informatique**, entrez ou sélectionnez les valeurs suivantes :
  + **Modèle de lancement EC2** — Choisissez le modèle de lancement dont le nom est `login-getstarted-lt`
  + **Profil d'instance IAM** — Choisissez le profil d'instance nommé `AWSPCS-getstarted-role`
  + **Sous-réseaux** : sélectionnez le sous-réseau dont le nom commence par. `hpc-networking:PublicSubnetA`
  + **Instances** — Sélectionnez`c6i.xlarge`.
  + **Configuration de mise à l'échelle** : pour le **nombre minimal d'instances, entrez`1`.** Pour **Nombre maximal d'instances, entrez`1`.**
+ Sous **Paramètres supplémentaires**, spécifiez les éléments suivants :
  + **ID AMI** — Sélectionnez l'AMI que vous souhaitez utiliser, dont le nom est au format suivant :

    ```
    aws-pcs-sample_ami-amzn2-platform-slurm-version
    ```

    Pour plus d'informations sur cet exemple AMIs, consultez[Utilisation d'exemples d'Amazon Machine Images (AMIs) avec AWS PCS](working-with_ami_samples.md).
+ Choisissez **Créer un groupe de nœuds de calcul**.

 Le champ **Status** indique **Création** pendant le provisionnement du groupe de nœuds de calcul. Vous pouvez passer à l'étape suivante du didacticiel pendant qu'il est en cours. 

# Création d'un groupe de nœuds de calcul pour exécuter des tâches de calcul dans AWS PCS
<a name="getting-started_create-cng_workers"></a>

 Au cours de cette étape, vous allez lancer un groupe de nœuds de calcul qui évolue de manière élastique pour exécuter les tâches soumises au cluster. 

**Pour créer le groupe de nœuds de calcul**
+ Ouvrez la [console AWS PCS](https://console.aws.amazon.com/pcs) et accédez à **Clusters**.
+ Sélectionnez le cluster nommé `get-started`
+ Accédez à **Compute node groups** et choisissez **Create**.
+ Dans la section **Configuration du groupe de nœuds de calcul**, fournissez les informations suivantes :
  + **Nom du groupe de nœuds de calcul** — Entrez`compute-1`.
+ Sous **Configuration informatique**, entrez ou sélectionnez les valeurs suivantes :
  + **Modèle de lancement EC2** — Choisissez le modèle de lancement dont le nom est `compute-getstarted-lt`
  + **Profil d'instance IAM** — Choisissez le profil d'instance nommé `AWSPCS-getstarted-role`
  + **Sous-réseaux** : sélectionnez le sous-réseau dont le nom commence par. `hpc-networking:PrivateSubnetA`
  + **Instances** — Sélectionnez`c6i.xlarge`.
  + **Configuration de mise à l'échelle** : pour le **nombre minimal d'instances, entrez`0`.** Pour **Nombre maximal d'instances, entrez`4`.**
+ Sous **Paramètres supplémentaires**, spécifiez les éléments suivants :
  + **ID AMI** — Sélectionnez l'AMI que vous souhaitez utiliser, dont le nom est au format suivant :

    ```
    aws-pcs-sample_ami-amzn2-platform-slurm-version
    ```

    Pour plus d'informations sur cet exemple AMIs, consultez[Utilisation d'exemples d'Amazon Machine Images (AMIs) avec AWS PCS](working-with_ami_samples.md).
+ Choisissez **Créer un groupe de nœuds de calcul**.

 Le champ **Status** indique **Création** pendant le provisionnement du groupe de nœuds de calcul.

**Important**  
 Attendez que le champ **État** indique **Actif** avant de passer à l'étape suivante de ce didacticiel. 

# Créez une file d'attente pour gérer les tâches dans AWS PCS
<a name="getting-started_create-queue"></a>

 Vous soumettez une tâche à une file d'attente pour l'exécuter. La tâche reste dans la file d'attente jusqu'à ce que AWS PCS la planifie pour qu'elle s'exécute sur un groupe de nœuds de calcul. Chaque file d'attente est associée à un ou plusieurs groupes de nœuds de calcul, qui fournissent les EC2 instances nécessaires pour effectuer le traitement. 

 Au cours de cette étape, vous allez créer une file d'attente qui utilise le groupe de nœuds de calcul pour traiter les tâches. 

**Pour créer une file d’attente**
+ Ouvrez la [console AWS PCS](https://console.aws.amazon.com/pcs).
+ Sélectionnez le cluster nommé`get-started`.
+ Accédez à **Calculer les groupes de nœuds** et assurez-vous que le statut du `compute-1` groupe est **Actif**.
**Important**  
Le statut du `compute-1` groupe doit être **Actif** avant de passer à l'étape suivante.
+ Accédez à **Files d'attente** et choisissez **Créer une file d'attente**.
  + Dans la section **Configuration de la file d'attente**, indiquez les valeurs suivantes :
    + **Nom de la file d'attente** — Entrez ce qui suit : `demo`
    + **Groupes de nœuds de calcul** : sélectionnez le groupe de nœuds de calcul nommé`compute-1`.
+ Choisissez **Créez une file d'attente**.

 Le champ **État** indique **Création** pendant la création de la file d'attente. 

**Important**  
 Attendez que le champ **État** indique **Actif** avant de passer à l'étape suivante de ce didacticiel. 

# Connectez-vous à votre cluster AWS PCS
<a name="getting-started_connect"></a>

 Lorsque le statut du groupe de nœuds de `login` calcul devient **actif**, vous pouvez vous connecter à l' EC2 instance qu'il a créée. 

**Pour vous connecter au nœud de connexion**
+ Ouvrez la [console AWS PCS](https://console.aws.amazon.com/pcs) et accédez à **Clusters**.
+ Sélectionnez le cluster nommé`get-started`.
+ Choisissez **Compute node groups**.
+ Accédez au groupe de nœuds de calcul nommé`login`.
+ Trouvez l'**ID du groupe de nœuds Compute**.
+ Dans une autre fenêtre ou un autre onglet du navigateur, ouvrez la [ EC2 console Amazon](https://console.aws.amazon.com/ec2).
  + Choisissez **Instances**.
  + Recherchez des EC2 instances avec la balise suivante. Remplacez *node-group-id* par la valeur de l'**ID du groupe de nœuds de calcul** de l'étape précédente. Il devrait y avoir une instance.

    ```
    aws:pcs:compute-node-group-id=node-group-id
    ```
  + Connectez-vous à l' EC2 instance. Vous pouvez utiliser le gestionnaire de session ou SSH.

------
#### [ Session Manager ]
    + Sélectionnez l’instance.
    + Choisissez **Se connecter**.
    + Sous **Connect to instance**, sélectionnez **Session Manager**.
    + Choisissez **Se connecter**.
    + Choisissez **Se connecter**. Une borne interactive s'ouvre dans votre navigateur.

------
#### [ SSH ]
    + Sélectionnez l’instance.
    + Choisissez **Se connecter**.
    + Sous **Connect to instance**, sélectionnez **SSH client**.
    + Suivez les instructions fournies par la console.
**Note**  
Le nom d'utilisateur de l'instance ne l'est **`ec2-user`**pas`root`.

------

# Explorez l'environnement de cluster dans AWS PCS
<a name="getting-started_explore"></a>

 Une fois connecté au cluster, vous pouvez exécuter des commandes shell. Par exemple, vous pouvez changer d'utilisateur, travailler avec des données sur des systèmes de fichiers partagés et interagir avec Slurm. 

## Changer d'utilisateur
<a name="getting-started_explore_change-user"></a>

 Si vous vous êtes connecté au cluster à l'aide du gestionnaire de session, vous êtes peut-être connecté en tant que`ssm-user`. Il s'agit d'un utilisateur spécial créé pour le gestionnaire de session. Passez à l'utilisateur par défaut sur Amazon Linux 2 à l'aide de la commande suivante. Vous n'aurez pas besoin de le faire si vous vous êtes connecté via SSH.

```
sudo su - ec2-user
```

## Travailler avec des systèmes de fichiers partagés
<a name="getting-started_explore_fs"></a>

Vous pouvez vérifier que le système de fichiers EFS et FSx les systèmes de fichiers Lustre sont disponibles à l'aide de la commande`df -h`. La sortie de votre cluster doit ressembler à ce qui suit :

```
[ec2-user@ip-10-3-6-103 ~]$ df -h
Filesystem                 Size  Used Avail Use% Mounted on
devtmpfs                   3.8G     0  3.8G   0% /dev
tmpfs                      3.9G     0  3.9G   0% /dev/shm
tmpfs                      3.9G  556K  3.9G   1% /run
tmpfs                      3.9G     0  3.9G   0% /sys/fs/cgroup
/dev/nvme0n1p1              24G   18G  6.6G  73% /
127.0.0.1:/                8.0E     0  8.0E   0% /home
10.3.132.79@tcp:/zlshxbev  1.2T  7.5M  1.2T   1% /shared
tmpfs                      780M     0  780M   0% /run/user/0
tmpfs                      780M     0  780M   0% /run/user/1000
```

 Le système de `/home` fichiers monte 127.0.0.1 et possède une très grande capacité. Il s'agit du système de fichiers EFS que vous avez créé plus tôt dans le didacticiel. Tous les fichiers écrits ici seront disponibles `/home` sur tous les nœuds du cluster. 

 Le système de `/shared` fichiers monte une adresse IP privée et a une capacité de 1,2 To. Il s'agit du système de fichiers FSx for Lustre que vous avez créé plus tôt dans le didacticiel. Tous les fichiers écrits ici seront disponibles `/shared` sur tous les nœuds du cluster. 

## Interagir avec Slurm
<a name="getting-started_explore_slurm"></a>

**Contents**
+ [Répertorier les files d'attente et les nœuds](#getting-started_explore_slurm_queues)
+ [Afficher les offres d'emploi](#getting-started_explore_slurm_jobs)

### Répertorier les files d'attente et les nœuds
<a name="getting-started_explore_slurm_queues"></a>

 Vous pouvez répertorier les files d'attente et les nœuds auxquels elles sont associées à l'aide`sinfo`. La sortie de votre cluster doit ressembler à ce qui suit : 

```
[ec2-user@ip-10-3-6-103 ~]$ sinfo
PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
demo         up   infinite      4  idle~ compute-1-[1-4]
[ec2-user@ip-10-3-6-103 ~]$
```

 Notez le nom de la partition`demo`. Son statut est `up` et il dispose d'un maximum de 4 nœuds. Il est associé aux nœuds du groupe de `compute-1` nœuds. Si vous modifiez le groupe de nœuds de calcul et augmentez le nombre maximum d'instances à 8, le nombre de nœuds sera lu `8` et la liste des nœuds sera lue`compute-1-[1-8]`. Si vous avez créé un deuxième groupe de nœuds de calcul nommé `test` avec 4 nœuds et que vous l'avez ajouté à la `demo` file d'attente, ces nœuds apparaîtront également dans la liste des nœuds. 

### Afficher les offres d'emploi
<a name="getting-started_explore_slurm_jobs"></a>

 Vous pouvez répertorier toutes les tâches du système, quel que soit leur état, avec`squeue`. La sortie de votre cluster doit ressembler à ce qui suit : 

```
[ec2-user@ip-10-3-6-103 ~]$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```

Réessayez de l'exécuter `squeue` ultérieurement, lorsqu'une tâche Slurm est en attente ou en cours d'exécution. 

# Exécuter une tâche à nœud unique dans AWS PCS
<a name="getting-started_run-job"></a>

 Pour exécuter une tâche à l'aide de Slurm, vous devez préparer un script de soumission spécifiant les exigences de la tâche et le soumettre à une file d'attente à l'aide de la `sbatch` commande. Généralement, cela se fait à partir d'un répertoire partagé, de sorte que les nœuds de connexion et de calcul disposent d'un espace commun pour accéder aux fichiers. 

 Connectez-vous au nœud de connexion de votre cluster et exécutez les commandes suivantes à l'invite du shell.
+ Devenez l'utilisateur par défaut. Accédez au répertoire partagé.

  ```
  sudo su - ec2-user
  cd /shared
  ```
+ Utilisez les commandes suivantes pour créer un exemple de script de tâche :

  ```
  cat << EOF > job.sh
  #!/bin/bash
  #SBATCH -J single
  #SBATCH -o single.%j.out
  #SBATCH -e single.%j.err
  
  echo "This is job \${SLURM_JOB_NAME} [\${SLURM_JOB_ID}] running on \${SLURMD_NODENAME}, submitted from \${SLURM_SUBMIT_HOST}" && sleep 60 && echo "Job complete"
  EOF
  ```
+ Soumettez le script de tâche au planificateur Slurm :

  ```
  sbatch -p demo job.sh
  ```
+  Lorsque la tâche est soumise, elle renvoie un identifiant de tâche sous forme de numéro. Utilisez cet identifiant pour vérifier le statut du travail. Remplacez *job-id* dans la commande suivante par le numéro renvoyé par`sbatch`. 

  ```
  squeue --job job-id
  ```  
**Example**  

  ```
  squeue --job 1
  ```

   La `squeue` commande renvoie un résultat similaire à ce qui suit : 

  ```
  JOBID PARTITION NAME USER     ST TIME NODES NODELIST(REASON)
  1     demo      test ec2-user CF 0:47 1     compute-1
  ```
+  Continuez à vérifier l'état de la tâche jusqu'à ce qu'elle atteigne le statut `R` (en cours). Le travail est terminé quand il `squeue` ne renvoie rien. 
+  Inspectez le contenu du `/shared` répertoire. 

  ```
  ls -alth /shared
  ```

  Le résultat de la commande est similaire à ce qui suit :

  ```
  -rw-rw-r- 1 ec2-user ec2-user 107 Mar 19 18:33 single.1.out
  -rw-rw-r- 1 ec2-user ec2-user 0 Mar 19 18:32 single.1.err
  -rw-rw-r- 1 ec2-user ec2-user 381 Mar 19 18:29 job.sh
  ```

   Les fichiers `single.1.err` ont été nommés `single.1.out` et écrits par l'un des nœuds de calcul de votre cluster. Comme la tâche a été exécutée dans un répertoire partagé (`/shared`), elles sont également disponibles sur votre nœud de connexion. C'est pourquoi vous avez configuré un système de fichiers FSx for Lustre pour ce cluster. 
+  Inspectez le contenu du `single.1.out` fichier. 

  ```
  cat /shared/single.1.out
  ```

   La sortie est similaire à ce qui suit :

  ```
  This is job test [1] running on compute-1, submitted from ip-10-3-13-181
  Job complete
  ```

# Exécuter une tâche MPI multi-nœuds avec Slurm sur PCS AWS
<a name="getting-started_run-mpi-job"></a>

 Ces instructions montrent comment utiliser Slurm pour exécuter une tâche MPI (Message Passing Interface) dans PCS. AWS 

Exécutez les commandes suivantes à l'invite du shell de votre nœud de connexion.
+  Devenez l'utilisateur par défaut. Accédez à son répertoire personnel. 

  ```
  sudo su - ec2-user
  cd ~/
  ```
+  Créez du code source dans le langage de programmation C. 

  ```
  cat > hello.c << EOF
  // * mpi-hello-world - https://www.mpitutorial.com
  // Released under MIT License
  // 
  // Copyright (c) 2014 MPI Tutorial.
  //
  // 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, subject to the following conditions:
  // The above copyright notice and this permission notice shall be included in 
  // all copies or substantial portions of the Software.
  //
  // 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.
  
  #include <mpi.h>
  #include <stdio.h>
  #include <stddef.h>
  
  int main(int argc, char** argv) {
    // Initialize the MPI environment. The two arguments to MPI Init are not
    // currently used by MPI implementations, but are there in case future
    // implementations might need the arguments.
    MPI_Init(NULL, NULL);
  
    // Get the number of processes
    int world_size;
    MPI_Comm_size(MPI_COMM_WORLD, &world_size);
  
    // Get the rank of the process
    int world_rank;
    MPI_Comm_rank(MPI_COMM_WORLD, &world_rank);
  
    // Get the name of the processor
    char processor_name[MPI_MAX_PROCESSOR_NAME];
    int name_len;
    MPI_Get_processor_name(processor_name, &name_len);
  
    // Print off a hello world message
    printf("Hello world from processor %s, rank %d out of %d processors\n",
           processor_name, world_rank, world_size);
  
    // Finalize the MPI environment. No more MPI calls can be made after this
    MPI_Finalize();
  }
  EOF
  ```
+ Chargez le module OpenMPI.

  ```
  module load openmpi
  ```
+ Compilez le programme C.

  ```
  mpicc -o hello hello.c
  ```
+ Rédigez un script de soumission de tâches Slurm.

  ```
  cat > hello.sh << EOF
  #!/bin/bash
  #SBATCH -J multi
  #SBATCH -o multi.out
  #SBATCH -e multi.err
  #SBATCH --exclusive
  #SBATCH --nodes=4
  #SBATCH --ntasks-per-node=1
  
  srun $HOME/hello
  EOF
  ```
+ Accédez au répertoire partagé.

  ```
  cd /shared
  ```
+ Soumettez le script de tâche.

  ```
  sbatch -p demo ~/hello.sh
  ```
+ `squeue`À utiliser pour surveiller le travail jusqu'à ce qu'il soit terminé.
+ Vérifiez le contenu de `multi.out` :

  ```
  cat multi.out
  ```

  La sortie est similaire à ce qui suit. Notez que chaque rang possède sa propre adresse IP car il s'est exécuté sur un nœud différent.

  ```
  Hello world from processor ip-10-3-133-204, rank 0 out of 4 processors
  Hello world from processor ip-10-3-128-219, rank 2 out of 4 processors
  Hello world from processor ip-10-3-141-26, rank 3 out of 4 processors
  Hello world from processor ip-10-3-143-52, rank 1 out of 4 processor
  ```

# Supprimer vos AWS ressources pour AWS PCS
<a name="getting-started_delete"></a>

 Une fois que vous avez terminé avec les groupes de clusters et de nœuds que vous avez créés pour ce didacticiel, vous devez supprimer les ressources que vous avez créées. 

**Important**  
Vous recevez des frais de facturation pour toutes les ressources utilisées dans votre Compte AWS

**Pour supprimer les ressources AWS PCS que vous avez créées pour ce didacticiel**
+ Ouvrez la [console AWS PCS](https://console.aws.amazon.com/pcs/home#/clusters).
+ Accédez au cluster nommé **get-started**.
+ Accédez à la section **Files d'attente**.
+ Sélectionnez la file d'attente nommée **demo**.
+ Sélectionnez **Delete (Supprimer)**.
**Important**  
Attendez que la file d'attente soit supprimée avant de continuer.
+ Accédez à la section **Groupes de nœuds de calcul**.
+ Sélectionnez le groupe de nœuds de calcul nommé **compute-1**.
+ Sélectionnez **Delete (Supprimer)**.
+ Sélectionnez le groupe de nœuds de calcul nommé **login**.
+ Sélectionnez **Delete (Supprimer)**.
**Important**  
Attendez que les deux groupes de nœuds de calcul aient été supprimés avant de continuer.
+ **Sur la page détaillée du cluster pour **démarrer**, choisissez Supprimer.**
**Important**  
Attendez que le cluster ait été supprimé avant de passer aux étapes suivantes.

**Pour supprimer les autres AWS ressources que vous avez créées pour ce didacticiel**
+ Ouvrez la [console IAM](https://console.aws.amazon.com/iam).
  + Sélectionnez **Roles** (Rôles).
  + Sélectionnez le rôle nommé **AWSPCS-getstarted-role**, puis choisissez **Supprimer**.
  + Une fois le rôle supprimé, choisissez **Politiques**.
  + Sélectionnez la politique nommée **AWSPCS-getstarted-policy**, puis choisissez **Supprimer**.
+ Ouvrez la [CloudFormation console](https://console.aws.amazon.com/cloudformation).
  + Sélectionnez la pile nommée **getstarted-lt**.
  + Sélectionnez **Delete (Supprimer)**.
**Important**  
Attendez que la pile soit supprimée avant de continuer.
+ Ouvrez la [console Amazon EFS](https://console.aws.amazon.com/efs).
  + Choisissez **File Systems (Systèmes de fichiers)**.
  + Sélectionnez le système de fichiers nommé **getstarted-efs**.
  + Sélectionnez **Delete (Supprimer)**.
**Important**  
Attendez que le système de fichiers soit supprimé avant de continuer.
+ Ouvrez la [ FSx console Amazon](https://console.aws.amazon.com/fsx).
  + Choisissez **File Systems (Systèmes de fichiers)**.
  + Sélectionnez le système de fichiers nommé **getstarted-fsx**.
  + Sélectionnez **Delete (Supprimer)**.
**Important**  
Attendez que le système de fichiers soit supprimé avant de continuer.
+ Ouvrez la [CloudFormation console](https://console.aws.amazon.com/cloudformation).
  + Sélectionnez la pile nommée **getstarted-sg**.
  + Sélectionnez **Delete (Supprimer)**.
+ Ouvrez la [CloudFormation console](https://console.aws.amazon.com/cloudformation).
  + Sélectionnez la pile nommée **hpc-networking**.
  + Sélectionnez **Supprimer**.