As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Tutoriais sobre como usar AWS ParallelCluster
Os tutoriais a seguir mostram como começar a usar a AWS ParallelCluster versão 3 e fornecem orientações sobre as melhores práticas para algumas tarefas comuns.
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Topics**
+ [Executando seu primeiro trabalho em AWS ParallelCluster](tutorials-running-your-first-job-on-version-3.md)
+ [Criação de uma AWS ParallelCluster AMI personalizada](building-custom-ami-v3.md)
+ [Integração do Active Directory](tutorials_05_multi-user-ad.md)
+ [Configurando a criptografia de armazenamento compartilhado com uma chave AWS KMS](tutorials_04_encrypted_kms_fs-v3.md)
+ [Executando trabalhos em um cluster de modo de várias filas](multi-queue-tutorial-v3.md)
+ [Usando a AWS ParallelCluster API](tutorials_06_API_use.md)
+ [Criação de um cluster com Slurm contabilidade](tutorials_07_slurm-accounting-v3.md)
+ [Criando um cluster com um externo Slurmdbd contabilidade](external-slurmdb-accounting.md)
+ [Revertendo para uma versão anterior do documento do AWS Systems Manager](tutorials_08_ssm-document-version-rev-v3.md)
+ [Criando um cluster com CloudFormation](tutorials_09_cfn-custom-resource-v3.md)
+ [Implemente a ParallelCluster API com o Terraform](tutorial-deploy-terraform.md)
+ [Criar um cluster como o Terraform](tutorial-create-cluster-terraform.md)
+ [Criar uma AMI do personalizada com o Terraform](tutorial-create-ami-terraform.md)
+ [AWS ParallelCluster Integração da interface do usuário com o Identity Center](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Executar trabalhos em contêineres com Pyxis](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [Criação de um cluster com um Lustre habilitado para EFA FSx](tutorial-efa-enabled-fsx-lustre.md)
+ [Support NVIDIA-IMEX com instância p6e-gb200](support-nvidia-imex-p6e-gb200-instance.md)
+ [Personalize as interfaces de rede de nós de computação com substituições de modelos de lançamento](tutorial-network-customization-v3.md)
# Executando seu primeiro trabalho em AWS ParallelCluster
Este tutorial explica como executar seu primeiro trabalho do Hello World no AWS ParallelCluster
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a CLI [`pcluster`](pcluster-v3.md).
## Verificar a instalação
Primeiro, verificamos se AWS ParallelCluster está correto, incluindo a dependência do Node.js, instalada e configurada.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
Isso retorna a versão em execução do AWS ParallelCluster.
## Criação de seu primeiro cluster
Agora é hora de criar seu primeiro cluster. Como a workload desse tutorial não é de desempenho intensivo, podemos usar o tamanho de instância padrão de `t2.micro`. (Para workloads de produção, escolha um tamanho de instância que melhor atenda às suas necessidades.) Vamos chamar o cluster de `hello-world`.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**nota**
O Região da AWS a ser usado deve ser especificado para a maioria dos `pcluster` comandos. Se não estiver especificado na variável de ambiente `AWS_DEFAULT_REGION` ou na configuração `region` na seção `[default]` do arquivo `~/.aws/config` o parâmetro `--region` deverá ser fornecido na linha de comando `pcluster`.
Se a saída fornecer uma mensagem sobre configuração, será necessário executar o seguinte para configurar o AWS ParallelCluster:
```
$ pcluster configure --config hello-world.yaml
```
Se o comando [`pcluster create-cluster`](pcluster.create-cluster-v3.md) for bem-sucedido, você verá um resultado semelhante a este:
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Você monitora a criação do cluster usando:
```
$ pcluster describe-cluster --cluster-name hello-world
```
Os relatórios `clusterStatus` "`CREATE_IN_PROGRESS`" enquanto o cluster está sendo criado. A `clusterStatus` muda para "`CREATE_COMPLETE`" quando o cluster é criado com sucesso. O resultado também nos fornece `publicIpAddress` e `privateIpAddress` do nosso nó de cabeçalho.
## Fazer login em seu nó principal
Use o arquivo pem OpenSSH para fazer login no nó principal.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
Depois de fazer login, execute o comando `sinfo` para verificar se os nós de computação estão definidos e configurados.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
A saída mostra que temos uma fila em nosso cluster, com até dez nós.
## Executar o primeiro trabalho usando o Slurm
Depois, criamos uma tarefa que permanece em espera por um tempo e então emite seu próprio nome de host como saída. Crie um arquivo chamado `hellojob.sh` com o seguinte conteúdo:
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
Depois, envie a tarefa usando `sbatch` e verifique se ela é executada.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
Agora, você pode visualizar a fila e verificar o status do trabalho. O provisionamento de uma nova instância do Amazon EC2 é iniciada em segundo plano. Você pode monitorar o status das instâncias do cluster com o comando `sinfo`.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
A saída mostra que o trabalho foi enviado a `queue1`. Aguarde 30 segundos para que a tarefa seja concluída e execute `squeue` novamente.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
Agora que não há trabalhos na fila, podemos verificar a saída em nosso diretório atual.
```
$ 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
```
Na saída, vemos um arquivo `out` "”. Podemos ver a saída do nosso trabalho:
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
A saída também mostra que a tarefa foi executada com êxito na instância `queue1-dy-queue1t2micro-1`.
No cluster que você acabou de criar, somente o diretório inicial é compartilhado entre todos os nós do cluster.
Para saber mais sobre como criar e usar clusters, consulte [Práticas recomendadas](best-practices-v3.md).
Se seu aplicativo exigir software, bibliotecas ou dados compartilhados, considere as seguintes opções:
+ Crie uma AMI personalizada AWS ParallelCluster habilitada que inclua seu software conforme descrito em[Criação de uma AWS ParallelCluster AMI personalizada](building-custom-ami-v3.md).
+ Use a [StorageSettings](SharedStorage-v3.md)opção no arquivo de AWS ParallelCluster configuração para especificar um sistema de arquivos compartilhado e armazenar o software instalado no local de montagem especificado.
+ Use [Ações de bootstrap personalizadas](custom-bootstrap-actions-v3.md) para automatizar o procedimento de bootstrap de cada nó do seu cluster.
# Criação de uma AWS ParallelCluster AMI personalizada
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Importante**
Se você criar uma AMI personalizada, será necessário repetir as etapas usadas para criar sua AMI personalizada com cada versão nova do AWS ParallelCluster .
Antes de continuar lendo, recomendamos que você analise antes a seção [Ações de bootstrap personalizadas](custom-bootstrap-actions-v3.md). Determine se as modificações que deseja fazer podem ser expressas em scripts e são compatíveis com versões futuras do AWS ParallelCluster .
Embora criar uma AMI personalizada em geral não seja o ideal, há cenários específicos em que AWS ParallelCluster é necessário criar uma AMI personalizada para. Este tutorial mostra como criar uma AMI personalizada para esses cenários.
**Pré-requisitos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a CLI [`pcluster`](pcluster-v3.md) e compilar imagens.
## Como personalizar a AWS ParallelCluster AMI
Há duas maneiras de criar uma AWS ParallelCluster AMI personalizada. Um desses dois métodos é criar uma nova AMI usando a AWS ParallelCluster CLI. Outro método exige que você faça modificações manuais para criar uma nova AMI que esteja disponível na sua Conta da AWS.
## Crie uma AWS ParallelCluster AMI personalizada
Se você tiver uma AMI e um software personalizados, poderá aplicar as alterações necessárias AWS ParallelCluster em cima deles. AWS ParallelCluster depende do serviço EC2 Image Builder para criar designs personalizados. AMIs Para obter mais informações, consulte o [Guia do usuário do Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
Principais pontos:
+ O processo leva cerca de 1 hora. Esse tempo pode variar se houver [`Build`](Build-v3.md) / [`Components`](Build-v3.md#Build-v3-Components) adicionais a serem instalados no momento da construção.
+ A AMI é marcada com as versões dos componentes principais. Isso inclui o kernel, o programador e o driver [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). Um subconjunto das versões dos componentes também é relatado na descrição da AMI.
+ A partir da AWS ParallelCluster versão 3.0.0, um novo conjunto de comandos da CLI pode ser usado para gerenciar o ciclo de vida das imagens. Isso inclui [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md), e [`delete-image`](pcluster.delete-image-v3.md).
+ Esse método é repetível. Você pode executá-lo novamente para se manter AMIs atualizado (por exemplo, atualizações do sistema operacional) e usá-las ao atualizar um cluster existente.
**nota**
Se você usar esse método na Partição da AWS China, poderá obter erros de rede. Por exemplo, você pode ver esses erros no `pcluster build-image` comando quando ele baixa pacotes de GitHub ou de um repositório do sistema operacional. Se ela exceder esse limite, recomendamos usar um dos métodos alternativos a seguir:
Siga a abordagem [Modificar uma AWS ParallelCluster AMI](#modify-an-aws-parallelcluster-ami-v3) que ignora esse comando.
Crie a imagem em outra partição e região, como`us-east-1`, e depois store/restore mova-a para a região da China. Para ter mais informações, consulte [Armazenar e restaurar uma AMI usando o S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) no *Guia do usuário do Amazon EC2*.
Etapas:
1. Configure suas Conta da AWS credenciais para que o AWS ParallelCluster cliente possa fazer chamadas para operações de AWS API em seu nome. Para obter uma lista das permissões necessárias, consulte [AWS Identity and Access Management permissões em AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md).
1. Crie um arquivo básico de configuração de *imagem de compilação*. Para fazer isso, especifique o [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType) a ser usado para criar a imagem e o [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage). Eles são usados como ponto de partida para criar a AMI. Para obter mais informações sobre parâmetros opcionais de criação, consulte [Configuração de imagem](image-builder-configuration-file-v3.md).
```
Build:
InstanceType:
ParentImage:
```
1. Use o comando CLI [`pcluster build-image`](pcluster.build-image-v3.md)para criar uma AWS ParallelCluster AMI a partir da AMI que você fornece como base.
```
$ pcluster build-image --image-id IMAGE_ID --image-configuration IMAGE_CONFIG.yaml --region REGION
{
"image": {
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_IN_PROGRESS",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"region": "us-east-1",
"version": "3.15.0"
}
}
```
**Atenção**
O `pcluster build-image` usa a VPC padrão. Se você excluir a VPC padrão usando AWS Control Tower nossa AWS Landing Zone, a ID da sub-rede deverá ser especificada no arquivo de configuração da imagem. Para obter mais informações, consulte [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId).
Para obter uma lista de outros parâmetros, consulte a página de referência do comando [`pcluster build-image`](pcluster.build-image-v3.md). Os resultados do comando anterior são os seguintes:
+ Uma CloudFormation pilha é criada com base na configuração da imagem. A pilha inclui todos os recursos do EC2 Image Builder necessários para a construção.
+ Os recursos criados incluem os componentes oficiais do Image Builder AWS ParallelCluster aos quais os componentes personalizados do Image Builder podem ser adicionados. Para obter mais informações, consulte [Criar um componente personalizado com o Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) no Guia do *usuário do EC2 Image Builder*.
+ O EC2 Image Builder inicia uma instância de compilação, aplica AWS ParallelCluster o livro de receitas, instala a pilha de software e AWS ParallelCluster executa as tarefas de configuração necessárias. O AWS ParallelCluster livro de receitas é usado para criar e inicializar AWS ParallelCluster.
+ A instância é interrompida e uma nova AMI é criada a partir dela.
+ Outra instância é executada na AMI recém-criada. Durante a fase de teste, o EC2 Image Builder executa testes definidos nos componentes do Image Builder.
+ Se a compilação for bem-sucedida, a pilha será excluída. Se a construção falhar, a pilha será retida e estará disponível para inspeção.
1. Você pode monitorar o status do processo de compilação executando o comando a seguir. Depois que a compilação for concluída, você poderá executá-la para recuperar o ID da AMI fornecido na resposta.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
# BEFORE COMPLETE
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?...",
},
"imageId": "IMAGE_ID",
"imagebuilderImageStatus": "BUILDING",
"imageBuildStatus": "BUILD_IN_PROGRESS",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"region": "us-east-1",
"version": "3.15.0",
"cloudformationStackTags": [
{
"value": "3.15.0",
"key": "parallelcluster:version"
},
{
"value": "IMAGE_ID",
"key": "parallelcluster:image_name"
},
...
],
"imageBuildLogsArn": "arn:aws:logs:us-east-1:123456789012:log-group:/aws/imagebuilder/ParallelClusterImage-IMAGE_ID",
"cloudformationStackCreationTime": "2022-04-05T21:36:26.176Z"
}
# AFTER COMPLETE
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.us-east-1.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?Signature=..."
},
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_COMPLETE",
"region": "us-east-1",
"ec2AmiInfo": {
"amiName": "IMAGE_ID 2022-04-05T21-39-24.020Z",
"amiId": "ami-1234stuv5678wxyz",
"description": "AWS ParallelCluster AMI for alinux2, kernel-4.14.238-182.422.amzn2.x86_64, lustre-2.10.8-5.amzn2.x86_64, efa-1.13.0-1.amzn2.x86_64, dcv-2021.1.10598-1.el7.x86_64, slurm-20-11-8-1",
"state": "AVAILABLE",
"tags": [
{
"value": "2021.3.11591-1.el7.x86_64",
"key": "parallelcluster:dcv_version"
},
...
],
"architecture": "x86_64"
},
"version": "3.15.0"
}
```
1. Para criar o cluster, insira o ID de AMI no campo [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) na configuração do cluster.
**Solução de problemas e monitoramento do processo de criação de AMI**
A criação da imagem é concluída em cerca de uma hora. Você pode monitorar o processo executando o comando [`pcluster describe-image`](pcluster.describe-image-v3.md) ou os comandos de recuperação de log.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
O [`build-image`](pcluster.build-image-v3.md)comando cria uma CloudFormation pilha com todos os recursos do Amazon EC2 necessários para criar a imagem e inicia o processo do EC2 Image Builder.
Depois de executar o [`build-image`](pcluster.build-image-v3.md)comando, é possível recuperar eventos da CloudFormation pilha usando o. [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md) Você pode filtrar os resultados com o parâmetro `--query` para ver os eventos mais recentes. Para obter mais informações, consulte [Filtragem AWS CLI de saída](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html) no *Guia do AWS Command Line Interface usuário*.
```
$ 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"
}
```
Após cerca de 15 minutos, os eventos da pilha aparecem na entrada de eventos de log relacionada à criação do Image Builder. Agora você pode listar fluxos de logs de imagens e monitorar as etapas do Image Builder usando os comandos [`pcluster list-image-log-streams`](pcluster.list-image-log-streams-v3.md) e [`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md).
```
$ pcluster list-image-log-streams --image-id IMAGE_ID --region REGION \
--query 'logStreams[*].logStreamName'
"3.15.0/1"
]
$ pcluster get-image-log-events --image-id IMAGE_ID --region REGION \
--log-stream-name 3.15.0/1 --limit 3
{
"nextToken": "f/36295977202298886557255241372854078762600452615936671762",
"prevToken": "b/36295977196879805474012299949460899222346900769983430672",
"events": [
{
"message": "ExecuteBash: FINISHED EXECUTION",
"timestamp": "2022-04-05T22:13:26.633Z"
},
{
"message": "Document arn:aws:imagebuilder:us-east-1:123456789012:component/parallelclusterimage-test-abcd1234-ef56-gh78-ij90-1234abcd5678/3.15.0/1",
"timestamp": "2022-04-05T22:13:26.741Z"
},
{
"message": "TOE has completed execution successfully",
"timestamp": "2022-04-05T22:13:26.819Z"
}
]
}
```
Continue verificando o comando [`describe-image`](pcluster.describe-image-v3.md) até ver o status do `BUILD_COMPLETE`.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
{
"imageConfiguration": {
"url": "https://parallelcluster-1234abcd5678efgh-v1-do-not-delete.s3.us-east-1.amazonaws.com/parallelcluster/3.15.0/images/IMAGE_ID-abcd1234efgh5678/configs/image-config.yaml?Signature=..."
},
"imageId": "IMAGE_ID",
"imageBuildStatus": "BUILD_COMPLETE",
"region": "us-east-1",
"ec2AmiInfo": {
"amiName": "IMAGE_ID 2022-04-05T21-39-24.020Z",
"amiId": "ami-1234stuv5678wxyz",
"description": "AWS ParallelCluster AMI for alinux2, kernel-4.14.238-182.422.amzn2.x86_64, lustre-2.10.8-5.amzn2.x86_64, efa-1.13.0-1.amzn2.x86_64, dcv-2021.1.10598-1.el7.x86_64, slurm-20-11-8-1",
"state": "AVAILABLE",
"tags": [
{
"value": "2021.3.11591-1.el7.x86_64",
"key": "parallelcluster:dcv_version"
},
...
],
"architecture": "x86_64"
},
"version": "3.15.0"
}
```
Se você precisar solucionar um problema de criação de AMI personalizada, crie um arquivo dos logs de imagem conforme descrito nas etapas a seguir.
É possível arquivar os logs em um bucket do Amazon S3 ou em um arquivo local, dependendo do parâmetro `--output`.
```
$ pcluster export-image-logs --image-id IMAGE_ID --region REGION \
--bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER
{
"url": "https://BUCKET_NAME.s3.us-east-1.amazonaws.com/BUCKET-FOLDER/IMAGE_ID-logs-202209071136.tar.gz?AWSAccessKeyId=..."
}
$ pcluster export-image-logs --image-id IMAGE_ID \
--region REGION --bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER --output-file /tmp/archive.tar.gz
{
"path": "/tmp/archive.tar.gz"
}
```
O arquivo contém os fluxos de CloudWatch registros relacionados ao processo do Image Builder e aos eventos de CloudFormation pilha. O comando pode levar alguns minutos para ser executado.
**Gerenciando o personalizado AMIs**
A partir da AWS ParallelCluster versão 3.0.0, um novo conjunto de comandos foi adicionado à CLI para criar, monitorar e gerenciar o ciclo de vida da imagem. Para obter mais informações sobre os comandos, consulte [comandos pcluster](pcluster-v3.md).
## Modificar uma AWS ParallelCluster AMI
Esse método consiste em modificar uma AWS ParallelCluster AMI oficial adicionando personalização a ela. A base AWS ParallelCluster AMIs é atualizada com novos lançamentos. Eles AMIs têm todos os componentes necessários AWS ParallelCluster para funcionar quando instalados e configurados. Você pode começar com um deles como base.
Principais pontos:
+ Esse método é mais rápido que o comando [`build-image`](pcluster.build-image-v3.md). No entanto, é um processo manual e não pode ser repetido automaticamente.
+ Com esse método, você não tem acesso aos comandos de recuperação de logs e gerenciamento do ciclo de vida da imagem que estão disponíveis por meio da CLI.
Etapas:
------
#### [ New Amazon EC2 console ]
1. Encontre a AMI que corresponde à específica Região da AWS que você usa. Para encontrá-la, use o [`pcluster list-official-images`](pcluster.list-official-images-v3.md)comando com o `--region` parâmetro para selecionar os `--architecture` parâmetros Região da AWS e `--os` e específicos para filtrar a AMI desejada com o sistema operacional e a arquitetura que você deseja usar. Na saída, recupere o ID da imagem do Amazon EC2.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. No painel de navegação, escolha **Imagens** e, em seguida **AMIs**. Pesquise a ID de imagem do EC2 recuperada, selecione a AMI e escolha **Iniciar instância a partir da AMI**.
1. Role para baixo e escolha seu **tipo de instância**.
1. Escolha seu **par de chaves** e **execute a instância**.
1. Faça login na instância usando o usuário do SO e chave SSH.
1. Personalize manualmente sua instância para atender às suas necessidades.
1. Execute o seguinte comando para preparar a instância para a criação da AMI.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. No console, escolha **Estado da instância** e **Interromper instância**.
Vá para **Instâncias**, escolha a nova instância, selecione **Instance state (Estado da instância)**, e **Stop instance (Interromper instância)**.
1. [Crie uma nova AMI a partir da instância usando o console do Amazon EC2 ou AWS CLI create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Do console do Amazon EC2**
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Escolha a instância que você criou e modificou.
1. Em **Ações**, escolha **Imagem**, e, em seguida, **Criar imagem**.
1. Escolha **Create Image**.
1. Insira o ID de AMI no campo [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) na configuração do cluster e crie um cluster.
------
#### [ Old Amazon EC2 console ]
1. Encontre a AWS ParallelCluster AMI que corresponde à específica Região da AWS que você usa. Para encontrá-la, você pode usar o [`pcluster list-official-images`](pcluster.list-official-images-v3.md)comando com o `--region` parâmetro para selecionar os `--architecture` parâmetros Região da AWS e `--os` e específicos para filtrar a AMI desejada com o sistema operacional e a arquitetura que você deseja usar. Na saída, recupere o ID da imagem do Amazon EC2.
1. Faça login no Console de gerenciamento da AWS e abra o console do Amazon EC2 em. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. No painel de navegação, escolha **Imagens** e, em seguida **AMIs**. Defina o filtro para **Imagens públicas** e pesquise a ID de imagem do EC2 recuperada, selecione a AMI e escolha **Executar**.
1. Escolha seu tipo de instância e selecione **Avançar: Configurar detalhes da instância**, ou **Revisar e iniciar** para iniciar sua instância.
1. Escolha **Executar**, selecione seu **par de chaves**, e **Executar instâncias**.
1. Faça login na instância usando o usuário do SO e chave SSH. Para obter mais informações, navegue até **Instâncias**, selecione a nova instância e **Conectar**.
1. Personalize manualmente sua instância para atender às suas necessidades.
1. Execute o seguinte comando para preparar a instância para a criação da AMI:
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. No console do Amazon EC2, escolha **Instâncias** no painel de navegação, selecione a nova instância, **Ações**, **Estado da instância** e **Interromper**.
1. [Crie uma nova AMI a partir da instância usando o console do Amazon EC2 ou AWS CLI create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Do console do Amazon EC2**
1. No painel de navegação, escolha **Instances (Instâncias)**.
1. Escolha a instância que você criou e modificou.
1. Em **Ações**, escolha **Imagem**, e, em seguida, **Criar imagem**.
1. Escolha **Create Image**.
1. Insira o ID de AMI no campo [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) na configuração do cluster e crie um cluster.
------
# Integração do Active Directory
Neste tutorial, você criará um ambiente de vários usuários. Esse ambiente inclui um AWS ParallelCluster que está integrado a um AWS Managed Microsoft AD (Active Directory) em`corp.example.com`. Você configura um usuário `Admin` para gerenciar o diretório, um usuário `ReadOnly` para ler o diretório e um usuário `user000` para fazer login no cluster. Você pode usar o caminho automatizado ou o caminho manual para criar os recursos de rede, um Active Directory (AD) e a instância do Amazon EC2 que você usa para configurar o AD. Independentemente do caminho, a infraestrutura que você cria é pré-configurada para ser integrada AWS ParallelCluster usando um dos seguintes métodos:
+ LDAPS com verificação de certificado (recomendado como a opção mais segura)
+ LDAPS sem verificação de certificado
+ LDAP
O LDAP por si só *não* fornece criptografia. Para garantir a transmissão segura de informações potencialmente confidenciais, é altamente recomendável que você use LDAPS (LDAP sobre TLS/SSL) para clusters integrados com o. ADs *Para obter mais informações, consulte [Habilitar o LDAPS do lado do servidor usando o AWS Managed Microsoft AD Guia](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html) de Administração. Directory Service *
Depois de criar esses recursos, continue configurando e criando seu cluster integrado ao Active Directory (AD). Após criar o cluster, faça login como o usuário que você criou. Para obter mais informações sobre a configuração que você cria neste tutorial, consulte [Acesso de vários usuários aos clusters](multi-user-v3.md) e a seção de configuração [`DirectoryService`](DirectoryService-v3.md).
Este tutorial aborda como criar um ambiente que ofereça suporte ao acesso de vários usuários aos clusters. Este tutorial não aborda como você cria e usa um Directory Service AD. As etapas que você segue para configurar um AWS Managed Microsoft AD neste tutorial são fornecidas somente para fins de teste. Eles *não são* fornecidos para substituir a documentação oficial e as melhores práticas que você pode encontrar no [AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html) e [Simple AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html) no * Guia de Administração do Directory Service *.
**nota**
As senhas de usuário do diretório expiram de acordo com as definições da propriedade da política de senha do diretório. Para redefinir as senhas do diretório com AWS ParallelCluster, consulte[Como redefinir uma senha de usuário e senhas expiradas](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd).
**nota**
Os endereços IP do controlador de domínio do diretório podem mudar devido às alterações do controlador de domínio e à manutenção do diretório. Se você escolheu o método automatizado de criação rápida para criar a infraestrutura de diretórios, deverá alinhar manualmente o balanceador de carga na frente dos controladores de diretório quando os endereços IP do diretório mudarem. Se você usar o método de criação rápida, os endereços IP do diretório não serão alinhados automaticamente com os balanceadores de carga.
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a CLI [`pcluster`](pcluster-v3.md).
Conforme você avança no tutorial, substitua`inputs highlighted in red`, como `region-id` e`d-abcdef01234567890`, por seus próprios nomes IDs e. `0123456789012`Substitua pelo seu Conta da AWS número.
# Crie a infraestrutura do AD
Escolha a guia *Automatizado* para criar a infraestrutura do Active Directory (AD) com um modelo de criação CloudFormation rápida.
Escolha a guia *Manual* para criar manualmente a infraestrutura do AD.
## Automatizado
1. Faça login no Console de gerenciamento da AWS.
1. Abra a [CloudFormation Criação Rápida (região us-east-1](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-ad&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/ad-integration.yaml)) para criar os seguintes recursos no console: CloudFormation
+ Uma VPC com duas sub-redes e roteamento para acesso público, se nenhuma VPC for especificada.
+ Um AWS Managed Microsoft AD.
+ Uma instância do Amazon EC2 associada ao AD que você pode usar para gerenciar o diretório.
1. Na seção **Parâmetros** da página de **pilha de criação rápida**, insira valores para os seguintes parâmetros:
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Anote a senha. Você precisará dela posteriormente neste tutorial.
1. Em **DomainName**, insira **corp.example.com**
1. Em **Keypair**, insira o nome do par de chaves do Amazon EC2.
1. Na parte inferior da página, marque as caixas de seleção que reconhecem cada um dos recursos de acesso.
1. Selecione **Criar pilha**.
1. Depois que a CloudFormation pilha atingir o `CREATE_COMPLETE` estado, escolha a guia **Saídas** da pilha. Anote os nomes dos recursos de saída e IDs porque você precisa usá-los em etapas posteriores. As saídas fornecem as informações necessárias para criar o cluster.
![\[Um diagrama que mostra as saídas da pilha criadas no Console de gerenciamento da AWS.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/ad-cfn.png)
1. Para concluir os exercícios [(Opcional) Gerenciar usuários e grupos do AD](tutorials_05_multi-user-ad-step2.md), você precisa do ID do diretório. Escolha **Recursos** e role para baixo para anotar o ID do diretório.
1. Continue em [(Opcional) Gerenciar usuários e grupos do AD](tutorials_05_multi-user-ad-step2.md) ou [Criar um cluster](tutorials_05_multi-user-ad-step3.md).
## Manual
Crie uma VPC no serviço de diretório com as duas sub-redes em diferentes zonas de disponibilidade e um AWS Managed Microsoft AD.
### Crie o AD
**nota**
O diretório e o nome do domínio são `corp.example.com`. O nome curto é `CORP`.
Altere a senha `Admin` no script.
O Active Directory (AD) leva pelo menos 15 minutos para ser criado.
Use o script Python a seguir para criar a VPC, as sub-redes e os recursos do AD em seu local. Região da AWS Salve esse arquivo como `ad.py` e execute-o.
```
import boto3
import time
from pprint import pprint
vpc_name = "PclusterVPC"
ad_domain = "corp.example.com"
admin_password = "asdfASDF1234"
ec2 = boto3.client("ec2")
ds = boto3.client("ds")
region = boto3.Session().region_name
# Create the VPC, Subnets, IGW, Routes
vpc = ec2.create_vpc(CidrBlock="10.0.0.0/16")["Vpc"]
vpc_id = vpc["VpcId"]
time.sleep(30)
ec2.create_tags(Resources=[vpc_id], Tags=[{"Key": "Name", "Value": vpc_name}])
subnet1 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.0.0/17", AvailabilityZone=f"{region}a")["Subnet"]
subnet1_id = subnet1["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet1_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet1"}])
ec2.modify_subnet_attribute(SubnetId=subnet1_id, MapPublicIpOnLaunch={"Value": True})
subnet2 = ec2.create_subnet(VpcId=vpc_id, CidrBlock="10.0.128.0/17", AvailabilityZone=f"{region}b")["Subnet"]
subnet2_id = subnet2["SubnetId"]
time.sleep(30)
ec2.create_tags(Resources=[subnet2_id], Tags=[{"Key": "Name", "Value": f"{vpc_name}/subnet2"}])
ec2.modify_subnet_attribute(SubnetId=subnet2_id, MapPublicIpOnLaunch={"Value": True})
igw = ec2.create_internet_gateway()["InternetGateway"]
ec2.attach_internet_gateway(InternetGatewayId=igw["InternetGatewayId"], VpcId=vpc_id)
route_table = ec2.describe_route_tables(Filters=[{"Name": "vpc-id", "Values": [vpc_id]}])["RouteTables"][0]
ec2.create_route(RouteTableId=route_table["RouteTableId"], DestinationCidrBlock="0.0.0.0/0", GatewayId=igw["InternetGatewayId"])
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsSupport={"Value": True})
ec2.modify_vpc_attribute(VpcId=vpc_id, EnableDnsHostnames={"Value": True})
# Create the Active Directory
ad = ds.create_microsoft_ad(
Name=ad_domain,
Password=admin_password,
Description="ParallelCluster AD",
VpcSettings={"VpcId": vpc_id, "SubnetIds": [subnet1_id, subnet2_id]},
Edition="Standard",
)
directory_id = ad["DirectoryId"]
# Wait for completion
print("Waiting for the directory to be created...")
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
while directory["Stage"] in {"Requested", "Creating"}:
time.sleep(3)
directories = ds.describe_directories(DirectoryIds=[directory_id])["DirectoryDescriptions"]
directory = directories[0]
dns_ip_addrs = directory["DnsIpAddrs"]
pprint({"directory_id": directory_id,
"vpc_id": vpc_id,
"subnet1_id": subnet1_id,
"subnet2_id": subnet2_id,
"dns_ip_addrs": dns_ip_addrs})
```
A seguir está um exemplo de saída do script do 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"
}
```
Anote os nomes dos recursos de saída IDs e. Você vai usá-los em etapas subsequentes.
Após concluir o script, avance para a próxima etapa.
### Criar uma instância do Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Faça login no Console de gerenciamento da AWS.
1. Se você não tiver uma função com as políticas listadas na etapa 4 em anexo, abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Caso contrário, vá para a etapa 5.
1. Crie a `ResetUserPassword` política, substituindo o conteúdo destacado em vermelho por seu Região da AWS ID, ID da conta e ID do diretório da saída do script que você executou para criar o AD.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Crie um perfil do IAM com as políticas a seguir anexada.
+ AWS política gerenciada [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS política gerenciada [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword política
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No **painel do Amazon EC2**, escolha **Executar instância**.
1. Em **Imagens de aplicações e sistemas operacionais**, selecione uma AMI recente do Amazon Linux 2.
1. Em **tipo de instância**, escolha t2.micro.
1. Em **par de chaves**, escolha um par de chaves.
1. Em **Configurações de rede**, escolha **Editar**.
1. Em **VPC**, selecione a VPC do diretório.
1. Role para baixo e selecione **Detalhes avançados**.
1. Em **Detalhes avançados**, **Diretório de ingresso em domínio**, escolha**corp.example.com**.
1. Para o **perfil de instância do IAM**, escolha a função que você criou na etapa 1 ou uma função com as políticas listadas na etapa 4 em anexo.
1. Em **Resumo**, escolha **Executar instância**.
1. Anote o ID da instância (por exemplo, i-1234567890abcdef0) e espere que a instância termine de ser executada.
1. Após a instância ser executada, vá para a próxima etapa.
------
#### [ Old Amazon EC2 console ]
1. Faça login no Console de gerenciamento da AWS.
1. Se você não tiver uma função com as políticas listadas na etapa 4 em anexo, abra o console do IAM em [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Caso contrário, vá para a etapa 5.
1. Crie a política `ResetUserPassword`. Substitua o conteúdo destacado em vermelho por sua Região da AWS Conta da AWS ID, ID e ID do diretório da saída do script que você executou para criar o Active Directory (AD).
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Crie um perfil do IAM com as políticas a seguir anexada.
+ AWS política gerenciada [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS política gerenciada [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ Política ResetUserPassword
1. Abra o console do Amazon EC2 em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. No **painel do Amazon EC2**, escolha **Executar instância**.
1. Em **Imagens de aplicações e sistemas operacionais**, selecione uma AMI recente do Amazon Linux 2.
1. Em **tipo de instância**, escolha t2.micro.
1. Em **par de chaves**, escolha um par de chaves.
1. Em **Configurações de rede**, escolha **Editar**.
1. Em **Configurações de rede**, **VPC**, selecione o diretório VPC.
1. Role para baixo e selecione **Detalhes avançados**.
1. Em **Detalhes avançados**, **Diretório de ingresso em domínio**, escolha**corp.example.com**.
1. Em **Detalhes avançados**, **Perfil da instância**, escolha a função que você criou na etapa 1 ou uma função com as políticas listadas na etapa 4 em anexo.
1. Em **Resumo**, escolha **Executar instância**.
1. Anote o ID da instância (por exemplo, i-1234567890abcdef0) e espere que a instância termine de ser executada.
1. Após a instância ser executada, vá para a próxima etapa.
------
### Associe sua instância ao AD
1.
**Conecte-se à sua instância e entre no realm do AD como `admin`.**
Execute os comandos a seguir para se conectar à instância.
```
$ 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.
**Instale o software necessário e entre no realm.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Substitua a senha do administrador pela sua senha `admin`.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Se o procedimento anterior tiver sido bem-sucedido, você se juntará ao realm e poderá avançar para a etapa seguinte.
### Adicionar usuários ao AD
1.
**Crie o ReadOnlyUser e um usuário adicional.**
Nesta etapa, você usa as ferramentas [adcli](https://www.mankier.com/package/adcli) e [openldap-clients](https://www.mankier.com/package/openldap-clients) que você instalou na etapa anterior.
```
$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=ReadOnlyUser ReadOnlyUser
```
```
$ echo $ADMIN_PW | adcli create-user -x -U Admin --domain=corp.example.com --display-name=user000 user000
```
1. **Verifique se os usuários foram criados:**
Os endereços IP DNS do diretório são saídas do 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"
```
Por padrão, quando você cria um usuário com o `ad-cli`, o usuário é desabilitado.
1.
****Redefina e ative as senhas de usuário da sua máquina local:****
Faça logout da instância do Amazon EC2.
**nota**
`ro-p@ssw0rd`é a senha de`ReadOnlyUser`, recuperada de AWS Secrets Manager.
`user-p@ssw0rd` é a senha de um usuário do cluster fornecida quando você se conecta (`ssh`) ao cluster.
`directory-id` é uma saída do 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. **Adicione a senha a um segredo do Secrets Manager.**
Agora que você criou `ReadOnlyUser` e definiu a senha, armazene-a em um segredo que seja AWS ParallelCluster usado para validar logins.
Use o Secrets Manager para criar um novo segredo para manter a senha do `ReadOnlyUser` como valor. O formato do valor secreto deve ser somente texto sem formatação (não no formato JSON). Anote o ARN secreto para futuras etapas.
```
$ 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
```
### LDAPS com configuração de verificação de certificado (recomendado)
Anote o recurso IDs. Você vai usá-los em etapas subsequentes.
1.
**Gere certificado de domínio localmente.**
```
$ 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.
**Armazene o certificado no Secrets Manager para torná-lo recuperável de dentro do cluster posteriormente.**
```
$ 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. Adicione a seguinte política ao perfil do IAM que você criou para unir a instância do Amazon EC2 ao domínio do AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Importe o certificado para 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.
**Crie um balanceador de carga que é colocado na frente dos endpoints do 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.
**Crie o grupo-alvo que tem como alvo os endpoints do Active Directory.**
```
$ aws elbv2 create-target-group --name CorpExampleCom-Targets --protocol TCP \
--port 389 \
--target-type ip \
--vpc-id vpc-021345abcdef6789 \
--region region-id
{
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
"TargetGroupName": "CorpExampleCom-Targets",
"Protocol": "TCP",
"Port": 389,
"VpcId": "vpc-021345abcdef6789",
"HealthCheckProtocol": "TCP",
"HealthCheckPort": "traffic-port",
"HealthCheckEnabled": true,
"HealthCheckIntervalSeconds": 30,
"HealthCheckTimeoutSeconds": 10,
"HealthyThresholdCount": 3,
"UnhealthyThresholdCount": 3,
"TargetType": "ip",
"IpAddressType": "ipv4"
}
]
}
```
1.
**Registre os endpoints do Active Directory (AD) no grupo de destino.**
```
$ aws elbv2 register-targets --target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
--targets Id=192.0.2.254,Port=389 Id=203.0.113.237,Port=389 \
--region region-id
```
1.
**Crie o receptor LB com o certificado.**
```
$ aws elbv2 create-listener --load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 \
--protocol TLS \
--port 636 \
--default-actions Type=forward,TargetGroupArn=arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 \
--ssl-policy ELBSecurityPolicy-TLS-1-2-2017-01 \
--certificates CertificateArn=arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 \
--region region-id
"Listeners": [
{
"ListenerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b",
"LoadBalancerArn": "arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4",
"Port": 636,
"Protocol": "TLS",
"Certificates": [
{
"CertificateArn": "arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72"
}
],
"SslPolicy": "ELBSecurityPolicy-TLS-1-2-2017-01",
"DefaultActions": [
{
"Type": "forward",
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81",
"ForwardConfig": {
"TargetGroups": [
{
"TargetGroupArn": "arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81"
}
]
}
}
]
}
]
}
```
1.
**Crie a zona hospedada para tornar o domínio detectável dentro da VPC do 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.
**Crie um arquivo chamado `recordset-change.json` com o conteúdo a seguir. O `HostedZoneId` é o ID de zona hospedada canônica do balanceador de carga.**
```
{
"Changes": [
{
"Action": "CREATE",
"ResourceRecordSet": {
"Name": "corp.example.com",
"Type": "A",
"Region": "region-id",
"SetIdentifier": "example-active-directory",
"AliasTarget": {
"HostedZoneId": "Z2IFOLAFXWLO4F",
"DNSName": "CorpExampleCom-NLB-3afe296bf4ba80d4.elb.region-id.amazonaws.com",
"EvaluateTargetHealth": true
}
}
}
]
}
```
1.
**Envie a alteração do conjunto de registros para a zona hospedada, desta vez usando o ID da zona hospedada.**
```
$ 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.
**Crie um documento de política `policy.json` com o conteúdo a seguir.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Crie um documento de política chamado `policy.json` com o conteúdo a seguir.**
```
$ 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. Continue seguindo as etapas em [(Opcional) Gerenciar usuários e grupos do AD](tutorials_05_multi-user-ad-step2.md) ou [Criar um cluster](tutorials_05_multi-user-ad-step3.md).
# (Opcional) Gerenciar usuários e grupos do AD
Nesta etapa, você gerencia usuários e grupos de uma instância do Amazon EC2 Amazon Linux 2 que está associada ao domínio Active Delivery (AD).
Se você seguiu o caminho *automatizado*, reinicie e faça login na instância associada ao AD que foi criada como parte da automação.
Se você seguiu o caminho *manual*, reinicie e faça login na instância que você criou e ingressou no AD nas etapas anteriores.
Nessas etapas, você usa as ferramentas [adcli](https://www.mankier.com/package/adcli) e [openldap-clients](https://www.mankier.com/package/openldap-clients) que foram instaladas na instância como parte da etapa anterior.
**Fazer login em uma instância do Amazon EC2 que esteja associada ao domínio do AD**
1. No console do Amazon EC2, selecione a instância sem título do Amazon EC2 criada nas etapas anteriores. A instância deve se encontrar no estado **Interrompido**.
1. Se o estado da instância for **Interrompido**, escolha **Estado da instância** e, em seguida, **Iniciar instância**.
1. Depois que as verificações de status forem aprovadas, selecione a instância e escolha **Conectar** e SSH na instância.
**Gerencie usuários e grupos quando conectados a uma instância do Amazon EC2 Linux 2 que ingressou no AD**
Ao executar os comandos `adcli` com a opção ` -U "Admin"`, você será solicitado a inserir a senha `Admin` do AD. Você inclui a senha `Admin` do AD como parte dos comandos `ldapsearch`.
1.
**Criar um usuário.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Defina uma senha de usuário.**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**Crie um grupo.**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**Adicione um usuário a um grupo.**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Descrever usuários e grupos.**
Descrever todos os usuários.
```
$ 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"
```
Descrever um usuário específico.
```
$ ldapsearch "(&(objectClass=user)(cn=clusteruser))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrever todos os usuários com um padrão de nome.
```
$ 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"
```
Descrever todos os usuários que fazem parte de um grupo específico.
```
$ ldapsearch "(&(objectClass=user)(memberOf=CN=clusterteam,OU=Users,OU=CORP,DC=corp,DC=example,DC=com))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
Descrever todos os grupos
```
$ 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"
```
Descrever um grupo específico
```
$ ldapsearch "(&(objectClass=group)(cn=clusterteam))" -x -h "192.0.2.254" -b "DC=corp,DC=example,DC=com" -D "CN=Admin,OU=Users,OU=CORP,DC=corp,DC=example,DC=com" -w "p@ssw0rd"
```
1.
**Remover um usuário de um grupo.**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Excluem um usuário.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Exclua um grupo.**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# Criar um cluster
Se você ainda não saiu da instância do Amazon EC2, faça isso agora.
O ambiente está configurado para criar um cluster que possa autenticar usuários no Active Directory (AD).
Crie uma configuração de cluster simples e forneça as configurações relevantes para se conectar ao AD. Para obter mais informações, consulte a seção [`DirectoryService`](DirectoryService-v3.md).
Escolha uma das seguintes configurações de cluster e copie-a em um arquivo chamado `ldaps_config.yaml`, `ldaps_nocert_config.yaml`, ou `ldap_config.yaml`.
Recomendamos que você escolha a configuração LDAPS com verificação de certificado. Se você escolher essa configuração, também deverá copiar o script de bootstrap em um arquivo chamado `active-directory.head.post.sh`. E você deve armazená-lo em um bucket do Amazon S3, conforme indicado no arquivo de configuração.
## LDAPS com configuração de verificação de certificado (recomendado)
**nota**
`KeyName`: um dos seus pares de chaves do Amazon EC2.
`SubnetId / SubnetIds`: uma das sub-redes IDs fornecidas na saída da pilha de criação CloudFormation rápida (tutorial automatizado) ou do script python (tutorial manual).
`Region`: A região em que você criou a infraestrutura do AD.
`DomainAddr`: Esse endereço IP é um dos endereços DNS do seu serviço AD.
`PasswordSecretArn`: O nome de recurso da Amazon (ARN) do segredo que contém a senha para o `DomainReadOnlyUser`.
`BucketName`: o nome do bucket que contém o script de bootstrap.
`AdditionalPolicies`/`Policy`: O Amazon Resource Name (ARN) da política de certificação de domínio lido. ReadCertExample
`CustomActions` / `OnNodeConfigured` / `Args`: O nome de recurso da Amazon (ARN) do segredo que contém a política de certificação de domínio.
Para uma melhor postura de segurança, sugerimos usar a configuração `HeadNode`/`Ssh`/`AllowedIps` para limitar o acesso SSH ao nó principal.
Observe que o certificado especificado em `LdapTlsCaCert` deve estar acessível a todos os nós do cluster.
**Requisitos rígidos**
O certificado especificado em `LdapTlsCaCert` deve estar acessível a todos os nós do cluster.
Um nó sem acesso ao certificado não conseguirá resolver usuários do diretório.
```
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 de bootstrap**
Depois de criar o arquivo bootstrap e antes de carregá-lo no bucket do S3, execute `chmod +x active-directory.head.post.sh` para dar permissão de AWS ParallelCluster execução.
```
#!/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 sem configuração de verificação de certificado
**nota**
`KeyName`: um dos seus pares de chaves do Amazon EC2.
`SubnetId / SubnetIds`: uma das sub-redes IDs que está na saída da pilha de criação CloudFormation rápida (tutorial automatizado) ou do script python (tutorial manual).
`Region`: A região em que você criou a infraestrutura do AD.
`DomainAddr`: Esse endereço IP é um dos endereços DNS do seu serviço AD.
`PasswordSecretArn`: O nome de recurso da Amazon (ARN) do segredo que contém a senha para o `DomainReadOnlyUser`.
Para uma melhor postura de segurança, sugerimos usar a AllowedIps configuração HeadNode /Ssh/ para limitar o acesso SSH ao nó 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
```
## Configuração LDAP
**nota**
`KeyName`: um dos seus pares de chaves do Amazon EC2.
`SubnetId / SubnetIds`: uma das sub-redes IDs fornecidas na saída da pilha de criação CloudFormation rápida (tutorial automatizado) ou do script python (tutorial manual).
`Region`: A região em que você criou a infraestrutura do AD.
`DomainAddr`: Esse endereço IP é um dos endereços DNS do seu serviço AD.
`PasswordSecretArn`: O nome de recurso da Amazon (ARN) do segredo que contém a senha para o `DomainReadOnlyUser`.
Para uma melhor postura de segurança, sugerimos usar a AllowedIps configuração HeadNode /Ssh/ para limitar o acesso SSH ao nó 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
```
Crie o cluster usando o comando a seguir.
```
$ 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"
}
}
```
# Conectar ao cluster como usuário
Você pode determinar o status do cluster com os comandos a seguir.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
A saída é a seguinte:
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
Quando o status chegar a `"CREATE_COMPLETE"`, faça login com o nome de usuário e a senha criados.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
Você pode fazer login sem a senha fornecendo a chave SSH que foi criada para o novo usuário em `/home/user000@HEAD_NODE_IP/.ssh/id_rsa`.
Se o comando `ssh` for bem-sucedido, você se conectou com êxito ao cluster como um usuário autenticado para usar o Active Directory (AD).
# Limpeza
1.
**Na sua máquina local, exclua o 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.
**Verifique o progresso do cluster que está sendo excluído.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Após excluir o cluster com sucesso, avance para a próxima etapa.
## Automatizada
**Excluir os recursos do Active Directory**
1. De [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/).
1. No painel de navegação, escolha **Pilhas**.
1. Na lista de pilhas, escolha a pilha AD (por exemplo, `pcluster-ad`).
1. Escolha **Excluir**.
## Manual
1.
**Encerre a instância do Amazon EC2.**
1. Em [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/), escolha **Instâncias** no painel de navegação.
1. Na lista de instâncias, selecione a instância que você criou para adicionar usuários ao diretório.
1. Escolha **Estado da instância** e **Terminar instância**.
1.
**Excluir a zona hospedada.**
1. Crie um `recordset-delete.json`, com o seguinte conteúdo. Neste exemplo, HostedZoneId é o ID canônico da zona hospedada do balanceador de carga.
```
{
"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. Envie a alteração do conjunto de registros para a zona hospedada usando o ID da zona hospedada.
```
$ 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. Excluir a zona hospedada.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**Exclui o receptor do LB.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**Excluir um grupo de destino.**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**Excluir o balanceador de carga.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**Excluir a política que o cluster usa para ler o certificado do Secrets Manager.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**Excluir o segredo que contém o certificado de domínio.**
```
$ 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.
**Excluir o certificado do ACM.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Excluir os recursos do Active Directory (AD).**
1. Obtenha o seguinte recurso IDs da saída do script `ad.py` python:
+ ID AD
+ Sub-rede AD IDs
+ ID VPC AD
1. Exclua o diretório executando o comando a seguir.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. Liste os grupos de segurança na VPC.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. Exclua o grupo de segurança personalizado.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. Exclua as sub-redes.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. Descreva o gateway da 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. Separe o gateway da Internet.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Exclua o gateway da internet.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. Exclua a VPC.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Exclua o segredo que contém a senha `ReadOnlyUser`.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# Configurando a criptografia de armazenamento compartilhado com uma chave AWS KMS
Saiba como configurar uma AWS KMS chave gerenciada pelo cliente para criptografar e proteger seus dados nos sistemas de armazenamento de arquivos em cluster para AWS ParallelCluster os quais estão configurados.
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster suporta as seguintes opções de configuração de armazenamento compartilhado:
+ [`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)
Você pode usar essas opções para fornecer uma AWS KMS chave gerenciada pelo cliente para o Amazon EBS, o Amazon EFS e FSx para a criptografia do sistema de armazenamento compartilhado Lustre. Para usá-los, você deve criar e configurar uma política do IAM para o seguinte:
+ [`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)
**Pré-requisitos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
**Topics**
+ [Crie a política do](creating-the-role-v3.md)
+ [Configurar e criar o cluster](creating-the-cluster-v3.md)
# Crie a política do
Neste tutorial, você criará uma política para configurar a criptografia de armazenamento compartilhado com uma AWS KMS chave.
**Crie uma política.**
1. Acesse o console do IAM: [https://console.aws.amazon.com/iam/página inicial](https://console.aws.amazon.com/iam/home).
1. Selecione **Políticas**.
1. Selecione **Criar política**.
1. Selecione a guia **JSON** e cole a política a seguir. Certifique-se de substituir todas as ocorrências de `123456789012` pelo seu Conta da AWS ID e pela chave Amazon Resource Name (ARN) Região da AWS e pelo seu próprio.
------
#### [ 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. Nesse tutorial, crie um nome para a política `ParallelClusterKmsPolicy` e escolha **Criar política**.
1. Anote o ARN da política. Você precisará dele para configurar seu cluster.
# Configurar e criar o cluster
Veja a seguir um exemplo de configuração de cluster que inclui um sistema de arquivos compartilhado Amazon Elastic Block Store com criptografia.
```
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
```
Substitua os itens em vermelho por seus próprios valores. Em seguida, crie um cluster que use sua AWS KMS chave para criptografar seus dados no Amazon EBS.
A configuração é semelhante para o Amazon EFS e FSx para os sistemas de arquivos Lustre.
A configuração `SharedStorage` do Amazon EFS é a seguinte.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
A `SharedStorage` configuração do FSx for Lustre é a seguinte.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# Executando trabalhos em um cluster de modo de várias filas
Este tutorial aborda como executar seu primeiro trabalho "Hello World" no [modo AWS ParallelCluster de várias filas](configuration-of-multiple-queues-v3.md).
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
## Configure seu cluster
Primeiro, verifique se AWS ParallelCluster está instalado corretamente executando o comando a seguir.
```
$ pcluster version
```
Para saber mais sobre o `pcluster version`, consulte [`pcluster version`](pcluster.version-v3.md).
Esse comando retorna a versão em execução do AWS ParallelCluster.
Em seguida, execute o `pcluster configure` para gerar um arquivo de configuração básico. Siga todas as instruções que seguem esse comando.
```
$ pcluster configure --config multi-queue-mode.yaml
```
Para obter mais informações sobre o comando `pcluster configure`, consulte [`pcluster configure`](pcluster.configure-v3.md).
Depois de concluir esta etapa, um arquivo de configuração básico chamado `multi-queue-mode.yaml` é exibido. Esse arquivo contém uma configuração básica de cluster.
Na próxima etapa, você modifica seu novo arquivo de configuração e inicia um cluster com várias filas.
**nota**
Algumas instâncias que este tutorial usa não são elegíveis para o nível gratuito.
Para este tutorial, modifique seu arquivo de configuração para que corresponda à configuração a seguir. Os itens destacados em vermelho representam os valores do arquivo de configuração. Mantenha seus próprios valores.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: yourkeypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: spot
ComputeResources:
- Name: c5xlarge
InstanceType: c5.xlarge
MinCount: 1
MaxCount: 10
- Name: t2micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
- Name: ondemand
ComputeResources:
- Name: c52xlarge
InstanceType: c5.2xlarge
MinCount: 0
MaxCount: 10
Networking:
SubnetIds:
- subnet-021345abcdef6789
```
## Crie seu cluster do
Crie um cluster chamado `multi-queue-cluster` com base no seu arquivo de configuração.
```
$ pcluster create-cluster --cluster-name multi-queue-cluster --cluster-configuration multi-queue-mode.yaml
{
"cluster": {
"clusterName": "multi-queue-cluster",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:eu-west-1:123456789012:stack/multi-queue-cluster/1234567-abcd-0123-def0-abcdef0123456",
"region": "eu-west-1",
"version": "3.15.0",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Para obter mais informações sobre o comando `pcluster create-cluster`, consulte [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
Para verificar o status do cluster, execute o comando a seguir.
```
$ 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"
}
}
```
Quando o cluster é criado, o campo `clusterStatus` exibe `CREATE_COMPLETE`.
## Faça o login no nó principal.
Use seu arquivo de chave SSH privada para fazer login no nó principal.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
Para saber mais sobre o `pcluster ssh`, consulte [`pcluster ssh`](pcluster.ssh-v3.md).
Depois de fazer login, execute o comando `sinfo` para verificar se suas filas do programador estão definidas e configuradas.
Para obter mais informações sobre `sinfo`, consulte [sinfo](https://slurm.schedmd.com/sinfo.html) na documentação *Slurm*.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
spot* up infinite 18 idle~ spot-dy-c5xlarge-[1-9],spot-dy-t2micro-[1-9]
spot* up infinite 2 idle spot-st-c5xlarge-1,spot-st-t2micro-1
ondemand up infinite 10 idle~ ondemand-dy-c52xlarge-[1-10]
```
A saída mostra que você tem um `t2.micro` e um nó de computação `c5.xlarge` no estado `idle` que estão disponíveis no seu cluster.
Todos os outros nós estão no estado de economia de energia, indicado pelo sufixo `~` no estado do nó, sem nenhuma instância do Amazon EC2 dando suporte. A fila padrão é indicada por um sufixo `*` após o nome da fila. A `spot` é sua fila de trabalhos padrão.
## Executar trabalho no modo de várias filas
Em seguida, tente fazer com que o trabalho fique em latência por um tempo. Posteriormente, o trabalho gera seu próprio nome de host. Certifique-se de que esse script possa ser executado pelo usuário atual.
```
$ tee <
Neste tutorial, você cria e testa a API com o [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) e um AWS ParallelCluster CloudFormation modelo. Em seguida, você usa o cliente de exemplo disponível GitHub para usar a API. Para obter mais informações sobre como usar a API, consulte a [AWS ParallelCluster API](api-reference-v3.md).
Para obter mais informações, consulte [Criar um componente personalizado com o Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) no *Guia do usuário do EC2 Image Builder*.
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos**
+ O AWS CLI é [instalado](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) e configurado em seu ambiente computacional.
+ AWS ParallelCluster é instalado em um ambiente virtual. Para obter mais informações, consulte [Instalar AWS ParallelCluster em um ambiente virtual (recomendado)](install-v3-virtual-environment.md).
+ Você tem um [par de EC2 chaves da Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
## Etapa 1: criar a API com o Amazon API Gateway
**Fique no seu diretório de usuários domésticos e ative seu ambiente virtual:**
1. Instale um processador de linha de comando JSON útil.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. Execute o comando a seguir para obter sua AWS ParallelCluster versão e atribuí-la a uma variável de ambiente.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. Crie uma variável de ambiente e atribua seu ID de região a ela.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. Execute o comando a seguir para implantar a 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"
}
```
Depois que o processo estiver concluído, avance para a próxima etapa.
## Etapa 2: testar a API no console do Amazon API Gateway
1. Faça login no Console de gerenciamento da AWS.
1. Vá até o [console do Amazon API Gateway](https://console.aws.amazon.com/apigateway/home).
1. Escolha sua implantação de API.
![\[Console do Amazon API Gateway com uma lista dos seus gateways que você pode escolher.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/gateway_choose.png)
1. Escolha **Stages** e selecione um estágio.
![\[Uma visão de console dos estágios que você pode escolher. Você também pode ver o URL que o Gateway de API fornece para sua API.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/gateway_address.png)
1. Observe a URL que o Gateway de API fornece para acessar ou invocar sua API. Está destacado em azul.
1. Escolha **Recursos** e selecione **`GET`** em**`/clusters`**.
1. Escolha o ícone de **TESTE** e, em seguida, role para baixo e escolha o ícone de **TESTE**.
![\[Uma visão de console dos recursos da API e dos mecanismos de teste.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/gateway_test.png)
A resposta à sua `/clusters GET` aparece.
![\[Uma visão de console dos recursos da API, dos mecanismos de teste e da resposta da sua solicitação de teste.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/gateway.png)
## Etapa 3: preparar e testar um cliente de exemplo para invocar a API
Clone o AWS ParallelCluster código-fonte `cd` até o `api` diretório e instale as bibliotecas de cliente do Python.
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. Navegue de volta ao seu diretório de usuário inicial.
1. Exporte a URL base do Gateway de API que o cliente usa durante a execução.
```
$ export PCLUSTER_API_URL=$( aws cloudformation describe-stacks --stack-name ${API_STACK_NAME} --query 'Stacks[0].Outputs[?OutputKey==`ParallelClusterApiInvokeUrl`].OutputValue' --output text )
echo "export PCLUSTER_API_URL=${PCLUSTER_API_URL}" |tee -a ~/.bashrc
```
1. Exporte um nome de cluster que o cliente usa para criar um cluster.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. Execute os comandos a seguir para armazenar as credenciais que o cliente de exemplo usa para acessar a 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
```
## Etapa 4: copiar o script do código do cliente e executar testes de cluster
1. Copie o seguinte exemplo de código de cliente para o `test_pcluster_client.py` no seu diretório de usuário inicial. O código do cliente faz solicitações para fazer o seguinte:
+ Crie o cluster.
+ Descrever o cluster.
+ Listar os clusters.
+ Descrever a frota de computação.
+ Descrever as instâncias do 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. Criar uma configuração do cluster.
```
$ pcluster configure --config cluster-config.yaml
```
1. A biblioteca de cliente da API detecta automaticamente os detalhes da configuração de suas variáveis de ambiente (por exemplo `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`, ou `AWS_SESSION_TOKEN`) ou `$HOME/.aws`. O comando a seguir muda seu perfil atual do IAM para o ParallelClusterApiUserRole designado.
```
$ eval $(aws sts assume-role --role-arn ${PCLUSTER_API_USER_ROLE} --role-session-name ApiTestSession | jq -r '.Credentials | "export AWS_ACCESS_KEY_ID=\(.AccessKeyId)\nexport AWS_SECRET_ACCESS_KEY=\(.SecretAccessKey)\nexport AWS_SESSION_TOKEN=\(.SessionToken)\n"')
```
**Erro a ser observado:**
Se você vir um erro semelhante ao seguinte, você já presumiu que o ParallelClusterApiUserRole e o seu `AWS_SESSION_TOKEN` expiraram.
```
An error occurred (AccessDenied) when calling the AssumeRole operation:
User: arn:aws:sts::XXXXXXXXXXXX:assumed-role/ParallelClusterApiUserRole-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX/ApiTestSession
is not authorized to perform: sts:AssumeRole on resource: arn:aws:iam::XXXXXXXXXXXX:role/ParallelClusterApiUserRole-XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
```
Elimine a função e execute novamente o comando `aws sts assume-role` para usar o ParallelClusterApiUserRole.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
Para fornecer suas permissões de usuário atuais para acesso à API, você deve [expandir a Política de Recursos](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html).
1. Execute o seguinte comando para testar o cliente de exemplo.
```
$ 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!
```
## Etapa 5: copiar o script do código do cliente e excluir cluster
1. Copie o seguinte código de cliente de exemplo para `delete_cluster_client.py`. O código do cliente faz uma solicitação para excluir o 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. Execute o comando a seguir para excluir o 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. Depois de terminar o teste, desfaça a definição das variáveis de ambiente.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## Etapa 6: limpar
Você pode usar o Console de gerenciamento da AWS ou AWS CLI para excluir sua API.
1. No CloudFormation console, escolha a pilha de API e, em seguida, escolha **Excluir**.
1. Se estiver usando o AWS CLI, execute o comando a seguir.
Usando CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Criação de um cluster com Slurm contabilidade
Saiba como configurar e criar um cluster com Slurm contabilidade. Para obter mais informações, consulte [Slurmcontabilidade com AWS ParallelCluster](slurm-accounting-v3.md).
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
Neste tutorial, você usa um [modelo de criação CloudFormation rápida (us-east-1) para criar um banco de dados sem servidor para](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml) MySQL. [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) O modelo instrui CloudFormation a criar todos os componentes necessários para implantar um banco de dados Amazon Aurora sem servidor na mesma VPC do cluster. O modelo também cria uma configuração básica de rede e segurança para a conexão entre o cluster e o banco de dados.
**nota**
A partir da versão 3.3.0, suporta AWS ParallelCluster Slurm contabilidade com o parâmetro de configuração do cluster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[Database](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database).
**nota**
O modelo de criação rápida serve como exemplo. Este modelo não abrange todos os casos de uso possíveis para um Slurm servidor de banco de dados contábil. É sua responsabilidade criar um servidor de banco de dados com a configuração e a capacidade adequadas para suas workloads de produção.
**Pré-requisitos:**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de EC2 chaves da Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
+ A região na qual você implanta o modelo de criação rápida oferece suporte à Amazon Aurora MySQL serverless v2. Para ter mais informações, consulte [Aurora Serverless v2 com 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).
## Etapa 1: criar a VPC e as sub-redes para AWS ParallelCluster
Para usar o CloudFormation modelo fornecido para o Slurm banco de dados contábil, você deve ter a VPC do cluster pronta. Você pode fazer isso manualmente ou como parte do procedimento [Configure e crie um cluster com a interface de linha de AWS ParallelCluster comando](install-v3-configuring.md). Se você já usou o AWS ParallelCluster, talvez tenha uma VPC pronta para a implantação do cluster e do servidor de banco de dados.
## Etapa 2: criar a pilha de banco de dados
Use o [modelo de criação CloudFormation rápida (us-east-1) para criar](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) uma pilha de banco de dados para Slurm contabilidade. O modelo requer as seguintes entradas:
+ Credenciais do servidor de banco de dados, especificamente o nome de usuário e senha do administrador.
+ Dimensionamento do cluster sem Amazon Aurora servidor. Isso depende do carregamento esperado do cluster.
+ Parâmetros de rede, especificamente a VPC e as sub-redes de destino ou blocos CIDR para a criação das sub-redes.
Selecione as credenciais e o tamanho apropriados para seu servidor de banco de dados. Para as opções de rede, você precisa usar a mesma VPC na qual o cluster AWS ParallelCluster está implantado. Você pode criar as sub-redes para o banco de dados e passá-las como entrada para o modelo. Ou forneça dois blocos CIDR separados para as duas sub-redes e deixe o CloudFormation modelo criar as duas sub-redes para blocos CIDR. Certifique-se de que os blocos CIDR não se sobreponham às sub-redes existentes. Se os blocos CIDR se sobrepuserem às sub-redes existentes, a pilha não será criada.
O servidor de banco de dados leva vários minutos para ser criado.
## Etapa 3: criar um cluster com Slurm contabilidade ativada
O CloudFormation modelo fornecido gera uma CloudFormation pilha com algumas saídas definidas. A partir do Console de gerenciamento da AWS, você pode visualizar as saídas na guia **Saídas** na visualização da CloudFormation pilha. Para habilitar o Slurm contabilidade, algumas dessas saídas devem ser usadas no arquivo de configuração do AWS ParallelCluster cluster:
+ `DatabaseHost`: usado para o parâmetro de configuração do cluster [`SlurmSettings`](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database) / [`Uri`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-Uri).
+ `DatabaseAdminUser`: usado para o valor do parâmetro de configuração do cluster [`SlurmSettings`](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database) / [`UserName`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-UserName).
+ `DatabaseSecretArn`: usado para o parâmetro de configuração do cluster [`SlurmSettings`](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database) / [`PasswordSecretArn`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-PasswordSecretArn).
+ `DatabaseClientSecurityGroup`: esse é o grupo de segurança anexado ao nó do cabeçalho do cluster definido no parâmetro de configuração [`HeadNode`](HeadNode-v3.md) / [`Networking`](HeadNode-v3.md#HeadNode-v3-Networking) / [`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups).
Atualize os parâmetros `Database` do arquivo de configuração do cluster com os valores de saída. Use a [`pcluster`](pcluster-v3.md) CLI para criar um cluster.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
Depois que o cluster for criado, você poderá começar a usar Slurm comandos contábeis, como `sacctmgr` ou`sacct`.
# Criando um cluster com um externo Slurmdbd contabilidade
Saiba como configurar e criar um cluster com recursos externos Slurmdbd contabilidade. Para obter mais informações, consulte [.Slurm contabilidade com AWS ParallelCluster](slurm-accounting-v3.md).
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
A AWS ParallelCluster interface do usuário é construída em uma arquitetura sem servidor e você pode usá-la no AWS Free Tier categoria para a maioria dos casos. Para ter mais informações, consulte [AWS ParallelCluster UI costs](install-pcui-costs-v3.md).
Neste tutorial, você usa um modelo de AWS CloudFormation criação rápida para criar os componentes necessários para implantar uma instância do Slurmdbd na mesma VPC do cluster. O modelo cria uma configuração básica de rede e segurança para a conexão entre o cluster e o banco de dados.
**nota**
Começando com`version 3.10.0`, AWS ParallelCluster oferece suporte ao Slurmdbd externo com o parâmetro de configuração do cluster. `SlurmSettings / ExternelSlurmdbd`
**nota**
O modelo de criação rápida serve como exemplo. Esse modelo não abrange todos os casos de uso possíveis. É sua responsabilidade criar um Slurmdbd externo com a configuração e capacidade apropriadas para seus workloads de produção.
**Pré-requisitos:**
+ AWS ParallelCluster [está instalado](install-v3-parallelcluster.md).
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um [par de chaves do Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Você tem uma AWS Identity and Access Management função com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
+ Você tem um Slurm banco de dados contábil. Para percorrer um tutorial de criação Slurm banco de dados contábil, siga as etapas 1 e 2 em [Criar a pilha do Slurm Accounting Database](tutorials_07_slurm-accounting-v3.md).
## Etapa 1: criar a pilha do Slurmdbd
Neste tutorial, use um [modelo de CloudFormation criação rápida (`us-east-1`) para criar](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) uma pilha do Slurmdbd. O modelo requer as seguintes entradas:
**Redes**
+ **VPCId**: o ID da VPC para iniciar a instância do Slurmdbd.
+ **SubnetId**: o ID da sub-rede para iniciar a instância do Slurmdbd.
+ **PrivatePrefix**: o prefixo CIDR da VPC.
+ **PrivateIp**: um IP privado secundário a ser atribuído à instância do Slurmdbd.
**Conexão de banco de dados**
+ **DBMSClientSG**: O grupo de segurança a ser anexado à instância do Slurmdbd. Este grupo de segurança deve permitir conexões entre o servidor do banco de dados e a instância do Slurmdbd.
+ **DBMSDatabaseNome**: O nome do banco de dados.
+ **DBMSUsername**: O nome de usuário do banco de dados.
+ **DBMSPasswordSecretArn**: O segredo que contém a senha do banco de dados.
+ **DBMSUri**: o URI do servidor de banco de dados.
**Configurações das instâncias**
+ **InstanceType**: um tipo de instância a ser usado para a instância slurmdbd.
+ **KeyName**: um par de EC2 chaves da Amazon para usar na instância slurmdbd.
**Configurações do Slurmdbd**
+ **AMIID**: uma AMI da instância do Slurmdbd. A AMI deve ser uma ParallelCluster AMI. A versão da ParallelCluster AMI determina a versão do Slurmdbd.
+ **MungeKeySecretArn**: o segredo que contém a chave munge a ser usada para autenticar as comunicações entre o Slurmdbd e os clusters.
+ **SlurmdbdPort**: um número de porta que o slurmdbd usa.
+ **EnableSlurmdbdSystemService**: ativa o slurmdbd como serviço do sistema e o executa quando uma instância é iniciada.
**Atenção**
Se o banco de dados foi criado por uma versão diferente do SlurmDB, não use Slurmdbd como um serviço do sistema.
Se o banco de dados contiver um grande número de entradas, o Slurm Database Daemon (SlurmDBD) pode exigir dezenas de minutos para atualizar o banco de dados e não responder durante esse intervalo de tempo.
Antes da atualização SlurmDB, faça um backup do banco de dados. Para obter mais informações, consulte o [.Slurm documentação](https://slurm.schedmd.com/quickstart_admin.html#upgrade).
## Etapa 2: criar um cluster com recursos externos Slurmdbd habilitado
O CloudFormation modelo fornecido gera uma CloudFormation pilha com algumas saídas definidas.
Em Console de gerenciamento da AWS, visualize a guia **Saídas** na CloudFormation pilha para revisar as entidades criadas. Para habilitar o Slurm contabilidade, algumas dessas saídas devem ser usadas no AWS ParallelCluster arquivo de configuração:
+ **SlurmdbdPrivateIp**: usado para o parâmetro de [configuração do 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**: usado para o valor do parâmetro de configuração do 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**: esse é o grupo de segurança anexado ao nó principal do cluster definido no parâmetro [HeadNode](HeadNode-v3.md)/[Networking](HeadNode-v3.md#HeadNode-v3-Networking)/[AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups)configuration.
Além disso, na guia **Parâmetros** na visualização da CloudFormation pilha:
+ **MungeKeySecretArn**: usado para o valor do [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)parâmetro de configuração do [MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn)cluster/.
Atualize os parâmetros do banco de dados do arquivo de configuração do cluster com os valores de saída. Use o pcluster AWS CLI para criar o cluster.
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
Depois que o cluster for criado, você poderá começar a usar Slurm comandos contábeis, como `sacctmgr` ou`sacct`.
**Atenção**
Tráfego entre `ParallelCluster` e o externo SlurmDB não está criptografado. É recomendável executar o cluster e o externo SlurmDB em uma rede confiável.
# Revertendo para uma versão anterior do documento do AWS Systems Manager
Saiba como reverter para uma versão anterior do documento do AWS Systems Manager. Para obter mais informações, consulte [Documentos do AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html) no *Guia do usuário do AWS Systems Manager*.
Ao usar a interface de linha de AWS ParallelCluster comando (CLI) ou a API, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos:**
+ E Conta da AWS com permissões para gerenciar documentos SSM.
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
## Reverter para uma versão anterior do documento SSM
1. No seu terminal, execute o comando a seguir para obter a lista de documentos SSM existentes que você possui.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. Reverter para uma versão anterior do documento SSM. Neste exemplo, revertemos para uma versão anterior do documento `SessionManagerRunShell`. Você pode usar o documento `SessionManagerRunShell` SSM para personalizar cada sessão de shell SSM que você inicia.
1. Encontre o parâmetro `DocumentVersion` para `SessionManagerRunShell` executando o seguinte comando:
```
$ aws ssm describe-document --name "SSM-SessionManagerRunShell"
{
"Document": {
"Hash": "...",
"HashType": "Sha256",
"Name": "SSM-SessionManagerRunShell",
"Owner": "123456789012",
"CreatedDate": "2023-02-20T19:04:32.390000+00:00",
"Status": "Active",
"DocumentVersion": "1",
"Parameters": [
{
"Name": "linuxcmd",
"Type": "String",
"Description": "The command to run on connection...",
"DefaultValue": "if [ -d '/opt/parallelcluster' ]; then source /opt/parallelcluster/cfnconfig; sudo su - $cfn_cluster_user; fi; /bin/bash"
}
],
"PlatformTypes": [
"Windows",
"Linux",
"MacOS"
],
"DocumentType": "Session",
"SchemaVersion": "1.0",
"LatestVersion": "2",
"DefaultVersion": "1",
"DocumentFormat": "JSON",
"Tags": []
}
}
```
A versão mais recente é `2`.
1. Reverta para a versão anterior executando o seguinte comando:
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. Verifique se a versão do documento foi revertida executando o comando `describe-document` novamente:
```
$ 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": []
}
}
```
A versão mais recente é `1`.
# Criando um cluster com CloudFormation
Saiba como criar um cluster com um recurso AWS ParallelCluster CloudFormation personalizado. Para obter mais informações, consulte [AWS CloudFormation recurso personalizado](cloudformation-v3.md).
Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos:**
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
## Criação de clusters com uma pilha de criação CloudFormation rápida
Neste tutorial, você usa uma pilha de criação rápida para implantar um CloudFormation modelo que cria um cluster e os seguintes recursos: AWS
+ Uma CloudFormation pilha raiz criada usando uma pilha de criação CloudFormation rápida.
+ CloudFormation Pilhas aninhadas que incluem políticas padrão, configuração padrão de VPC e um provedor de recursos personalizado.
+ Um exemplo AWS ParallelCluster de pilha de clusters e um cluster no qual você pode fazer login e executar trabalhos.
**Crie um cluster com AWS CloudFormation**
1. Faça login no Console de gerenciamento da AWS.
1. Abra o [link CloudFormation de criação rápida](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=mycluster&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/parallelcluster/3.15.0/templates/1-click/cluster-example.yaml) para criar os seguintes recursos no CloudFormation console:
+ Uma CloudFormation pilha aninhada com uma VPC com uma sub-rede pública e privada para executar o nó principal do cluster e os nós de computação, respectivamente.
+ Uma CloudFormation pilha aninhada com um recurso AWS ParallelCluster personalizado para gerenciar o cluster.
+ Uma CloudFormation pilha aninhada com as políticas padrão para gerenciar o cluster.
+ Uma CloudFormation pilha raiz para as pilhas aninhadas.
+ Um AWS ParallelCluster cluster com o Slurm agendador e um número definido de nós de computação.
![\[A interface de usuário de CloudFormation criação rápida do console.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. Na seção **Parâmetros** de **pilha de criação rápida**, insira valores para os seguintes parâmetros:
1. Para **KeyName**, insira o nome do seu par de chaves do Amazon EC2.
1. Para **AvailabilityZone**, escolha uma AZ para seus nós de cluster, por exemplo,`us-east-1a`.
1. Na parte inferior da página, marque as caixas de seleção que reconhecem cada um dos recursos de acesso.
1. Selecione **Criar pilha**.
1. Aguarde até que a CloudFormation pilha alcance o `CREATE_COMPLETE` estado.
## Criação de clusters com a interface de linha de CloudFormation comando (CLI)
Neste tutorial, você usa a interface de linha de AWS comando (CLI) para CloudFormation implantar um CloudFormation modelo que cria um cluster.
**Crie os seguintes AWS recursos:**
+ Uma CloudFormation pilha raiz criada usando uma pilha de criação CloudFormation rápida.
+ CloudFormation Pilhas aninhadas que incluem políticas padrão, configuração padrão de VPC e um provedor de recursos personalizado.
+ Um exemplo AWS ParallelCluster de pilha de clusters e um cluster no qual você pode fazer login e executar trabalhos.
Substitua*inputs highlighted in red*, por exemplo*keypair*, por seus próprios valores.
**Crie um cluster com AWS CloudFormation**
1. Crie um CloudFormation modelo chamado `cluster_template.yaml` com o seguinte conteúdo:
```
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. Execute o seguinte comando da AWS CLI para implantar a CloudFormation pilha para criação e gerenciamento 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
```
## Exibir saída CloudFormation do cluster
Visualize a saída do CloudFormation cluster para obter detalhes úteis do cluster. A propriedade `ValidationMessages` adicionada fornece acesso às mensagens de validação das operações de criação e atualização do cluster.
1. Navegue até o [CloudFormation console](https://console.aws.amazon.com/cloudformation/home) e selecione a pilha que inclui seu recurso AWS ParallelCluster personalizado.
1. Escolha **Detalhes da pilha** e selecione a guia **Saídas**.
![\[A tabela CloudFormation de saída do console mostrando valores para HeadNodeIp e. ValidationMessages\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/cfn-outputs.png)
As mensagens de validação poderão estar truncadas. Para obter mais informações sobre recuperação de logs, consulte [AWS ParallelCluster solução de problemas](troubleshooting-v3.md).
## Acessar seu cluster
Acessar o cluster.
**`ssh` no nó principal do cluster**
1. Depois que a implantação da CloudFormation pilha for concluída, obtenha o endereço IP do nó principal com o seguinte comando:
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
Você também pode recuperar o endereço IP do nó principal a partir do **HeadNodeIp**parâmetro na guia **Saídas** da pilha de clusters no console. CloudFormation
Você pode encontrar o endereço IP do nó principal aqui porque ele foi adicionado na `Outputs` seção do CloudFormation modelo de cluster, especificamente para este exemplo de cluster.
1. Conecte-se ao nó principal do cluster executando o comando a seguir:
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## Limpeza
Excluir o cluster.
1. Execute o seguinte comando da AWS CLI para excluir a CloudFormation pilha e o cluster.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. Verifique o status de exclusão da pilha executando o seguinte comando.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# Implemente a ParallelCluster API com o Terraform
Neste tutorial, você definirá um projeto simples do Terraform para implantar uma ParallelCluster API.
**Pré-requisitos**
+ O Terraform v1.5.7\$1 está instalado.
+ Função do IAM com as permissões para implantar a ParallelCluster API. Consulte [Permissões obrigatórias](tutorial-deploy-terraform-permissions.md).
# Definir um projeto Terraform
Neste tutorial, você definirá um projeto Terraform.
1. Crie um diretório denominado `my-pcluster-api`.
Todos os arquivos que você criar estarão dentro desse diretório.
1. Crie o arquivo `provider.tf` para configurar o AWS provedor.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. Crie o arquivo `main.tf` para definir os recursos usando o ParallelCluster módulo.
```
module "parallelcluster_pcluster_api" {
source = "aws-tf/parallelcluster/aws//modules/pcluster_api"
version = "1.1.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
parameters = {
EnableIamAdminAccess = "true"
}
}
```
1. 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 "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. Crie o arquivo `terraform.tfvars` para definir valores arbitrários para as variáveis.
O arquivo abaixo implanta uma ParallelCluster API 3.11.1 `us-east-1` usando o nome da pilha. `MyParallelClusterAPI-3111` Você poderá referenciar essa implantação de ParallelCluster API usando o nome da pilha.
**nota**
A `api_version` atribuição no código a seguir pode ser substituída por qualquer AWS ParallelCluster versão compatível.
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. Crie o arquivo `outputs.tf` para definir os resultados gerados por esse projeto.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
O diretório do projeto é:
```
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.
```
# Implantar a API
Para implantar a API, execute os comandos padrão do Terraform na ordem.
1. Criar o projeto:
```
terraform init
```
1. Definir o plano de implantação:
```
terraform plan -out tfplan
```
1. Implantar o plano:
```
terraform apply tfplan
```
# Permissões obrigatórias
Você precisa das seguintes permissões para implantar a ParallelCluster API com o 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"
}
]
}
```
------
# Criar um cluster como o Terraform
Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos**
+ O Terraform v1.5.7\$1 está instalado.
+ A versão 3.8.0\$1 de [AWS ParallelCluster API](api-reference-v3.md) está implantada em sua conta. Consulte [Implemente a ParallelCluster API com o Terraform](tutorial-deploy-terraform.md).
+ Papel do IAM com as permissões para invocar a ParallelCluster API. Consulte [Permissões obrigatórias]
# Definir um projeto Terraform
Neste tutorial, você definirá um projeto Terraform simples para implantar um cluster.
1. Crie um diretório denominado `my-clusters`.
Todos os arquivos que você criar estarão dentro desse diretório.
1. 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"
}
}
}
```
1. 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
}
```
1. Crie o arquivo `main.tf` para definir os recursos usando o ParallelCluster módulo.
```
module "pcluster" {
source = "aws-tf/parallelcluster/aws"
version = "1.1.0"
region = var.region
api_stack_name = var.api_stack_name
api_version = var.api_version
deploy_pcluster_api = false
template_vars = local.config_vars
cluster_configs = local.cluster_configs
config_path = "config/clusters.yaml"
}
```
1. 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 elemento `cluster_config`. Para cada cluster, você pode definir explicitamente as propriedades do cluster dentro das variáveis locais (consulte `DemoCluster01`) ou referenciar um arquivo externo (consulte `DemoCluster02`).
Para revisar as propriedades do cluster que você pode definir no elemento de configuração, consulte [Arquivo de configuração do cluster](cluster-configuration-file-v3.md).
Para revisar as opções que você pode definir para a criação de cluster, consulte [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
```
locals {
cluster_configs = {
DemoCluster01 : {
region : local.config_vars.region
rollbackOnFailure : false
validationFailureLevel : "WARNING"
suppressValidators : [
"type:KeyPairValidator"
]
configuration : {
Region : local.config_vars.region
Image : {
Os : "alinux2"
}
HeadNode : {
InstanceType : "t3.small"
Networking : {
SubnetId : local.config_vars.subnet
}
Iam : {
AdditionalIamPolicies : [
{ Policy : "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" }
]
}
}
Scheduling : {
Scheduler : "slurm"
SlurmQueues : [{
Name : "queue1"
CapacityType : "ONDEMAND"
Networking : {
SubnetIds : [local.config_vars.subnet]
}
Iam : {
AdditionalIamPolicies : [
{ Policy : "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" }
]
}
ComputeResources : [{
Name : "compute"
InstanceType : "t3.small"
MinCount : "1"
MaxCount : "4"
}]
}]
SlurmSettings : {
QueueUpdateStrategy : "TERMINATE"
}
}
}
}
DemoCluster02 : {
configuration : "config/cluster_config.yaml"
}
}
}
```
1. 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
```
1. Crie o arquivo`config/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, consulte [Arquivo de configuração do 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. Crie o arquivo `clusters_vars.tf` para definir as variáveis que podem ser injetadas nas configurações do cluster.
Este 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 você precise usar lógica personalizada para determiná-los.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. 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."
}
```
1. 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-rede`subnet-123456789`, usando a ParallelCluster API 3.11.1 existente, que já está implantada com o nome da pilha. `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. Crie o arquivo `outputs.tf` para definir os resultados gerados 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 na ordem.
**nota**
Este exemplo pressupõe que você já tenha implantado a ParallelCluster API na sua conta.
1. Criar o projeto:
```
terraform init
```
1. Definir o plano de implantação:
```
terraform plan -out tfplan
```
1. Implantar 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
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
}
```
# 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 CloudFormation pilha da ParallelCluster API para verificar se ela existe e recuperar seus parâmetros e saídas
------
#### [ 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"
}
]
}
```
------
# Criar uma AMI do personalizada com o Terraform
Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos**
+ O Terraform v1.5.7\$1 está instalado.
+ A versão 3.8.0\$1 de [AWS ParallelCluster API](api-reference-v3.md) está implantada em sua conta. Consulte [Criar um cluster como o Terraform](tutorial-create-cluster-terraform.md).
+ Papel do IAM com as permissões para invocar a ParallelCluster API. Consulte [Permissões obrigatórias](tutorial-create-ami-terraform-permissions.md).
# Definir um projeto Terraform
Neste tutorial, você definirá um projeto simples do Terraform para implantar uma AMI ParallelCluster personalizada.
1. Crie um diretório denominado `my-amis`.
Todos os arquivos que você criar estarão dentro desse diretório.
1. 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"
}
}
}
```
1. 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
}
```
1. Crie o arquivo `main.tf` para definir os recursos usando o ParallelCluster módulo.
Para revisar as propriedades da imagem que você pode definir dentro no elemento `image_configuration`, consulte [Arquivos de configuração de imagem de compilação](image-builder-configuration-file-v3.md).
Para revisar as opções que você pode definir para a criação de imagens, por exemplo `image_id` e `rollback_on_failure`, consulte [`pcluster build-image`](pcluster.build-image-v3.md).
```
data "aws-parallelcluster_list_official_images" "parent_image" {
region = var.region
os = var.os
architecture = var.architecture
}
resource "aws-parallelcluster_image" "demo01" {
image_id = "demo01"
image_configuration = yamlencode({
"Build":{
"InstanceType": "c5.2xlarge",
"ParentImage": data.aws-parallelcluster_list_official_images.parent_image.official_images[0].amiId,
"UpdateOsPackages": {"Enabled": false}
}
})
rollback_on_failure = false
}
```
1. 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 "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. Crie o arquivo `terraform.tfvars` para definir seus valores arbitrários para as variáveis.
Com o arquivo abaixo, implante a AMI personalizada `us-east-1` com base na arquitetura Amazon Linux 2 para x86\$164, usando a ParallelCluster API 3.11.1 existente, que já está implantada com o nome da pilha. `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. Crie o arquivo `outputs.tf` para definir os resultados gerados por esse projeto.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
O diretório do projeto é:
```
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.
```
# Implantar a API
Para implantar a AMI, execute os comandos padrão do Terraform em ordem.
1. Criar o projeto:
```
terraform init
```
1. Definir o plano de implantação:
```
terraform plan -out tfplan
```
1. Implantar o plano:
```
terraform apply tfplan
```
# Permissões obrigatórias
Você precisa das seguintes permissões para implantar uma AMI personalizada com o Terraform:
+ assumir a função de ParallelCluster API, que é responsável por interagir com a ParallelCluster API
+ descrever a CloudFormation pilha da ParallelCluster API, para verificar se ela existe e recuperar seus parâmetros e saídas
------
#### [ 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 Integração da interface do usuário com o Identity Center
O objetivo deste tutorial é demonstrar como integrar a AWS ParallelCluster interface do usuário com o IAM Identity Center para uma solução de login único que unifica os usuários no Active Directory e pode ser compartilhada com clusters. AWS ParallelCluster
Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos:**
+ Uma AWS ParallelCluster UI existente que pode ser instalada seguindo as instruções contidas [aqui](install-pcui-v3.md).
+ Um Active Directory gerenciado existente, de preferência um que você também usará para [integração com AWS ParallelCluster](tutorials_05_multi-user-ad.md).
## Habilitar o IAM Identity Center
Se você já tem um centro de identidade conectado ao seu AWS Managed Microsoft AD (Active Directory), ele pode ser usado e você pode pular para a seção **Adicionar seu aplicativo ao IAM Identity Center**.
Se você ainda não tiver uma central de identidade conectada a uma AWS Managed Microsoft AD, siga as etapas abaixo para configurá-la.
**Habilitar o Centro de Identidade**
1. No console, acesse o Centro de Identidade do IAM. (Verifique se você está na região em que você tem o seu AWS Managed Microsoft AD.)
1. Clique no botão **Habilitar**. Pode aparecer a pergunta se você deseja habilitar organizações. Esse é um requisito para que você possa optar por habilitá-lo. **Observação**: isso enviará um e-mail de confirmação ao administrador da conta, informando que deve seguir o link para confirmar.
**Conectar o Centro de Identidade ao AD gerenciado**
1. Na próxima página, após habilitar o centro de identidade, você verá Etapas de configuração recomendadas. Em Etapa 1, selecione **Escolha sua fonte de identidade**.
1. Na seção Fonte de identidade, clique no menu suspenso **Ações** (no canto superior direito) e selecione **Alterar fonte de identidade**.
1. Selecione **Active Directory**.
1. Em **Diretórios existentes**, escolha o diretório.
1. Clique em Next.
1. Revise suas alterações, vá até o final, digite ACCEPT na caixa de texto para confirmar e clique em **Alterar fonte de identidade**.
1. Aguarde a conclusão das alterações. Depois, você verá um banner verde no topo.
**Sincronizar usuários e grupos com o Centro de Identidade**
1. No banner verde, clique em **Iniciar configuração guiada** (botão no canto superior direito)
![\[Captura de tela destacando o botão Iniciar configuração guiada.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. Em **Configurar mapeamentos de atributos**, clique em **Avançar**
1. Na seção Configurar escopo de sincronização, digite o nome dos usuários que você deseja sincronizar com o Centro de Identidade e clique em **Adicionar**.
1. Quando terminar de adicionar usuários e grupos, clique em **Avançar**
![\[Captura de tela destacando o botão Avançar.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. Revise suas alterações e clique em **Salvar configuração**
1. Se você ver um aviso na próxima tela sobre os usuários não estarem sincronizados, selecione o **botão Retomar sincronização** no canto superior direito.
1. Em seguida, para habilitar usuários, na guia **Usuários** à esquerda, selecione um usuário e clique em **Habilitar acesso do usuário** > **Habilitar acesso do usuário**
**Observação**: talvez seja necessário selecionar Retomar sincronização se houver um banner de aviso na parte superior e, em seguida, aguardar que os usuários sincronizem (tente o botão de atualização para ver se eles já foram sincronizados).
![\[Captura de tela destacando a guia Usuários.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## Adicionar a aplicação ao Centro de Identidade do IAM
Depois de sincronizar os usuários com o Centro de Identidade do IAM, você precisará adicionar uma nova aplicação. Isso configura quais aplicações habilitadas para SSO estarão disponíveis no portal do Centro de Identidade do IAM. Nesse caso, adicionaremos a interface de usuário do AWS ParallelCluster como uma aplicação, enquanto o Centro de Identidade do IAM será o provedor de identidades.
A próxima etapa adicionará a AWS ParallelCluster interface do usuário como um aplicativo no IAM Identity Center. AWS ParallelCluster A interface do usuário é um portal da web que ajuda o usuário a gerenciar seus clusters. Para ter mais informações, consulte [AWS ParallelCluster UI](pcui-using-v3.md).
**Configurar a aplicação no Centro de Identidade**
1. Em **Centro de Identidade do IAM** > **Aplicações** (na barra de menu à esquerda, clique em Aplicações).
1. Clique em **Adicionar aplicação**.
1. Selecione **Adicionar aplicação SAML 2.0 personalizada**.
1. Clique em **Avançar**.
1. Selecione o nome de exibição e a descrição que você gostaria de usar (por exemplo, PCUI e AWS ParallelCluster UI)
1. Em **Metadados do Centro de Identidade do IAM**, copie o link para o arquivo de metadados SAML do Centro de Identidade do IAM e salve para mais tarde. Ele será usado ao configurar o SSO no aplicativo web.
1. Em **Propriedades da aplicação**, no URL inicial da aplicação, insira o endereço da PCUI. **Isso pode ser encontrado acessando o CloudFormation console, selecionando a pilha que corresponde à PCUI (por exemplo, parallelcluster-ui) e indo até a guia Saídas para encontrar** ParallelCluster UIUrl
por exemplo https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. Em **Metadados da aplicação**, escolha **Digite manualmente seus valores de metadados**. Depois, forneça os valores a seguir.
1. **Importante**: garanta a substituição dos valores domain-prefix, region e userpool-id por informações específicas do ambiente.
1. O domain-prefix, region e userpool-id podem ser obtidos em **Grupos de usuários** no console do **Amazon Cognito**.
![\[Captura de tela destacando o nome do grupo de usuários em Grupos de usuários do Cognito\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. Selecione o grupo de usuários que corresponde ao PCUI (que terá um nome de grupo de usuários como EK3 TO45 PCUI-CD8A2-Cognito-153 S98-UserPool)
1. Acesse **Integração de aplicações**.
![\[Captura de tela destacando o Domínio Cognito na guia Integração de Aplicativos\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. URL do Application Assertion Consumer Service (ACS): https://.auth. .amazoncognito. com/saml2/idpresponse
Público SAML da aplicação: urn:amazon:cognito:sp:
1. Selecione **Enviar**. Depois, acesse a página **Detalhes** da aplicação que você adicionou.
1. Selecione a lista suspensa **Ações** e escolha **Editar mapeamentos de atributos**. Em seguida, forneça os seguintes atributos:
1. Atributo do usuário na aplicação: **assunto** (Observação: o **assunto** é preenchido previamente.) → Mapeia para este valor de string ou atributo de usuário no Centro de Identidade do IAM: **\$1\$1user:email\$1**, Formato: **emailAddress**
1. Atributo do usuário na aplicação: **email** → Mapeia para este valor de string ou atributo do usuário no Centro de Identidade do IAM: **\$1\$1user:email\$1**, Formato: **não especificado**
![\[Captura de tela destacando a seção Mapeamentos de atributos para PCUI.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. Salve as alterações.
1. Escolha o botão **Atribuir usuários** e atribua seu usuário à aplicação. Esses são os usuários no Active Directory que terão acesso à interface PCUI.
![\[Captura de tela destacando Atribuir usuários para o aplicativo.\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**Configurar o Centro de Identidade do IAM como IdP SAML no grupo de usuários**
1. Nas configurações do grupo de usuários, selecione **Experiência de login** > **Adicionar provedor de identidades**.
![\[Captura de tela destacando a guia Experiência de login\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. Escolha um IdP SAML.
1. Para o **nome do provedor**, forneça **IdentityCenter**
1. Em **Fonte do documento de metadados**, escolha **Inserir um URL de endpoint do documento de metadados** e forneça o URL copiado durante a configuração da aplicação do Centro de Identidade.
1. Em **Atributos**, para e-mail, escolha email.
![\[Captura de tela destacando a guia Experiência de login\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. Selecione **Adicionar provedor de identidade**.
**Integrar o IdP ao cliente da aplicação do grupo de usuários**
1. Depois, na seção **Integração de aplicações** do grupo de usuários, escolha o cliente informado em **Lista de clientes de aplicação**.
![\[Captura de tela destacando a guia Experiência de login\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. Em **IU hospedada**, escolha **Editar**.
1. Em **Provedores de identidade **IdentityCenter****, escolha também.
1. Selecione **Save changes** (Salvar alterações)
**Validar sua configuração**
1. Em seguida, validaremos a configuração que acabamos de criar fazendo login na PCUI. Faça login no portal da PCUI, e agora você verá uma opção para fazer login com o ID corporativo:
![\[Captura de tela destacando a guia Experiência de login\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. **IdentityCenter**Clicar no botão deve levar você ao login do IdP do IAM Identity Center seguido por uma página com seus aplicativos que inclui o PCUI. Abra esse aplicativo.
1. Depois de acessar a tela a seguir, o usuário será adicionado ao grupo de usuários do Cognito.
![\[Captura de tela destacando a guia Experiência de login\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**Tornar seu usuário um administrador**
1. Agora, acesse **Grupos de usuários** no console do **Amazon Cognito** e selecione o usuário que acabou de ser criado, que deve ter o prefixo identitycenter.
![\[Captura de tela destacando a guia Experiência de login\]](http://docs.aws.amazon.com/pt_br/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. Em **Associações de grupo**, selecione **Adicionar usuário ao grupo**, escolha **administrador** e clique em **Adicionar**.
1. Agora, ao clicar em **Continuar com**, IdentityCenter você será direcionado para a página da AWS ParallelCluster interface do usuário.
# Executar trabalhos em contêineres com Pyxis
Saiba como criar um cluster capaz de executar trabalhos em contêineres usando o Pyxis, que é um plugin SPANK para gerenciar trabalhos em contêineres no SLURM. Os contêineres no Pyxis são gerenciados pelo Enroot, que é uma ferramenta para transformar container/OS imagens tradicionais em sandboxes sem privilégios. Para ter mais informações, consulte [NVIDIA Pyxis](https://github.com/NVIDIA/pyxis) e [NVIDIA Enroot](https://github.com/NVIDIA/enroot).
**nota**
Esse recurso está disponível com a versão AWS ParallelCluster 3.11.1
Os scripts deste tutorial movem (`mv`) alguns arquivos, o que os exclui de seus locais originais. Se você quiser manter cópias desses arquivos em seus locais originais, altere os scripts para usar o comando copy (`cp`) em vez disso.
Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
**Pré-requisitos:**
+ O AWS CLI está [instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Um perfil do IAM com as [permissões](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) necessárias para executar a [CLI pcluster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
## Criar um cluster
A partir do AWS ParallelCluster 3.11.1, tudo oficial AMIs vem com o Pyxis e o Enroot pré-instalados. Em particular, o SLURM é recompilado com suporte ao Pyxis, e o Enroot é instalado como um binário no sistema. No entanto, você deve configurá-los de acordo com suas necessidades específicas. As pastas usadas pelo Enroot e pelo Pyxis terão um impacto crítico no desempenho do cluster. Para ter mais informações, consulte a [documentação do Pyxis](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration) e a [documentação do Enroot](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example).
Para sua comodidade, você pode encontrar exemplos de configurações para Pyxis, Enroot e SPANK em `/opt/parallelcluster/examples/`.
Para implantar um cluster usando as configurações de exemplo que fornecemos, conclua o tutorial a seguir.
**Como criar o cluster com configuração de amostra**
O Pyxis e o Enroot devem ser configurados no nó principal. Comece criando os diretórios persistentes e voláteis para o Enroot, depois crie o diretório de runtime para o Pyxis e, por fim, habilite o Pyxis como plug-in SPANK em todo o cluster.
1. Execute o script abaixo como ação [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured)personalizada no nó principal para configurar o Pyxis e o Enroot no nó 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. O Pyxis e o Enroot devem ser configurados na frota de computação criando os diretórios persistentes e voláteis para o Enroot e o diretório de runtime para o Pyxis. Execute o script abaixo como ação [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personalizada nos nós de computação para configurar o Pyxis e o Enroot na frota de computação.
```
#!/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
```
## Enviar trabalhos
Agora que o Pyxis está configurado no cluster, você pode enviar trabalhos em contêineres usando os comandos sbatch e srun, que agora são enriquecidos com opções específicas de contêiner.
```
# 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'
```
# Criação de um cluster com um Lustre habilitado para EFA FSx
Neste tutorial, você criará um cluster que usa um sistema de arquivos FSx Lustre habilitado para EFA como armazenamento compartilhado. Usar um sistema de arquivos FSx Lustre com o EFA ativado pode aumentar o desempenho em até 8 vezes. Para verificar se um sistema de arquivos habilitado para EFA é o que você precisa, consulte [Trabalhando com sistemas de arquivos habilitados *FSx para* EFA](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html) no Guia do usuário do Lustre.
Ao usar AWS ParallelCluster, você paga apenas pelos AWS recursos criados ao criar ou atualizar AWS ParallelCluster imagens e clusters. Para obter mais informações, consulte [AWS serviços usados por AWS ParallelCluster](aws-services-v3.md).
## Requisitos
+ A AWS CLI está [instalada e](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) configurada.
+ A ParallelCluster CLI está [instalada e](install-v3-parallelcluster.md) configurada.
+ Um [par de chaves do Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) para fazer login no cluster.
+ Uma função do IAM com as [permissões](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) necessárias para executar a ParallelCluster CLI.
## Criar security groups
Crie dois grupos de segurança na mesma VPC em que o cluster e o sistema de arquivos serão implantados: um para o cliente em execução nos nós do cluster e outro para o sistema de arquivos.
```
# 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
```
No restante do tutorial, assumiremos `sg-client` e `sg-file-system` somos os IDs do grupo de segurança do cliente e do sistema de arquivos, respectivamente.
Configure o grupo de segurança do cliente para permitir todo o tráfego de saída para o sistema de arquivos, conforme [exigido pelo EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security).
```
# Allow all outbound traffic from the client to the file system
aws ec2 authorize-security-group-egress \
--group-id sg-client \
--protocol -1 \
--port -1 \
--source-group sg-file-system \
--region region
```
Configure o grupo de segurança do sistema de arquivos para permitir todo o inbound/outbound tráfego interno e todo o tráfego de entrada do cliente, conforme [exigido pelo 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
```
## Crie o sistema de arquivos
Crie o sistema de arquivos na mesma Zona de Disponibilidade (AZ) em que estarão os nós de computação e `subnet-compute-nodes` substitua por sua ID no código a seguir. Isso é necessário para permitir que o EFA trabalhe com seu sistema de arquivos. Observe que, como parte da criação do sistema de arquivos, habilitamos o EFA usando a EfaEnable propriedade.
```
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
```
Anote o ID do sistema de arquivos retornado pelo comando anterior. No restante do tutorial, `fs-id` substitua por esse ID do sistema de arquivos.
## Criar um cluster
1. Crie o cluster com as seguintes configurações definidas no arquivo de configuração AWS ParallelCluster YAML:
1. AMI baseada em um sistema operacional compatível, como o Ubuntu 22.04.
1. Os nós de computação devem usar um [tipo de instância compatível com EFA com](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), como g6.16xlarge.
+ Os nós de computação devem estar na mesma AZ em que está o sistema de arquivos.
+ Os nós de computação devem ter [Efa/Enabled definido como verdadeiro](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled).
+ Os nós de computação devem executar o script de configuração `configure-efa-fsx-lustre-client.sh` como uma ação [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)personalizada. O script, fornecido na [documentação FSx oficial](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) e oferecido em nosso bucket público para sua conveniência, tem como objetivo configurar o cliente FSx Lustre em nós de computação para permitir que eles usem o EFA.
1. Crie um arquivo de configuração 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
```
Em seguida, crie um cluster usando essa configuração:
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## Validar FSx com o EFA está funcionando
Para verificar se o tráfego de rede do Lustre está usando o EFA, use a `lnetctl` ferramenta Lustre que pode mostrar o tráfego de rede de uma determinada interface de rede. Para isso, execute os seguintes comandos em um nó de computação:
```
# 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
```
Se o recurso estiver funcionando, espera-se que o número de pacotes que fluem pela interface aumente.
# Support NVIDIA-IMEX com instância p6e-gb200
Este tutorial mostra como começar a usar o P6e-GB200, para aproveitar o melhor desempenho da GPU para treinamento e inferência de IA. AWS ParallelCluster As instâncias [p6e-gb200.36xlarge só estão disponíveis via P6e- GB200 UltraServers onde é o tamanho do Ultraserver e](https://aws.amazon.com/ec2/instance-types/p6/) `u-p6e-gb200x72` é o que forma o ultrasserver. `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) Ao comprar um Ultraserver`u-p6e-gb200x72`, ele estará disponível por meio de [blocos de capacidade EC2 para ML](https://aws.amazon.com/ec2/capacityblocks/), que terão 18 instâncias. `p6e-gb200.36xlarge` Para saber mais, consulte [P6e-. GB200](https://aws.amazon.com/ec2/instance-types/p6/)
AWS ParallelCluster versão 3.14.0:
+ fornece a pilha completa de software NVIDIA (drivers, CUDA, EFA, NVIDIA-IMEX) exigida por esse tipo de instância
+ cria configurações nvidia-imex para o ultrasserver P6e GB200
+ ativa e inicia o `nvidia-imex` serviço para o ultrasserver P6e GB200
+ configura o plug-in de topologia Slurm Block para que cada Ultraserver P6e-GB200 (um bloco de capacidade EC2) seja um Slurm Block com o tamanho certo (consulte a entrada da versão 3.14.0). [Notas de release e histórico de documentos](document_history.md)
No entanto, a GPU-to-GPU comunicação via NVLink requer configurações adicionais, especificamente um [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)arquivo que contém os endereços IP dos nós de computação em um domínio IMEX que ParallelCluster não é gerado automaticamente. Para ajudar a gerar esse arquivo, fornecemos um script de prólogo que descobre automaticamente o nó de computação IPs e configura as [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)seguintes recomendações de integração com o [NVIDIA IMEX Slurm](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration) Job Scheduler. Este tutorial explica como criar o script prolog, implantá-lo por meio de uma ação HeadNode personalizada e validar a configuração do IMEX.
**nota**
O P6e- GB200 é suportado a partir da AWS ParallelCluster v3.14.0 no Amazon Linux 2023, Ubuntu 22.04 e Ubuntu 24.04. Para ver as versões detalhadas do software e uma lista atualizada das distribuições suportadas, consulte o [AWS ParallelCluster changelog](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md).
## Crie um script Prolog para gerenciar o NVIDIA-IMEX
**Limitação:**
+ Esse script de prólogo será executado após o envio de um trabalho exclusivo. Isso é para garantir que uma reinicialização do IMEX não interrompa nenhuma tarefa em execução nos nós P6e-GB200 que pertençam a um domínio IMEX.
Abaixo está o `91_nvidia_imex_prolog.sh` script que você deve configurar como um prólogo no Slurm. Ele é usado para atualizar automaticamente a configuração nvidia-imex nos nós de computação. O nome do script tem um prefixo de `91` para aderir à convenção de [nomenclatura do SchedMD](https://slurm.schedmd.com/prolog_epilog.html). Isso garante que ele seja executado antes de qualquer outro script de prólogo na sequência. O script reconfigura a configuração do nó NVIDIA Imex quando um trabalho é iniciado e recarrega os daemons NVIDIA necessários.
**nota**
Esse script não será executado caso vários trabalhos sejam iniciados simultaneamente nos mesmos nós, portanto, sugerimos usar o `--exclusive` sinalizador no envio.
```
#!/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"
```
## Crie o script HeadNode OnNodeStart de ação personalizado
Crie uma ação `install_custom_action.sh` personalizada que baixará o script de prolog mencionado acima em um diretório compartilhado `/opt/slurm/etc/scripts/prolog.d/` que é acessado pelos Compute Nodes e defina as permissões adequadas a serem executadas.
```
#!/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}"
```
## Criar um cluster
Crie um cluster incluindo instâncias P6e-. GB200 Abaixo, você pode encontrar um exemplo de configuração contendo SlurmQueues o tipo Ultraserver. `u-p6e-gb200x72`
Atualmente, o P6e- GB200 está disponível apenas em Locais Zones. Algumas [Zonas Locais não oferecem suporte a um NAT Gateway](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html), portanto, siga as [opções de conectividade para Zonas Locais](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html) conforme ParallelCluster necessário [Configurando grupos de segurança para ambientes restritos](security-groups-configuration.md) para se conectar aos AWS Serviços. Siga o [Instâncias de lançamento com Blocos de Capacidade (CB)](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch), pois os Ultraservers estão disponíveis somente como blocos de capacidade.
```
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:
-
```
## Validar a configuração do IMEX
O `91_nvidia_imex_prolog.sh` prólogo será executado quando você enviar um trabalho do Slurm. Abaixo está um exemplo de trabalho para verificar o status do domínio 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"
```
Verifique a saída do 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
```
# Personalize as interfaces de rede de nós de computação com substituições de modelos de lançamento
A partir da AWS ParallelCluster versão 3.15.0, o `LaunchTemplateOverrides` parâmetro permite que você personalize as interfaces de rede dos nós de computação substituindo a configuração padrão da interface de rede pela configuração em um modelo de execução referenciado. Toda a seção de interface de rede dos nós de computação é substituída pela seção de interface de rede do modelo de execução usado para substituir.
Este tutorial mostra um exemplo de como substituir a configuração de rede padrão dos nós de `p6-b300.48xlarge` computação. Essa personalização é útil quando você precisa de uma configuração de interface de rede específica que seja diferente da AWS ParallelCluster configurada por padrão. Neste exemplo, configuramos o caso de uso 2 para instâncias P6-B300, conforme descrito na documentação de tipos de instância compatíveis com o Amazon EC2 [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html).
**nota**
É recomendável usar o AWS CLI para criar o modelo de lançamento em vez do console para obter o máximo de flexibilidade.
**nota**
O modelo de lançamento deve conter somente substituições de interfaces de rede. AWS ParallelCluster tem uma validação que impede a substituição de outros parâmetros.
**Atenção**
Se você usar a substituição para configurar interfaces de rede de uma forma que não seja compatível com o tipo de instância que está sendo usado, as instâncias falharão na inicialização.
**Pré-requisitos**
+ AWS ParallelCluster a versão 3.15.0 ou posterior [está](install-v3-parallelcluster.md) instalada.
+ O AWS CLI [está instalado e configurado.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Você tem um perfil do IAM com as [permissões](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) necessárias para executar a [`pcluster`](pcluster-v3.md) CLI.
## Etapa 1: criar grupos de segurança
Ao criar o modelo de execução para usar na substituição, você deve fazer referência a um grupo de segurança. O grupo AWS ParallelCluster de segurança padrão para o recurso computacional não existe até a criação do cluster, portanto, você deve criar um grupo de segurança personalizado. Esse grupo de segurança deve então ser referenciado pelo grupo de segurança do nó principal para permitir o tráfego entre o nó principal e os nós de computação.
Se você estiver atualizando um cluster existente para personalizar a nova capacidade, poderá usar o grupo de segurança padrão do nó de AWS ParallelCluster computação no modelo de execução em vez de criar um personalizado.
Crie os dois grupos de segurança a seguir:
+ **Grupo de segurança adicional do nó principal** (`sg-1234abcd`):
+ Entrada: todo o tráfego do grupo de segurança computacional
+ **Grupo de segurança computacional** (`sg-abcd1234`):
+ Entrada: todo o tráfego do grupo de segurança do nó principal
+ Entrada: todo o tráfego de self () compute-to-compute
+ Saída: permissão padrão para tudo
## Etapa 2: criar o modelo de lançamento
Crie um modelo de lançamento que defina a configuração da interface de rede para os nós de `p6-b300.48xlarge` computação. Para a interface de rede primária (índice da placa de rede 0, índice do dispositivo 0), use uma interface de rede ENA (padrão). Para as placas de rede restantes, crie uma interface somente EFA (índices de placa de rede de 1 a 16, índice de dispositivo 0) e uma interface ENA (padrão) (índices de placa de rede de 1 a 16, índice de dispositivo 1).
Execute o AWS CLI comando a seguir para criar o modelo de lançamento (`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"}
]
}'
```
## Etapa 3: criar o cluster com substituições do modelo de execução
Crie uma configuração de cluster que use o `LaunchTemplateOverrides` parâmetro para referenciar o modelo de execução que você criou.
```
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.
```