翻訳は機械翻訳により提供されています。提供された翻訳内容と英語版の間で齟齬、不一致または矛盾がある場合、英語版が優先します。
# の使用方法に関するチュートリアル 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)
+ [
# カスタム AMI AWS ParallelCluster の構築
](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 UI と Identity Center の統合
](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
```
**注記**
AWS リージョン 使用する は、ほとんどの`pcluster`コマンドで指定する必要があります。`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]
```
出力には、クラスターに 1 つのキューがあり、最大 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 を構築します[カスタム AMI AWS ParallelCluster の構築](building-custom-ami-v3.md)。
+ AWS ParallelCluster 設定ファイルの [StorageSettings](SharedStorage-v3.md) オプションを使用して共有ファイルシステムを指定し、インストールしたソフトウェアを指定されたマウント場所に保存します。
+ [カスタムブートストラップアクション](custom-bootstrap-actions-v3.md) を使用して、クラスターの各ノードのブートストラップ手順を自動化します。
# カスタム AMI AWS ParallelCluster の構築
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 ロールがある。
## AMI AWS ParallelCluster をカスタマイズする方法
カスタム AMI を構築するには、2 AWS ParallelCluster つの方法があります。これら 2 つの方法の 1 つは、 CLI を使用して新しい AMI AWS ParallelCluster を構築することです。もう一つの方法では、手動で変更を加えて AWS アカウントで使用できる新しい AMI を構築する必要があります。
## カスタム AMI AWS ParallelCluster を構築する
カスタマイズされた AMI とソフトウェアがある場合は、その AWS ParallelCluster 上に に必要な変更を適用できます。 AWS ParallelCluster は EC2 Image Builder サービスを使用してカスタマイズされた AMIs。詳細については、「[Image Builder User Guide](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` コマンドでこれらのエラーが表示される場合があります。このような場合には、次の代替方法のいずれかを使用することをお勧めします。
このコマンドをバイパスする「[AMI AWS ParallelCluster の変更](#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. 基本的なビルドイメージ**設定ファイルを作成します。これを行うには、イメージの構築に使用する [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType) と、[`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage) を指定します。これらは AMI を作成するための開始点として使用されます。オプションのビルドパラメータの詳細については、「[Image Configuration](image-builder-configuration-file-v3.md)」を参照してください。
```
Build:
InstanceType:
ParentImage:
```
1. CLI コマンドを使用して[`pcluster build-image`](pcluster.build-image-v3.md)、ベースとして指定した AWS ParallelCluster AMI から AMI を構築します。
```
$ 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 Landing Zone を使用してデフォルトの 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 *
+ 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 commands](pcluster-v3.md)」を参照してください。
## AMI AWS ParallelCluster の変更
この方法は、公式 AMI AWS ParallelCluster にカスタマイズを追加して変更することで構成されます。 AWS ParallelCluster AMIs新しいリリースで更新されます。これらの AMIs には、インストールおよび設定時に が機能 AWS ParallelCluster するために必要なすべてのコンポーネントがあります。これらのいずれかをベースとして開始できます。
キーポイント:
+ この方法は、[`build-image`](pcluster.build-image-v3.md) コマンドよりも高速です。ただし、これは手動のプロセスであり、自動的に繰り返すことはできません。
+ この方法では、CLI で利用できるログ検索やイメージライフサイクル管理コマンドにはアクセスできません。
手順:
------
#### [ New Amazon EC2 console ]
1. 使用する特定の に対応する AMI を見つけ AWS リージョン ます。これを見つけるには、 `--region`パラメータを指定して [`pcluster list-official-images`](pcluster.list-official-images-v3.md) コマンドを使用し、使用する OS AWS リージョン `--os`とアーキテクチャを使用して目的の AMI をフィルタリングする特定の パラメータと `--architecture`パラメータを選択します。出力から、Amazon EC2 イメージ ID を取得します。
1. にサインイン AWS マネジメントコンソール し、[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. ナビゲーションペインで、[**Instances (インスタンス)**] を選択します。
1. 作成および変更したインスタンスを選択します。
1. **[アクション]**で、**[イメージ]**、**[イメージの作成]** の順に選択します。
1. [**Create Image**] を選択します。
1. クラスター設定内の [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) フィールドに新しい AMI ID を入力して、クラスターを作成します。
------
#### [ Old Amazon EC2 console ]
1. 使用する特定の に対応する AWS ParallelCluster AMI を見つけ AWS リージョン ます。これを見つけるには、 `--region`パラメータで [`pcluster list-official-images`](pcluster.list-official-images-v3.md) コマンドを使用して、使用する OS AWS リージョン とアーキテクチャで目的の AMI をフィルタリングする特定の `--os`パラメータと `--architecture`パラメータを選択できます。出力から、Amazon EC2 イメージ ID を取得できます。
1. にサインイン AWS マネジメントコンソール し、[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. ナビゲーションペインで、[**Instances (インスタンス)**] を選択します。
1. 作成および変更したインスタンスを選択します。
1. **[アクション]** で、**[イメージ]**、**[イメージの作成]** の順に選択します。
1. [**Create Image**] を選択します。
1. クラスター設定内の [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi) フィールドに新しい AMI ID を入力して、クラスターを作成します。
------
# Active Directory の統合
このチュートリアルでは、マルチユーザー環境を作成します。この環境には、 の (Active Directory) と AWS ParallelCluster AWS Managed Microsoft AD 統合された が含まれています`corp.example.com`。ディレクトリを管理する `Admin` ユーザー、ディレクトリを読み取る `ReadOnly` ユーザー、クラスターにログインする `user000` ユーザーを設定します。自動パスまたは手動パスのいずれかを使用して、AD の設定に使用するネットワークリソース、Active Directory (AD)、Amazon EC2 インスタンスを作成できます。パスに関係なく、作成するインフラストラクチャは、次のいずれかの方法 AWS ParallelCluster を使用して統合するように事前設定されています。
+ 証明書の検証付き LDAPS (最も安全なオプションとして推奨)
+ 証明書の検証なしの LDAPS
+ LDAP
LDAP 自体は暗号化を提供しません**。機密である可能性の高い情報を安全に送信するために、AD と統合されたクラスターには LDAPS (TLS/SSL 経由の LDAP) を使用することを強くお勧めします。詳細については、「 管理ガイド」の「 [を使用してサーバー側の LDAPS を有効にする AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html)」を参照してください。 Directory Service **
これらのリソースを作成したら、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 Active Directory](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 に置き換えてます。を自分の AWS アカウント 番号`0123456789012`に置き換えます。
# AD インフラストラクチャを作成する
*自動*タブを選択して、 CloudFormation クイック作成テンプレートを使用して Active Directory (AD) インフラストラクチャを作成します。
[手動]** タブを選択し、AD インフラストラクチャを手動で作成します。
## 自動
1. AWS マネジメントコンソールにサインインします。
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 コンソールに以下のリソースを作成します。
+ 2 つのサブネットとパブリックアクセス用のルーティングを持つ VPC (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 マネジメントコンソールで作成されたスタック出力を示す図。\]](http://docs.aws.amazon.com/ja_jp/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) に進みます。
## 手動
異なるアベイラビリティゾーンにある 2 つのサブネットと、 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 マネジメントコンソールにサインインします。
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. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/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 マネジメントコンソールにサインインします。
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. Amazon EC2 コンソールの [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/) を開いてください。
1. **[Amazon EC2 ダッシュボード]** で、**[インスタンスを起動]** を選択します。
1. **[アプリケーションイメージと OS イメージ]** で、最近の Amazon Linux 2 AMI を選択します。
1. [**Instance type (インスタンスタイプ)**] として [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 領域に結合します。**
次のコマンドを実行して、インスタンスに接続します。
```
$ 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.
**必要なソフトウェアをインストールし、領域に結合します。**
```
$ 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:
```
上記が成功した場合は、領域に結合したので、次のステップに進むことができます。
### アカウントにユーザーを追加
1.
**ReadOnlyUser と追加のユーザーを作成します。**
このステップでは、前のステップでインストールした [adcli](https://www.mankier.com/package/adcli) ツールと [openldap-clients](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-clients](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` パスワードの入力を求められます。`ldapsearch` コマンドの一部として AD `Admin` パスワードを含めます。
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 アドレスの 1 つ。
`PasswordSecretArn`: `DomainReadOnlyUser` のパスワードが含まれているシークレットの Amazon リソースネーム (ARN)。
`BucketName`: ブートストラップスクリプトを保持するバケットの名前。
`AdditionalPolicies`/`Policy`: 読み取りドメイン認証ポリシー ReadCertExampl の 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 の 1 つ。
`Region`: AD インフラストラクチャを作成したリージョン。
`DomainAddr`: この IP アドレスは AD サービスの DNS アドレスの 1 つ。
`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 アドレスの 1 つ。
`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 Directory (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. ナビゲーションペインで、[**Stacks**] を選択します。
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. [**Create policy**] (ポリシーの作成) を選択します。
1. **[JSON]** タブを選択し、以下のポリシーを貼り付けます。のすべての出現を `123456789012` AWS アカウント ID とキー Amazon リソースネーム (ARN) 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
```
# マルチキューモードのクラスターでジョブを実行する
このチュートリアルでは、[複数のキューモードで](configuration-of-multiple-queues-v3.md) AWS ParallelCluster で最初の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]
```
この出力では、1 つの `t2.micro` コンピューティングノードと 1 つの`c5.xlarge` コンピューティングノードが `idle` 状態で存在し、クラスター内で利用可能であることがわかります。
その他のノードはすべて省電力状態にあることが、ノード状態の `~` サフィックスで示されています。これらは 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)」を参照してください。 *EC2 *
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 ゲートウェイを使用して 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. 以下のコマンドを実行して、API をデプロイします。
```
API_STACK_NAME="pc-api-stack"
echo "export API_STACK_NAME=${API_STACK_NAME}" |tee -a ~/.bashrc
```
```
aws cloudformation create-stack \
--region ${AWS_DEFAULT_REGION} \
--stack-name ${API_STACK_NAME} \
--template-url https://${AWS_DEFAULT_REGION}-aws-parallelcluster.s3.${AWS_DEFAULT_REGION}.amazonaws.com/parallelcluster/${PCLUSTER_VERSION}/api/parallelcluster-api.yaml \
--capabilities CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND \
--parameters ParameterKey=EnableIamAdminAccess,ParameterValue=true
{
"StackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/my-api-stack/abcd1234-ef56-gh78-ei90-1234abcd5678"
}
```
プロセスが完了したら、次のステップに進みます。
## ステップ 2: Amazon API Gateway コンソールで API をテストする
1. AWS マネジメントコンソールにサインインします。
1. [Amazon API Gateway](https://console.aws.amazon.com/apigateway/home) コンソールに移動します。
1. API デプロイを選択します。
![\[Amazon API Gateway コンソールには、選択可能なゲートウェイのリストが表示されます。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/gateway_choose.png)
1. **[ステージ]** を選択し、ステージを選択します。
![\[選択できるステージのコンソールビュー。API ゲートウェイが API に提供する URL を表示することもできます。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/gateway_address.png)
1. API Gateway が API にアクセスしたり呼び出したりするために提供する URL を書き留めておきます。青色で強調表示されています。
1. **[リソース]** を選択し、**`/clusters`** の下の **`GET`** を選択します。
1. **[テスト]** アイコンを選択し、下にスクロールして **[テスト]** アイコンを選択します。
![\[API リソースとテストメカニズムのコンソールビュー。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/gateway_test.png)
`/clusters GET` に対するレスポンスが表示されます。
![\[API リソース、テストメカニズム、テストリクエストからの応答を示すコンソールビュー。\]](http://docs.aws.amazon.com/ja_jp/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 Gateway ベース 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 Client ライブラリは、環境変数 (`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 マネジメントコンソール または を使用して 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) を使用して [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) for MySQL サーバーレスデータベースを作成します。このテンプレートは、クラスターと同じ VPC に Amazon Aurora サーバーレスデータベースをデプロイするために必要なすべてのコンポーネントを作成するよう CloudFormation に指示します。このテンプレートは、クラスターとデータベース間の接続のための基本的なネットワークとセキュリティの設定も作成します。
**注記**
バージョン 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 Serverless 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 を使用する必要があります。データベースのサブネットを作成し、テンプレートへの入力として渡すことができます。または、2 つのサブネットに独立した 2 つの CIDR ブロックを指定し、CloudFormation テンプレートで CIDR ブロックの 2 つのサブネットを作成します。CIDR ブロックが既存のサブネットと重複しないようにしてください。CIDR ブロックが既存のサブネットと重複している場合、スタックの作成は失敗します。
データベースサーバーの作成には数分かかります。
## ステップ 3: Slurm アカウンティングを有効にしたクラスターを作成する
提供されている CloudFormation テンプレートは、いくつかの定義済みの出力を含む CloudFormation スタックを生成します。から AWS マネジメントコンソール、CloudFormation スタックビューの**出力**タブで出力を表示できます。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 インスタンスをデプロイするために必要なコンポーネントを作成します。このテンプレートは、クラスターとデータベース間の接続のための基本的なネットワークとセキュリティの設定を作成します。
**注記**
以降`version 3.10.0`、 はクラスター設定パラメータ を使用して外部 Slurmdbd 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)がある。
+ CLI の実行に必要な[アクセス許可](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies)を持つ [`pcluster`](pcluster-v3.md) 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 スタックを生成します。
から AWS マネジメントコンソール、 CloudFormation スタックの**出力**タブを表示して、作成されたエンティティを確認します。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 ドキュメントバージョンに戻す方法について説明します。SSM ドキュメントの詳細については、「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 ParallelCluster イメージとクラスターを作成または更新するときに作成された AWS リソースに対してのみ料金が発生します。詳細については、「[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 マネジメントコンソールにサインインします。
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/ja_jp/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. **[クイック作成スタック]** の **[パラメータ]** セクションで、以下のパラメータの値を入力します。
1. **[KeyName]** に、Amazon EC2 のキーペア名を入力します。
1. **[AvailabilityZone]** では、クラスターノード用のアベイラビリティーゾーンを選択します (`us-east-1a` など)。
1. ページの下部で、アクセス機能を必要とすることを確認するチェックボックスを選択します。
1. **[スタックの作成]** を選択してください。
1. CloudFormation スタックが `CREATE_COMPLETE` の状態に達するまで待ちます。
## コマンドラインインターフェイス (CLI) CloudFormation を使用したクラスターの作成
このチュートリアルでは、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. **[スタックの詳細]** を選択し、**[出力]** タブを選択します。
![\[HeadNodeIp と ValidationMessages の値を示す、コンソールの CloudFormation 出力テーブル。\]](http://docs.aws.amazon.com/ja_jp/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. ParallelCluster モジュールを使用してリソースを定義するファイル `main.tf` を作成します。
```
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 ParallelCluster イメージとクラスターを作成または更新するときに作成された AWS リソースに対してのみ料金が発生します。詳細については、「[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 ロール。「必要な IAM 許可」を参照してください。
# Terraform プロジェクトを定義する
このチュートリアルでは、クラスターをデプロイするためのシンプルな Terraform プロジェクトを定義します。
1. `my-clusters` という名前のディレクトリを作成します。
作成するすべてのファイルは、このディレクトリに入ります。
1. ParallelCluster プロバイダーをインポートするファイル `terraform.tf` を作成します。
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. ParallelCluster と AWS プロバイダーを設定するファイル `providers.tf` を作成します。
```
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. ParallelCluster モジュールを使用してリソースを定義するファイル `main.tf` を作成します。
```
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. 複数のクラスターを Terraform ローカル変数として定義するファイル `clusters.tf` を作成します。
**注記**
`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. 複数のクラスターを YAML 設定として定義するファイル `config/clusters.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` を作成します。
以下のファイルは`subnet-123456789`、スタック名 `us-east-1`で に既にデプロイされている既存の ParallelCluster API 3.11.1 を使用して、サブネット `eu-west-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 スタックを記述して、そのスタックが存在することを確認し、そのパラメータと出力を取得します。
------
#### [ 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 ParallelCluster イメージとクラスターを作成または更新するときに作成された AWS リソースに対してのみ料金が発生します。詳細については、「[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. ParallelCluster プロバイダーをインポートするファイル `terraform.tf` を作成します。
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. ParallelCluster と AWS プロバイダーを設定するファイル `providers.tf` を作成します。
```
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. ParallelCluster モジュールを使用してリソースを定義するファイル `main.tf` を作成します。
`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`、変数の任意の値を設定します。
以下の ファイルでは、スタック名 `us-east-1`で既にデプロイされている既存の ParallelCluster API 3.11.1 を使用して、x86\$164 アーキテクチャ用の Amazon Linux 2 `us-east-1`に基づいて にカスタム AMI をデプロイします`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.
```
# AMI をデプロイする
AMI をデプロイするには、標準の Terraform コマンドを順に実行します。
1. プロジェクトをビルドします。
```
terraform init
```
1. デプロイプランを定義します。
```
terraform plan -out tfplan
```
1. プランをデプロイします。
```
terraform apply tfplan
```
# 必要なアクセス許可
Terraform でカスタム AMI をデプロイするには、以下のアクセス許可が必要です。
+ ParallelCluster API とのやり取りを担当する ParallelCluster API ロールを引き受ける
+ ParallelCluster API の CloudFormation スタックを記述して、そのスタックが存在することを確認し、そのパラメータと出力を取得します。
------
#### [ 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 UI と Identity Center の統合
このチュートリアルの目的は、UI を AWS ParallelCluster IAM Identity Center と統合して、 AWS ParallelCluster クラスターと共有できる Active Directory のユーザーを統合するシングルサインオンソリューションを実現する方法を示すことです。
を使用する場合 AWS ParallelCluster、 AWS ParallelCluster イメージとクラスターを作成または更新したときに作成された AWS リソースに対してのみ料金が発生します。詳細については、「[AWS が使用する サービス AWS ParallelCluster](aws-services-v3.md)」を参照してください。
**前提条件:**
+ [こちら](install-pcui-v3.md)の手順に従ってインストールできる既存の AWS ParallelCluster UI
+ 既存の Managed Active Directory、できれば[統合 AWS ParallelCluster](tutorials_05_multi-user-ad.md)にも使用する Managed Active Directory。
## IAM Identity Center を有効にする
既に AWS Managed Microsoft AD (Active Directory) に接続されているアイデンティティセンターがある場合は、それを使用できます。**「IAM アイデンティティセンターへのアプリケーションの追加」セクションに進んでください**。
にまだ ID センターが接続されていない場合は AWS Managed Microsoft AD、以下の手順に従ってセットアップします。
**アイデンティティセンターを有効にする**
1. コンソールで、IAM アイデンティティセンターに移動します ( があるリージョンにいることを確認してください) AWS Managed Microsoft AD。
1. **[有効化]** ボタンをクリックすると、組織を有効にするかどうかを確認するメッセージが表示される場合があります。これは必須事項であるため、有効にすることを選択します。**注**: これにより、アカウントの管理者に対して、リンクをたどって確認する必要があるという確認メッセージが E メールで送信されます。
**アイデンティティセンターを Managed AD に接続する**
1. アイデンティティセンターを有効にした後の次のページに、推奨されるセットアップ手順が表示されます。ステップ 1 で **[アイデンティティソースを選択]** を選択します。
1. [アイデンティティソース] セクションで、**[アクション]** ドロップダウンメニュー (右上) をクリックし、**[アイデンティティソースを変更]** を選択します。
1. **[Active Directory]** を選択します。
1. **[既存のディレクトリ]** で、ディレクトリを選択します。
1. [次へ] をクリックします。
1. 変更を確認して下にスクロールし、テキストボックスに「ACCEPT」と入力して確認します。次に、**[アイデンティティソースを変更]** をクリックします。
1. 変更が完了するまで待つと、上部に緑色のバナーが表示されます。
**ユーザーとグループをアイデンティティセンターに同期する**
1. 緑色のバナーで、**[ガイド付き設定を開始]** (右上のボタン) をクリックします。
![\[[ガイド付き設定を開始] ボタンを強調表示するスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. **[属性マッピングを設定]** で、**[次へ]** をクリックします。
1. [同期の範囲を設定] セクションで、アイデンティティセンターに同期するユーザーの名前を入力し、**[追加]** をクリックします。
1. ユーザーとグループの追加が完了したら、**[次へ]** をクリックします。
![\[[次へ] ボタンを強調表示するスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. 変更内容を確認してから、**[設定を保存]** をクリックします。
1. 次の画面にユーザーが同期されていないという警告が表示された場合は、右上の **[同期を再開]** ボタンを選択します。
1. 次に、ユーザーを有効にするには、左側の **[ユーザー]** タブでユーザーを選択し、**[ユーザーアクセスを有効化]** > **[ユーザーアクセスを有効化]** をクリックします。
**注**: 上部に警告バナーが表示されている場合は、[同期を再開] を選択し、ユーザーが同期するまで待つ必要があります (ユーザーが同期されたかどうかを確認するには、[更新] ボタンを試してください)。
![\[[ユーザー] タブを強調表示するスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## アプリケーションを IAM アイデンティティセンターに追加する
ユーザーを IAM アイデンティティセンターと同期したら、新しいアプリケーションを追加する必要があります。これにより、IAM アイデンティティセンターポータルから使用できる SSO 対応アプリケーションを設定します。この場合、アプリケーションとして AWS ParallelCluster UI を追加し、IAM アイデンティティセンターを ID プロバイダーにします。
次のステップでは、IAM Identity Center で AWS ParallelCluster UI をアプリケーションとして追加します。 AWS ParallelCluster UI は、ユーザーがクラスターを管理するのに役立つウェブポータルです。詳細については、「[AWS ParallelCluster UI](pcui-using-v3.md)」を参照してください。
**アイデンティティセンターでアプリケーションをセットアップする**
1. **[IAM アイデンティティセンター]** > **[アプリケーション]** (左側のメニューバー) で [アプリケーション] をクリックします。
1. **[アプリケーションを追加]** をクリックします。
1. **[カスタム SAML 2.0 アプリケーションを追加]** を選択します。
1. **[次へ]** をクリックします。
1. 使用する表示名と説明を選択します (PCUI や AWS ParallelCluster UI など)
1. **[IAM アイデンティティセンターのメタデータ]** で、IAM アイデンティティセンター SAML メタデータファイルへのリンクをコピーして保存します。これは、後ほどウェブアプリケーションで SSO を設定するときに使用します。
1. **[アプリケーションのプロパティ]** の [アプリケーション開始 URL] で、PCUI アドレスを入力します。これを確認するには、CloudFormation コンソールに移動して、PCUI に対応するスタック (例: parallelcluster-ui) を選択し、**[出力]** タブに移動して ParallelClusterUIUrl を見つけます。
例: https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. **[アプリケーションメタデータ]** で **[メタデータの値を手動で入力]** を選択します。次に、以下の値を指定します。
1. **重要:** domain-prefix、region、userpool-id の値は、環境固有の情報に置き換えてください。
1. domain-prefix、region、userpool-id は、**[Amazon Cognito]** > **[ユーザープールコンソール]** を開いて取得できます。
![\[Cognito ユーザープールの下のユーザープール名を強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/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/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. [アプリケーションのアサーションコンシューマーサービス (ACS) の URL]: https://.auth..amazoncognito.com/saml2/idpresponse
[アプリケーション SAML 対象者]: urn:amazon:cognito:sp:
1. **[送信]** を選択します。次に、追加したアプリケーションの **[詳細]** ページに移動します。
1. **[アクション]** ドロップダウンリストを選択し、**[属性マッピングを編集]** を選択します。次に、以下の属性を指定します。
1. [アプリケーションのユーザー属性]: **subject** (注: **subject** は事前入力済み) → [この文字列値または IAM アイデンティティセンターのユーザー属性にマッピング]: **\$1\$1user:email\$1**、[形式]: **emailAddress**
1. [アプリケーションのユーザー属性]: **email** → [この文字列値または IAM アイデンティティセンターのユーザー属性にマッピング]: **\$1\$1user:email\$1**、[形式]: **未指定**
![\[PCUI の属性マッピングセクションを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. 変更内容を保存します。
1. **[ユーザーを割り当て]** ボタンを選択し、ユーザーをアプリケーションに割り当てます。これらは、PCUI インターフェイスにアクセスできる Active Directory 内のユーザーです。
![\[アプリケーションのユーザーの割り当てを強調表示するスクリーンショット。\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**ユーザープールで IAM アイデンティティセンターを SAML IdP として設定する**
1. ユーザープール設定で、**[サインインエクスペリエンス]** > **[ID プロバイダーを追加]** を選択します。
![\[サインインエクスペリエンスタブを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. SAML IdP を選択します。
1. **[プロバイダー名]** に **[IdentityCenter]** を指定します。
1. **[メタデータドキュメントソース]** で **[メタデータドキュメントのエンドポイント URL を入力]** を選択し、アイデンティティセンターのアプリケーションをセットアップしたときにコピーした URL を指定します。
1. **[属性]** の [email] で、E メールを選択します。
![\[サインインエクスペリエンスタブを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. **[ID プロバイダーを追加]** を選択します。
**IdP をユーザープールアプリケーションクライアントと統合する**
1. 次に、ユーザープールの **[アプリケーションの統合]** セクションで、**[アプリケーションクライアントのリスト]** にリストされているクライアントを選択します。
![\[サインインエクスペリエンスタブを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. **[ホストされた UI]** で、**[編集]** を選択します。
1. **[ID プロバイダー]** で、**[IdentityCenter]** も選択します。
1. **[変更を保存]** を選択します。
**セットアップを検証する**
1. 次に、PCUI にログインして、先ほど作成したセットアップを検証します。PCUI ポータルにサインインすると、企業 ID でサインインするオプションが表示されます。
![\[サインインエクスペリエンスタブを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. **[IdentityCenter]** ボタンをクリックすると、IAM アイデンティティセンターの IdP ログインに移動し、アプリケーション (PCUI を含む) を示すページが表示されます。PCUI アプリケーションを開きます。
1. 次の画面に移動すると、ユーザーが Cognito ユーザープールに追加されます。
![\[サインインエクスペリエンスタブを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**ユーザーを管理者にする**
1. ここで、**[Amazon Cognito]** > **ユーザープールコンソール**に移動し、identitycenter をプレフィックスとする、新しく作成したユーザーを選択します。
![\[サインインエクスペリエンスタブを強調表示するスクリーンショット\]](http://docs.aws.amazon.com/ja_jp/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. **[グループメンバーシップ]** で、**[ユーザーをグループに追加]**、**[管理者]** の順に選択し、**[追加]** をクリックします。
1. これで、**IdentityCenter で続行**をクリックすると、UI AWS ParallelCluster ページに移動します。
# Pyxis でコンテナ化されたジョブを実行する
Pyxis を使用して、コンテナ化されたジョブを実行できるクラスターを作成する方法について説明します。Pyxis は、SLURM でコンテナ化されたジョブを管理する SPANK プラグインです。Pyxis のコンテナは Enroot で管理します。Enroot は、従来のコンテナ/OS イメージを特権のないサンドボックスに変換するツールです。詳細については、「[NVIDIA Pyxis](https://github.com/NVIDIA/pyxis) と 「[NVIDIA Enroot](https://github.com/NVIDIA/enroot)」を参照してください。
**注記**
この機能は v3.11.1 AWS ParallelCluster で使用できます。
このチュートリアルのスクリプトは、一部のファイルを移動 (`mv`) し、元の場所から削除します。これらのファイルのコピーを元の場所に保持する場合は、代わりにコピー (`cp`) コマンドを使用するようにスクリプトを変更します。
を使用する場合 AWS ParallelCluster、 AWS ParallelCluster イメージとクラスターを作成または更新したときに作成された AWS リソースに対してのみ料金が発生します。詳細については、「[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)を参照してください。
便宜上、Pyxis (SPANK プラグイン) と Enroot の両方のサンプル設定を `/opt/parallelcluster/examples/` 内に用意しています。
用意されているサンプル設定を使用してクラスターをデプロイするには、次のチュートリアルを完了します。
**サンプル設定を使用してクラスターを作成するには**
Pyxis と Enroot をヘッドノードで設定する必要があります。そのためには、まず Enroot の永続ディレクトリと揮発性ディレクトリを作成します。次に Pyxis のランタイムディレクトリを作成します。最後に Pyxis をクラスター全体の SPANK プラグインとして有効にします。
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 および 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 ParallelCluster イメージとクラスターを作成または更新したときに作成された AWS リソースに対してのみ料金が発生します。詳細については、「[AWS が使用する サービス AWS ParallelCluster](aws-services-v3.md)」を参照してください。
## 要件
+ CLI AWS [がインストールされ、設定されています](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 に 2 つのセキュリティグループを作成します。1 つはクラスターノードで実行されているクライアント用、もう 1 つはファイルシステム用です。
```
# 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` と `sg-file-system`がそれぞれクライアントとファイルシステムのセキュリティグループ ID であることを前提としています。
[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)で提供されており、お客様の便宜のためにパブリックバケットで提供されています。これは、コンピューティングノードで FSx Lustre クライアントを設定して EFA を使用できるようにすることを目的としています。
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 インスタンスは、 が Ultraserver サイズで、 が Ultraserver を形成する InstanceType である P6e-GB200 UltraServers を介してのみ使用できます](https://aws.amazon.com/ec2/instance-types/p6/)。 `u-p6e-gb200x72` `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) Ultraserver を購入する`u-p6e-gb200x72`と、18 個の`p6e-gb200.36xlarge`インスタンスを持つ [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 Block トポロジプラグインを設定します (バージョン 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)の推奨事項を設定するプロログスクリプトが用意されています。このチュートリアルでは、プロログスクリプトを作成し、HeadNode カスタムアクションを使用してデプロイし、IMEX セットアップを検証する方法について説明します。
**注記**
P6e-GB200 は、Amazon Linux AWS ParallelCluster 2023、Ubuntu 22.04、および Ubuntu 24.04 の v3.14.0 以降でサポートされています。サポートされているディストリビューションの詳細なソフトウェアバージョンと更新されたリストについては、[AWS ParallelCluster 変更ログ](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md)を参照してください。
## NVIDIA-Imex を管理する Prolog スクリプトを作成する
**制限:**
+ このプロログスクリプトは、排他的ジョブの送信時に実行されます。これは、IMEX 再起動によって、IMEX ドメインに属する p6e-Gb200 ノードで実行中のジョブが中断されないようにするためです。
以下は、Slurm でプロログとして設定する必要がある`91_nvidia_imex_prolog.sh`スクリプトです。これは、コンピューティングノードの nvidia-imex 設定を自動的に更新するために使用されます。スクリプトの名前には、[SchedMD の命名規則](https://slurm.schedmd.com/prolog_epilog.html)に準拠`91`するためのプレフィックス があります。これにより、シーケンス内の他のプロログスクリプトより先に実行されます。このスクリプトは、ジョブの開始時に 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 カスタムアクションスクリプトを作成する
コンピューティングノードによってアクセス`/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 セットアップの検証
`91_nvidia_imex_prolog.sh` プロログは、Slurm ジョブを送信すると実行されます。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 コンピューティングノードセキュリティグループを使用できます。
次の 2 つのセキュリティグループを作成します。
+ **ヘッドノードの追加セキュリティグループ** (`sg-1234abcd`):
+ Ingress: コンピューティングセキュリティグループからのすべてのトラフィック
+ **コンピューティングセキュリティグループ** (`sg-abcd1234`):
+ Ingress: ヘッドノードセキュリティグループからのすべてのトラフィック
+ Ingress: 自己からのすべてのトラフィック (compute-to-compute)
+ 出力: デフォルトの allow-all
## ステップ 2: 起動テンプレートを作成する
`p6-b300.48xlarge` コンピューティングノードのネットワークインターフェイス設定を定義する起動テンプレートを作成します。プライマリネットワークインターフェイス (ネットワークカードインデックス 0、デバイスインデックス 0) には、ENA (デフォルト) ネットワークインターフェイスを使用します。残りのネットワークカードでは、EFA 専用インターフェイス (ネットワークカードインデックス 1～16、デバイスインデックス 0) と ENA (デフォルト) インターフェイス (ネットワークカードインデックス 1～16、デバイスインデックス 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.
```