Defina um projeto Terraform Implantar o cluster Permissões obrigatórias

Criação de um cluster com o Terraform

Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para ter mais informações, consulte AWS serviços usados por AWS ParallelCluster.

Pré-requisitos

O Terraform v1.5.7+ está instalado.
AWS ParallelCluster APIA versão v3.8.0+ está implantada em sua conta. Consulte Implantando a ParallelCluster API com o Terraform.
Papel do IAM com as permissões para invocar a ParallelCluster API. Consulte [Permissões necessárias]

Defina um projeto Terraform

Neste tutorial, você definirá um projeto simples do Terraform para implantar um cluster.

Crie um diretório chamadomy-clusters.

Todos os arquivos que você criar estarão dentro desse diretório.

Crie o arquivo terraform.tf para importar o ParallelCluster provedor.


terraform {
  required_version = ">= 1.5.7"
  required_providers {
    aws-parallelcluster = {
      source  = "aws-tf/aws-parallelcluster"
      version = "1.0.0"
    }
  }
}

Crie o arquivo providers.tf para configurar ParallelCluster os AWS provedores e.


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
}

Crie o arquivo main.tf para definir os recursos usando o ParallelCluster módulo.


module "pcluster" {
  source  = "aws-tf/parallelcluster/aws"
  version = "1.0.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"
}

Crie o arquivo clusters.tf para definir vários clusters como variáveis locais do Terraform.

nota

Você pode definir vários clusters dentro do cluster_config elemento. Para cada cluster, você pode definir explicitamente as propriedades do cluster nas variáveis locais (consulteDemoCluster01) ou referenciar um arquivo externo (consulteDemoCluster02).

Para revisar as propriedades do cluster que você pode definir no elemento de configuração, consulteArquivo de configuração do cluster.

Para analisar as opções que você pode definir para a criação de clusters, consultepcluster create-cluster.


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"
    }
  }
}

Crie o arquivo config/clusters.yaml para definir vários clusters como configuração 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

Crie o arquivoconfig/cluster_config.yaml, que é um arquivo de ParallelCluster configuração padrão em que as variáveis do Terraform podem ser injetadas.

Para revisar as propriedades do cluster que você pode definir no elemento de configuração, consulteArquivo de configuração do cluster.


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

Crie o arquivo clusters_vars.tf para definir as variáveis que podem ser injetadas nas configurações do cluster.

Esse arquivo permite definir valores dinâmicos que podem ser usados em configurações de cluster, como região e sub-rede.

Este exemplo recupera valores diretamente das variáveis do projeto, mas talvez seja necessário usar uma lógica personalizada para determiná-los.
```
locals {
  config_vars = {
    subnet = var.subnet_id
    region = var.cluster_region
  }
}
```

Crie o arquivo variables.tf para definir as variáveis que podem ser injetadas neste projeto.


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."
}

Crie o arquivo terraform.tfvars para definir valores arbitrários para as variáveis.

O arquivo abaixo implanta os clusters eu-west-1 na sub-redesubnet-123456789, usando a ParallelCluster API 3.10.0 existente, que já está implantada com o nome da pilha. us-east-1 MyParallelClusterAPI-310
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-310"
api_version = "3.10.0"

cluster_region = "eu-west-1"
subnet_id = "subnet-123456789"
```

Crie o arquivo outputs.tf para definir as saídas retornadas por esse projeto.


output "clusters" {
  value = module.pcluster.clusters
}

O diretório do projeto é:


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.

Implantar o cluster

Para implantar o cluster, execute os comandos padrão do Terraform em ordem.

nota

Este exemplo pressupõe que você já tenha implantado a ParallelCluster API na sua conta.

Crie o projeto:
```
terraform init
```
Defina o plano de implantação:
```
terraform plan -out tfplan
```
Implante o plano:
```
terraform apply tfplan
```

Implemente a ParallelCluster API com clusters

Se você não implantou a ParallelCluster API e deseja implantá-la com os clusters, altere os seguintes arquivos:

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

  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
}

Permissões obrigatórias

Você precisa das seguintes permissões para implantar um cluster com o Terraform:

assumir a função de ParallelCluster API, que é responsável por interagir com a ParallelCluster API
descrever a AWS CloudFormation pilha da ParallelCluster API para verificar se ela existe e recuperar seus parâmetros e saídas


{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Action": "sts:AssumeRole",
            "Resource": "arn:PARTITION:iam::ACCOUNT:role/PCAPIUserRole-*",
            "Effect": "Allow",
            "Sid": "AssumePCAPIUserRole"
        },
        {
            "Action": [
                "cloudformation:DescribeStacks"
            ],
            "Resource": "arn:PARTITION:cloudformation:REGION:ACCOUNT:stack/*",
            "Effect": "Allow",
            "Sid": "CloudFormation"
        }
    ]
}

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Implantando a ParallelCluster API com o Terraform

Criação de uma AMI personalizada com o Terraform