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.

# 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"
        }
    ]
}
```

------