기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.
# 사용 방법에 대한 자습서 AWS ParallelCluster
다음 자습서에서는 AWS ParallelCluster 버전 3을 시작하는 방법을 보여주고 몇 가지 일반적인 작업에 대한 모범 사례 지침을 제공합니다.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**Topics**
+ [
# 에서 첫 번째 작업 실행 AWS ParallelCluster
](tutorials-running-your-first-job-on-version-3.md)
+ [
# 사용자 지정 AWS ParallelCluster AMI 빌드
](building-custom-ami-v3.md)
+ [
# Active Directory 통합
](tutorials_05_multi-user-ad.md)
+ [
# AWS KMS 키를 사용하여 공유 스토리지 암호화 구성
](tutorials_04_encrypted_kms_fs-v3.md)
+ [
# 다중 대기열 모드 클러스터에서 작업 실행
](multi-queue-tutorial-v3.md)
+ [
# AWS ParallelCluster API 사용
](tutorials_06_API_use.md)
+ [
# Slurm 화계를 사용하여 클러스터 생성
](tutorials_07_slurm-accounting-v3.md)
+ [
# 외부 Slurmdbd 회계를 사용하여 클러스터 생성
](external-slurmdb-accounting.md)
+ [
# 이전 AWS Systems Manager 문서 버전으로 되돌리기
](tutorials_08_ssm-document-version-rev-v3.md)
+ [
# 를 사용하여 클러스터 생성 CloudFormation
](tutorials_09_cfn-custom-resource-v3.md)
+ [
# Terraform을 사용하여 ParallelCluster API 배포
](tutorial-deploy-terraform.md)
+ [
# Terraform을 사용하여 클러스터 생성
](tutorial-create-cluster-terraform.md)
+ [
# Terraform을 사용하여 사용자 지정 AMI 생성
](tutorial-create-ami-terraform.md)
+ [
# AWS ParallelCluster Identity Center와 UI 통합
](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Pyxis를 사용하여 컨테이너화된 작업 실행](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [
# EFA 지원 FSx Lustre를 사용하여 클러스터 생성
](tutorial-efa-enabled-fsx-lustre.md)
+ [
# p6e-gb200 인스턴스에서 NVIDIA-Imex 지원
](support-nvidia-imex-p6e-gb200-instance.md)
+ [
# 시작 템플릿 재정의로 컴퓨팅 노드 네트워크 인터페이스 사용자 지정
](tutorial-network-customization-v3.md)
# 에서 첫 번째 작업 실행 AWS ParallelCluster
이 자습서에서는에서 첫 번째 Hello World 작업을 실행하는 방법을 안내합니다. AWS ParallelCluster
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
## 설치 확인
먼저 Node.js 종속성을 포함하여 AWS ParallelCluster 가 올바르게 설치 및 구성되었는지 확인합니다.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
그러면의 실행 중인 버전이 반환됩니다 AWS ParallelCluster.
## 첫 번째 클러스터 생성
이제 첫 번째 클러스터를 생성할 시간입니다. 이 자습서의 워크로드는 성능 집약적이 아니기 때문에 `t2.micro`의 기본 인스턴스 크기를 사용합니다. (프로덕션 워크로드의 경우 더 적합한 인스턴스 크기를 선택해야 합니다.) 클러스터 `hello-world`를 호출해 보겠습니다.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**참고**
대부분의 `pcluster` 명령에 사용할 AWS 리전 를 지정해야 합니다. `AWS_DEFAULT_REGION` 환경 변수나 `~/.aws/config` 파일 `[default]` 섹션의 `region` 설정에 그것이 지정되지 않은 경우 `pcluster` 명령줄에 `--region` 파라미터를 제공해야 합니다.
구성에 대한 메시지가 출력되는 경우 다음을 실행하여 AWS ParallelCluster를 구성해야 합니다.
```
$ pcluster configure --config hello-world.yaml
```
[`pcluster create-cluster`](pcluster.create-cluster-v3.md) 명령이 제대로 실행되면 다음과 비슷한 출력이 표시됩니다.
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
다음을 사용하여 클러스터 생성을 모니터링합니다.
```
$ pcluster describe-cluster --cluster-name hello-world
```
`clusterStatus`는 클러스터를 생성하는 동안 “`CREATE_IN_PROGRESS`”를 보고합니다. 클러스터가 성공적으로 생성되면 `clusterStatus`이 “`CREATE_COMPLETE`”로 전환됩니다. 출력은 헤드 노드의 `publicIpAddress` 및 `privateIpAddress`도 제공합니다.
## 헤드 노드에 로그인
OpenSSH pem 파일을 사용하여 헤드 노드에 로그인합니다.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
로그인되면 `sinfo` 명령을 실행하여 컴퓨팅 노드가 설정되고 구성되어 있는지 확인합니다.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
출력은 클러스터에 최대 10개의 노드로 구성된 대기열이 하나 있음을 보여줍니다.
## Slurm을 사용하여 첫 번째 작업 실행
이제 잠시 동안 대기한 다음 고유의 호스트 이름을 출력하는 작업을 생성합니다. 다음 콘텐츠를 통해 `hellojob.sh`라는 파일을 생성합니다.
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
그런 다음 `sbatch`를 사용하여 작업을 제출하고 작업이 실행되는지 확인합니다.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
이제 대기열을 보고 작업 상태를 확인할 수 있습니다. 새로운 Amazon EC2 인스턴스를 프로비저닝하는 작업은 백그라운드에서 시작됩니다. `sinfo` 명령을 사용하여 클러스터 인스턴스의 상태를 모니터링할 수 있습니다.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
출력에는 작업이 `queue1`에 제출되었음을 보여줍니다. 작업이 완료될 때까지 30초 동안 기다린 후 `squeue`을 다시 실행합니다.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
이제 대기열에 작업이 없으므로 현재 디렉터리에서 출력을 확인할 수 있습니다.
```
$ 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
```
출력에는 “`out`” 파일이 표시됩니다. 작업의 출력이 표시됩니다.
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
출력에서는 작업이 `queue1-dy-queue1t2micro-1` 인스턴스에서 성공적으로 실행되었음을 보여줍니다.
방금 생성한 클러스터에서는 클러스터의 모든 노드에서 홈 디렉터리만 공유됩니다.
클러스터 생성 및 사용에 대해 자세히 알아보려면 [모범 사례](best-practices-v3.md) 섹션을 참조하세요.
애플리케이션에 공유 소프트웨어, 라이브러리 또는 데이터가 필요한 경우 다음 옵션을 고려해 보세요.
+ 에 설명된 대로 소프트웨어가 포함된 AWS ParallelCluster 활성화된 사용자 지정 AMI를 빌드합니다[사용자 지정 AWS ParallelCluster AMI 빌드](building-custom-ami-v3.md).
+ AWS ParallelCluster 구성 파일의 [StorageSettings](SharedStorage-v3.md) 옵션을 사용하여 공유 파일 시스템을 지정하고 설치된 소프트웨어를 지정된 탑재 위치에 저장합니다.
+ [사용자 지정 부트스트랩 작업](custom-bootstrap-actions-v3.md)를 사용하여 클러스터 각 노드의 부트스트랩 절차를 자동화할 수 있습니다.
# 사용자 지정 AWS ParallelCluster AMI 빌드
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**중요**
사용자 지정 AMI를 빌드한다면, 새로운 각 AWS ParallelCluster 릴리스에서 사용자 지정 AMI를 생성하는 데 사용된 단계를 반복해야 합니다.
자세한 내용을 읽기 전에 먼저 [사용자 지정 부트스트랩 작업](custom-bootstrap-actions-v3.md) 섹션을 검토하는 것이 좋습니다. 수정하려는 내용이 스크립트로 작성되고 향후 AWS ParallelCluster 릴리스에서 지원할 수 있는지 확인하세요.
일반적으로 사용자 지정 AMI를 빌드하는 것은 이상적이지 않지만에 대한 사용자 지정 AMI를 빌드해야 하는 특정 시나리오 AWS ParallelCluster 가 있습니다. 이 자습서에서는 이러한 시나리오에 맞는 사용자 지정 AMI를 빌드하는 방법에 대해 설명합니다.
**사전 조건**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하고 이미지를 빌드하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
## AWS ParallelCluster AMI를 사용자 지정하는 방법
사용자 지정 AWS ParallelCluster AMI를 빌드하는 방법에는 두 가지가 있습니다. 이 두 가지 방법 중 하나는 AWS ParallelCluster CLI를 사용하여 새 AMI를 빌드하는 것입니다. 또 다른 방법을 사용하려면 수동으로 수정하여 AWS 계정에서 MI를 새로 빌드해야 합니다.
## 사용자 지정 AWS ParallelCluster AMI 빌드
사용자 지정 AMI 및 소프트웨어가 있는 경우 그 위에 AWS ParallelCluster 에 필요한 변경 사항을 적용할 수 있습니다. AWS ParallelCluster 는 EC2 Image Builder 서비스를 사용하여 사용자 지정 AMIs. 자세한 내용은 [Image Builder 사용 설명서](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html)를 참조하세요.
중요 사항:
+ 이 프로세스에는 1시간 가량 소요됩니다. 이 시간은 빌드 시 추가로 [`Build`](Build-v3.md)/[`Components`](Build-v3.md#Build-v3-Components)를 설치할 경우 달라질 수 있습니다.
+ AMI에는 주요 구성 요소 버전으로 태그가 지정되어 있습니다. 여기에는 커널, 스케줄러, [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) 드라이버가 포함됩니다. 구성 요소 버전의 하위 집합도 AMI 설명에 보고됩니다.
+ AWS ParallelCluster 3.0.0부터 새로운 CLI 명령 세트를 사용하여 이미지 수명 주기를 관리할 수 있습니다. 여기에 [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md) 및 [`delete-image`](pcluster.delete-image-v3.md)도 추가되었습니다.
+ 이 방법은 반복할 수 있습니다. 다시 실행하여 AMI를 최신 상태로 유지(예: OS 업데이트)한 다음 기존 클러스터를 업데이트할 때 사용할 수 있습니다.
**참고**
AWS 중국 파티션에서이 방법을 사용하면 네트워크 오류가 발생할 수 있습니다. 예를 들어 GitHub 또는 OS 리포지토리에서 패키지를 다운로드할 때 `pcluster build-image` 명령에서 이러한 오류가 표시될 수 있습니다. 이 오류가 발생하면 다음 대체 방법 중 하나를 사용하는 것이 좋습니다.
이 명령을 우회하는 [AWS ParallelCluster AMI 수정](#modify-an-aws-parallelcluster-ami-v3) 방법을 따릅니다.
`us-east-1`와 같은 다른 파티션 및 리전에 이미지를 빌드한 다음 저장/복원하여 중국 리전으로 이동합니다. 자세한 내용은 *Amazon EC2 사용 설명서*의 [S3를 사용하여 AMI 저장 및 복원](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html)을 참조하세요.
단계:
1. AWS ParallelCluster 클라이언트가 사용자를 대신하여 AWS API 작업을 호출할 수 있도록 AWS 계정 자격 증명을 구성합니다. 필요한 권한 목록은 [AWS Identity and Access Management 의 권한 AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md) 섹션을 참조하세요.
1. 기본 *이미지 빌드* 구성 파일을 생성합니다. 이렇게 하려면 이미지 및 [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage)를 빌드하는 데 사용할 [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType)을 지정합니다. 이는 AMI를 생성하기 위한 시작점으로 사용됩니다. 선택적 빌드 파라미터에 대한 자세한 내용은 [이미지 구성](image-builder-configuration-file-v3.md)을 참조하세요.
```
Build:
InstanceType:
ParentImage:
```
1. CLI 명령을 사용하여 기본으로 제공하는 AWS ParallelCluster AMI에서 시작하는 AMI를 [`pcluster build-image`](pcluster.build-image-v3.md) 빌드합니다.
```
$ 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"
}
}
```
**주의**
`pcluster build-image`는 기본 VPC를 사용합니다. AWS Control Tower 또는 AWS 랜딩 영역을 사용하여 기본 VPC를 삭제하는 경우 이미지 구성 파일에 서브넷 ID를 지정해야 합니다. 자세한 내용은 [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId) 단원을 참조하십시오.
기타 파라미터 목록은 [`pcluster build-image`](pcluster.build-image-v3.md) 명령 참조 페이지를 참조하세요. 이전 명령의 결과는 다음과 같습니다.
+ CloudFormation 스택은 이미지 구성을 기반으로 생성됩니다. 스택에는 빌드에 필요한 모든 EC2 Image Builder 리소스가 포함되어 있습니다.
+ 생성된 리소스에는 사용자 지정 Image Builder AWS ParallelCluster 구성 요소를 추가할 수 있는 공식 Image Builder 구성 요소가 포함됩니다. 자세한 내용은 *EC2 * [ Image Builder 사용 설명서의 Image Builder를 사용하여 사용자 지정 구성 요소 생성을](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) 참조하세요.
+ EC2 Image Builder는 빌드 인스턴스를 시작하고, AWS ParallelCluster 쿡북을 적용하고, AWS ParallelCluster 소프트웨어 스택을 설치하고, 필요한 구성 작업을 수행합니다. AWS ParallelCluster 쿡북은 빌드 및 부트스트랩에 사용됩니다 AWS ParallelCluster.
+ 인스턴스가 중지되고 이 인스턴스에서 새 AMI가 생성됩니다.
+ 새로 생성한 AMI에서 다른 인스턴스가 시작됩니다. 테스트 단계에서 EC2 Image Builder는 Image Builder 구성 요소에 정의된 테스트를 실행합니다.
+ 빌드가 성공하면 스택이 삭제됩니다. 빌드가 실패하더라도 스택은 유지되며 검사할 수 있습니다.
1. 다음 명령을 실행하여 빌드 프로세스의 상태를 모니터링할 수 있습니다. 빌드가 완료되면 이를 실행하여 응답에 제공된 AMI ID를 검색할 수 있습니다.
```
$ 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. 클러스터를 생성하려면 클러스터 구성 내의 [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) 필드에 AMI ID를 입력합니다.
AMI 생성 프로세스 문제 해결 및 모니터링****
이미지 생성은 약 1시간 후에 완료됩니다. [`pcluster describe-image`](pcluster.describe-image-v3.md) 명령 또는 로그 검색 명령을 실행하여 프로세스를 모니터링할 수 있습니다.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
이 [`build-image`](pcluster.build-image-v3.md) 명령은 이미지를 빌드하는 데 필요한 모든 Amazon EC2 리소스가 포함된 CloudFormation 스택을 생성하고 EC2 Image Builder 프로세스를 시작합니다.
[`build-image`](pcluster.build-image-v3.md) 명령을 실행한 후에는 [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md)를 사용하여 CloudFormation 스택 이벤트를 검색할 수 있습니다. `--query` 파라미터로 결과를 필터링하여 최신 이벤트를 확인할 수 있습니다. 자세한 내용은 *AWS Command Line Interface 사용 설명서*의 [AWS CLI 출력 필터링](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html)을 참조하세요.
```
$ 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"
}
```
약 15분 후 Image Builder 생성과 관련된 로그 이벤트 항목에 스택 이벤트가 나타납니다. 이제 [`pcluster list-image-log-streams`](pcluster.list-image-log-streams-v3.md) 및 [`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md) 명령을 사용하여 이미지 로그 스트림을 나열하고 Image Builder 단계를 모니터링할 수 있습니다.
```
$ 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"
}
]
}
```
`BUILD_COMPLETE` 상태가 표시될 때까지 [`describe-image`](pcluster.describe-image-v3.md) 명령을 사용하여 계속 확인하세요.
```
$ 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"
}
```
사용자 지정 AMI 생성 문제를 해결해야 하는 경우 다음 단계에 설명된 대로 이미지 로그의 아카이브를 생성하세요.
`--output` 파라미터에 따라 Amazon S3 버킷 또는 로컬 파일에 로그를 보관할 수 있습니다.
```
$ 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"
}
```
아카이브에는 Image Builder 프로세스 및 CloudFormation 스택 이벤트와 관련된 CloudWatch Logs Streams가 포함되어 있습니다. 이 명령을 실행하는 데 몇 분이 걸릴 수 있습니다.
사용자 지정 AMI 관리****
AWS ParallelCluster 3.0.0부터 이미지 수명 주기를 빌드, 모니터링 및 관리하기 위한 새로운 명령 세트가 CLI에 추가되었습니다. 명령에 대한 자세한 내용은 [pcluster 명령](pcluster-v3.md)을 참조하세요.
## AWS ParallelCluster AMI 수정
이 방법은 그 위에 사용자 지정을 추가하여 공식 AWS ParallelCluster AMI를 수정하는 것으로 구성됩니다. AWS ParallelCluster AMIs 새 릴리스로 업데이트됩니다. 이러한 AMIs에는 설치 및 구성 시가 작동하는 AWS ParallelCluster 데 필요한 모든 구성 요소가 있습니다. 이 중 하나를 기본으로 삼아 시작할 수 있습니다.
중요 사항:
+ 이 방법은 [`build-image`](pcluster.build-image-v3.md) 명령보다 빠릅니다. 하지만 이 프로세스는 수동 프로세스이므로 자동으로 반복할 수 없습니다.
+ 이 방법을 사용하면 CLI를 통해 사용할 수 있는 로그 검색 및 이미지 수명 주기 관리 명령에 액세스할 수 없습니다.
단계:
------
#### [ New Amazon EC2 console ]
1. AWS 리전 사용하는 특정에 해당하는 AMI를 찾습니다. 이를 찾으려면 파라미터와 함께 [`pcluster list-official-images`](pcluster.list-official-images-v3.md) 명령을 사용하여 사용하려는 OS AWS 리전 및 아키텍처로 원하는 AMI를 필터링`--architecture`할 특정 `--os` 및 파라미터를 `--region` 선택합니다. 출력에서 Amazon EC2 이미지 ID를 검색합니다.
1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) Amazon EC2 콘솔을 엽니다.
1. 탐색 창에서 **이미지**와 **AMI**를 선택합니다. 검색된 EC2 이미지 ID를 검색하고 AMI를 선택한 다음 **AMI에서 인스턴스 시작**을 선택합니다.
1. 아래로 스크롤하여 **인스턴스 유형**을 선택합니다.
1. **키 페어**를 선택하고 **인스턴스를 시작합니다**.
1. OS 사용자와 SSH 키를 사용하여 인스턴스에 로그인합니다.
1. 요구 사항에 맞추어 인스턴스를 수동으로 사용자 지정합니다.
1. 다음 명령을 실행하여 AMI 생성을 위해 인스턴스를 준비합니다.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. 콘솔에서 **인스턴스 상태**와 **인스턴스 중지**를 선택합니다.
**인스턴스**를 중지하려면 인스턴스를 선택하고 **인스턴스 상태**, **인스턴스 중지**를 차례로 선택합니다.
1. Amazon EC2 콘솔 또는 AWS CLI [create-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)를 사용하여 인스턴스에서 새 AMI를 생성합니다.
**Amazon EC2 콘솔에서**
1. 탐색 창에서 **인스턴스**를 선택합니다.
1. 생성하고 수정한 인스턴스를 선택합니다.
1. **작업**, **이미지**, **이미지 생성**을 차례로 선택합니다.
1. **이미지 생성**을 선택합니다.
1. 클러스터를 생성하려면 클러스터 구성 내의 [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) 필드에 새 AMI ID를 입력합니다.
------
#### [ Old Amazon EC2 console ]
1. AWS 리전 사용하는 특정에 해당하는 AWS ParallelCluster AMI를 찾습니다. 명령을 `--region` 파라미터와 [`pcluster list-official-images`](pcluster.list-official-images-v3.md) 함께 사용하여 특정 AWS 리전 `--os` 및 `--architecture` 파라미터를 선택하여 사용하려는 OS 및 아키텍처로 원하는 AMI를 필터링할 수 있습니다. 출력에서 Amazon EC2 이미지 ID를 검색할 수 있습니다.
1. 에 로그인 AWS Management Console 하고 [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) Amazon EC2 콘솔을 엽니다.
1. 탐색 창에서 **이미지**와 **AMI**를 선택합니다. 필터를 **퍼블릭 이미지**로 설정하고 검색된 EC2 이미지 ID를 검색하고 AMI를 선택한 다음 **시작**을 선택합니다.
1. 인스턴스 유형을 선택하고 **다음: 인스턴스 세부 정보 구성** 또는 **검토 및 시작을** 선택하여 인스턴스를 시작합니다.
1. **시작**을 선택하고 **키 페어**를 선택한 다음 **인스턴스를 시작**합니다.
1. OS 사용자와 SSH 키를 사용하여 인스턴스에 로그인합니다. 자세한 내용을 보려면 **인스턴스**로 이동하여 새 인스턴스를 선택한 다음 **연결**을 선택하세요.
1. 요구 사항에 맞추어 인스턴스를 수동으로 사용자 지정합니다.
1. 다음 명령을 실행하여 AMI 생성을 위해 인스턴스를 준비합니다.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Amazon EC2 콘솔의 탐색 창에서 **인스턴스**를 선택하고 새 인스턴스를 선택한 다음 **작업**, **인스턴스 상태**, **중지**를 선택합니다.
1. Amazon EC2 콘솔 또는 AWS CLI [create-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)를 사용하여 인스턴스에서 새 AMI를 생성합니다.
**Amazon EC2 콘솔에서**
1. 탐색 창에서 **인스턴스**를 선택합니다.
1. 생성하고 수정한 인스턴스를 선택합니다.
1. **작업**, **이미지**, **이미지 생성**을 차례로 선택합니다.
1. **이미지 생성**을 선택합니다.
1. 클러스터를 생성하려면 클러스터 구성 내의 [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) 필드에 새 AMI ID를 입력합니다.
------
# Active Directory 통합
이 자습서에서는 다중 사용자 환경을 생성합니다. 이 환경에 AWS ParallelCluster 는의 (Active Directory)와 통합된가 AWS Managed Microsoft AD 포함되어 있습니다`corp.example.com`. `Admin` 사용자는 디렉터리를 관리하고, `ReadOnly` 사용자는 디렉터리를 읽고, `user000` 사용자는 클러스터에 로그인하도록 구성합니다. 자동 경로 또는 수동 경로를 사용하여 AD를 구성하는 데 사용하는 네트워킹 리소스, Active Directory(AD) 및 Amazon EC2 인스턴스를 만들 수 있습니다. 경로에 관계없이 생성하는 인프라는 다음 방법 중 하나를 AWS ParallelCluster 사용하여 통합되도록 사전 구성됩니다.
+ 인증서 검증이 포함된 LDAPS(가장 안전한 옵션으로 권장)
+ 인증서 검증이 없는 LDAPS
+ LDAP
LDAP 자체로는 암호화를 제공하지 않습니다**. 잠재적으로 민감한 정보를 안전하게 전송하려면 AD와 통합된 클러스터에는 LDAPS(LDAP over TLS/SSL)를 사용하는 것이 좋습니다. 자세한 내용은 Directory Service *관리 안내서*의를 [사용하여 서버 측 LDAPS 활성화 AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html)를 참조하세요.
이러한 리소스를 만든 후에는 Active Directory(AD)와 통합된 클러스터를 구성하고 생성하세요. 클러스터가 생성된 후에는 생성한 사용자로 로그인합니다. 이 자습서에서 생성하는 구성에 대한 자세한 내용은 [클러스터에 대한 다중 사용자 액세스](multi-user-v3.md) 및 [`DirectoryService`](DirectoryService-v3.md) 구성 섹션을 참조하세요.
이 자습서에서는 클러스터에 대한 다중 사용자 액세스를 지원하는 환경을 만드는 방법을 다룹니다. 이 자습서에서는 Directory Service AD를 생성하고 사용하는 방법을 다루지 않습니다. 이 자습서 AWS Managed Microsoft AD 에서를 설정하기 위해 수행하는 단계는 테스트 목적으로만 제공됩니다.Directory Service 관리 안내서**의 [AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html) 및 [Simple AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html)에서 찾을 수 있는 공식 설명서 및 모범 사례를 대체하기 위해 제공되는 것은 아닙니다**.
**참고**
디렉터리 사용자 암호는 디렉터리 암호 정책 속성 정의에 따라 만료됩니다. 를 사용하여 디렉터리 암호를 재설정하려면 섹션을 AWS ParallelCluster참조하세요[사용자 암호 및 만료된 암호를 재설정하는 방법](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd).
**참고**
디렉터리 도메인 컨트롤러 IP 주소는 도메인 컨트롤러 변경 및 디렉터리 유지 보수로 인해 변경될 수 있습니다. 디렉터리 인프라를 생성하기 위해 자동화된 빠른 생성 방법을 선택한 경우 디렉터리 IP 주소가 변경될 때 디렉터리 컨트롤러 앞에 로드 밸런서를 수동으로 정렬해야 합니다. 빠른 생성 메서드를 사용하는 경우 디렉터리 IP 주소가 로드 밸런서와 자동으로 정렬되지 않습니다.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
자습서를 진행하면서 `region-id` 및 `d-abcdef01234567890`과 같은 `inputs highlighted in red`를 자신의 이름과 ID로 바꾸세요. `0123456789012`를 사용자 AWS 계정 번호로 바꿉니다.
# AD 인프라 생성
*자동* 탭을 선택하여 CloudFormation 빠른 생성 템플릿을 사용하여 Active Directory(AD) 인프라를 생성합니다.
수동** 탭을 선택하여 AD 인프라를 수동으로 생성합니다.
## 자동
1. AWS Management Console에 로그인합니다.
1. [CloudFormation 빠른 생성(리전 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)을 열어 CloudFormation 콘솔에서 다음 리소스를 생성합니다.
+ VPC가 지정되지 않은 경우 서브넷 2개와 퍼블릭 액세스를 위한 라우팅이 있는 VPC.
+ AWS Managed Microsoft AD.
+ 디렉터리를 관리하는 데 사용할 수 있는 AD에 조인된 Amazon EC2 인스턴스.
1. **빠른 스택 생성** 페이지 **파라미터** 섹션에서 다음 파라미터의 암호를 입력합니다.
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
암호를 기록해 둡니다. 이 자습서 뒷부분에서 이 정보가 필요합니다.
1. **DomainName**에는 **corp.example.com**을 입력합니다.
1. **Keypair**에는 Amazon EC2 키 페어의 이름을 입력합니다.
1. 페이지 하단에서 각 액세스 기능이 필요함을 확인하는 확인란을 선택합니다.
1. **스택 생성**을 선택합니다.
1. CloudFormation 스택이 `CREATE_COMPLETE` 상태에 도달한 후 스택의 **출력** 탭을 선택합니다. 출력 리소스 이름과 ID는 이후 단계에서 사용해야 하므로 기록해 두세요. 출력은 클러스터를 생성하는 데 필요한 정보를 제공합니다.
![\[AWS Management Console에서 생성된 스택 출력을 보여주는 다이어그램.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/ad-cfn.png)
1. [(선택 사항)AD 사용자 및 그룹 관리](tutorials_05_multi-user-ad-step2.md) 연습을 완료하려면 디렉터리 ID가 필요합니다. **리소스**를 선택하고 아래로 스크롤하여 디렉터리 ID를 기록해 둡니다.
1. [(선택 사항)AD 사용자 및 그룹 관리](tutorials_05_multi-user-ad-step2.md) 또는 [클러스터 생성](tutorials_05_multi-user-ad-step3.md)에서 계속하세요.
## 수동
다양한 가용 영역 및 AWS Managed Microsoft AD에 있는 두 개의 서브넷으로 디렉터리 서비스용 VPC를 생성합니다.
### AD 생성
**참고**
디렉터리 및 도메인 이름은 `corp.example.com`입니다. 짧은 이름은 `CORP`입니다.
스크립트에서 `Admin` 암호를 변경합니다.
Active Directory(AD)를 생성하는 데 최소 15분이 걸립니다.
다음 Python 스크립트를 사용하여 로컬에서 VPC, 서브넷 및 AD 리소스를 생성합니다 AWS 리전. 이 파일을 `ad.py`로 저장하고 실행하세요.
```
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})
```
다음은 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"
}
```
출력 리소스 이름 및 ID를 적어 두세요. 이후 단계에서 사용하게 됩니다.
스크립트가 완료되면 다음 단계를 계속합니다.
### Amazon EC2 인스턴스 생성
------
#### [ New Amazon EC2 console ]
1. AWS Management Console에 로그인합니다.
1. 첨부된 4단계에 나열된 정책에 해당하는 역할이 없는 경우 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 여세요. 그렇지 않으면 5단계로 건너뛰세요.
1. `ResetUserPassword` 정책을 생성하여 빨간색으로 강조 표시된 콘텐츠를 AD를 생성하기 위해 실행한 스크립트 출력의 AWS 리전 ID, 계정 ID 및 디렉터리 ID로 바꿉니다.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. 다음과 같은 정책을 연결하여 IAM 역할을 생성합니다.
+ AWS 관리형 정책 [AmazonSSMManagedInstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS 관리형 정책 [AmazonSSMDirectoryServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword 정책
1. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)에서 Amazon EC2 콘솔을 엽니다.
1. **Amazon EC2 대시보드**에서 **인스턴스 시작**을 선택하세요.
1. **애플리케이션 및 OS 이미지**에서 최신 Amazon Linux 2 AMI를 선택합니다.
1. **인스턴스 유형**에서 t2.micro를 선택합니다.
1. **키 페어(로그인)**에서 키 페어를 선택합니다.
1. **네트워크 설정**에서 **편집**을 선택합니다.
1. **VPC**에서 디렉터리 VPC를 선택합니다.
1. 아래로 스크롤하여 **고급 세부 정보**를 선택합니다.
1. **고급 세부 정보**의 **도메인 가입 디렉터리**에서 **corp.example.com**을 선택합니다.
1. **IAM 인스턴스 프로파일**에서 1단계에서 생성한 역할 또는 4단계에서 나열된 정책이 연결된 역할을 선택합니다.
1. **요약**에서 **인스턴스 시작**을 선택합니다.
1. 인스턴스 ID(예: i-1234567890abcdef0)를 기록하고 인스턴스 시작이 완료될 때까지 기다립니다.
1. 인스턴스가 시작된 후 이어서 다음 단계를 수행합니다.
------
#### [ Old Amazon EC2 console ]
1. AWS Management Console에 로그인합니다.
1. 첨부된 4단계에 나열된 정책에 해당하는 역할이 없는 경우 [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/)에서 IAM 콘솔을 여세요. 그렇지 않으면 5단계로 건너뛰세요.
1. `ResetUserPassword` 정책을 생성합니다. 빨간색으로 강조 표시된 콘텐츠를 Active Directory(AD)를 생성하기 위해 실행한 스크립트 출력의 AWS 리전 ID, AWS 계정 ID 및 디렉터리 ID로 바꿉니다.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. 다음과 같은 정책을 연결하여 IAM 역할을 생성합니다.
+ AWS 관리형 정책 [AmazonSSMManagedInstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS 관리형 정책 [AmazonSSMDirectoryServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword 정책
1. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)에서 Amazon EC2 콘솔을 엽니다.
1. **Amazon EC2 대시보드**에서 **인스턴스 시작**을 선택하세요.
1. **애플리케이션 및 OS 이미지**에서 최신 Amazon Linux 2 AMI를 선택합니다.
1. **인스턴스 유형**에서 t2.micro를 선택합니다.
1. **키 페어(로그인)**에서 키 페어를 선택합니다.
1. **네트워크 설정**에서 **편집**을 선택합니다.
1. **네트워크 설정**, **VPC**에서 디렉터리 VPC를 선택합니다.
1. 아래로 스크롤하여 **고급 세부 정보**를 선택합니다.
1. **고급 세부 정보**의 **도메인 가입 디렉터리**에서 **corp.example.com**을 선택합니다.
1. **고급 세부 정보**, **인스턴스 프로파일**에서 1단계에서 생성한 역할 또는 4단계에서 나열한 정책이 연결된 역할을 선택합니다.
1. **요약**에서 **인스턴스 시작**을 선택합니다.
1. 인스턴스 ID(예:i-1234567890abcdef0) 를 메모하고 인스턴스 시작이 완료될 때까지 기다립니다.
1. 인스턴스가 시작된 후 이어서 다음 단계를 수행합니다.
------
### 인스턴스를 AD에 조인합니다.
1.
**인스턴스에 연결하고 `admin`로서 AD Realm에 조인하세요.**
인스턴스에 연결하고 다음 명령을 실행합니다.
```
$ 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.
**필요한 소프트웨어를 설치하고 Realm에 조인하세요.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**관리자 암호를 `admin` 암호로 바꿉니다.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
위의 방법이 성공하면 Realm에 조인되어 다음 단계를 진행할 수 있습니다.
### AD에 사용자 추가
1.
**ReadOnlyUser 및 추가 사용자를 생성합니다.**
이 단계에서는 이전 단계에서 설치한 [adcli](https://www.mankier.com/package/adcli) 및 [openldap-client](https://www.mankier.com/package/openldap-clients) 도구를 사용합니다.
```
$ 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. 사용자가 생성되었는지 확인합니다.****
디렉터리 DNS IP 주소는 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"
```
기본적으로 `ad-cli`를 사용하여 사용자를 생성하면 해당 사용자는 비활성화됩니다.
1.
**로컬 시스템에서 사용자 암호 재설정 및 활성화:******
Amazon EC2 인스턴스에서 로그아웃합니다.
**참고**
`ro-p@ssw0rd`는에서 `ReadOnlyUser`가져온의 암호입니다 AWS Secrets Manager.
`user-p@ssw0rd`는 클러스터에 연결(`ssh`)할 때 제공되는 클러스터 사용자의 암호입니다.
`directory-id`는 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. Secrets Manager 보안 암호에 암호를 추가합니다.****
이제를 생성하고 암호를 `ReadOnlyUser` 설정했으므로가 로그인을 검증하는 데 AWS ParallelCluster 사용하는 보안 암호에 저장합니다.
Secrets Manager를 사용하여 `ReadOnlyUser`의 암호를 값으로 보관할 새 보안 암호를 생성합니다. 보안 암호 값 형식은 JSON 형식이 아닌 일반 텍스트만 사용해야 합니다. 향후 단계를 위해 보안 암호 ARN을 기록해 두세요.
```
$ 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 설정
리소스 ID를 기록해 두세요. 이후 단계에서 사용하게 됩니다.
1.
**로컬에서 도메인 인증서를 생성합니다.**
```
$ 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.
**인증서를 Secrets Manager에 저장하여 나중에 클러스터 내에서 검색할 수 있도록 합니다.**
```
$ 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. Amazon EC2 인스턴스를 AD 도메인에 조인하기 위해 생성한 IAM 역할에 다음 정책을 추가합니다.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**인증서를 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.
**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.
**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.
**Active Directory(AD) 엔드포인트를 대상 그룹에 등록합니다.**
```
$ 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.
**인증서를 사용하여 LB 리스너를 생성합니다.**
```
$ 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.
**클러스터 VPC 내에서 도메인을 검색할 수 있도록 호스팅 영역을 생성합니다.**
```
$ 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.
**다음 콘텐츠가 포함된 `recordset-change.json`라는 이름의 파일을 추가합니다. `HostedZoneId`는 로드 밸런서의 표준 호스팅 영역 ID입니다.**
```
{
"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.
**이번에는 호스팅 영역 ID를 사용하여 레코드세트 변경 내용을 호스팅 영역에 제출합니다.**
```
$ 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.
**다음 콘텐츠가 포함된 정책 문서 `policy.json`을 생성합니다.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**다음 콘텐츠가 포함된 `policy.json`라는 정책 문서를 생성합니다.**
```
$ 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. [(선택 사항)AD 사용자 및 그룹 관리](tutorials_05_multi-user-ad-step2.md) 또는 [클러스터 생성](tutorials_05_multi-user-ad-step3.md)의 단계를 계속 따르세요.
# (선택 사항)AD 사용자 및 그룹 관리
이 단계에서는 Active Delivery(AD) 도메인에 연결된 Amazon EC2 Amazon Linux 2 인스턴스에서 사용자와 그룹을 관리합니다.
자동** 경로를 따랐다면 자동화의 일부로 생성된 AD 조인 인스턴스를 다시 시작하고 로그인하세요.
수동** 경로를 따랐다면 이전 단계에서 만들고 AD에 연결한 인스턴스를 다시 시작하고 로그인하세요.
이 단계에서는 이전 단계의 일부로 인스턴스에 설치된 [adcli](https://www.mankier.com/package/adcli) 및 [openldap-client](https://www.mankier.com/package/openldap-clients) 도구를 사용합니다.
**AD 도메인에 연결된 Amazon EC2 인스턴스에 로그인합니다.**
1. Amazon EC2 콘솔에서 이전 단계에서 생성한 제목 없는 Amazon EC2 인스턴스를 선택합니다. 인스턴스가 **중지된** 상태여야 합니다.
1. 인스턴스 상태가 **중지된** 경우** 인스턴스 상태**를 선택한 다음 **인스턴스 시작**을 선택합니다.
1. 상태 확인이 통과되면 인스턴스를 선택하고 **연결** 및 SSH를 선택하고 인스턴스에 로그인합니다.
**AD에 조인된 Amazon EC2 Amazon Linux 2 인스턴스에 로그인한 사용자 및 그룹을 관리합니다.**
` -U "Admin"` 옵션을 사용하여 `adcli` 명령을 실행하면 AD `Admin` 암호를 입력하라는 메시지가 표시됩니다. AD `Admin` 암호를 `ldapsearch` 명령의 일부로 포함합니다.
1.
**사용자를 생성합니다.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**사용자 암호를 재설정합니다.**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**그룹을 생성합니다.**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**그룹에 사용자를 추가합니다.**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**사용자 및 그룹을 설명합니다.**
모든 사용자를 설명합니다.
```
$ 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"
```
특정 사용자를 설명합니다.
```
$ 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"
```
이름 패턴으로 모든 사용자를 설명합니다.
```
$ 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"
```
특정 그룹에 속한 모든 사용자를 설명합니다.
```
$ 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"
```
모든 그룹을 설명합니다.
```
$ 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"
```
특정 그룹을 설명합니다.
```
$ 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.
**그룹에서 사용자를 제거합니다.**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**사용자를 삭제합니다.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**그룹을 삭제합니다.**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# 클러스터 생성
Amazon EC2 인스턴스를 종료하지 않았다면 지금 종료하세요.
환경은 Active Directory(AD)에 대해 사용자를 인증할 수 있는 클러스터를 생성하도록 설정되어 있습니다.
간단한 클러스터 구성을 만들고 AD 연결과 관련된 설정을 제공합니다. 자세한 내용은 [`DirectoryService`](DirectoryService-v3.md)(을)를 참조하세요.
다음 클러스터 구성 중 하나를 선택하고 `ldaps_config.yaml`, `ldaps_nocert_config.yaml` 또는 `ldap_config.yaml`이라는 이름의 파일에 복사합니다.
인증서 검증이 있는 LDAPS 구성을 선택하는 것이 좋습니다. 이 구성을 선택하는 경우 부트스트랩 스크립트도 `active-directory.head.post.sh`로 이름이 지정된 파일에 복사해야 합니다. 그리고 구성 파일에 표시된 대로 Amazon S3 버킷에 저장해야 합니다.
## 인증서 검증 구성이 포함된 LDAPS(권장)
**참고**
`KeyName`: Amazon EC2 키페어 중 하나입니다.
`SubnetId / SubnetIds`: CloudFormation 빠른 생성 스택(자동 자습서) 또는 python 스크립트(수동 자습서)의 출력에 제공된 서브넷 ID 중 하나입니다.
`Region`: AD 인프라를 생성한 리전입니다.
`DomainAddr`: 이 IP 주소는 AD 서비스의 DNS 주소 중 하나입니다.
`PasswordSecretArn`: `DomainReadOnlyUser`의 암호가 포함된 보안 암호의 Amazon 리소스 이름(ARN)입니다.
`BucketName`: 부트스트랩 스크립트가 들어 있는 버킷의 이름입니다..
`AdditionalPolicies`/`Policy`: 읽기 도메인 인증 정책 ReadCertExample의 Amazon 리소스 이름(ARN)입니다.
`CustomActions`/`OnNodeConfigured`/`Args`: 도메인 인증 정책을 보유하는 보안 암호의 Amazon 리소스 이름(ARN).
더 나은 보안 태세를 위해 `HeadNode` / `Ssh` / `AllowedIps` 구성을 사용하여 헤드 노드에 대한 SSH 액세스를 제한하는 것이 좋습니다.
에 지정된 인증서는 모든 클러스터 노드에서 액세스할 수 있어야 `LdapTlsCaCert` 합니다.
**하드 요구 사항**
에 지정된 인증서는 모든 클러스터 노드에서 액세스할 수 있어야 `LdapTlsCaCert` 합니다.
인증서에 액세스할 수 없는 노드는 디렉터리에서 사용자를 확인할 수 없습니다.
```
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
```
부트스트랩 스크립트****
부트스트랩 파일을 생성한 후 S3 버킷에 업로드하기 전에를 실행`chmod +x active-directory.head.post.sh`하여 AWS ParallelCluster 실행 권한을 부여합니다.
```
#!/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
**참고**
`KeyName`: Amazon EC2 키페어 중 하나입니다.
`SubnetId / SubnetIds`: CloudFormation 빠른 생성 스택(자동 자습서) 또는 python 스크립트(수동 자습서)의 출력에 있는 서브넷 ID 중 하나입니다.
`Region`: AD 인프라를 생성한 리전입니다.
`DomainAddr`: 이 IP 주소는 AD 서비스의 DNS 주소 중 하나입니다.
`PasswordSecretArn`: `DomainReadOnlyUser`의 암호가 포함된 보안 암호의 Amazon 리소스 이름(ARN)입니다.
보안 태세를 강화하려면 HeadNode/Ssh/AllowedIps 구성을 사용하여 헤드 노드에 대한 SSH 액세스를 제한하는 것이 좋습니다.
```
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
```
## LDAP 구성
**참고**
`KeyName`: Amazon EC2 키페어 중 하나입니다.
`SubnetId / SubnetIds`: CloudFormation 빠른 생성 스택(자동 자습서) 또는 python 스크립트(수동 자습서)의 출력에 제공된 서브넷 ID 중 하나입니다.
`Region`: AD 인프라를 생성한 리전입니다.
`DomainAddr`: 이 IP 주소는 AD 서비스의 DNS 주소 중 하나입니다.
`PasswordSecretArn`: `DomainReadOnlyUser`의 암호가 포함된 보안 암호의 Amazon 리소스 이름(ARN)입니다.
보안 태세를 강화하려면 HeadNode/Ssh/AllowedIps 구성을 사용하여 헤드 노드에 대한 SSH 액세스를 제한하는 것이 좋습니다.
```
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
```
다음 명령을 사용하여 클러스터를 생성합니다.
```
$ 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"
}
}
```
# 사용자로서 클러스터에 연결
다음 명령을 사용하여 클러스터의 상태를 확인할 수 있습니다.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
출력값은 다음과 같습니다.
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
상태가 `"CREATE_COMPLETE"`가 되면 생성한 사용자 이름과 암호로 로그인합니다.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
`/home/user000@HEAD_NODE_IP/.ssh/id_rsa`에서 새 사용자를 위해 만든 SSH 키를 입력하면 암호 없이 로그인할 수 있습니다.
`ssh` 명령이 성공하면 Active Director (AD)를 사용하도록 인증된 사용자로 클러스터에 성공적으로 연결한 것입니다.
# 정리
1.
**로컬 시스템에서 클러스터를 삭제합니다.**
```
$ 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.
**삭제 중인 클러스터의 진행 상태를 확인합니다.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
클러스터가 성공적으로 삭제되면 다음 단계를 진행합니다.
## 자동
**Active Directory 리소스를 삭제합니다.**
1. [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/)으로 이동합니다.
1. 탐색 창에서 **스택**을 선택합니다.
1. 스택 목록에서 AD 스택(예:`pcluster-ad`)을 선택합니다.
1. **삭제**를 선택합니다.
## 수동
1.
**Amazon EC2 인스턴스를 삭제합니다.**
1. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) 에서 탐색 창에서 **인스턴스**를 선택합니다.
1. 디렉터리에 사용자를 추가하기 위해 생성한 인스턴스를 인스턴스 목록에서 선택합니다.
1. **인스턴스 상태**를 선택한 뒤 **인스턴스 종료**를 선택하세요.
1.
**호스팅 영역을 삭제합니다.**
1. 다음과 같은 콘텐츠로 `recordset-delete.json`을 생성합니다. 이 예시에서 HostedZoneID는 로드 밸런서의 표준 호스팅 영역 ID입니다.
```
{
"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. 호스팅 영역 ID를 사용하여 레코드세트 변경 내용을 호스팅 영역에 제출하세요.
```
$ 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. 호스팅 영역을 삭제합니다.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**LB 리스너를 삭제합니다.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**대상 그룹을 삭제합니다.**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**로드 밸런서를 삭제합니다.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**클러스터가 Secrets Manager에서 인증서를 읽는 데 사용하는 정책을 삭제합니다.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**도메인 인증서가 포함된 암호를 삭제합니다.**
```
$ 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.
**ACM에서 인증서를 삭제합니다.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Active Directory(AD) 리소스를 삭제합니다.**
1. Python 스크립트 `ad.py`의 출력에서 다음 리소스 ID를 가져옵니다.
+ AD ID
+ AD 서브넷 ID
+ AD VPC ID
1. 다음 명령을 실행하여 디렉터리를 삭제합니다.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. VPC의 보안 그룹을 나열합니다.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. 사용자 지정 보안 그룹을 삭제합니다.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. 서브넷을 삭제합니다.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. 인터넷 게이트웨이를 설명합니다.
```
$ 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. 인터넷 게이트웨이를 분리합니다.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. 인터넷 게이트웨이를 삭제합니다.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. VPC를 삭제합니다.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. `ReadOnlyUser` 암호가 포함된 보안 암호를 삭제합니다.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# AWS KMS 키를 사용하여 공유 스토리지 암호화 구성
에 대해 구성된 클러스터 파일 스토리지 시스템에서 데이터를 암호화하고 보호하도록 고객 관리형 AWS KMS 키를 설정하는 방법을 알아봅니다 AWS ParallelCluster.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
AWS ParallelCluster 는 다음과 같은 공유 스토리지 구성 옵션을 지원합니다.
+ [`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)
이러한 옵션을 사용하여 Amazon EBS, Amazon EFS 및 FSx for Lustre 공유 스토리지 시스템 암호화에 대한 고객 관리형 AWS KMS 키를 제공할 수 있습니다. 이를 사용하려면 다음 항목에 대한 IAM 정책을 만들고 구성해야 합니다.
+ [`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)
**사전 조건**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
**Topics**
+ [
# 정책을 생성합니다.
](creating-the-role-v3.md)
+ [
# 클러스터 구성 및 생성
](creating-the-cluster-v3.md)
# 정책을 생성합니다.
이 자습서에서는 AWS KMS 키를 사용하여 공유 스토리지 암호화를 구성하기 위한 정책을 생성합니다.
**정책을 생성합니다.**
1. IAM 콘솔 [https://console.aws.amazon.com/iam/home](https://console.aws.amazon.com/iam/home)으로 이동하세요.
1. **정책**을 선택하세요.
1. **정책 생성**을 선택합니다.
1. **JSON** 탭을 선택하고 다음 정책을 붙여넣습니다. 의 모든 발생을 AWS 계정 ID와 키 Amazon 리소스 이름(ARN)`123456789012`으로 바꾸고 AWS 리전 를 자신의 것으로 바꿔야 합니다.
------
#### [ 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. 이 튜토리얼에서는 정책 이름을 `ParallelClusterKmsPolicy`로 입력한 후 **정책 생성**을 선택하세요.
1. 정책 ARN을 기록해 둡니다. 클러스터를 구성하는 데 필요합니다.
# 클러스터 구성 및 생성
다음은 암호화가 적용된 Amazon Elastic Block Store 공유 파일 시스템을 포함하는 예제 클러스터 구성입니다.
```
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
```
빨간색 텍스트의 아이템을 원하는 값으로 교체합니다. 그런 다음 AWS KMS 키를 사용하여 Amazon EBS에서 데이터를 암호화하는 클러스터를 생성합니다.
구성은 Amazon EFS 및 FSx for Lustre 파일 시스템과 유사합니다.
Amazon EFS `SharedStorage` 구성은 다음과 같습니다.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
FSx for Lustre `SharedStorage` 구성은 다음과 같습니다.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# 다중 대기열 모드 클러스터에서 작업 실행
이 자습서에서는 AWS ParallelCluster [여러 대기열 모드로](configuration-of-multiple-queues-v3.md)에서 첫 번째 "Hello World" 작업을 실행하는 방법을 다룹니다.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
## 클러스터 구성
먼저 다음 명령을 실행하여 AWS ParallelCluster 가 올바르게 설치되었는지 확인합니다.
```
$ pcluster version
```
`pcluster version`에 대한 자세한 정보는 [`pcluster version`](pcluster.version-v3.md) 섹션을 참조하세요.
이 명령은의 실행 버전을 반환합니다 AWS ParallelCluster.
다음으로 `pcluster configure`을 실행하여 기본 구성 파일을 생성합니다. 이 명령 다음에 나오는 모든 메시지를 따릅니다.
```
$ pcluster configure --config multi-queue-mode.yaml
```
`pcluster configure` 명령에 대한 자세한 내용은 [`pcluster configure`](pcluster.configure-v3.md) 섹션을 참조하세요.
이 단계를 완료한 후에는 `multi-queue-mode.yaml`이라는 기본 구성 파일이 나타납니다. 이 파일에는 기본 클러스터 구성이 들어 있습니다.
다음 단계에서는 새 구성 파일을 수정하고 대기열이 여러 개 있는 클러스터를 시작합니다.
**참고**
이 자습서에서 사용된 일부 인스턴스는 프리 티어에 사용할 수 없습니다.
이 자습서에서는 다음 구성과 일치하도록 구성 파일을 수정하세요. 빨간색으로 강조 표시된 항목은 구성 파일 값을 나타냅니다. 자신의 고유한 값을 유지하세요.
```
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
```
## 클러스터 생성
구성 파일을 기반으로 `multi-queue-cluster`라는 이름이 지정된 클러스터를 만드세요.
```
$ 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"
}
}
```
`pcluster create-cluster` 명령에 대한 자세한 내용은 [`pcluster create-cluster`](pcluster.create-cluster-v3.md) 섹션을 참조하세요.
다음 명령을 실행하여 클러스터 상태를 확인합니다.
```
$ 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"
}
}
```
클러스터가 생성되면 `clusterStatus` 필드가 `CREATE_COMPLETE`를 표시합니다.
## 헤드 노드에 로그인
프라이빗 SSH 키 파일을 사용하여 헤드 노드에 로그인합니다.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
`pcluster ssh`에 대한 자세한 정보는 [`pcluster ssh`](pcluster.ssh-v3.md) 섹션을 참조하세요.
로그인되면 `sinfo` 명령을 실행하여 스케줄러 대기열이 설정 및 구성되어 있는지 확인합니다.
`sinfo`에 대한 자세한 내용은 Slurm 설명서**에서 [sinfo](https://slurm.schedmd.com/sinfo.html) 섹션을 참조하세요.
```
$ 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]
```
출력에는 클러스터에서 사용할 수 있는 `idle` 상태에 `t2.micro` 하나 및 `c5.xlarge` 컴퓨팅 노드 하나가 있는 것으로 표시됩니다.
다른 노드는 모두 절전 상태이며, 노드 상태에서는 `~` 접미사로 표시되며, 이를 뒷받침하는 Amazon EC2 인스턴스가 없습니다. 기본 대기열은 대기열 이름 뒤에 `*` 접미사로 표시됩니다. `spot`은 기본 작업 대기열입니다.
## 다중 대기열 모드에서 작업 실행
그런 다음 작업을 실행하여 잠시 휴면 모드로 전환해 보세요. 작업은 나중에 자체 호스트 이름을 출력합니다. 현재 사용자가 이 스크립트를 실행할 수 있는지 확인하세요.
```
$ tee <
이 자습서에서는 [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) 및 CloudFormation 템플릿을 사용하여 API를 빌드하고 테스트합니다. AWS ParallelCluster CloudFormation 그런 다음 GitHub에서 제공되는 예제 클라이언트를 사용하여 API를 사용합니다. API 사용에 대한 자세한 내용은 [AWS ParallelCluster API](api-reference-v3.md)를 참조하세요.
자세한 내용은 *EC2 * [ Image Builder 사용 설명서의 Image Builder를 사용하여 사용자 지정 구성 요소 생성을](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) 참조하세요.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건**
+ AWS CLI 는 컴퓨팅 환경에 [설치](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 및 구성됩니다.
+ AWS ParallelCluster 는 가상 환경에 설치됩니다. 자세한 내용은 [AWS ParallelCluster 가상 환경에 설치(권장)](install-v3-virtual-environment.md) 단원을 참조하십시오.
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
## 1단계: Amazon API Gateway를 사용하여 API 구축
**홈 사용자 디렉터리에 머물면서 가상 환경을 활성화하세요.**
1. 유용한 JSON 명령줄 프로세서를 설치하세요.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. 다음 명령을 실행하여 AWS ParallelCluster 버전을 가져와 환경 변수에 할당합니다.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. 환경 변수를 만들고 해당 변수에 리전 ID를 할당합니다.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. 다음 명령을 실행하여 VPC를 배포합니다.
```
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"
}
```
프로세스가 완료되면 다음 단계로 진행합니다.
## 2단계: Amazon API Gateway 콘솔의 API를 테스트합니다.
1. AWS Management Console에 로그인합니다.
1. [Amazon API Gateway 콘솔](https://console.aws.amazon.com/apigateway/home)로 이동합니다.
1. API 배포를 선택합니다.
![\[Amazon API Gateway 콘솔에는 선택할 수 있는 게이트웨이 목록이 있습니다.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/gateway_choose.png)
1. **스테이지**를 선택하고 스테이지를 선택합니다.
![\[스테이지를 선택할 수 있는 콘솔 보기입니다. API 게이트웨이가 API에 제공하는 URL도 볼 수 있습니다.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/gateway_address.png)
1. API 게이트웨이에서 API에 액세스하거나 API를 간접 호출하기 위해 제공하는 URL을 기록해 둡니다. 이것은 파란색으로 강조 표시되어 있습니다.
1. **리소스**를 선택하고 **`/clusters`** 아래의 **`GET`**을 선택합니다.
1. **테스트** 아이콘을 선택한 다음 아래로 스크롤하여 **테스트** 아이콘을 선택합니다.
![\[API 리소스 및 테스트 메커니즘의 콘솔 보기.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/gateway_test.png)
`/clusters GET`에 대한 응답이 나타납니다.
![\[API 리소스, 테스트 메커니즘, 테스트 요청의 응답에 대한 콘솔 보기.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/gateway.png)
## 3단계: API 간접 호출을 위한 예제 클라이언트 준비 및 테스트
AWS ParallelCluster 소스 코드를 `api` 디렉터리`cd`에 복제하고 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. 홈 사용자 디렉토리로 돌아갑니다.
1. 클라이언트가 실행 시 사용하는 API 게이트웨이 기본 URL을 내보냅니다.
```
$ 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. 클라이언트가 클러스터를 생성하는 데 사용하는 클러스터 이름을 내보냅니다.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. 다음 명령을 실행하여 예제 클라이언트가 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
```
## 4단계: 클라이언트 코드 스크립트 복사 및 클러스터 테스트 실행
1. 다음 예제 클라이언트 코드를 홈 사용자 디렉터리의 `test_pcluster_client.py`에 복사합니다. 클라이언트 코드는 다음을 수행하도록 요청합니다.
+ 클러스터를 생성합니다.
+ 클러스터를 설명합니다.
+ 클러스터를 나열합니다.
+ 컴퓨팅 플릿을 설명합니다.
+ 클러스터 인스턴스를 설명합니다.
```
# 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. 클러스터 구성을 생성합니다.
```
$ pcluster configure --config cluster-config.yaml
```
1. API 클라이언트 라이브러리는 환경 변수(예: `AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY` 또는 `AWS_SESSION_TOKEN`) 또는 `$HOME/.aws`에서 구성 세부 정보를 자동으로 검색합니다. 다음 명령은 현재 IAM 역할을 지정된 ParallelClusterApiUserRole로 전환합니다.
```
$ eval $(aws sts assume-role --role-arn ${PCLUSTER_API_USER_ROLE} --role-session-name ApiTestSession | jq -r '.Credentials | "export AWS_ACCESS_KEY_ID=\(.AccessKeyId)\nexport AWS_SECRET_ACCESS_KEY=\(.SecretAccessKey)\nexport AWS_SESSION_TOKEN=\(.SessionToken)\n"')
```
**주의해야 할 오류:**
다음과 비슷한 오류가 표시되면 이미 ParallelClusterApiUserRole 및 `AWS_SESSION_TOKEN`이 만료된 것으로 가정한 것입니다.
```
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
```
역할을 삭제한 다음 `aws sts assume-role` 명령을 다시 실행하여 ParallelClusterApiUserRole을 사용하세요.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
현재 사용자에게 API 액세스 권한을 제공하려면 [리소스 정책을 확장해야](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html) 합니다.
1. 다음 명령을 실행하여 예제 클라이언트를 시작합니다.
```
$ 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!
```
## 5단계: 클라이언트 코드 스크립트 복사 및 클러스터 삭제
1. 다음 예제 클라이언트 코드를 `delete_cluster_client.py`에 복사합니다. 클라이언트 코드는 클러스터 삭제를 요청합니다.
```
# 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. 다음 명령을 실행하여 클러스터를 삭제합니다.
```
$ 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. 테스트를 마친 후 환경 변수를 설정 해제하세요.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## 6단계: 정리
AWS Management Console 또는를 사용하여 API AWS CLI 를 삭제할 수 있습니다.
1. CloudFormation 콘솔에서 API 스택을 선택한 다음 **삭제**를 선택합니다.
1. AWS CLI를 사용 중이라면 다음 명령을 실행합니다.
사용 CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Slurm 화계를 사용하여 클러스터 생성
Slurm 회계를 사용하여 클러스터를 구성하고 생성하는 방법을 알아보세요. 자세한 내용은 [Slurm를 사용한 회계 AWS ParallelCluster](slurm-accounting-v3.md) 단원을 참조하십시오.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
이 자습서에서는 [CloudFormation 빠른 생성 템플릿(us-east-1)](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)를 생성합니다. 템플릿은 CloudFormation이 클러스터와 동일한 VPC에 Amazon Aurora 서버리스 데이터베이스를 배포하는 데 필요한 모든 구성 요소를 생성하도록 지시합니다. 또한 템플릿은 클러스터와 데이터베이스 간 연결을 위한 기본 네트워킹 및 보안 구성을 생성합니다.
**참고**
버전 3.3.0부터는 클러스터 구성 파라미터 [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [Database](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)로 Slurm 회계를 AWS ParallelCluster 지원합니다.
**참고**
빠른 생성 템플릿이 그 예시입니다. 이 템플릿은 Slurm 회계 데이터베이스 서버의 가능한 모든 사용 사례를 다루지는 않습니다. 프로덕션 워크로드에 적합한 구성과 용량을 갖춘 데이터베이스 서버를 만드는 것은 사용자의 책임입니다.
**사전 조건:**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있는 경우.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
+ 빠른 생성 템플릿을 배포하는 지역은 Amazon Aurora MySQL 서버리스 v2를 지원합니다. 자세한 내용은 [Aurora MySQL을 사용하는 Aurora Serverless v2](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)을 참조하세요.
## 1단계:에 대한 VPC 및 서브넷 생성 AWS ParallelCluster
제공된 CloudFormation 템플릿을 Slurm 회계 데이터베이스에 사용하려면 클러스터용 VPC가 준비되어 있어야 합니다. 이 작업은 수동으로 또는 [AWS ParallelCluster 명령줄 인터페이스를 사용하여 클러스터 구성 및 생성](install-v3-configuring.md) 절차의 일부로 수행할 수 있습니다. 이미 AWS ParallelCluster를 사용한 경우 클러스터 및 데이터베이스 서버를 배포할 수 있는 VPC가 준비되어 있을 수 있습니다.
## 2단계: 데이터베이스 스택 생성
[CloudFormation 빠른 생성 템플릿(us-east-1)](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml)을 사용하여 Slurm 회계를 위한 데이터베이스 스택을 생성할 수 있습니다. 템플릿에는 다음과 같은 입력이 필요합니다.
+ 데이터베이스 서버 보안 인증, 특히 관리자 사용자 이름과 암호
+ Amazon Aurora 서버리스 클러스터의 크기입니다. 이는 예상 클러스터 로드에 따라 달라집니다.
+ 네트워킹 파라미터, 특히 서브넷 생성을 위한 대상 VPC와 서브넷 또는 CIDR 블록
데이터베이스 서버에 적합한 보안 인증과 크기를 선택합니다. 네트워킹 옵션의 경우 AWS ParallelCluster 클러스터가 배포된 것과 동일한 VPC를 사용해야 합니다. 데이터베이스의 서브넷을 생성하여 템플릿의 입력으로 전달할 수 있습니다. 또는 두 서브넷에 대해 분리된 CIDR 블록 두 개를 제공하고 CloudFormation 템플릿에서 CIDR 블록을 위한 두 개의 서브넷을 생성하도록 하세요. CIDR 블록이 기존 서브넷과 겹치지 않는지 확인하세요. CIDR 블록이 기존 서브넷과 겹치는 경우 스택이 생성되지 않습니다.
데이터베이스 서버를 생성하는 데 몇 분 정도 걸립니다.
## 3단계: Slurm 회계가 활성화된 클러스터 생성
제공된 CloudFormation 템플릿은 일부 정의된 출력이 포함된 CloudFormation 스택을 생성합니다. 에서 CloudFormation 스택 보기의 출력 탭에서 **출력을** AWS Management Console볼 수 있습니다. Slurm 회계를 활성화하려면 AWS ParallelCluster 클러스터 구성 파일에서 다음 출력 중 일부를 사용해야 합니다.
+ `DatabaseHost`: [`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`: [`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`: [`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`: [`HeadNode`](HeadNode-v3.md)/[`Networking`](HeadNode-v3.md#HeadNode-v3-Networking)/[`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups) 구성 파라미터에 정의된 클러스터의 헤드 노드에 연결된 보안 그룹입니다.
클러스터 구성 파일 `Database` 파라미터를 출력 값으로 업데이트하세요. [`pcluster`](pcluster-v3.md) CLI를 사용하여 클러스터를 생성합니다.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
클러스터를 생성한 후 `sacctmgr` 또는 `sacct` 와 같은 Slurm 회계 명령을 사용할 수 있습니다.
# 외부 Slurmdbd 회계를 사용하여 클러스터 생성
외부 Slurmdbd 회계를 사용하여 클러스터를 구성하고 생성하는 방법을 알아봅니다. 자세한 내용은 [Slurm 회계를 AWS ParallelCluster](slurm-accounting-v3.md) 참조하세요.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 AWS 생성하거나 업데이트할 때 생성된 리소스에 대해서만 비용을 지불합니다. 자세한 내용은에서 [AWS 사용하는 서비스를 참조하세요 AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster UI는 서버리스 아키텍처를 기반으로 하며 대부분의 경우 AWS Free Tier 범주 내에서 사용할 수 있습니다. 자세한 내용은 [AWS ParallelCluster UI 비용](install-pcui-costs-v3.md)을 참조하십시오.
이 자습서에서는 AWS CloudFormation 빠른 생성 템플릿을 사용하여 클러스터와 동일한 VPC에 Slurmdbd 인스턴스를 배포하는 데 필요한 구성 요소를 생성합니다. 템플릿은 클러스터와 데이터베이스 간 연결을 위한 기본 네트워킹 및 보안 구성을 생성합니다.
**참고**
부터는 클러스터 구성 파라미터를 사용하여 외부 Slurmdbd를 `version 3.10.0` AWS ParallelCluster 지원합니다`SlurmSettings / ExternelSlurmdbd`.
**참고**
빠른 생성 템플릿이 그 예시입니다. 이 템플릿은 가능한 모든 사용 사례를 다루지는 않습니다. 프로덕션 워크로드에 적합한 구성과 용량을 갖춘 외부 Slurmdbd를 만드는 것은 사용자의 책임입니다.
**사전 조건:**
+ AWS ParallelCluster [가 설치](install-v3-parallelcluster.md)됩니다.
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon Elastic Compute Cloud 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)가 있습니다.
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한이](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) 있는 AWS Identity and Access Management 역할이 있습니다.
+ Slurm 회계 데이터베이스가 있습니다. Slurm 회계 데이터베이스 생성 자습서를 단계별로 살펴보려면 [Slurm 회계 데이터베이스 스택 생성](tutorials_07_slurm-accounting-v3.md)의 1단계와 2단계를 따르세요.
## 1단계: Slurmdbd 스택 생성
이 자습서에서는 [CloudFormation 빠른 생성 템플릿(`us-east-1`)](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)을 사용하여 Slurmdbd 스택을 생성합니다. 템플릿에는 다음과 같은 입력이 필요합니다.
**네트워킹**
+ **VPCId**: Slurmdbd 인스턴스를 시작할 VPC ID입니다.
+ **SubnetId**: Slurmdbd 인스턴스를 시작할 서브넷 ID입니다.
+ **PrivatePrefix**: VPC의 CIDR 접두사입니다.
+ **PrivateIp**: Slurmdbd 인스턴스에 할당할 보조 프라이빗 IP입니다.
**데이터베이스 연결**
+ **DBMSClientSG**: Slurmdbd 인스턴스에 연결할 보안 그룹입니다. 이 보안 그룹은 데이터베이스 서버와 Slurmdbd 인스턴스 간의 연결을 허용해야 합니다.
+ **DBMSDatabaseName**: 데이터베이스의 이름입니다.
+ **DBMSUsername**: 데이터베이스의 사용자 이름입니다.
+ **DBMSPasswordSecretArn**: 데이터베이스에 대한 암호를 포함하는 보안 암호입니다.
+ **DBMSUri**: 데이터베이스 서버의 URI입니다.
**인스턴스 설정**
+ **InstanceType**: slurmdbd 인스턴스에 사용할 인스턴스 유형입니다.
+ **KeyName**: slurmdbd 인스턴스에 사용할 Amazon EC2 키 페어입니다.
**Slurmdbd 설정**
+ **AMIID**: Slurmdbd 인스턴스의 AMI입니다. AMI는 ParallelCluster AMI여야 합니다. ParallelCluster AMI의 버전에 따라 Slurmdbd의 버전이 결정됩니다.
+ **MungeKeySecretArn**: Slurmdbd와 클러스터 간의 통신을 인증하는 데 사용할 munge 키가 포함된 보안 암호입니다.
+ **SlurmdbdPort**: slurmdbd에서 사용하는 포트 번호입니다.
+ **EnableSlurmdbdSystemService**: slurmdbd를 시스템 서비스로 활성화하고 인스턴스가 시작될 때 실행되도록 합니다.
**주의**
데이터베이스가 다른 버전의 SlurmDB에서 생성된 경우 Slurmdbd를 시스템 서비스로 사용하지 마세요.
데이터베이스에 많은 항목이 포함된 경우 Slurm Database Daemon (SlurmDBD)은 데이터베이스를 업데이트하고 이 시간 간격 동안 응답하지 않는 데 수십 분이 걸릴 수 있습니다.
SlurmDB를 업그레이드하기 전에 데이터베이스를 백업합니다. 자세한 내용은 [Slurm 설명서](https://slurm.schedmd.com/quickstart_admin.html#upgrade)를 참조하십시오.
## 2단계: 외부 Slurmdbd가 활성화된 클러스터 생성
제공된 CloudFormation 템플릿은 일부 정의된 출력이 있는 CloudFormation 스택을 생성합니다.
에서 CloudFormation 스택의 **출력** 탭을 AWS Management Console보고 생성된 엔터티를 검토합니다. Slurm 회계를 활성화하려면 이러한 출력 중 일부를 AWS ParallelCluster 구성 파일에 사용해야 합니다.
+ **SlurmdbdPrivateIp**: [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd) / [Host 클러스터 구성](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Host) 파라미터에 사용됩니다.
+ **SlurmdbdPort**: [ SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [ ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd) / [ 포트](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Port) 클러스터 구성 파라미터 값에 사용됩니다.
+ **AccountingClientSecurityGroup**: [HeadNode](HeadNode-v3.md) / [Networking](HeadNode-v3.md#HeadNode-v3-Networking) / [AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups) 구성 파라미터에 정의된 클러스터의 헤드 노드에 연결된 보안 그룹입니다.
또한 CloudFormation 스택 보기의 **파라미터** 탭에서 다음을 수행합니다.
+ **MungeKeySecretArn**: [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings) / [MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn) 클러스터 구성 파라미터 값에 사용됩니다.
클러스터 구성 파일 데이터베이스 파라미터를 출력 값으로 업데이트하세요. pcluster를 사용하여 클러스터를 AWS CLI 생성합니다.
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
클러스터를 생성한 후 `sacctmgr` 또는 `sacct` 와 같은 Slurm 회계 명령을 사용할 수 있습니다.
**주의**
`ParallelCluster`와 외부 SlurmDB간의 트래픽은 암호화되지 않습니다. 신뢰할 수 있는 네트워크에서 클러스터와 외부 SlurmDB를 실행하는 것이 좋습니다.
# 이전 AWS Systems Manager 문서 버전으로 되돌리기
이전 AWS Systems Manager 문서 버전으로 되돌리는 방법을 알아봅니다. 자세한 내용은AWS Systems Manager 사용 설명서**의 [AWS Systems Manager 문서](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html)를 참조하세요.
AWS ParallelCluster 명령줄 인터페이스(CLI) 또는 API를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건:**
+ SSM 문서를 관리할 수 있는 권한이 AWS 계정 있는 .
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
## 이전 SSM 문서 버전으로 되돌리기
1. 터미널에서 다음 명령을 실행하여 소유하고 있는 기존 SSM 문서 목록을 가져옵니다.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. SSM 문서를 이전 버전으로 되돌립니다. 이 예에서는 `SessionManagerRunShell` 문서의 이전 버전으로 되돌립니다. SSM `SessionManagerRunShell` 문서를 사용하여 시작하는 모든 SSM 쉘 세션을 사용자 지정할 수 있습니다.
1. 다음 명령어를 실행하여 `SessionManagerRunShell`을 위한 `DocumentVersion` 파라미터를 찾으세요.
```
$ 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": []
}
}
```
최신 버전은 `2`입니다.
1. 다음 명령을 실행하여 이전 버전으로 되돌립니다.
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. `describe-document` 명령을 다시 실행하여 문서 버전이 되돌려졌는지 확인합니다.
```
$ 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": []
}
}
```
최신 버전은 `1`입니다.
# 를 사용하여 클러스터 생성 CloudFormation
AWS ParallelCluster CloudFormation 사용자 지정 리소스를 사용하여 클러스터를 생성하는 방법을 알아봅니다. 자세한 내용은 [AWS CloudFormation 사용자 지정 리소스](cloudformation-v3.md) 단원을 참조하십시오.
를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스 AWS ParallelCluster에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건:**
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할
## CloudFormation 빠른 생성 스택을 사용한 클러스터 생성
이 자습서에서는 빠른 생성 스택을 사용하여 클러스터와 다음 AWS 리소스를 생성하는 CloudFormation 템플릿을 배포합니다.
+ CloudFormation 빠른 생성 스택을 사용하여 생성된 루트 CloudFormation 스택
+ 기본 정책, 기본 VPC 설정, 사용자 지정 리소스 공급자를 포함하는 중첩된 CloudFormation 스택
+ 예제 AWS ParallelCluster 클러스터 스택과에 로그인하고 작업을 실행할 수 있는 클러스터입니다.
**를 사용하여 클러스터 생성 AWS CloudFormation**
1. AWS Management Console에 로그인합니다.
1. CloudFormation [빠른 생성 링크](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)를 열어 CloudFormation 콘솔에서 다음 리소스를 생성합니다.
+ 클러스터 헤드 노드와 컴퓨팅 노드를 각각 실행하기 위한 퍼블릭 서브넷과 프라이빗 서브넷이 있는 VPC가 있는 중첩된 CloudFormation 스택
+ 클러스터를 관리하기 위한 AWS ParallelCluster 사용자 지정 리소스가 있는 중첩된 CloudFormation 스택입니다.
+ 클러스터 관리를 위한 기본 정책이 포함된 중첩된 CloudFormation 스택
+ 중첩된 스택을 위한 루트 CloudFormation 스택
+ Slurm 스케줄러와 정의된 수의 컴퓨팅 노드가 있는 AWS ParallelCluster 클러스터입니다.
![\[콘솔 CloudFormation의 빠른 생성 사용자 인터페이스\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. **빠른 스택 생성** **파라미터** 섹션에서 다음 파라미터의 값을 입력합니다.
1. **KeyName**에 Amazon EC2 키 페어의 이름을 입력합니다.
1. **AvailabilityZone**에 클러스터 노드의 AZ(예: `us-east-1a`)를 선택합니다.
1. 페이지 하단에서 각 액세스 기능이 필요함을 확인하는 확인란을 선택합니다.
1. **스택 생성**을 선택합니다.
1. CloudFormation 스택이 `CREATE_COMPLETE` 상태에 도달할 때까지 기다리세요.
## CloudFormation 명령줄 인터페이스(CLI)를 사용한 클러스터 생성
이 자습서에서는 CloudFormation용 AWS 명령줄 인터페이스(CLI)를 사용하여 클러스터를 생성하는 CloudFormation 템플릿을 배포합니다.
**다음 AWS 리소스를 생성합니다.**
+ CloudFormation 빠른 생성 스택을 사용하여 생성된 루트 CloudFormation 스택
+ 기본 정책, 기본 VPC 설정, 사용자 지정 리소스 공급자를 포함하는 중첩된 CloudFormation 스택
+ 예제 AWS ParallelCluster 클러스터 스택과에 로그인하고 작업을 실행할 수 있는 클러스터입니다.
*빨간색으로 강조 표시된 입력*(예: *키페어*)을 자체 값으로 바꿉니다.
**를 사용하여 클러스터 생성 AWS CloudFormation**
1. 다음 컨텐츠로 이름이 `cluster_template.yaml`인 CloudFormation 템플릿을 생성하세요.
```
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. 다음 AWS CLI 명령을 실행하여 클러스터 생성 및 관리를 위해 CloudFormation 스택을 배포합니다.
```
$ 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
```
## CloudFormation 클러스터 출력 보기
CloudFormation 클러스터 출력을 보고 유용한 클러스터 세부 정보를 얻을 수 있습니다. 추가된 `ValidationMessages` 속성은 클러스터 생성 및 업데이트 작업의 검증 메시지에 대한 액세스를 제공합니다.
1. [CloudFormation 콘솔](https://console.aws.amazon.com/cloudformation/home)로 이동하여 AWS ParallelCluster 사용자 지정 리소스가 포함된 스택을 선택합니다.
1. **스택 세부 정보**를 선택하고 **출력** 탭을 선택합니다.
![\[콘솔 CloudFormation은 HeadNodeIp 및 ValidationMessages의 값을 보여주는 테이블을 출력합니다.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/cfn-outputs.png)
검증 메시지는 잘릴 수 있습니다. 로그 검색에 대한 자세한 내용은 [AWS ParallelCluster 문제 해결](troubleshooting-v3.md) 섹션을 참조하세요.
## 클러스터에 액세스
클러스터에 액세스하세요.
**클러스터 헤드 노드에 `ssh`하세요.**
1. CloudFormation 스택 배포가 완료되면 다음 명령을 사용하여 헤드 노드의 IP 주소를 가져옵니다.
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
또한 CloudFormation 콘솔의 클러스터 스택 **출력** 탭에 있는 **HeadNodeIP** 파라미터에서 헤드 노드 IP 주소를 검색할 수 있습니다.
헤드 노드 IP 주소는 클러스터 CloudFormation 템플릿의 `Outputs` 섹션(특히 이 예제 클러스터의 경우)에 추가되었으므로 여기에서 찾을 수 있습니다.
1. 다음 명령을 실행하여 클러스터 헤드 노드에 연결합니다.
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## 정리
클러스터를 삭제합니다.
1. 다음 AWS CLI 명령을 실행하여 CloudFormation 스택과 클러스터를 삭제합니다.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. 다음 명령을 실행하여 스택 삭제 상태를 확인합니다.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# Terraform을 사용하여 ParallelCluster API 배포
이 자습서에서는 ParallelCluster API를 배포하는 간단한 Terraform 프로젝트를 정의합니다.
**사전 조건**
+ Terraform v1.5.7\$1가 설치되었습니다.
+ ParallelCluster API를 배포할 수 있는 권한이 있는 IAM 역할입니다. [필수 권한](tutorial-deploy-terraform-permissions.md)을(를) 참조하세요.
# Terraform 프로젝트 정의
이 자습서에서는 Terraform 프로젝트를 정의합니다.
1. 이름이 `my-pcluster-api`인 디렉터리를 생성합니다.
생성하는 모든 파일은 이 디렉터리 내에 있습니다.
1. 파일을 생성`provider.tf`하여 AWS 공급자를 구성합니다.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. `main.tf` 파일을 생성하여 ParallelCluster 모듈을 사용하여 리소스를 정의합니다.
```
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. `variables.tf` 파일을 생성하여 이 프로젝트에 주입할 수 있는 변수를 정의합니다.
```
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. `terraform.tfvars` 파일을 생성하여 변수에 대한 임의 값을 설정합니다.
아래 파일은 스택 이름를 `us-east-1` 사용하여에 ParallelCluster API 3.11.1을 배포합니다`MyParallelClusterAPI-3111`. 스택 이름을 사용하여 이 ParallelCluster API 배포를 참조할 수 있습니다.
**참고**
다음 코드의 `api_version` 할당은 지원되는 모든 AWS ParallelCluster 버전으로 대체할 수 있습니다.
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. `outputs.tf` 파일을 생성하여 이 프로젝트에서 반환되는 출력을 정의합니다.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
프로젝트 디렉터리:
```
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.
```
# API 배포
API를 배포하려면 표준 Terraform 명령을 순서대로 실행합니다.
1. 프로젝트 빌드:
```
terraform init
```
1. 배포 계획 정의:
```
terraform plan -out tfplan
```
1. 계획 배포:
```
terraform apply tfplan
```
# 필수 권한
Terraform을 사용하여 ParallelCluster API를 배포하려면 다음 권한이 필요합니다.
------
#### [ 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"
}
]
}
```
------
# Terraform을 사용하여 클러스터 생성
를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스 AWS ParallelCluster에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건**
+ Terraform v1.5.7\$1가 설치되었습니다.
+ [AWS ParallelCluster API](api-reference-v3.md) v3.8.0\$1가 계정에 배포됩니다. [Terraform을 사용하여 ParallelCluster API 배포](tutorial-deploy-terraform.md)을(를) 참조하세요.
+ ParallelCluster API를 간접적으로 호출할 수 있는 권한이 있는 IAM 역할입니다. [필수 권한] 참조
# Terraform 프로젝트 정의
이 자습서에서는 클러스터를 배포하기 위한 간단한 Terraform 프로젝트를 정의합니다.
1. 이름이 `my-clusters`인 디렉터리를 생성합니다.
생성하는 모든 파일은 이 디렉터리 내에 있습니다.
1. `terraform.tf` 파일을 생성하여 ParallelCluster 공급자를 가져옵니다.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. `providers.tf` 파일을 생성하여 ParallelCluster 및 AWS 공급자를 구성합니다.
```
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. `main.tf` 파일을 생성하여 ParallelCluster 모듈을 사용하여 리소스를 정의합니다.
```
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. `clusters.tf` 파일을 생성하여 여러 클러스터를 Terraform 로컬 변수로 정의합니다.
**참고**
`cluster_config` 요소 내에 여러 클러스터를 정의할 수 있습니다. 모든 클러스터에 대해 로컬 변수 내에서 클러스터 속성을 명시적으로 정의하거나(`DemoCluster01` 참조) 외부 파일을 참조할 수 있습니다(`DemoCluster02` 참조).
구성 요소 내에서 설정할 수 있는 클러스터 속성을 검토하려면 [클러스터 구성 파일](cluster-configuration-file-v3.md) 섹션을 참조하세요.
클러스터 생성을 위해 설정할 수 있는 옵션을 검토하려면 [`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. `config/clusters.yaml` 파일을 생성하여 여러 클러스터를 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. Terraform 변수를 삽입할 수 있는 표준 ParallelCluster 구성 파일인 `config/cluster_config.yaml` 파일을 생성합니다.
구성 요소 내에서 설정할 수 있는 클러스터 속성을 검토하려면 [클러스터 구성 파일](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. `clusters_vars.tf` 파일을 생성하여 클러스터 구성에 삽입할 수 있는 변수를 정의합니다.
이 파일을 사용하면 리전 및 서브넷과 같은 클러스터 구성에 사용할 수 있는 동적 값을 정의할 수 있습니다.
이 예제는 프로젝트 변수에서 직접 값을 검색하지만 사용자 지정 로직을 사용하여 값을 결정해야 할 수 있습니다.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. `variables.tf` 파일을 생성하여 이 프로젝트에 주입할 수 있는 변수를 정의합니다.
```
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. `terraform.tfvars` 파일을 생성하여 변수에 대한 임의 값을 설정합니다.
아래 파일은 스택 이름이 인에 이미 배포된 기존 ParallelCluster API 3.11.1을 `subnet-123456789`사용하여 서브넷 `eu-west-1` 내에서에 클러스터`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. `outputs.tf` 파일을 생성하여 이 프로젝트에서 반환되는 출력을 정의합니다.
```
output "clusters" {
value = module.pcluster.clusters
}
```
프로젝트 디렉터리:
```
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.
```
# 클러스터 배포
클러스터를 배포하려면 표준 Terraform 명령을 순서대로 실행합니다.
**참고**
이 예제에서는 계정에 ParallelCluster API를 이미 배포했다고 가정합니다.
1. 프로젝트 빌드:
```
terraform init
```
1. 배포 계획 정의:
```
terraform plan -out tfplan
```
1. 계획 배포:
```
terraform apply tfplan
```
## 클러스터를 사용하여 ParallelCluster API 배포
ParallelCluster API를 배포하지 않고 클러스터와 함께 배포하려는 경우 다음 파일을 변경합니다.
+ `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
}
```
# 필수 권한
Terraform을 사용하여 클러스터를 배포하려면 다음 권한이 필요합니다.
+ ParallelCluster API와의 상호 작용을 담당하는 ParallelCluster API 역할을 수임합니다.
+ ParallelCluster API의 CloudFormation 스택을 설명하여 API가 존재하는지 확인하고 파라미터 및 출력을 검색합니다.
------
#### [ 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"
}
]
}
```
------
# Terraform을 사용하여 사용자 지정 AMI 생성
를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스 AWS ParallelCluster에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건**
+ Terraform v1.5.7\$1가 설치되었습니다.
+ [AWS ParallelCluster API](api-reference-v3.md) v3.8.0\$1가 계정에 배포됩니다. [Terraform을 사용하여 클러스터 생성](tutorial-create-cluster-terraform.md)을(를) 참조하세요.
+ ParallelCluster API를 간접적으로 호출할 수 있는 권한이 있는 IAM 역할입니다. [필수 권한](tutorial-create-ami-terraform-permissions.md)을(를) 참조하세요.
# Terraform 프로젝트 정의
이 자습서에서는 ParallelCluster 사용자 지정 AMI를 배포하기 위한 간단한 Terraform 프로젝트를 정의합니다.
1. 이름이 `my-amis`인 디렉터리를 생성합니다.
생성하는 모든 파일은 이 디렉터리 내에 있습니다.
1. `terraform.tf` 파일을 생성하여 ParallelCluster 공급자를 가져옵니다.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. `providers.tf` 파일을 생성하여 ParallelCluster 및 AWS 공급자를 구성합니다.
```
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. `main.tf` 파일을 생성하여 ParallelCluster 모듈을 사용하여 리소스를 정의합니다.
`image_configuration` 요소 내에서 설정할 수 있는 이미지 속성을 검토하려면 [빌드 이미지 구성 파일](image-builder-configuration-file-v3.md) 섹션을 참조하세요.
이미지 생성을 위해 설정할 수 있는 옵션, 예를 들어 `image_id` 및 `rollback_on_failure`를 검토하려면 [`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. `variables.tf` 파일을 생성하여 이 프로젝트에 주입할 수 있는 변수를 정의합니다.
```
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. 파일을 생성`terraform.tfvars`하여 변수에 대한 임의 값을 설정합니다.
아래 파일을 사용하면 스택 이름이 인에 이미 배포된 기존 ParallelCluster API 3.11.1을 사용하여 x86\$164 아키텍처용 Amazon Linux 2를 `us-east-1` 기반으로 사용자 지정 AMI`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. `outputs.tf` 파일을 생성하여 이 프로젝트에서 반환되는 출력을 정의합니다.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
프로젝트 디렉터리:
```
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.
```
# API 배포
AMI를 배포하려면 표준 Terraform 명령을 순서대로 실행합니다.
1. 프로젝트 빌드:
```
terraform init
```
1. 배포 계획 정의:
```
terraform plan -out tfplan
```
1. 계획 배포:
```
terraform apply tfplan
```
# 필수 권한
Terraform을 사용하여 사용자 지정 AMI를 배포하려면 다음 권한이 필요합니다.
+ ParallelCluster API와의 상호 작용을 담당하는 ParallelCluster API 역할을 수임합니다.
+ ParallelCluster API의 CloudFormation 스택을 설명하여 API가 존재하는지 확인하고 파라미터 및 출력을 검색합니다.
------
#### [ 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 Identity Center와 UI 통합
이 자습서의 목표는 AWS ParallelCluster 클러스터와 공유할 수 있는 Active Directory의 사용자를 통합하는 Single Sign-On 솔루션을 위해 AWS ParallelCluster UI를 IAM Identity Center와 통합하는 방법을 보여주는 것입니다.
를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스 AWS ParallelCluster에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건:**
+ [여기](install-pcui-v3.md) 지침에 따라 설치할 수 있는 기존 AWS ParallelCluster UI입니다.
+ 통합에도 사용할 기존 관리형 Active Directory[AWS ParallelCluster](tutorials_05_multi-user-ad.md).
## IAM Identity Center 활성화
이미 AWS Managed Microsoft AD (Active Directory)에 연결된 자격 증명 센터가 있는 경우 이를 사용할 수 있으며 **IAM Identity Center에 애플리케이션 추가 섹션으로 건너뛸 수 있습니다**.
에 연결된 자격 증명 센터가 아직 없는 경우 아래 단계에 AWS Managed Microsoft AD따라 설정합니다.
**Identity Center 활성화**
1. 콘솔에서 IAM Identity Center로 이동합니다. (가 있는 리전에 있는지 확인합니다 AWS Managed Microsoft AD.)
1. **활성화** 버튼을 클릭하면 조직을 활성화할지 여부를 묻는 메시지가 표시될 수 있습니다. 이는 활성화하도록 선택할 수 있는 요구 사항입니다. **참고 **: 이렇게 하면 계정 관리자에게 확인 이메일이 전송되어 링크를 따라 확인해야 합니다.
**Managed AD에 Identity Center 연결**
1. Identity Center를 활성화한 후 다음 페이지에서 권장 설정 단계를 확인하고, 1단계에서 **자격 증명 소스 선택**을 선택합니다.
1. Identity Source 섹션에서 **작업** 드롭다운 메뉴(오른쪽 상단)를 클릭한 다음 **자격 증명 소스 변경**을 선택합니다.
1. **Active Directory**를 선택합니다.
1. **기존 디렉터리**에서 디렉터리를 선택합니다.
1. 다음을 클릭합니다.
1. 변경 사항을 검토하고 하단으로 스크롤한 다음 텍스트 상자에 수락을 입력하여 확인한 다음 **자격 증명 소스 변경**을 클릭합니다.
1. 변경 사항이 완료될 때까지 기다린 다음 상단에 녹색 배너가 표시됩니다.
**Identity Center에 사용자 및 그룹 동기화**
1. 녹색 배너에서 **안내에 따른 설정 시작**(오른쪽 상단의 버튼)을 클릭합니다.
![\[가이드 설정 시작 버튼을 강조 표시하는 스크린샷입니다.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. **속성 매핑 구성**에서 **다음**을 클릭합니다.
1. 동기화 범위 구성 섹션에서 Identity Center에 동기화하려는 사용자의 이름을 입력한 다음 **추가**를 클릭합니다.
1. 사용자 및 그룹 추가가 완료되면 **다음**을 클릭합니다.
![\[다음 버튼을 강조 표시하는 스크린샷.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. 변경 사항을 검토한 다음 **구성 저장**을 클릭합니다.
1. 동기화되지 않은 사용자에 대한 경고가 다음 화면에 표시되면 오른쪽 상단의 **동기화 재개 버튼**을 선택합니다.
1. 그런 다음 사용자를 활성화하려면 왼쪽의 **사용자** 탭에서 사용자를 선택한 다음 **사용자 액세스 활성화** > **사용자 액세스 활성화**를 클릭합니다.
**참고:** 상단에 경고 배너가 있는 경우 동기화 재개를 선택한 다음 사용자가 동기화할 때까지 기다려야 할 수 있습니다(새로 고침 버튼을 사용하여 아직 동기화되었는지 확인).
![\[사용자 탭을 강조 표시하는 스크린샷입니다.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## IAM Identity Center에 애플리케이션 추가
사용자를 IAM Identity Center와 동기화한 후에는 새 애플리케이션을 추가해야 합니다. 이렇게 하면 IAM Identity Center 포털에서 사용할 수 있는 SSO 활성화 애플리케이션이 구성됩니다. 이 경우 AWS ParallelCluster UI를 애플리케이션으로 추가하고 IAM Identity Center는 자격 증명 공급자가 됩니다.
다음 단계에서는 AWS ParallelCluster UI를 IAM Identity Center의 애플리케이션으로 추가합니다. AWS ParallelCluster UI는 사용자가 클러스터를 관리하는 데 도움이 되는 웹 포털입니다. 자세한 내용은 [AWS ParallelCluster UI](pcui-using-v3.md) 섹션을 참조하세요.
**Identity Center에서 애플리케이션 설정**
1. **IAM Identity Center** > **애플리케이션**(왼쪽 메뉴 모음에서 애플리케이션을 클릭)에서
1. **애플리케이션 추가**를 클릭합니다.
1. **사용자 지정 SAML 2.0 애플리케이션 추가**를 선택합니다.
1. **다음**을 클릭합니다.
1. 사용하려는 표시 이름 및 설명(예: PCUI 및 AWS ParallelCluster UI)을 선택합니다.
1. **IAM Identity Center 메타데이터**에서 IAM Identity Center SAML 메타데이터 파일의 링크를 복사하고 나중에 저장하면 웹 앱에서 SSO를 구성할 때 사용됩니다.
1. **애플리케이션 속성**의 애플리케이션 시작 URL에 PCUI 주소를 입력합니다. 이는 CloudFormation 콘솔로 이동하여 PCUI에 해당하는 스택(예: parallelcluster-ui)을 선택하고 **출력** 탭으로 이동하여 ParallelClusterUIUrl을 찾을 수 있습니다.
예: https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. **애플리케이션 메타데이터**에서 **메타데이터 값 수동 입력**을 선택합니다. 그리고 다음 값을 제공하십시오.
1. **중요**: 도메인 접두사, 리전 및 userpool-id 값을 사용자 환경에 고유한 정보로 바꾸어야 합니다.
1. **Amazon Cognito** > 사용자 풀 **콘솔을 열어 도메인 접두사, 리전 및 사용자 풀 ID를 가져올 수 있습니다**.
![\[Cognito 사용자 풀에서 사용자 풀 이름을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. PCUI에 해당하는 사용자 풀을 선택합니다(pcui-cd8a2-Cognito-153EK3TO45S98-userpool과 같은 사용자 풀 이름이 있음).
1. **앱 통합**으로 이동
![\[앱 통합 탭에서 Cognito 도메인을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. Application Assertion Consumer Service(ACS) URL: https://.auth..amazoncognito.com/saml2/idpresponse
애플리케이션 SAML 대상: urn:amazon:cognito:sp:
1. **제출**을 선택합니다. 그런 다음 추가한 애플리케이션의 **세부 정보** 페이지로 이동합니다.
1. **작업** 드롭다운 목록을 선택하고 **속성 매핑 편집**을 선택합니다. 그리고 다음 속성을 제공합니다.
1. 애플리케이션의 사용자 속성: **제목**(참고: **제목**은 미리 채워져 있습니다.) → IAM Identity Center의 이 문자열 값 또는 사용자 속성에 매핑: **\$1 \$1user:email\$1**, 형식: **emailAddress**
1. 애플리케이션의 사용자 속성: **이메일** → IAM Identity Center의 이 문자열 값 또는 사용자 속성에 매핑: **\$1\$1user:email\$1**, 형식: **지정되지 않음**
![\[PCUI용 속성 매핑 섹션을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. 변경 내용을 저장합니다.
1. **사용자 할당** 버튼을 선택한 다음 사용자를 애플리케이션에 할당합니다. 이들은 PCUI 인터페이스에 액세스할 수 있는 Active Directory의 사용자입니다.
![\[애플리케이션에 사용자 할당을 강조 표시하는 스크린샷입니다.\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**사용자 풀에서 IAM Identity Center를 SAML IdP로 구성**
1. 사용자 풀 설정에서 **로그인 환경** > **자격 증명 공급자 추가**를 선택합니다.
![\[로그인 환경 탭을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. SAML IdP 선택
1. **공급자 이름**에 **IdentityCenter**를 입력합니다.
1. **메타데이터 문서 소스**에서 **메타데이터 문서 엔드포인트 URL 입력**을 선택하고 Identity Center의 애플리케이션 설정 중에 복사된 URL을 제공합니다.
1. **속성** 아래에서 이메일에 대해 이메일을 선택합니다.
![\[로그인 환경 탭을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. **ID 제공업체 추가**를 선택합니다.
**IdP를 사용자 풀 앱 클라이언트와 통합**
1. 그런 다음 사용자 풀의 **앱 통합** 섹션에서 **앱 클라이언트 목록에 나열된 클라이언트**를 선택합니다.
![\[로그인 환경 탭을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. **호스팅된 UI**에서 **편집**을 선택합니다.
1. **자격 증명 공급자**에서 **IdentityCenter**도 선택합니다.
1. **변경 사항 저장**을 선택합니다
**설정 검증**
1. 다음으로 PCUI에 로그인하여 방금 생성한 설정을 검증하겠습니다. PCUI 포털에 로그인하면 기업 ID로 로그인할 수 있는 옵션이 표시됩니다.
![\[로그인 환경 탭을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. **IdentityCenter** 버튼을 클릭하면 IAM Identity Center IdP 로그인으로 이동한 다음 PCUI가 포함된 애플리케이션이 있는 페이지로 이동하여 해당 애플리케이션을 엽니다.
1. 다음 화면으로 이동하면 사용자가 Cognito 사용자 풀에 추가됩니다.
![\[로그인 환경 탭을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**사용자를 관리자로 설정**
1. 이제 **Amazon Cognito** > **사용자 풀 콘솔**로 이동하여 Identitycenter 접두사가 있어야 하는 새로 생성된 사용자를 선택합니다.
![\[로그인 환경 탭을 강조 표시하는 스크린샷\]](http://docs.aws.amazon.com/ko_kr/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. **그룹 멤버십**에서 **그룹에 사용자 추가**를 선택하고 **관리자**를 선택한 다음 **추가**를 클릭합니다.
1. 이제 ** IdentityCenter 계속**을 클릭하면 AWS ParallelCluster UI 페이지로 이동합니다.
# Pyxis를 사용하여 컨테이너화된 작업 실행
SLURM에서 컨테이너화된 작업을 관리하기 위한 SPANK 플러그인인 Pyxis를 사용하여 컨테이너화된 작업을 실행할 수 있는 클러스터를 생성하는 방법을 알아봅니다. Pyxis의 컨테이너는 기존 컨테이너/OS 이미지를 권한이 없는 샌드박스로 변환하는 도구인 Enroot에서 관리합니다. 자세한 내용은 [NVIDIA Pyxis](https://github.com/NVIDIA/pyxis) 및 [NVIDIA Enroot](https://github.com/NVIDIA/enroot)를 참조하세요.
**참고**
이 기능은 AWS ParallelCluster v3.11.1에서 사용할 수 있습니다.
이 자습서의 스크립트는 일부 파일을 이동(`mv`)하여 원래 위치에서 삭제합니다. 이러한 파일의 복사본을 원래 위치에 유지하려면 대신 copy(`cp`) 명령을 사용하도록 스크립트를 변경합니다.
를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스 AWS ParallelCluster에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
**사전 조건:**
+ AWS CLI 가[ 설치 및 구성되어 있습니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ [ pcluster CLI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)를 실행하는 데 필요한 [권한](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)을 가진 IAM 역할.
## 클러스터 생성
AWS ParallelCluster 3.11.1부터 모든 공식 AMIs Pyxis 및 Enroot가 사전 설치되어 있습니다. 특히 SLURM은 Pyxis 지원으로 재컴파일되고 Enroot는 시스템에 바이너리로 설치됩니다. 그러나 특정 요구 사항에 따라 구성해야 합니다. Enroot 및 Pyxis에서 사용하는 폴더는 클러스터 성능에 중요한 영향을 미칩니다. 자세한 내용은 [Pyxis 설명서](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration) 및 [Enroot 설명서](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example)를 참조하세요.
편의를 위해 `/opt/parallelcluster/examples/` 내에서 Pyxis, Enroot 및 SPANK 모두에 대한 샘플 구성을 찾을 수 있습니다.
제공된 샘플 구성을 사용하여 클러스터를 배포하려면 다음 자습서를 완료하세요.
**샘플 구성을 사용하여 클러스터를 생성하려면**
먼저 Enroot에 대한 영구 및 휘발성 디렉터리를 생성한 다음 Pyxis에 대한 런타임 디렉터리를 생성하고 마지막으로 전체 클러스터에서 Pyxis를 SPANK 플러그인으로 활성화하여 헤드 노드에 Pyxis 및 Enroot를 구성해야 합니다.
1. 헤드 노드에서 아래 스크립트를 [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured) 사용자 지정 작업으로 실행하여 헤드 노드에서 Pyxis 및 Enroot를 구성합니다.
```
#!/bin/bash
set -e
echo "Executing $0"
# Configure Enroot
ENROOT_PERSISTENT_DIR="/var/enroot"
ENROOT_VOLATILE_DIR="/run/enroot"
sudo mkdir -p $ENROOT_PERSISTENT_DIR
sudo chmod 1777 $ENROOT_PERSISTENT_DIR
sudo mkdir -p $ENROOT_VOLATILE_DIR
sudo chmod 1777 $ENROOT_VOLATILE_DIR
sudo mv /opt/parallelcluster/examples/enroot/enroot.conf /etc/enroot/enroot.conf
sudo chmod 0644 /etc/enroot/enroot.conf
# Configure Pyxis
PYXIS_RUNTIME_DIR="/run/pyxis"
sudo mkdir -p $PYXIS_RUNTIME_DIR
sudo chmod 1777 $PYXIS_RUNTIME_DIR
sudo mkdir -p /opt/slurm/etc/plugstack.conf.d/
sudo mv /opt/parallelcluster/examples/spank/plugstack.conf /opt/slurm/etc/
sudo mv /opt/parallelcluster/examples/pyxis/pyxis.conf /opt/slurm/etc/plugstack.conf.d/
sudo -i scontrol reconfigure
```
1. Pyxis 및 Enroot는 Enroot용 영구 및 휘발성 디렉터리와 Pyxis용 런타임 디렉터리를 생성하여 컴퓨팅 플릿에 구성해야 합니다. 컴퓨팅 노드에서 아래 스크립트를 [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart) 사용자 지정 작업으로 실행하여 컴퓨팅 플릿에서 Pyxis 및 Enroot를 구성합니다.
```
#!/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
```
## 작업 제출
이제 Pyxis가 클러스터에 구성되었으므로 sbatch and srun 명령을 사용하여 컨테이너화된 작업을 제출할 수 있습니다. 이제 컨테이너별 옵션이 풍부해집니다.
```
# 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'
```
# EFA 지원 FSx Lustre를 사용하여 클러스터 생성
이 자습서에서는 EFA 지원 FSx Lustre 파일 시스템을 공유 스토리지로 사용하는 클러스터를 생성합니다. EFA가 활성화된 FSx Lustre 파일 시스템을 사용하면 최대 8배의 성능 향상을 제공할 수 있습니다. EFA 지원 파일 시스템이 필요한지 확인하려면 *FSx for Lustre 사용 설명서*의 [EFA 지원 파일 시스템 작업을](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html) 참조하세요.
를 사용하는 경우 AWS ParallelCluster 이미지 및 클러스터를 생성하거나 업데이트할 때 생성된 AWS 리소스 AWS ParallelCluster에 대해서만 비용을 지불합니다. 자세한 내용은 [AWS 에서 사용하는 서비스 AWS ParallelCluster](aws-services-v3.md) 단원을 참조하십시오.
## 요구 사항
+ AWS CLI가 [설치 및 구성되어](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) 있습니다.
+ ParallelCluster CLI가 [설치 및 구성되어](install-v3-parallelcluster.md) 있습니다.
+ 클러스터에 로그인하기 위한 [Amazon EC2 키 페어](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html)입니다.
+ ParallelCluster CLI를 실행하는 데 필요한 [권한이](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) 있는 IAM 역할입니다.
## 보안 그룹 생성
클러스터와 파일 시스템이 배포될 동일한 VPC에 두 개의 보안 그룹을 생성합니다. 하나는 클러스터 노드에서 실행되는 클라이언트용이고 다른 하나는 파일 시스템용입니다.
```
# 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
```
나머지 자습서에서는 클라이언트 `sg-client` 및 파일 시스템의 보안 그룹 ID를 각각 및 `sg-file-system`로 가정합니다.
[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
```
[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
```
## 파일 시스템 생성
컴퓨팅 노드가 위치할 동일한 가용 영역(AZ) 내에 파일 시스템을 생성하고 다음 코드에서를 해당 ID`subnet-compute-nodes`로 바꿉니다. 이는 파일 시스템에서 EFA 작업을 허용하는 데 필요합니다. 파일 시스템 생성의 일부로 EfaEnable 속성을 사용하여 EFA를 활성화합니다.
```
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
```
이전 명령에서 반환한 파일 시스템 ID를 기록해 둡니다. 자습서의 나머지 부분에서를이 파일 시스템 ID`fs-id`로 바꿉니다.
## 클러스터 생성
1. YAML 구성 파일에 다음 구성이 설정된 클러스터를 AWS ParallelCluster 생성합니다.
1. Ubuntu 22.04와 같이 지원되는 OS를 기반으로 하는 AMI입니다.
1. 컴퓨팅 노드는 g6.16xlarge와 같이 [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html)가 있는 [EFA 지원 인스턴스 유형을](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) 사용해야 합니다.
+ 컴퓨팅 노드는 파일 시스템이 있는 동일한 AZ에 있어야 합니다.
+ 컴퓨팅 노드에는 [Efa/Enabled](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled)가 true로 설정되어 있어야 합니다.
+ 컴퓨팅 노드는 구성 스크립트를 [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart) 사용자 지정 작업`configure-efa-fsx-lustre-client.sh`으로 실행해야 합니다. [FSx 공식 설명서에](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) 제공되고 사용자의 편의를 위해 퍼블릭 버킷에 제공되는 스크립트는 EFA를 사용할 수 있도록 컴퓨팅 노드에서 FSx Lustre 클라이언트를 구성하기 위한 것입니다.
1. 클러스터 구성 파일 생성`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
```
그런 다음 해당 구성을 사용하여 클러스터를 생성합니다.
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## EFA로 FSx가 작동하는지 확인
Lustre 네트워크 트래픽이 EFA를 사용하고 있는지 확인하려면 지정된 네트워크 인터페이스에 대한 네트워크 트래픽을 표시할 수 있는 Lustre `lnetctl` 도구를 사용합니다. 이를 위해 컴퓨팅 노드에서 다음 명령을 실행합니다.
```
# 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
```
기능이 작동하는 경우 인터페이스를 통해 흐르는 패킷 수가 증가할 것으로 예상됩니다.
# p6e-gb200 인스턴스에서 NVIDIA-Imex 지원
이 자습서에서는 P6e-GB200 AWS ParallelCluster 에서를 시작하여 AI 훈련 및 추론에 가장 높은 GPU 성능을 활용하는 방법을 보여줍니다. [ p6e-gb200.36xlarge 인스턴스는 P6e-GB200 UltraServers를 통해서만 사용할 수](https://aws.amazon.com/ec2/instance-types/p6/) 있습니다. 여기서 `u-p6e-gb200x72`는 Ultraserver 크기이고는 Ultraserver를 구성하는 [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType)`p6e-gb200.36xlarge`입니다. Ultraserver를 구매`u-p6e-gb200x72`하면 `p6e-gb200.36xlarge` 인스턴스가 18개인 [ML용 EC2 용량 블록을](https://aws.amazon.com/ec2/capacityblocks/) 통해 사용할 수 있습니다. 자세한 내용은 [P6e-GB200](https://aws.amazon.com/ec2/instance-types/p6/)을 참조하세요.
AWS ParallelCluster 버전 3.14.0:
+ 는이 인스턴스 유형에 필요한 전체 NVIDIA 소프트웨어 스택(드라이버, CUDA, EFA, NVIDIA-IMEX)을 제공합니다.
+ 는 P6e-GB200 Ultraserver에 대한 nvidia-imex 구성을 생성합니다.
+ P6e-GB200 Ultraserver에 대한 `nvidia-imex` 서비스 활성화 및 시작
+ 는 모든 P6e-GB200 Ultraserver(EC2 용량 블록)가 적절한 크기의 Slurm 블록이 되도록 Slurm 블록 토폴로지 플러그인을 구성합니다(버전 3.14.0의 [릴리스 정보 및 문서 기록](document_history.md) 항목 참조).
그러나 NVLink를 통한 GPU-to-GPU 통신에는 추가 구성, 특히 ParallelCluster가 자동으로 생성하지 않는 IMEX 도메인에 있는 컴퓨팅 노드의 IP 주소가 포함된 [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) 파일이 필요합니다. 이 파일을 생성하는 데 도움이 되도록 컴퓨팅 노드 IPs를 자동으로 검색하고 [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) 다음과 같은 [ NVIDIA IMEX Slurm 작업 스케줄러 통합](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration) 권장 사항을 구성하는 prolog 스크립트를 제공합니다. 이 자습서에서는 로그 스크립트를 생성하고, HeadNode 사용자 지정 작업을 통해 배포하고, IMEX 설정을 검증하는 방법을 안내합니다.
**참고**
P6e-GB200은 Amazon Linux 2023, Ubuntu 22.04 및 Ubuntu 24.04에서 AWS ParallelCluster v3.14.0부터 지원됩니다. 자세한 소프트웨어 버전과 지원되는 배포의 업데이트된 목록은 [AWS ParallelCluster 변경 로그](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md)를 참조하세요.
## NVIDIA-Imex를 관리하기 위한 Prolog 스크립트 생성
**제한:**
+ 이 prolog 스크립트는 배타적 작업 제출 시 실행됩니다. 이는 IMEX 재시작이 IMEX 도메인에 속하는 p6e-Gb200 노드에서 실행 중인 작업을 중단하지 않도록 하기 위한 것입니다.
다음은 Slurm에서 prolog로 구성해야 하는 `91_nvidia_imex_prolog.sh` 스크립트입니다. 컴퓨팅 노드에서 nvidia-imex 구성을 자동으로 업데이트하는 데 사용됩니다. 스크립트의 이름에는 SchedMD의 이름 지정 규칙을 준수하기 `91` 위한 접두사가 있습니다. [ SchedMD](https://slurm.schedmd.com/prolog_epilog.html) 이렇게 하면 시퀀스의 다른 prolog 스크립트보다 먼저 실행됩니다. 스크립트는 작업이 시작될 때 NVIDIA Imex 노드의 구성을 재구성하고 필요한 NVIDIA 데몬을 다시 로드합니다.
**참고**
동일한 노드에서 여러 작업이 동시에 시작되는 경우이 스크립트는 실행되지 않으므로 제출 시 `--exclusive` 플래그를 사용하는 것이 좋습니다.
```
#!/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"
```
## HeadNode OnNodeStart 사용자 지정 작업 스크립트 생성
컴퓨팅 노드에서 액세스하고 실행할 적절한 권한을 설정하는 공유 디렉터리에 앞서 언급한 prolog 스크립트를 다운로드`/opt/slurm/etc/scripts/prolog.d/`하는 `install_custom_action.sh` 사용자 지정 작업을 생성합니다.
```
#!/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}"
```
## 클러스터 생성
P6e-GB200 인스턴스를 포함하는 클러스터를 생성합니다. 아래에서 Ultraserver 유형 용 SlurmQueues가 포함된 구성 예제를 찾을 수 있습니다`u-p6e-gb200x72`.
P6e-GB200은 현재 로컬 영역에서만 사용할 수 있습니다. 일부 [로컬 영역은 NAT 게이트웨이를 지원하지](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html) 않으므로 ParallelCluster가 AWS 서비스에 [제한된 환경에 대한 보안 그룹 구성](security-groups-configuration.md) 연결해야 하므로 [로컬 영역에 대한 연결 옵션을](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html) 따르세요. Ultraserver는 용량 블록으로만 사용할 수 있으므로 [용량 블록(CB)을 사용하여 인스턴스 시작](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch)를 따르세요.
```
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:
-
```
## IMEX 설정 검증
Slurm 작업을 제출하면 `91_nvidia_imex_prolog.sh` prolog가 실행됩니다. 다음은 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"
```
작업의 출력을 확인합니다.
```
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
```
# 시작 템플릿 재정의로 컴퓨팅 노드 네트워크 인터페이스 사용자 지정
AWS ParallelCluster 3.15.0부터 `LaunchTemplateOverrides` 파라미터를 사용하면 참조된 시작 템플릿의 구성으로 기본 네트워크 인터페이스 구성을 재정의하여 컴퓨팅 노드의 네트워크 인터페이스를 사용자 지정할 수 있습니다. 컴퓨팅 노드의 전체 네트워크 인터페이스 섹션은 재정의에 사용되는 시작 템플릿의 네트워크 인터페이스 섹션에서 덮어씁니다.
이 자습서에서는 `p6-b300.48xlarge` 컴퓨팅 노드의 기본 네트워크 구성을 재정의하는 예제를 살펴봅니다. 이 사용자 지정은가 AWS ParallelCluster 기본적으로 구성하는 것과 다른 특정 네트워크 인터페이스 구성이 필요한 경우에 유용합니다. 이 예제에서는 Amazon EC2 EFA 지원 인스턴스 유형 설명서에 설명된 대로 P6-B300 인스턴스에 대한 사용 사례 2를 구성합니다. [Amazon EC2 ](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html)
**참고**
유연성을 극대화 AWS CLI 하려면를 사용하여 콘솔 대신 시작 템플릿을 생성하는 것이 좋습니다.
**참고**
시작 템플릿에는 네트워크 인터페이스 재정의만 포함되어야 합니다. AWS ParallelCluster 에는 다른 파라미터를 재정의하는 것을 방지하는 검증이 있습니다.
**주의**
재정의를 사용하여 사용 중인 인스턴스 유형에서 지원하지 않는 방식으로 네트워크 인터페이스를 구성하면 인스턴스가 시작되지 않습니다.
**사전 조건**
+ AWS ParallelCluster 버전 3.15.0 이상이 [설치되어 있습니다](install-v3-parallelcluster.md).
+ 설치 AWS CLI [및 구성됩니다.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [`pcluster`](pcluster-v3.md) CLI를 실행하는 데 필요한 [권한](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)을 가진 IAM 역할이 있습니다.
## 1단계: 보안 그룹 생성
재정의에 사용할 시작 템플릿을 생성할 때 보안 그룹을 참조해야 합니다. 컴퓨팅 리소스의 기본 AWS ParallelCluster 보안 그룹은 클러스터를 생성할 때까지 존재하지 않으므로 사용자 지정 보안 그룹을 생성해야 합니다. 그런 다음 헤드 노드와 컴퓨팅 노드 간의 트래픽을 허용하려면 헤드 노드 보안 그룹에서이 보안 그룹을 참조해야 합니다.
기존 클러스터를 업데이트하여 새 용량을 사용자 지정하는 경우 사용자 지정 클러스터를 생성하는 대신 시작 템플릿의 기본 AWS ParallelCluster 컴퓨팅 노드 보안 그룹을 사용할 수 있습니다.
다음 두 보안 그룹을 생성합니다.
+ **헤드 노드 추가 보안 그룹**(`sg-1234abcd`):
+ 수신: 컴퓨팅 보안 그룹의 모든 트래픽
+ **컴퓨팅 보안 그룹**(`sg-abcd1234`):
+ 수신: 헤드 노드 보안 그룹의 모든 트래픽
+ 수신: 자체의 모든 트래픽(compute-to-compute)
+ 송신: 기본 allow-all
## 2단계: 시작 템플릿 생성
`p6-b300.48xlarge` 컴퓨팅 노드에 대한 네트워크 인터페이스 구성을 정의하는 시작 템플릿을 생성합니다. 기본 네트워크 인터페이스(네트워크 카드 인덱스 0, 디바이스 인덱스 0)의 경우 ENA(기본값) 네트워크 인터페이스를 사용합니다. 나머지 네트워크 카드의 경우 EFA 전용 인터페이스(네트워크 카드 인덱스 1\$116, 디바이스 인덱스 0)와 ENA(기본) 인터페이스(네트워크 카드 인덱스 1\$116, 디바이스 인덱스 1)를 생성합니다.
다음 AWS CLI 명령을 실행하여 시작 템플릿(`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"}
]
}'
```
## 3단계: 시작 템플릿 재정의로 클러스터 생성
`LaunchTemplateOverrides` 파라미터를 사용하여 생성한 시작 템플릿을 참조하는 클러스터 구성을 생성합니다.
```
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.
```