Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Tutorial tentang cara menggunakan AWS ParallelCluster
Tutorial berikut menunjukkan cara memulai dengan AWS ParallelCluster versi 3, dan memberikan panduan praktik terbaik untuk beberapa tugas umum.
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Lihat informasi yang lebih lengkap di [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Topics**
+ [
# Menjalankan pekerjaan pertama Anda AWS ParallelCluster
](tutorials-running-your-first-job-on-version-3.md)
+ [
# Membangun AWS ParallelCluster AMI khusus
](building-custom-ami-v3.md)
+ [
# Mengintegrasikan Active Directory
](tutorials_05_multi-user-ad.md)
+ [
# Mengkonfigurasi enkripsi penyimpanan bersama dengan kunci AWS KMS
](tutorials_04_encrypted_kms_fs-v3.md)
+ [
# Menjalankan pekerjaan dalam klaster mode antrian ganda
](multi-queue-tutorial-v3.md)
+ [
# Menggunakan AWS ParallelCluster API
](tutorials_06_API_use.md)
+ [
# Membuat cluster dengan Slurm akuntansi
](tutorials_07_slurm-accounting-v3.md)
+ [
# Membuat cluster dengan eksternal Slurmdbd akuntansi
](external-slurmdb-accounting.md)
+ [
# Mengembalikan ke versi dokumen AWS Systems Manager sebelumnya
](tutorials_08_ssm-document-version-rev-v3.md)
+ [
# Membuat cluster dengan CloudFormation
](tutorials_09_cfn-custom-resource-v3.md)
+ [
# Terapkan ParallelCluster API dengan Terraform
](tutorial-deploy-terraform.md)
+ [
# Membuat cluster dengan Terraform
](tutorial-create-cluster-terraform.md)
+ [
# Membuat AMI khusus dengan Terraform
](tutorial-create-ami-terraform.md)
+ [
# AWS ParallelCluster Integrasi UI dengan Pusat Identitas
](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Menjalankan pekerjaan kontainer dengan Pyxis](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [
# Membuat cluster dengan Lustre yang mendukung EFA FSx
](tutorial-efa-enabled-fsx-lustre.md)
+ [
# Support NVIDIA-IMEX dengan instans p6e-gb200
](support-nvidia-imex-p6e-gb200-instance.md)
+ [
# Sesuaikan antarmuka jaringan node komputasi dengan penggantian template peluncuran
](tutorial-network-customization-v3.md)
# Menjalankan pekerjaan pertama Anda AWS ParallelCluster
Tutorial ini memandu Anda menjalankan pekerjaan Hello World pertama Anda AWS ParallelCluster
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
## Memverifikasi instalasi Anda
Pertama, kami memverifikasi yang AWS ParallelCluster benar, termasuk ketergantungan Node.js, diinstal dan dikonfigurasi.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
Ini mengembalikan versi yang sedang berjalan dari AWS ParallelCluster.
## Membuat klaster pertama Anda
Sekarang saatnya membuat cluster pertama Anda. Karena beban kerja untuk tutorial ini tidak intensif kinerja, kita dapat menggunakan ukuran instance default. `t2.micro` (Untuk beban kerja produksi, Anda memilih ukuran instans yang paling sesuai dengan kebutuhan Anda.) Mari kita panggil cluster Anda`hello-world`.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**catatan**
Yang Wilayah AWS harus digunakan harus ditentukan untuk sebagian besar `pcluster` perintah. Jika tidak ditentukan dalam variabel `AWS_DEFAULT_REGION` lingkungan, atau `region` pengaturan di `[default]` bagian `~/.aws/config` file, maka `--region` parameter harus disediakan pada baris `pcluster` perintah.
Jika output memberi Anda pesan tentang konfigurasi, Anda perlu menjalankan yang berikut ini untuk mengkonfigurasi AWS ParallelCluster:
```
$ pcluster configure --config hello-world.yaml
```
Jika [`pcluster create-cluster`](pcluster.create-cluster-v3.md) perintah berhasil, Anda melihat output yang mirip dengan berikut ini:
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Anda memantau pembuatan cluster menggunakan:
```
$ pcluster describe-cluster --cluster-name hello-world
```
`clusterStatus`Laporan "`CREATE_IN_PROGRESS`" saat cluster sedang dibuat. `clusterStatus`Transisi ke "`CREATE_COMPLETE`" ketika cluster berhasil dibuat. Outputnya juga memberi kita `publicIpAddress` dan `privateIpAddress` dari simpul kepala kita.
## Masuk ke node kepala Anda
Gunakan file pem OpenSSH Anda untuk masuk ke node kepala Anda.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
Setelah Anda masuk, jalankan perintah `sinfo` untuk memverifikasi bahwa node komputasi Anda telah diatur dan dikonfigurasi.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
Outputnya menunjukkan bahwa kita memiliki satu antrian di cluster kita, dengan hingga sepuluh node.
## Menjalankan pekerjaan pertama Anda menggunakan Slurm
Selanjutnya, kami membuat pekerjaan yang tidur sebentar dan kemudian mengeluarkan nama hostnya sendiri. Buat file bernama`hellojob.sh`, dengan konten berikut.
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
Selanjutnya, kirimkan pekerjaan menggunakan`sbatch`, dan verifikasi bahwa itu berjalan.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
Sekarang, Anda dapat melihat antrian Anda dan memeriksa status pekerjaan. Penyediaan instans Amazon EC2 baru dimulai di latar belakang. Anda dapat memantau status instance cluster dengan `sinfo` perintah.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
Output menunjukkan bahwa pekerjaan telah diserahkan ke`queue1`. Tunggu 30 detik hingga pekerjaan selesai, lalu jalankan `squeue` lagi.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
Sekarang tidak ada pekerjaan dalam antrian, kita dapat memeriksa output di direktori kita saat ini.
```
$ 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
```
Dalam output, kita melihat file `out` "”. Kita bisa melihat output dari pekerjaan kita:
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
Outputnya juga menunjukkan bahwa pekerjaan kami berhasil berjalan pada instance`queue1-dy-queue1t2micro-1`.
Di cluster yang baru saja Anda buat, hanya direktori home yang dibagikan di antara semua node cluster.
Untuk mempelajari lebih lanjut tentang membuat dan menggunakan cluster, lihat[Praktik terbaik](best-practices-v3.md).
Jika aplikasi Anda memerlukan perangkat lunak, pustaka, atau data bersama, pertimbangkan opsi berikut:
+ Buat AMI kustom yang AWS ParallelCluster diaktifkan yang menyertakan perangkat lunak Anda seperti yang dijelaskan dalam[Membangun AWS ParallelCluster AMI khusus](building-custom-ami-v3.md).
+ Gunakan [StorageSettings](SharedStorage-v3.md)opsi dalam file AWS ParallelCluster konfigurasi untuk menentukan sistem file bersama dan menyimpan perangkat lunak yang Anda instal di lokasi pemasangan yang ditentukan.
+ Gunakan [Tindakan bootstrap kustom](custom-bootstrap-actions-v3.md) untuk mengotomatiskan prosedur bootstrap dari setiap node cluster Anda.
# Membangun AWS ParallelCluster AMI khusus
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**penting**
Jika Anda membuat AMI kustom, Anda harus mengulangi langkah-langkah yang Anda gunakan untuk membuat AMI kustom Anda dengan setiap AWS ParallelCluster rilis baru.
Sebelum membaca lebih lanjut, kami sarankan Anda terlebih dahulu meninjau [Tindakan bootstrap kustom](custom-bootstrap-actions-v3.md) bagian tersebut. Tentukan apakah modifikasi yang ingin Anda buat dapat ditulis dan didukung dengan AWS ParallelCluster rilis future.
Meskipun membangun AMI khusus secara umum tidak ideal, ada skenario khusus di mana membangun AMI khusus AWS ParallelCluster diperlukan. Tutorial ini mencakup cara membangun AMI kustom untuk skenario ini.
**Prasyarat**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan [`pcluster`](pcluster-v3.md) CLI dan membuat gambar.
## Cara menyesuaikan AWS ParallelCluster AMI
Ada dua cara untuk membangun AWS ParallelCluster AMI khusus. Salah satu dari dua metode ini adalah membangun AMI baru menggunakan AWS ParallelCluster CLI. Metode lain mengharuskan Anda untuk membuat modifikasi manual untuk membangun AMI baru yang tersedia di bawah Anda Akun AWS.
## Bangun AWS ParallelCluster AMI khusus
Jika Anda memiliki AMI dan perangkat lunak yang disesuaikan, Anda dapat menerapkan perubahan yang diperlukan AWS ParallelCluster di atasnya. AWS ParallelCluster bergantung pada layanan EC2 Image Builder untuk membangun yang disesuaikan. AMIs Untuk informasi selengkapnya, lihat [Panduan Pengguna Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
Poin kunci:
+ Prosesnya memakan waktu sekitar 1 jam. Waktu ini dapat bervariasi jika ada tambahan [`Build`](Build-v3.md)/[`Components`](Build-v3.md#Build-v3-Components)yang akan diinstal pada waktu pembuatan.
+ AMI ditandai dengan versi komponen utama. Ini termasuk kernel, scheduler, dan driver [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). Subset dari versi komponen juga dilaporkan dalam deskripsi AMI.
+ Mulai dari AWS ParallelCluster 3.0.0, satu set baru perintah CLI dapat digunakan untuk mengelola siklus hidup gambar. Produk ini mencakup [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md), dan [`delete-image`](pcluster.delete-image-v3.md).
+ Metode ini dapat diulang. Anda dapat menjalankannya kembali untuk terus AMIs diperbarui (misalnya, pembaruan OS), dan kemudian menggunakannya saat Anda memperbarui cluster yang ada.
**catatan**
Jika Anda menggunakan metode ini di Partisi AWS Tiongkok, Anda mungkin mendapatkan kesalahan jaringan. Misalnya, Anda mungkin melihat kesalahan ini dari `pcluster build-image` perintah saat mengunduh paket dari GitHub atau dari repositori OS. Jika ini terjadi, kami sarankan Anda menggunakan salah satu metode alternatif berikut:
Ikuti [Memodifikasi AWS ParallelCluster AMI](#modify-an-aws-parallelcluster-ami-v3) pendekatan yang melewati perintah ini.
Bangun gambar di Partisi dan Wilayah lain`us-east-1`, seperti, dan kemudian store/restore memindahkannya ke Wilayah Tiongkok. Untuk informasi selengkapnya, lihat [Menyimpan dan memulihkan AMI menggunakan S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) di Panduan *Pengguna Amazon EC2*.
Langkah:
1. Konfigurasikan Akun AWS kredensional Anda sehingga AWS ParallelCluster klien dapat melakukan panggilan ke operasi AWS API atas nama Anda. Untuk daftar izin yang diperlukan, lihat[AWS Identity and Access Management izin di AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md).
1. Buat file konfigurasi *image build* dasar. Untuk melakukan ini, tentukan yang [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType)akan digunakan untuk membangun gambar dan [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage). Ini digunakan sebagai titik awal untuk membuat AMI. Untuk informasi selengkapnya tentang parameter build opsional, lihat [Konfigurasi Gambar](image-builder-configuration-file-v3.md).
```
Build:
InstanceType:
ParentImage:
```
1. Gunakan perintah CLI [`pcluster build-image`](pcluster.build-image-v3.md)untuk membangun AWS ParallelCluster AMI mulai dari AMI yang Anda berikan sebagai basis.
```
$ 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"
}
}
```
**Awas**
`pcluster build-image`menggunakan VPC default. Jika Anda menghapus VPC default menggunakan AWS Control Tower atau AWS Landing Zone, ID subnet harus ditentukan dalam file konfigurasi gambar. Untuk informasi selengkapnya, lihat [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId).
Untuk daftar parameter lainnya, lihat halaman referensi [`pcluster build-image`](pcluster.build-image-v3.md)perintah. Hasil dari perintah sebelumnya adalah sebagai berikut:
+ CloudFormation Tumpukan dibuat berdasarkan konfigurasi gambar. Tumpukan mencakup semua sumber daya EC2 Image Builder yang diperlukan untuk build.
+ Sumber daya yang dibuat mencakup AWS ParallelCluster komponen Image Builder resmi yang dapat ditambahkan komponen Image Builder kustom. Untuk informasi selengkapnya, lihat [Membuat komponen kustom dengan Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) di *Panduan Pengguna EC2 Image Builder*.
+ EC2 Image Builder meluncurkan instance build, menerapkan AWS ParallelCluster buku masak, menginstal AWS ParallelCluster tumpukan perangkat lunak, dan melakukan tugas konfigurasi yang diperlukan. AWS ParallelCluster Buku masak digunakan untuk membangun dan bootstrap AWS ParallelCluster.
+ Instance dihentikan dan AMI baru dibuat darinya.
+ Contoh lain diluncurkan dari AMI yang baru dibuat. Selama fase pengujian, EC2 Image Builder menjalankan pengujian yang ditentukan dalam komponen Image Builder.
+ Jika build berhasil, tumpukan akan dihapus. Jika build gagal, tumpukan dipertahankan dan tersedia untuk diperiksa.
1. Anda dapat memantau status proses build dengan menjalankan perintah berikut. Setelah build selesai, Anda dapat menjalankannya untuk mengambil ID AMI yang diberikan dalam respons.
```
$ 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. Untuk membuat klaster Anda, masukkan ID AMI di [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)bidang dalam konfigurasi klaster Anda.
**Pemecahan masalah dan pemantauan proses pembuatan AMI**
Pembuatan gambar selesai dalam waktu sekitar satu jam. Anda dapat memantau proses dengan menjalankan [`pcluster describe-image`](pcluster.describe-image-v3.md)perintah atau perintah pengambilan log.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
[`build-image`](pcluster.build-image-v3.md)Perintah membuat CloudFormation tumpukan dengan semua sumber daya Amazon EC2 yang diperlukan untuk membuat gambar, dan meluncurkan proses EC2 Image Builder.
Setelah menjalankan [`build-image`](pcluster.build-image-v3.md)perintah, dimungkinkan untuk mengambil peristiwa CloudFormation tumpukan dengan menggunakan [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md). Anda dapat memfilter hasil dengan `--query` parameter untuk melihat peristiwa terbaru. Untuk informasi selengkapnya, lihat [Memfilter AWS CLI output](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html) di *Panduan AWS Command Line Interface Pengguna*.
```
$ 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"
}
```
Setelah sekitar 15 menit, peristiwa tumpukan muncul di entri peristiwa log yang terkait dengan pembuatan Image Builder. Anda sekarang dapat membuat daftar aliran log gambar dan memantau langkah-langkah Image Builder dengan menggunakan [`pcluster list-image-log-streams`](pcluster.list-image-log-streams-v3.md)dan [`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md)perintah.
```
$ 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"
}
]
}
```
Lanjutkan untuk memeriksa dengan [`describe-image`](pcluster.describe-image-v3.md)perintah sampai Anda melihat `BUILD_COMPLETE` statusnya.
```
$ 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"
}
```
Jika Anda perlu memecahkan masalah pembuatan AMI kustom, buat arsip log gambar seperti yang dijelaskan dalam langkah-langkah berikut.
Dimungkinkan untuk mengarsipkan log di bucket Amazon S3 atau dalam file lokal, tergantung pada parameternya`--output`.
```
$ pcluster export-image-logs --image-id IMAGE_ID --region REGION \
--bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER
{
"url": "https://BUCKET_NAME.s3.us-east-1.amazonaws.com/BUCKET-FOLDER/IMAGE_ID-logs-202209071136.tar.gz?AWSAccessKeyId=..."
}
$ pcluster export-image-logs --image-id IMAGE_ID \
--region REGION --bucket BUCKET_NAME --bucket-prefix BUCKET_FOLDER --output-file /tmp/archive.tar.gz
{
"path": "/tmp/archive.tar.gz"
}
```
Arsip berisi Aliran CloudWatch Log yang terkait dengan proses Image Builder dan peristiwa CloudFormation tumpukan. Perintah mungkin memakan waktu beberapa menit untuk dijalankan.
**Mengelola Kustom AMIs**
Mulai dari AWS ParallelCluster 3.0.0, serangkaian perintah baru telah ditambahkan di CLI untuk membangun, memantau, dan mengelola siklus hidup gambar. Untuk informasi selengkapnya tentang perintah, lihat [perintah pcluster](pcluster-v3.md).
## Memodifikasi AWS ParallelCluster AMI
Metode ini terdiri dari memodifikasi AWS ParallelCluster AMI resmi dengan menambahkan kustomisasi di atasnya. Basis AWS ParallelCluster AMIs diperbarui dengan rilis baru. Ini AMIs memiliki semua komponen yang diperlukan AWS ParallelCluster untuk berfungsi ketika diinstal dan dikonfigurasi. Anda bisa mulai dengan salah satu dari ini sebagai basis Anda.
Poin kunci:
+ Metode ini lebih cepat dari [`build-image`](pcluster.build-image-v3.md)perintah. Namun, ini adalah proses manual dan tidak dapat diulang secara otomatis.
+ Dengan metode ini, Anda tidak memiliki akses ke pengambilan log dan perintah manajemen siklus hidup gambar yang tersedia melalui CLI.
Langkah:
------
#### [ New Amazon EC2 console ]
1. Temukan AMI yang sesuai dengan spesifik Wilayah AWS yang Anda gunakan. Untuk menemukannya, gunakan [`pcluster list-official-images`](pcluster.list-official-images-v3.md)perintah dengan `--region` parameter untuk memilih parameter spesifik Wilayah AWS dan `--os` dan `--architecture` untuk memfilter AMI yang diinginkan dengan OS dan arsitektur yang ingin Anda gunakan. Dari output, ambil ID Gambar Amazon EC2.
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Di panel navigasi, pilih **Gambar**, lalu **AMIs**. Cari ID Gambar EC2 yang diambil, pilih AMI, dan pilih **Launch instance dari AMI**.
1. Gulir ke bawah dan pilih **jenis Instance** Anda.
1. Pilih **pasangan Kunci** Anda dan **Launch Instance**.
1. Masuk ke instans Anda menggunakan pengguna OS dan SSH kunci Anda.
1. Sesuaikan instans Anda secara manual untuk memenuhi kebutuhan Anda.
1. Jalankan perintah berikut untuk mempersiapkan instance Anda untuk pembuatan AMI.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Dari konsol, pilih **Instance state** dan **Stop instance**.
Arahkan ke **Instans**, pilih instans baru, pilih **Status instans**, dan **Stop instance**.
1. [Buat AMI baru dari instans menggunakan konsol Amazon EC2 atau AWS CLI create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Dari konsol Amazon EC2**
1. Pilih **Instans** di panel navigasi.
1. Pilih contoh yang Anda buat dan modifikasi.
1. Di **Actions**, pilih **Image** dan kemudian **Create image**.
1. Pilih **Buat Gambar**.
1. Masukkan ID AMI baru di [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)bidang dalam konfigurasi klaster Anda dan buat klaster.
------
#### [ Old Amazon EC2 console ]
1. Temukan AWS ParallelCluster AMI yang sesuai dengan spesifik Wilayah AWS yang Anda gunakan. Untuk menemukannya, Anda dapat menggunakan [`pcluster list-official-images`](pcluster.list-official-images-v3.md)perintah dengan `--region` parameter untuk memilih `--architecture` parameter spesifik Wilayah AWS dan `--os` dan untuk memfilter AMI yang diinginkan dengan OS dan arsitektur yang ingin Anda gunakan. Dari output Anda dapat mengambil ID Gambar Amazon EC2.
1. Masuk ke Konsol Manajemen AWS dan buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Di panel navigasi, pilih **Gambar**, lalu **AMIs**. **Atur filter untuk **gambar Publik** dan cari ID Gambar EC2 yang diambil, pilih AMI, dan pilih Luncurkan.**
1. Pilih jenis instans Anda dan pilih **Next: Configure Instance Details** or **Review and Launch** untuk meluncurkan instans Anda.
1. Pilih **Luncurkan**, pilih **pasangan Kunci** Anda, dan **Luncurkan Instans.**
1. Masuk ke instans Anda menggunakan pengguna OS dan kunci SSH Anda. Untuk informasi selengkapnya, navigasikan ke **Instans**, pilih instans baru dan **Connect**.
1. Sesuaikan instans Anda secara manual untuk memenuhi kebutuhan Anda.
1. Jalankan perintah berikut untuk menyiapkan instance Anda untuk pembuatan AMI:
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. **Dari konsol Amazon EC2, pilih **Instans di panel navigasi, pilih instans** baru Anda dan pilih **Tindakan**, Status **Instans**, dan Berhenti.**
1. [Buat AMI baru dari instans menggunakan konsol Amazon EC2 atau AWS CLI create-image.](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html)
**Dari konsol Amazon EC2**
1. Pilih **Instans** di panel navigasi.
1. Pilih instance yang Anda buat dan modifikasi.
1. Di **Actions**, pilih **Image** dan kemudian **Create Image**.
1. Pilih **Buat Gambar**.
1. Masukkan ID AMI baru di [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)bidang dalam konfigurasi klaster Anda dan buat klaster.
------
# Mengintegrasikan Active Directory
Dalam tutorial ini, Anda membuat lingkungan beberapa pengguna. Lingkungan ini mencakup AWS ParallelCluster yang terintegrasi dengan AWS Managed Microsoft AD (Active Directory) di`corp.example.com`. Anda mengonfigurasi `Admin` pengguna untuk mengelola direktori, `ReadOnly` pengguna untuk membaca direktori, dan `user000` pengguna untuk masuk ke cluster. Anda dapat menggunakan jalur otomatis atau jalur manual untuk membuat sumber daya jaringan, Direktori Aktif (AD), dan instans Amazon EC2 yang Anda gunakan untuk mengonfigurasi AD. Terlepas dari jalurnya, infrastruktur yang Anda buat sudah dikonfigurasi sebelumnya untuk diintegrasikan AWS ParallelCluster menggunakan salah satu metode berikut:
+ LDAPS dengan verifikasi sertifikat (direkomendasikan sebagai opsi paling aman)
+ LDAPS tanpa verifikasi sertifikat
+ LDAP
LDAP dengan sendirinya *tidak* menyediakan enkripsi. Untuk memastikan transmisi informasi yang berpotensi sensitif dengan aman, kami sangat menyarankan Anda menggunakan LDAPS (LDAP over TLS/SSL) untuk cluster yang terintegrasi dengannya. ADs *Untuk informasi selengkapnya, lihat [Mengaktifkan LDAPS sisi server menggunakan AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html) dalam Panduan Administrasi. Directory Service *
Setelah Anda membuat sumber daya ini, lanjutkan untuk mengkonfigurasi dan membuat klaster Anda terintegrasi dengan Active Directory (AD) Anda. Setelah cluster dibuat, masuk sebagai pengguna yang Anda buat. Untuk informasi lebih lanjut tentang konfigurasi yang Anda buat dalam tutorial ini, lihat [Beberapa akses pengguna ke cluster](multi-user-v3.md) dan bagian [`DirectoryService`](DirectoryService-v3.md)konfigurasi.
Tutorial ini mencakup cara membuat lingkungan yang mendukung beberapa akses pengguna ke cluster. Tutorial ini tidak mencakup cara Anda membuat dan menggunakan Directory Service AD. Langkah-langkah yang Anda ambil untuk mengatur AWS Managed Microsoft AD dalam tutorial ini disediakan untuk tujuan pengujian saja. Mereka *tidak* disediakan untuk menggantikan dokumentasi resmi dan praktik terbaik yang dapat Anda temukan di [AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)dan [Simple AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html) di *Panduan Directory Service Administrasi*.
**catatan**
Kata sandi pengguna direktori kedaluwarsa sesuai dengan definisi properti kebijakan kata sandi direktori. Untuk mengatur ulang kata sandi direktori dengan AWS ParallelCluster, lihat[Cara mengatur ulang kata sandi pengguna dan kata sandi yang kedaluwarsa](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd).
**catatan**
Alamat IP pengontrol domain direktori dapat berubah karena perubahan pengontrol domain dan pemeliharaan direktori. Jika Anda memilih metode pembuatan cepat otomatis untuk membuat infrastruktur direktori, Anda harus menyelaraskan penyeimbang beban secara manual di depan pengontrol direktori saat alamat IP direktori berubah. Jika Anda menggunakan metode quick create, alamat IP direktori tidak secara otomatis selaras dengan load balancer.
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
Saat Anda membaca tutorial, ganti`inputs highlighted in red`, seperti `region-id` dan`d-abcdef01234567890`, dengan nama Anda sendiri dan IDs. Ganti `0123456789012` dengan Akun AWS nomor Anda.
# Buat infrastruktur AD
Pilih tab *Otomatis* untuk membuat infrastruktur Active Directory (AD) dengan templat buat CloudFormation cepat.
Pilih tab *Manual* untuk membuat infrastruktur AD secara manual.
## Otomatis
1. Masuk ke Konsol Manajemen AWS.
1. Buka [CloudFormation Quick Create (region 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)) untuk membuat sumber daya berikut di konsol: CloudFormation
+ VPC dengan dua subnet dan routing untuk akses publik, jika tidak ada VPC yang ditentukan.
+ Sebuah AWS Managed Microsoft AD.
+ Instans Amazon EC2 yang bergabung dengan AD yang dapat Anda gunakan untuk mengelola direktori.
1. Di bagian **Quick create stack** page **Parameters**, masukkan kata sandi untuk parameter berikut:
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Catat kata sandi. Anda menggunakannya nanti dalam tutorial ini.
1. Untuk **DomainName**, masukkan **corp.example.com**
1. Untuk **Keypair**, masukkan nama key pair Amazon EC2.
1. Centang kotak untuk mengetahui setiap kemampuan akses di bagian bawah halaman.
1. Pilih **Buat tumpukan**.
1. Setelah CloudFormation tumpukan mencapai `CREATE_COMPLETE` status, pilih tab **Output** dari tumpukan. Catat nama sumber daya keluaran dan IDs karena Anda perlu menggunakannya di langkah selanjutnya. Output memberikan informasi yang diperlukan untuk membuat cluster.
![\[Diagram yang menunjukkan output tumpukan yang dibuat di file. Konsol Manajemen AWS\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/ad-cfn.png)
1. Untuk menyelesaikan latihan[(Opsional) Kelola pengguna dan grup AD](tutorials_05_multi-user-ad-step2.md), Anda memerlukan ID direktori. Pilih **Sumber Daya** dan gulir ke bawah untuk mencatat ID direktori.
1. Lanjutkan di [(Opsional) Kelola pengguna dan grup AD](tutorials_05_multi-user-ad-step2.md) atau[Buat cluster](tutorials_05_multi-user-ad-step3.md).
## Manual
Buat VPC untuk layanan direktori dengan dua subnet di Availability Zone yang berbeda dan file. AWS Managed Microsoft AD
### Buat AD
**catatan**
Direktori dan nama domain adalah`corp.example.com`. Nama pendeknya adalah`CORP`.
Ubah `Admin` kata sandi dalam skrip.
Active Directory (AD) membutuhkan waktu setidaknya 15 menit untuk membuatnya.
Gunakan skrip Python berikut untuk membuat VPC, subnet, dan sumber daya AD di lokal Anda. Wilayah AWS Simpan file ini sebagai `ad.py` dan jalankan.
```
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})
```
Berikut ini adalah contoh output dari script 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"
}
```
Catat nama sumber daya keluaran dan IDs. Anda menggunakannya di langkah selanjutnya.
Setelah skrip selesai, lanjutkan ke langkah berikutnya.
### Membuat instans Amazon EC2
------
#### [ New Amazon EC2 console ]
1. Masuk ke Konsol Manajemen AWS.
1. Jika Anda tidak memiliki peran dengan kebijakan yang tercantum di langkah 4 terlampir, buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Jika tidak, lewati ke langkah 5.
1. Buat `ResetUserPassword` kebijakan, ganti konten berwarna merah yang disorot dengan ID, ID Akun, dan ID direktori dari output skrip yang Anda jalankan untuk membuat AD. Wilayah AWS
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Buat peran IAM dengan kebijakan berikut terlampir.
+ AWS kebijakan terkelola [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS kebijakan terkelola [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword kebijakan
1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Di **Dasbor Amazon EC2**, pilih **Launch** Instance.
1. Di **Gambar Aplikasi dan OS**, pilih AMI Amazon Linux 2 terbaru.
1. Untuk **jenis Instance**, pilih t2.micro.
1. Untuk **Key pair**, pilih key pair.
1. Untuk **pengaturan Jaringan**, pilih **Edit**.
1. Untuk **VPC**, pilih direktori VPC.
1. Gulir ke bawah dan pilih **Detail lanjutan**.
1. Di **Detail lanjutan**, **Domain bergabung direktori**, pilih**corp.example.com**.
1. Untuk **profil Instans IAM**, pilih peran yang Anda buat di langkah 1 atau peran dengan kebijakan yang tercantum di langkah 4 terlampir.
1. Dalam **Ringkasan** pilih **Launch instance**.
1. Catat ID Instance (misalnya, i-1234567890abcdef0) dan tunggu hingga instance selesai diluncurkan.
1. Setelah instance diluncurkan, lanjutkan ke langkah berikutnya.
------
#### [ Old Amazon EC2 console ]
1. Masuk ke Konsol Manajemen AWS.
1. Jika Anda tidak memiliki peran dengan kebijakan yang tercantum di langkah 4 terlampir, buka konsol IAM di [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Jika tidak, lewati ke langkah 5.
1. Buat `ResetUserPassword` kebijakan. Ganti konten yang disorot merah dengan Wilayah AWS Akun AWS ID, ID, dan ID direktori Anda dari output skrip yang Anda jalankan untuk membuat Active Directory (AD).
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Buat peran IAM dengan kebijakan berikut terlampir.
+ AWS kebijakan terkelola [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS kebijakan terkelola [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPasswordkebijakan
1. Buka konsol Amazon EC2 di. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Di **Dasbor Amazon EC2**, pilih **Launch** Instance.
1. Di **Gambar Aplikasi dan OS**, pilih AMI Amazon Linux 2 terbaru.
1. Untuk **jenis Instance**, piliht2.micro.
1. Untuk **Key pair**, pilih key pair.
1. Di **Pengaturan jaringan**, pilih **Edit**.
1. Di **Pengaturan jaringan**, **VPC**, pilih direktori VPC.
1. Gulir ke bawah dan pilih **Detail lanjutan**.
1. Di **Detail lanjutan**, **Domain bergabung direktori**, pilih**corp.example.com**.
1. Di **Detail lanjutan**, **Profil instans**, pilih peran yang Anda buat di langkah 1 atau peran dengan kebijakan yang tercantum di langkah 4 terlampir.
1. Dalam **Ringkasan** pilih **Launch instance**.
1. Catat ID Instance (misalnya,i-1234567890abcdef0) dan tunggu instance selesai diluncurkan.
1. Setelah instance diluncurkan, lanjutkan ke langkah berikutnya.
------
### Bergabunglah dengan instans Anda ke AD
1.
**Hubungkan ke instans Anda dan bergabunglah dengan ranah AD sebagai`admin`.**
Jalankan perintah berikut untuk terhubung ke instance.
```
$ 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.
**Instal perangkat lunak yang diperlukan dan bergabunglah dengan dunia.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Ganti kata sandi admin dengan `admin` kata sandi Anda.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Jika sebelumnya telah berhasil, Anda bergabung ke ranah dan dapat melanjutkan ke langkah berikutnya.
### Menambahkan pengguna ke AD
1.
**Buat ReadOnlyUser dan pengguna tambahan.**
Pada langkah ini, Anda menggunakan alat [adcli](https://www.mankier.com/package/adcli) dan [openldap-client](https://www.mankier.com/package/openldap-clients) yang Anda instal pada langkah sebelumnya.
```
$ 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. **Verifikasi pengguna dibuat:**
Alamat IP DNS direktori adalah output dari skrip 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"
```
Secara default, saat Anda membuat pengguna dengan`ad-cli`, pengguna dinonaktifkan.
1.
****Setel ulang dan aktifkan kata sandi pengguna dari mesin lokal Anda:****
Keluar dari instans Amazon EC2 Anda.
**catatan**
`ro-p@ssw0rd`adalah kata sandi dari`ReadOnlyUser`, diambil dari AWS Secrets Manager.
`user-p@ssw0rd`adalah kata sandi pengguna cluster yang disediakan saat Anda menghubungkan (`ssh`) ke cluster.
`directory-id`Ini adalah output dari skrip 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. **Tambahkan kata sandi ke rahasia Secrets Manager.**
Sekarang setelah Anda membuat `ReadOnlyUser` dan mengatur kata sandi, simpan dalam rahasia yang AWS ParallelCluster digunakan untuk memvalidasi login.
Gunakan Secrets Manager untuk membuat rahasia baru untuk menyimpan kata sandi `ReadOnlyUser` sebagai nilai. Format nilai rahasia harus berupa teks biasa saja (bukan format JSON). Catat rahasia ARN untuk langkah-langkah masa depan.
```
$ 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 dengan pengaturan verifikasi sertifikat (disarankan)
Catat sumber daya IDs. Anda menggunakannya dalam langkah-langkah nanti.
1.
**Hasilkan sertifikat domain, secara lokal.**
```
$ 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.
**Simpan sertifikat ke Secrets Manager untuk membuatnya dapat diambil dari dalam cluster nanti.**
```
$ 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. Tambahkan kebijakan berikut ke peran IAM yang Anda buat untuk bergabung dengan instans Amazon EC2 ke domain AD.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Impor sertifikat ke 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.
**Buat dan penyeimbang beban yang diletakkan di depan titik akhir 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.
**Buat grup target yang menargetkan titik akhir 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.
**Daftarkan titik akhir Active Directory (AD) ke dalam grup target.**
```
$ 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.
**Buat pendengar LB dengan sertifikat.**
```
$ 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.
**Buat zona yang dihosting untuk membuat domain dapat ditemukan di dalam VPC cluster.**
```
$ aws route53 create-hosted-zone --name corp.example.com \
--vpc VPCRegion=region-id,VPCId=vpc-021345abcdef6789 \
--caller-reference "ParallelCluster AD Tutorial"
{
"Location": "https://route53.amazonaws.com/2013-04-01/hostedzone/Z09020002B5MZQNXMSJUB",
"HostedZone": {
"Id": "/hostedzone/Z09020002B5MZQNXMSJUB",
"Name": "corp.example.com.",
"CallerReference": "ParallelCluster AD Tutorial",
"Config": {
"PrivateZone": true
},
"ResourceRecordSetCount": 2
},
"ChangeInfo": {
"Id": "/change/C05533343BF3IKSORW1TQ",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T13:21:53.863000+00:00"
},
"VPC": {
"VPCRegion": "region-id",
"VPCId": "vpc-021345abcdef6789"
}
}
```
1.
**Buat file yang diberi nama `recordset-change.json` dengan konten berikut. `HostedZoneId`adalah ID zona host kanonik dari penyeimbang beban.**
```
{
"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.
**Kirim perubahan recordset ke zona yang dihosting, kali ini menggunakan ID zona yang dihosting.**
```
$ 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.
**Buat dokumen kebijakan `policy.json` dengan konten berikut.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Buat dokumen kebijakan yang diberi nama `policy.json` dengan konten berikut.**
```
$ 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. Terus ikuti langkah-langkah di [(Opsional) Kelola pengguna dan grup AD](tutorials_05_multi-user-ad-step2.md) atau[Buat cluster](tutorials_05_multi-user-ad-step3.md).
# (Opsional) Kelola pengguna dan grup AD
Pada langkah ini, Anda mengelola pengguna dan grup dari instans Amazon EC2 Amazon Linux 2 yang bergabung dengan domain Pengiriman Aktif (AD).
Jika Anda mengikuti jalur *otomatis*, mulai ulang dan masuk ke instans gabungan AD yang dibuat sebagai bagian dari otomatisasi.
Jika Anda mengikuti jalur *manual*, mulai ulang dan masuk ke instans yang Anda buat dan bergabung dengan AD di langkah-langkah sebelumnya.
Dalam langkah-langkah ini, Anda menggunakan alat [adcli](https://www.mankier.com/package/adcli) dan [openldap-client](https://www.mankier.com/package/openldap-clients) yang diinstal dalam instance sebagai bagian dari langkah sebelumnya.
**Masuk ke instans Amazon EC2 yang bergabung dengan domain AD**
1. Dari konsol Amazon EC2, pilih instans Amazon EC2 tanpa judul yang dibuat pada langkah sebelumnya. Status instance mungkin **Dihentikan**.
1. Jika status instance **Dihentikan**, pilih **status Instance** dan kemudian **Mulai instance**.
1. Setelah pemeriksaan status lulus, pilih instance dan pilih **Connect** dan SSH masuk ke instance.
**Kelola pengguna dan grup saat masuk ke instans Amazon EC2 Amazon Linux 2 yang bergabung dengan AD**
Ketika Anda menjalankan `adcli` perintah dengan ` -U "Admin"` opsi, Anda diminta untuk memasukkan `Admin` kata sandi AD. Anda menyertakan `Admin` kata sandi AD sebagai bagian dari `ldapsearch` perintah.
1.
**Buat pengguna.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Tetapkan kata sandi pengguna.**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**Buat grup.**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**Tambahkan pengguna ke grup.**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Jelaskan pengguna dan grup.**
Jelaskan semua pengguna.
```
$ 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"
```
Jelaskan pengguna tertentu.
```
$ 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"
```
Jelaskan semua pengguna dengan pola nama.
```
$ 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"
```
Jelaskan semua pengguna yang merupakan bagian dari grup tertentu.
```
$ 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"
```
Jelaskan semua kelompok
```
$ 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"
```
Jelaskan kelompok tertentu
```
$ 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.
**Hapus pengguna dari grup.**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Hapus pengguna.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Hapus grup.**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# Buat cluster
Jika Anda belum keluar dari instans Amazon EC2, lakukan sekarang.
Lingkungan diatur untuk membuat cluster yang dapat mengautentikasi pengguna terhadap Active Directory (AD).
Buat konfigurasi cluster sederhana dan berikan pengaturan yang relevan untuk menghubungkan ke AD. Untuk informasi selengkapnya, lihat bagian [`DirectoryService`](DirectoryService-v3.md).
Pilih salah satu konfigurasi klaster berikut dan salin ke file yang diberi nama`ldaps_config.yaml`,`ldaps_nocert_config.yaml`, atau`ldap_config.yaml`.
Kami menyarankan Anda memilih konfigurasi LDAPS dengan verifikasi sertifikat. Jika Anda memilih konfigurasi ini, Anda juga harus menyalin skrip bootstrap ke file yang diberi nama`active-directory.head.post.sh`. Dan, Anda harus menyimpannya di bucket Amazon S3 seperti yang ditunjukkan dalam file konfigurasi.
## LDAPS dengan konfigurasi verifikasi sertifikat (disarankan)
**catatan**
`KeyName`: Salah satu keypair Amazon EC2 Anda.
`SubnetId / SubnetIds`: Salah satu subnet yang IDs disediakan dalam output dari CloudFormation quick create stack (tutorial otomatis) atau skrip python (tutorial manual).
`Region`: Wilayah tempat Anda membuat infrastruktur AD.
`DomainAddr`: Alamat IP ini adalah salah satu alamat DNS layanan AD Anda.
`PasswordSecretArn`: Nama Sumber Daya Amazon (ARN) dari rahasia yang berisi kata sandi untuk file. `DomainReadOnlyUser`
`BucketName`: Nama bucket yang menyimpan skrip bootstrap.
`AdditionalPolicies`/`Policy`: Nama Sumber Daya Amazon (ARN) dari kebijakan sertifikasi domain baca. ReadCertExample
`CustomActions`/`OnNodeConfigured`/`Args`: Nama Sumber Daya Amazon (ARN) rahasia yang memegang kebijakan sertifikasi domain.
Untuk postur keamanan yang lebih baik, kami sarankan untuk menggunakan `AllowedIps` konfigurasi `HeadNode``Ssh`//untuk membatasi akses SSH ke node kepala.
Perhatikan bahwa sertifikat yang ditentukan `LdapTlsCaCert` harus dapat diakses oleh semua node cluster.
**Persyaratan Sulit**
Sertifikat yang ditentukan `LdapTlsCaCert` harus dapat diakses oleh semua node cluster.
Sebuah node tanpa akses ke sertifikat tidak akan dapat menyelesaikan pengguna dari direktori.
```
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
```
**Skrip bootstrap**
Setelah Anda membuat file bootstrap dan sebelum Anda mengunggahnya ke bucket S3 Anda, jalankan `chmod +x active-directory.head.post.sh` untuk memberikan izin AWS ParallelCluster jalankan.
```
#!/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 tanpa konfigurasi verifikasi sertifikat
**catatan**
`KeyName`: Salah satu keypair Amazon EC2 Anda.
`SubnetId / SubnetIds`: Salah satu subnet IDs yang ada di output dari CloudFormation quick create stack (tutorial otomatis) atau skrip python (tutorial manual).
`Region`: Wilayah tempat Anda membuat infrastruktur AD.
`DomainAddr`: Alamat IP ini adalah salah satu alamat DNS layanan AD Anda.
`PasswordSecretArn`: Nama Sumber Daya Amazon (ARN) dari rahasia yang berisi kata sandi untuk file. `DomainReadOnlyUser`
Untuk postur keamanan yang lebih baik, kami sarankan untuk menggunakan AllowedIps konfigurasi HeadNode /Ssh/ untuk membatasi akses SSH ke node kepala.
```
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
```
## Konfigurasi LDAP
**catatan**
`KeyName`: Salah satu keypair Amazon EC2 Anda.
`SubnetId / SubnetIds`: Salah satu subnet yang IDs disediakan dalam output dari CloudFormation quick create stack (tutorial otomatis) atau skrip python (tutorial manual).
`Region`: Wilayah tempat Anda membuat infrastruktur AD.
`DomainAddr`: Alamat IP ini adalah salah satu alamat DNS layanan AD Anda.
`PasswordSecretArn`: Nama Sumber Daya Amazon (ARN) dari rahasia yang berisi kata sandi untuk file. `DomainReadOnlyUser`
Untuk postur keamanan yang lebih baik, kami sarankan untuk menggunakan AllowedIps konfigurasi HeadNode /Ssh/ untuk membatasi akses SSH ke node kepala.
```
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
```
Buat klaster Anda dengan perintah berikut.
```
$ 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"
}
}
```
# Connect ke cluster sebagai pengguna
Anda dapat menentukan status cluster dengan perintah berikut.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
Outputnya adalah sebagai berikut.
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
Saat status mencapai`"CREATE_COMPLETE"`, masuk dengan nama pengguna dan kata sandi yang dibuat.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
Anda dapat masuk tanpa kata sandi dengan memberikan SSH kunci yang dibuat untuk pengguna baru di`/home/user000@HEAD_NODE_IP/.ssh/id_rsa`.
Jika `ssh` perintah berhasil, Anda telah berhasil terhubung ke cluster sebagai pengguna yang diautentikasi untuk menggunakan Active Directory (AD).
# Bersihkan
1.
**Dari mesin lokal Anda, hapus klaster.**
```
$ 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.
**Periksa kemajuan cluster yang dihapus.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Setelah cluster berhasil dihapus, lanjutkan ke langkah berikutnya.
## Otomatis
**Hapus sumber daya Direktori Aktif**
1. Dari [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/).
1. Di panel navigasi, pilih **Stacks (Tumpukan)**.
1. Dari daftar tumpukan, pilih tumpukan AD (misalnya,`pcluster-ad`).
1. Pilih **Hapus**.
## Manual
1.
**Hapus instans Amazon EC2.**
1. Dari [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/), pilih **Instans** di panel navigasi.
1. Dari daftar instance, pilih instance yang Anda buat untuk menambahkan pengguna ke direktori.
1. Pilih **status Instance**, lalu **Hentikan instance**.
1.
**Hapus zona yang dihosting.**
1. Buat `recordset-delete.json` dengan konten berikut. Dalam contoh ini, HostedZoneId adalah ID zona host kanonik dari penyeimbang beban.
```
{
"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. Kirim perubahan recordset ke zona yang dihosting menggunakan ID zona yang dihosting.
```
$ 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. Hapus zona yang dihosting.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**Hapus pendengar LB.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**Hapus grup target.**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**Hapus penyeimbang beban.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**Hapus kebijakan yang digunakan klaster untuk membaca sertifikat dari Secrets Manager.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**Hapus rahasia yang berisi sertifikat domain.**
```
$ 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.
**Hapus sertifikat dari ACM.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Hapus sumber daya Active Directory (AD).**
1. Dapatkan sumber daya berikut IDs dari output skrip `ad.py` python:
+ ID IKLAN
+ Subnet AD IDs
+ ID VPC IKLAN
1. Hapus direktori dengan menjalankan perintah berikut.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. Buat daftar grup keamanan di VPC.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. Hapus grup keamanan khusus.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. Hapus subnet.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. Jelaskan gateway internet.
```
$ aws ec2 describe-internet-gateways \
--filters Name=attachment.vpc-id,Values=vpc-021345abcdef6789 \
--region region-id
{
"InternetGateways": [
{
"Attachments": [
{
"State": "available",
"VpcId": "vpc-021345abcdef6789"
}
],
"InternetGatewayId": "igw-1234567890abcdef",
"OwnerId": "123456789012",
"Tags": []
}
]
}
```
1. Lepaskan gateway internet.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Hapus gateway internet.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. Hapus VPC.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Hapus rahasia yang berisi `ReadOnlyUser` kata sandi.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# Mengkonfigurasi enkripsi penyimpanan bersama dengan kunci AWS KMS
Pelajari cara menyiapkan AWS KMS kunci terkelola pelanggan untuk mengenkripsi dan melindungi data Anda di sistem penyimpanan file cluster yang dikonfigurasi. AWS ParallelCluster
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster mendukung opsi konfigurasi penyimpanan bersama berikut:
+ [`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)
Anda dapat menggunakan opsi ini untuk menyediakan AWS KMS kunci terkelola pelanggan untuk Amazon EBS, Amazon EFS, dan FSx untuk enkripsi sistem penyimpanan bersama Lustre. Untuk menggunakannya, Anda harus membuat dan mengonfigurasi kebijakan IAM untuk hal-hal berikut:
+ [`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)
**Prasyarat**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
**Topics**
+ [
# Buat kebijakan
](creating-the-role-v3.md)
+ [
# Konfigurasikan dan buat cluster
](creating-the-cluster-v3.md)
# Buat kebijakan
Dalam tutorial ini, Anda akan membuat kebijakan untuk mengkonfigurasi enkripsi penyimpanan bersama dengan AWS KMS kunci.
**Buat kebijakan.**
1. Pergi ke Konsol IAM: [https://console.aws.amazon.com/iam/rumah](https://console.aws.amazon.com/iam/home).
1. Pilih **Policies** (Kebijakan).
1. Pilih **Buat kebijakan**.
1. Pilih tab **JSON** dan tempel di kebijakan berikut. Pastikan untuk mengganti semua kemunculan `123456789012` dengan Akun AWS ID Anda dan kunci Amazon Resource Name (ARN) Wilayah AWS dan dengan milik Anda sendiri.
------
#### [ 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. Untuk tutorial ini, beri nama kebijakan`ParallelClusterKmsPolicy`, lalu pilih **Create Policy**.
1. Catat kebijakan ARN. Anda membutuhkannya untuk mengkonfigurasi cluster Anda.
# Konfigurasikan dan buat cluster
Berikut ini adalah contoh konfigurasi cluster yang mencakup sistem file bersama Amazon Elastic Block Store dengan enkripsi.
```
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
```
Ganti item dalam teks merah dengan nilai Anda sendiri. Kemudian, buat cluster yang menggunakan AWS KMS kunci Anda untuk mengenkripsi data Anda di Amazon EBS.
Konfigurasinya serupa untuk Amazon EFS dan FSx untuk sistem file Lustre.
`SharedStorage`Konfigurasi Amazon EFS adalah sebagai berikut.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
`SharedStorage`Konfigurasi FSx untuk Lustre adalah sebagai berikut.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# Menjalankan pekerjaan dalam klaster mode antrian ganda
Tutorial ini mencakup cara menjalankan pekerjaan "Hello World" pertama Anda AWS ParallelCluster dengan [beberapa mode antrian](configuration-of-multiple-queues-v3.md).
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
## Konfigurasikan klaster Anda
Pertama, verifikasi AWS ParallelCluster yang diinstal dengan benar dengan menjalankan perintah berikut.
```
$ pcluster version
```
Untuk informasi selengkapnya tentang `pcluster version`, lihat [`pcluster version`](pcluster.version-v3.md).
Perintah ini mengembalikan versi yang sedang berjalan dari AWS ParallelCluster.
Selanjutnya, jalankan `pcluster configure` untuk menghasilkan file konfigurasi dasar. Ikuti semua petunjuk yang mengikuti perintah ini.
```
$ pcluster configure --config multi-queue-mode.yaml
```
Untuk informasi selengkapnya tentang `pcluster configure` perintah, lihat[`pcluster configure`](pcluster.configure-v3.md).
Setelah Anda menyelesaikan langkah ini, file konfigurasi dasar bernama `multi-queue-mode.yaml` muncul. File ini berisi konfigurasi cluster dasar.
Pada langkah berikutnya, Anda memodifikasi file konfigurasi baru Anda dan meluncurkan cluster dengan beberapa antrian.
**catatan**
Beberapa contoh yang digunakan tutorial ini tidak memenuhi syarat tingkat gratis.
Untuk tutorial ini, ubah file konfigurasi Anda agar sesuai dengan konfigurasi berikut. Item yang disorot dengan warna merah mewakili nilai file konfigurasi Anda. Pertahankan nilai-nilai Anda sendiri.
```
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
```
## Buat klaster Anda
Buat cluster yang diberi nama `multi-queue-cluster` berdasarkan file konfigurasi Anda.
```
$ 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"
}
}
```
Untuk informasi selengkapnya tentang `pcluster create-cluster` perintah, lihat[`pcluster create-cluster`](pcluster.create-cluster-v3.md).
Untuk memeriksa status cluster, jalankan perintah berikut.
```
$ 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"
}
}
```
Ketika cluster dibuat, `clusterStatus` bidang menunjukkan`CREATE_COMPLETE`.
## Masuk ke node kepala
Gunakan file kunci SSH pribadi Anda untuk masuk ke node kepala.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
Untuk informasi selengkapnya tentang `pcluster ssh`, lihat [`pcluster ssh`](pcluster.ssh-v3.md).
Setelah masuk, jalankan `sinfo` perintah untuk memverifikasi bahwa antrian penjadwal Anda sudah diatur dan dikonfigurasi.
Untuk informasi lebih lanjut tentang`sinfo`, lihat [sinfo](https://slurm.schedmd.com/sinfo.html) dalam *Slurmdokumentasi*.
```
$ 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]
```
Output menunjukkan bahwa Anda memiliki satu `t2.micro` dan satu node `c5.xlarge` komputasi dalam `idle` keadaan yang tersedia di cluster Anda.
Node lain semuanya dalam status hemat daya, ditunjukkan oleh `~` sufiks dalam status node, tanpa instans Amazon EC2 yang mendukungnya. Antrian default ditunjukkan oleh `*` akhiran setelah nama antreannya. `spot`adalah antrian pekerjaan default Anda.
## Jalankan pekerjaan dalam beberapa mode antrian
Selanjutnya, cobalah untuk menjalankan pekerjaan untuk tidur sebentar. Pekerjaan itu kemudian mengeluarkan nama hostnya sendiri. Pastikan skrip ini dapat dijalankan oleh pengguna saat ini.
```
$ tee <
Dalam tutorial ini, Anda membangun dan menguji API dengan [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) dan AWS ParallelCluster CloudFormation template. Kemudian, Anda menggunakan contoh klien yang tersedia GitHub untuk menggunakan API. Untuk informasi selengkapnya tentang penggunaan API, lihat[AWS ParallelCluster API](api-reference-v3.md).
Untuk informasi selengkapnya, lihat [Membuat komponen kustom dengan Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) di *Panduan Pengguna EC2 Image Builder*.
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat**
+ AWS CLI Ini [diinstal](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) dan dikonfigurasi di lingkungan komputasi Anda.
+ AWS ParallelCluster dipasang di lingkungan virtual. Untuk informasi selengkapnya, lihat [Instal AWS ParallelCluster di lingkungan virtual (disarankan)](install-v3-virtual-environment.md).
+ Anda memiliki [ EC2 key pair Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
## Langkah 1: Bangun API dengan Amazon API Gateway
**Tetap di direktori pengguna rumah Anda dan aktifkan lingkungan virtual Anda:**
1. Instal prosesor baris perintah JSON yang bermanfaat.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. Jalankan perintah berikut untuk mendapatkan AWS ParallelCluster versi Anda dan menetapkannya ke variabel lingkungan.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. Buat variabel lingkungan dan tetapkan ID Wilayah Anda untuk itu.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. Jalankan perintah berikut untuk menerapkan 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"
}
```
Setelah proses selesai, lanjutkan ke langkah berikutnya.
## Langkah 2: Uji API di konsol Amazon API Gateway
1. Masuk ke Konsol Manajemen AWS.
1. Arahkan ke [konsol Amazon API Gateway](https://console.aws.amazon.com/apigateway/home).
1. Pilih penerapan API Anda.
![\[Konsol Amazon API Gateway dengan daftar gateway yang dapat Anda pilih.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/gateway_choose.png)
1. Pilih **Tahapan** dan pilih panggung.
![\[Tampilan konsol dari tahapan yang dapat Anda pilih. Anda juga dapat melihat URL yang disediakan API Gateway untuk API Anda.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/gateway_address.png)
1. Perhatikan URL yang disediakan API Gateway untuk mengakses atau menjalankan API Anda. Ini disorot dengan warna biru.
1. Pilih **Sumber Daya**, dan pilih **`GET`**di bawah **`/clusters`**.
1. Pilih ikon **TEST** dan kemudian gulir ke bawah dan pilih ikon **TEST**.
![\[Tampilan konsol dari sumber daya API dan mekanisme pengujian.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/gateway_test.png)
Respons terhadap Anda `/clusters GET` muncul.
![\[Tampilan konsol sumber daya API, mekanisme pengujian, dan respons dari permintaan pengujian Anda.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/gateway.png)
## Langkah 3: Siapkan dan uji contoh klien untuk menjalankan API
Kloning kode AWS ParallelCluster sumber, `cd` ke `api` direktori, dan instal pustaka klien 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. Arahkan kembali ke direktori pengguna beranda Anda.
1. Ekspor URL dasar API Gateway yang digunakan klien saat menjalankan.
```
$ 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. Ekspor nama cluster yang digunakan klien untuk membuat cluster.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. Jalankan perintah berikut untuk menyimpan kredensi yang digunakan klien contoh untuk mengakses 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
```
## Langkah 4: Salin skrip kode klien dan jalankan tes cluster
1. Salin contoh kode klien berikut ke `test_pcluster_client.py` dalam direktori pengguna rumah Anda. Kode klien membuat permintaan untuk melakukan hal berikut:
+ Buat cluster.
+ Jelaskan cluster.
+ Buat daftar cluster.
+ Jelaskan armada komputasi.
+ Jelaskan contoh cluster.
```
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Author: Evan F. Bollig (Github: bollig)
import time, datetime
import os
import pcluster_client
from pprint import pprint
from pcluster_client.api import (
cluster_compute_fleet_api,
cluster_instances_api,
cluster_operations_api
)
from pcluster_client.model.create_cluster_request_content import CreateClusterRequestContent
from pcluster_client.model.cluster_status import ClusterStatus
region=os.environ.get("AWS_DEFAULT_REGION")
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = pcluster_client.Configuration(
host = os.environ.get("PCLUSTER_API_URL")
)
cluster_name=os.environ.get("CLUSTER_NAME")
# Enter a context with an instance of the API client
with pcluster_client.ApiClient(configuration) as api_client:
cluster_ops = cluster_operations_api.ClusterOperationsApi(api_client)
fleet_ops = cluster_compute_fleet_api.ClusterComputeFleetApi(api_client)
instance_ops = cluster_instances_api.ClusterInstancesApi(api_client)
# Create cluster
build_done = False
try:
with open('cluster-config.yaml', encoding="utf-8") as f:
body = CreateClusterRequestContent(cluster_name=cluster_name, cluster_configuration=f.read())
api_response = cluster_ops.create_cluster(body, region=region)
except pcluster_client.ApiException as e:
print("Exception when calling create_cluster: %s\n" % e)
build_done = True
time.sleep(60)
# Confirm cluster status with describe_cluster
while not build_done:
try:
api_response = cluster_ops.describe_cluster(cluster_name, region=region)
pprint(api_response)
if api_response.cluster_status == ClusterStatus('CREATE_IN_PROGRESS'):
print('. . . working . . .', end='', flush=True)
time.sleep(60)
elif api_response.cluster_status == ClusterStatus('CREATE_COMPLETE'):
print('READY!')
build_done = True
else:
print('ERROR!!!!')
build_done = True
except pcluster_client.ApiException as e:
print("Exception when calling describe_cluster: %s\n" % e)
# List clusters
try:
api_response = cluster_ops.list_clusters(region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling list_clusters: %s\n" % e)
# DescribeComputeFleet
try:
api_response = fleet_ops.describe_compute_fleet(cluster_name, region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling compute fleet: %s\n" % e)
# DescribeClusterInstances
try:
api_response = instance_ops.describe_cluster_instances(cluster_name, region=region)
pprint(api_response)
except pcluster_client.ApiException as e:
print("Exception when calling describe_cluster_instances: %s\n" % e)
```
1. Buat konfigurasi cluster.
```
$ pcluster configure --config cluster-config.yaml
```
1. Pustaka Klien API secara otomatis mendeteksi detail konfigurasi dari variabel lingkungan Anda (misalnya,, `AWS_ACCESS_KEY_ID``AWS_SECRET_ACCESS_KEY`, atau`AWS_SESSION_TOKEN`) atau`$HOME/.aws`. Perintah berikut mengalihkan peran IAM Anda saat ini ke yang ditunjukParallelClusterApiUserRole.
```
$ 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"')
```
**Kesalahan yang harus diperhatikan:**
Jika Anda melihat kesalahan yang mirip dengan yang berikut ini, Anda sudah berasumsi ParallelClusterApiUserRole dan kesalahan Anda `AWS_SESSION_TOKEN` telah kedaluwarsa.
```
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
```
Jatuhkan peran dan kemudian jalankan kembali `aws sts assume-role` perintah untuk menggunakan. ParallelClusterApiUserRole
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
Untuk memberikan izin pengguna saat ini untuk akses API, Anda harus [memperluas Kebijakan Sumber Daya](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html).
1. Jalankan perintah berikut untuk menguji contoh klien.
```
$ 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!
```
## Langkah 5: Salin skrip kode klien dan hapus cluster
1. Salin contoh kode klien berikut ke`delete_cluster_client.py`. Kode klien membuat permintaan untuk menghapus cluster.
```
# Copyright 2021 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to use, copy, modify,
# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
# permit persons to whom the Software is furnished to do so.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
# Author: Evan F. Bollig (Github: bollig)
import time, datetime
import os
import pcluster_client
from pprint import pprint
from pcluster_client.api import (
cluster_compute_fleet_api,
cluster_instances_api,
cluster_operations_api
)
from pcluster_client.model.create_cluster_request_content import CreateClusterRequestContent
from pcluster_client.model.cluster_status import ClusterStatus
region=os.environ.get("AWS_DEFAULT_REGION")
# Defining the host is optional and defaults to http://localhost
# See configuration.py for a list of all supported configuration parameters.
configuration = pcluster_client.Configuration(
host = os.environ.get("PCLUSTER_API_URL")
)
cluster_name=os.environ.get("CLUSTER_NAME")
# Enter a context with an instance of the API client
with pcluster_client.ApiClient(configuration) as api_client:
cluster_ops = cluster_operations_api.ClusterOperationsApi(api_client)
# Delete the cluster
gone = False
try:
api_response = cluster_ops.delete_cluster(cluster_name, region=region)
except pcluster_client.ApiException as e:
print("Exception when calling delete_cluster: %s\n" % e)
time.sleep(60)
# Confirm cluster status with describe_cluster
while not gone:
try:
api_response = cluster_ops.describe_cluster(cluster_name, region=region)
pprint(api_response)
if api_response.cluster_status == ClusterStatus('DELETE_IN_PROGRESS'):
print('. . . working . . .', end='', flush=True)
time.sleep(60)
except pcluster_client.ApiException as e:
gone = True
print("DELETE COMPLETE or Exception when calling describe_cluster: %s\n" % e)
```
1. Jalankan perintah berikut untuk menghapus cluster.
```
$ python3 delete_cluster_client.py
{'cloud_formation_stack_status': 'DELETE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'DELETE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'head_node': {'instance_id': 'i-abcdef01234567890',
'instance_type': 't2.micro',
'launch_time': datetime.datetime(2022, 4, 28, 16, 53, 48, tzinfo=tzlocal()),
'private_ip_address': '172.31.17.132',
'public_ip_address': '34.201.100.37',
'state': 'running'},
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
.
.
.
. . . working . . . {'cloud_formation_stack_status': 'DELETE_IN_PROGRESS',
'cloudformation_stack_arn': 'arn:aws:cloudformation:us-east-1:123456789012:stack/test-api-cluster/abcd1234-ef56-gh78-ij90-1234abcd5678',
'cluster_configuration': {'url': 'https://parallelcluster-021345abcdef6789-v1-do-not-delete...},
'cluster_name': 'test-api-cluster',
'cluster_status': 'DELETE_IN_PROGRESS',
'compute_fleet_status': 'UNKNOWN',
'creation_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'last_updated_time': datetime.datetime(2022, 4, 28, 16, 50, 47, 943000, tzinfo=tzlocal()),
'region': 'us-east-1',
'tags': [{'key': 'parallelcluster:version', 'value': '3.1.3'}],
'version': '3.1.3'}
. . . working . . . DELETE COMPLETE or Exception when calling describe_cluster: (404)
Reason: Not Found
.
.
.
HTTP response body: {"message":"Cluster 'test-api-cluster' does not exist or belongs to an incompatible ParallelCluster major version."}
```
1. Setelah Anda selesai menguji, hapus pengaturan variabel lingkungan.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## Langkah 6: Bersihkan
Anda dapat menggunakan Konsol Manajemen AWS atau AWS CLI untuk menghapus API Anda.
1. Dari CloudFormation konsol, pilih tumpukan API lalu pilih **Hapus**.
1. Jalankan perintah berikut jika menggunakan AWS CLI.
Menggunakan CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Membuat cluster dengan Slurm akuntansi
Pelajari cara mengonfigurasi dan membuat klaster dengan Slurm akuntansi. Untuk informasi selengkapnya, lihat [Slurmakuntansi dengan AWS ParallelCluster](slurm-accounting-v3.md).
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
Dalam tutorial ini, Anda menggunakan [template CloudFormation quick-create (us-east-1) untuk membuat database tanpa](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) server MySQL. [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html) Template menginstruksikan CloudFormation untuk membuat semua komponen yang diperlukan untuk menyebarkan database Amazon Aurora tanpa server pada VPC yang sama dengan cluster. Template juga menciptakan jaringan dasar dan konfigurasi keamanan untuk koneksi antara cluster dan database.
**catatan**
Dimulai dengan versi 3.3.0, mendukung AWS ParallelCluster Slurm akuntansi dengan parameter konfigurasi klaster [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[Database](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database).
**catatan**
Template quick-create berfungsi sebagai contoh. Template ini tidak mencakup semua kemungkinan kasus penggunaan Slurm server basis data akuntansi. Anda bertanggung jawab untuk membuat server database dengan konfigurasi dan kapasitas yang sesuai untuk beban kerja produksi Anda.
**Prasyarat:**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [ EC2 key pair Amazon](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
+ Wilayah tempat Anda menerapkan template quick-create mendukung Amazon Aurora MySQL tanpa server v2. Untuk informasi lebih lanjut, lihat [Aurora Serverless v2 dengan Aurora](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) MySQL.
## Langkah 1: Buat VPC dan subnet untuk AWS ParallelCluster
Untuk menggunakan CloudFormation template yang disediakan untuk Slurm database akuntansi, Anda harus memiliki VPC untuk cluster siap. Anda dapat melakukan ini secara manual atau sebagai bagian dari [Konfigurasikan dan buat cluster dengan antarmuka baris AWS ParallelCluster perintah](install-v3-configuring.md) prosedur. Jika Anda sudah menggunakan AWS ParallelCluster, Anda mungkin memiliki VPC yang siap untuk penyebaran cluster dan server database.
## Langkah 2: Buat tumpukan database
Gunakan [template CloudFormation quick-create (us-east-1) untuk membuat tumpukan database](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 akuntansi. Template membutuhkan masukan berikut:
+ Kredensi server database, khususnya nama pengguna admin dan kata sandi.
+ Ukuran cluster tanpa Amazon Aurora server. Ini tergantung pada pemuatan cluster yang diharapkan.
+ Parameter jaringan, khususnya target VPC dan subnet atau blok CIDR untuk pembuatan subnet.
Pilih kredensi dan ukuran yang sesuai untuk server database Anda. Untuk opsi jaringan, Anda diharuskan menggunakan VPC yang sama dengan yang digunakan AWS ParallelCluster cluster. Anda dapat membuat subnet untuk database dan meneruskannya sebagai input ke template. Atau, sediakan dua blok CIDR terpisah untuk dua subnet dan biarkan CloudFormation template membuat dua subnet untuk blok CIDR. Pastikan bahwa blok CIDR tidak tumpang tindih dengan subnet yang ada. Jika blok CIDR tumpang tindih dengan subnet yang ada, tumpukan gagal dibuat.
Server database membutuhkan waktu beberapa menit untuk dibuat.
## Langkah 3: Buat cluster dengan Slurm akuntansi diaktifkan
CloudFormation Template yang disediakan menghasilkan CloudFormation tumpukan dengan beberapa output yang ditentukan. Dari Konsol Manajemen AWS, Anda dapat melihat output di tab **Output** di tampilan CloudFormation tumpukan. Untuk mengaktifkan Slurm akuntansi, beberapa output ini harus digunakan dalam file konfigurasi AWS ParallelCluster cluster:
+ `DatabaseHost`: Digunakan untuk parameter konfigurasi [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//[`Uri`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-Uri)cluster.
+ `DatabaseAdminUser`: Digunakan untuk nilai parameter konfigurasi [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//[`UserName`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-UserName)cluster.
+ `DatabaseSecretArn`: Digunakan untuk parameter konfigurasi [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//[`PasswordSecretArn`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-PasswordSecretArn)cluster.
+ `DatabaseClientSecurityGroup`: Ini adalah grup keamanan yang dilampirkan ke node kepala cluster yang didefinisikan dalam parameter [`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups)konfigurasi [`HeadNode`[`Networking`](HeadNode-v3.md#HeadNode-v3-Networking)](HeadNode-v3.md)//.
Perbarui `Database` parameter file konfigurasi cluster Anda dengan nilai output. Gunakan [`pcluster`](pcluster-v3.md) CLI untuk membuat cluster.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
Setelah cluster dibuat, Anda dapat mulai menggunakan Slurm perintah akuntansi seperti `sacctmgr` atau`sacct`.
# Membuat cluster dengan eksternal Slurmdbd akuntansi
Pelajari cara mengonfigurasi dan membuat klaster dengan eksternal Slurmdbd akuntansi. Untuk informasi selengkapnya, lihat [Slurm akuntansi dengan AWS ParallelCluster](slurm-accounting-v3.md).
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster UI dibangun di atas arsitektur tanpa server dan Anda dapat menggunakannya di dalam AWS Free Tier kategori untuk sebagian besar kasus. Untuk informasi selengkapnya, lihat [biaya AWS ParallelCluster UI](install-pcui-costs-v3.md).
Dalam tutorial ini, Anda menggunakan template AWS CloudFormation quick-create untuk membuat komponen yang diperlukan untuk menyebarkan instance Slurmdbd pada VPC yang sama dengan cluster. Template membuat jaringan dasar dan konfigurasi keamanan untuk koneksi antara cluster dan database.
**catatan**
Dimulai dengan`version 3.10.0`, AWS ParallelCluster mendukung Slurmdbd eksternal dengan parameter konfigurasi cluster. `SlurmSettings / ExternelSlurmdbd`
**catatan**
Template quick-create berfungsi sebagai contoh. Template ini tidak mencakup semua kemungkinan kasus penggunaan. Merupakan tanggung jawab Anda untuk membuat Slurmdbd eksternal dengan konfigurasi dan kapasitas yang sesuai untuk beban kerja produksi Anda.
**Prasyarat:**
+ AWS ParallelCluster [diinstal](install-v3-parallelcluster.md).
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki [key pair Amazon Elastic Compute Cloud](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Anda memiliki AWS Identity and Access Management peran dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan [`pcluster`](pcluster-v3.md) CLI.
+ Anda memiliki Slurm basis data akuntansi. Untuk melangkah melalui tutorial membuat Slurm database akuntansi, ikuti langkah 1 dan 2 di [Buat tumpukan Database Akuntansi Slurm](tutorials_07_slurm-accounting-v3.md).
## Langkah 1: Buat tumpukan Slurmdbd
Dalam tutorial ini, gunakan [CloudFormation quick-create template (`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) untuk membuat tumpukan Slurmdbd. Template membutuhkan masukan berikut:
**Jaringan**
+ **VPCId**: ID VPC untuk meluncurkan instance Slurmdbd.
+ **SubnetId**: Subnet ID untuk meluncurkan instance Slurmdbd.
+ **PrivatePrefix**: Awalan CIDR dari VPC.
+ **PrivateIp**: IP pribadi sekunder untuk menetapkan ke instance Slurmdbd.
**Koneksi basis data**
+ **DBMSClientSG**: Grup keamanan yang akan dilampirkan ke instance Slurmdbd. Grup keamanan ini harus memungkinkan koneksi antara server database dan instance Slurmdbd.
+ **DBMSDatabaseNama**: Nama database.
+ **DBMSUsername**: Nama pengguna ke database.
+ **DBMSPasswordSecretArn**: Rahasia yang berisi kata sandi ke database.
+ **DBMSUri**: URI dari server database.
**Pengaturan instans**
+ **InstanceType**: Jenis instance yang akan digunakan untuk instance slurmdbd.
+ **KeyName**: Sebuah EC2 key pair Amazon untuk digunakan untuk instance slurmdbd.
**Pengaturan slurmdbd**
+ **AMIID**: AMI dari instance Slurmdbd. AMI harus menjadi ParallelCluster AMI. Versi ParallelCluster AMI menentukan versi Slurmdbd.
+ **MungeKeySecretArn**: Rahasia yang berisi kunci munge untuk digunakan untuk mengautentikasi komunikasi antara Slurmdbd dan cluster.
+ **SlurmdbdPort**: Nomor port yang digunakan slurmdbd.
+ **EnableSlurmdbdSystemService**: Mengaktifkan slurmdbd sebagai layanan sistem dan menjalankannya ketika sebuah instance diluncurkan.
**Awas**
Jika database dibuat oleh versi yang berbeda SlurmDB, jangan gunakan Slurmdbd sebagai layanan sistem.
Jika database berisi sejumlah besar entri, Slurm Database Daemon (SlurmDBD) mungkin memerlukan puluhan menit untuk memperbarui database dan tidak responsif selama interval waktu ini.
Sebelum memutakhirkan SlurmDB, buat cadangan database. Untuk informasi lebih lanjut, lihat [Slurm dokumentasi](https://slurm.schedmd.com/quickstart_admin.html#upgrade).
## Langkah 2: Buat cluster dengan eksternal Slurmdbd diaktifkan
CloudFormation Template yang disediakan menghasilkan CloudFormation tumpukan dengan beberapa output yang ditentukan.
Dari Konsol Manajemen AWS, lihat tab **Output** di CloudFormation tumpukan untuk meninjau entitas yang dibuat. Untuk mengaktifkan Slurm akuntansi, beberapa output ini harus digunakan dalam daftar AWS ParallelCluster konfigurasi:
+ **SlurmdbdPrivateIp**: Digunakan untuk parameter [konfigurasi klaster [SlurmSettings[ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//Host](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Host).
+ **SlurmdbdPort**: Digunakan untuk nilai [ SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)parameter konfigurasi klaster [ ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)//[Port](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Port).
+ **AccountingClientSecurityGroup**: Ini adalah grup keamanan yang dilampirkan ke node kepala cluster yang didefinisikan dalam parameter [HeadNode](HeadNode-v3.md)/[Networking](HeadNode-v3.md#HeadNode-v3-Networking)/[AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups)configuration.
Tambahan, dari tab **Parameter** di tampilan CloudFormation tumpukan:
+ **MungeKeySecretArn**: Digunakan untuk nilai parameter konfigurasi [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn)cluster.
Perbarui parameter database file konfigurasi klaster Anda dengan nilai output. Gunakan pcluster AWS CLI untuk membuat cluster.
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
Setelah cluster dibuat, Anda dapat mulai menggunakan Slurm perintah akuntansi seperti `sacctmgr` atau`sacct`.
**Awas**
Lalu lintas antara `ParallelCluster` dan eksternal SlurmDB tidak dienkripsi. Disarankan untuk menjalankan cluster dan eksternal SlurmDB dalam jaringan yang terpercaya.
# Mengembalikan ke versi dokumen AWS Systems Manager sebelumnya
Pelajari cara mengembalikan ke versi dokumen AWS Systems Manager sebelumnya. Untuk informasi selengkapnya tentang dokumen SSM, lihat [Dokumen AWS Systems Manager](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html) di *Panduan Pengguna AWS Systems Manager*.
Saat menggunakan antarmuka baris AWS ParallelCluster perintah (CLI) atau API, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat:**
+ An Akun AWS dengan izin untuk mengelola dokumen SSM.
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
## Kembali ke versi dokumen SSM sebelumnya
1. Di terminal Anda, jalankan perintah berikut untuk mendapatkan daftar dokumen SSM yang ada yang Anda miliki.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. Kembalikan dokumen SSM ke versi sebelumnya. Dalam contoh ini, kita kembali ke versi `SessionManagerRunShell` dokumen sebelumnya. Anda dapat menggunakan `SessionManagerRunShell` dokumen SSM untuk menyesuaikan setiap sesi shell SSM yang Anda mulai.
1. Temukan `DocumentVersion` parameternya `SessionManagerRunShell` dengan menjalankan perintah berikut:
```
$ 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": []
}
}
```
Versi terbaru adalah `2`.
1. Kembalikan ke versi sebelumnya dengan menjalankan perintah berikut:
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. Verifikasi bahwa versi dokumen telah dikembalikan dengan menjalankan `describe-document` perintah lagi:
```
$ 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": []
}
}
```
Versi terbaru adalah `1`.
# Membuat cluster dengan CloudFormation
Pelajari cara membuat klaster dengan sumber daya AWS ParallelCluster CloudFormation khusus. Untuk informasi selengkapnya, lihat [AWS CloudFormation sumber daya kustom](cloudformation-v3.md).
Saat menggunakan AWS ParallelCluster, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat:**
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ [Pasangan kunci](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) Amazon EC2.
+ Peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
## Pembuatan cluster dengan CloudFormation tumpukan cepat
Dalam tutorial ini, Anda menggunakan tumpukan quick-create untuk menyebarkan CloudFormation template yang membuat cluster dan sumber daya berikut: AWS
+ CloudFormation Tumpukan root dibuat dengan menggunakan tumpukan CloudFormation quick-create.
+ CloudFormation Tumpukan bersarang yang menyertakan kebijakan default, pengaturan VPC default, dan penyedia sumber daya khusus.
+ Contoh tumpukan AWS ParallelCluster cluster dan cluster tempat Anda dapat masuk dan menjalankan pekerjaan.
**Buat cluster dengan AWS CloudFormation**
1. Masuk ke Konsol Manajemen AWS.
1. Buka [tautan CloudFormation buat cepat untuk membuat](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) sumber daya berikut di konsol: CloudFormation
+ CloudFormation Tumpukan bersarang dengan VPC dengan subnet publik dan pribadi untuk menjalankan node kepala cluster dan node komputasi, masing-masing.
+ CloudFormation Tumpukan bersarang dengan sumber daya AWS ParallelCluster khusus untuk mengelola cluster.
+ CloudFormation Tumpukan bersarang dengan kebijakan default untuk mengelola cluster.
+ CloudFormation Tumpukan root untuk tumpukan bersarang.
+ Sebuah AWS ParallelCluster cluster dengan Slurm scheduler dan jumlah node komputasi yang ditentukan.
![\[Konsol CloudFormation cepat membuat antarmuka pengguna.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. Di bagian **Quick create stack** **Parameters**, masukkan nilai untuk parameter berikut:
1. Untuk **KeyName**, masukkan nama key pair Amazon EC2 Anda.
1. Untuk **AvailabilityZone**, pilih AZ untuk node cluster Anda, misalnya,`us-east-1a`.
1. Centang kotak untuk mengetahui setiap kemampuan akses di bagian bawah halaman.
1. Pilih **Buat tumpukan**.
1. Tunggu CloudFormation tumpukan mencapai `CREATE_COMPLETE` status.
## Pembuatan cluster dengan CloudFormation Command Line Interface (CLI)
Dalam tutorial ini, Anda menggunakan AWS Command Line Interface (CLI) CloudFormation untuk menyebarkan CloudFormation template yang membuat cluster.
**Buat AWS sumber daya berikut:**
+ CloudFormation Tumpukan root dibuat dengan menggunakan tumpukan CloudFormation quick-create.
+ CloudFormation Tumpukan bersarang yang menyertakan kebijakan default, penyiapan VPC default, dan penyedia sumber daya khusus.
+ Contoh tumpukan AWS ParallelCluster cluster dan cluster tempat Anda dapat masuk dan menjalankan pekerjaan.
Ganti*inputs highlighted in red*, seperti*keypair*, dengan nilai-nilai Anda sendiri.
**Buat cluster dengan AWS CloudFormation**
1. Buat CloudFormation template bernama `cluster_template.yaml` dengan konten berikut:
```
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. Jalankan perintah AWS CLI berikut untuk menyebarkan CloudFormation tumpukan untuk pembuatan dan pengelolaan cluster.
```
$ 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
```
## Lihat keluaran CloudFormation cluster
Lihat output CloudFormation cluster untuk mendapatkan detail cluster yang berguna. `ValidationMessages`Properti yang ditambahkan menyediakan akses ke pesan validasi dari operasi pembuatan dan pembaruan cluster.
1. Arahkan ke [CloudFormation konsol](https://console.aws.amazon.com/cloudformation/home) dan pilih tumpukan yang menyertakan sumber daya AWS ParallelCluster kustom Anda.
1. Pilih **Stack details**, dan pilih tab **Outputs**.
![\[Tabel CloudFormation keluaran konsol yang menunjukkan nilai untuk HeadNodeIp dan ValidationMessages.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/cfn-outputs.png)
Pesan validasi mungkin terpotong. Untuk informasi selengkapnya tentang cara mengambil log, lihat[AWS ParallelCluster pemecahan masalah](troubleshooting-v3.md).
## Akses klaster Anda
Akses cluster.
**`ssh`ke simpul kepala cluster**
1. Setelah penyebaran CloudFormation tumpukan selesai, dapatkan alamat IP node kepala dengan perintah berikut:
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
Anda juga dapat mengambil alamat IP node kepala dari **HeadNodeIp**parameter di tab **Output** tumpukan cluster di CloudFormation konsol.
Anda dapat menemukan alamat IP node kepala di sini karena ditambahkan di `Outputs` bagian CloudFormation template cluster, khusus untuk contoh cluster ini.
1. Connect ke node kepala cluster dengan menjalankan perintah berikut:
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## Bersihkan
Hapus klaster .
1. Jalankan perintah AWS CLI berikut untuk menghapus CloudFormation tumpukan dan cluster.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. Periksa status penghapusan tumpukan dengan menjalankan perintah berikut.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# Terapkan ParallelCluster API dengan Terraform
Dalam tutorial ini, Anda akan mendefinisikan proyek Terraform sederhana untuk menerapkan API. ParallelCluster
**Prasyarat**
+ Terraform v1.5.7\$1 diinstal.
+ Peran IAM dengan izin untuk menerapkan API. ParallelCluster Lihat [Izin yang diperlukan](tutorial-deploy-terraform-permissions.md).
# Tentukan proyek Terraform
Dalam tutorial ini, Anda akan mendefinisikan proyek Terraform.
1. Buat direktori yang disebut`my-pcluster-api`.
Semua file yang Anda buat akan berada di dalam direktori ini.
1. Buat file `provider.tf` untuk mengkonfigurasi AWS penyedia.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. Buat file `main.tf` untuk menentukan sumber daya menggunakan ParallelCluster modul.
```
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. Buat file `variables.tf` untuk menentukan variabel yang dapat disuntikkan untuk proyek ini.
```
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. Buat file `terraform.tfvars` untuk menetapkan nilai arbitrer untuk variabel.
File di bawah ini menerapkan ParallelCluster API 3.11.1 dalam `us-east-1` menggunakan nama tumpukan. `MyParallelClusterAPI-3111` Anda akan dapat mereferensikan penerapan ParallelCluster API ini menggunakan nama tumpukannya.
**catatan**
`api_version`Penugasan dalam kode berikut dapat diganti dengan AWS ParallelCluster versi yang didukung.
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. Buat file `outputs.tf` untuk menentukan output yang dikembalikan oleh proyek ini.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
Direktori proyek adalah:
```
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.
```
# Terapkan API
Untuk menerapkan API, jalankan perintah Terraform standar secara berurutan.
1. Membangun proyek:
```
terraform init
```
1. Tentukan rencana penyebaran:
```
terraform plan -out tfplan
```
1. Menyebarkan rencana:
```
terraform apply tfplan
```
# Izin yang diperlukan
Anda memerlukan izin berikut untuk menerapkan ParallelCluster API dengan Terraform:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"cloudformation:DescribeStacks",
"cloudformation:GetTemplate"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormationRead"
},
{
"Action": [
"cloudformation:CreateStack",
"cloudformation:DeleteStack",
"cloudformation:CreateChangeSet"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/MyParallelClusterAPI*",
"Effect": "Allow",
"Sid": "CloudFormationWrite"
},
{
"Action": [
"cloudformation:CreateChangeSet"
],
"Resource": [
"arn:aws:cloudformation:us-east-1:111122223333:aws:transform/Include",
"arn:aws:cloudformation:us-east-1:111122223333:aws:transform/Serverless-2016-10-31"
],
"Effect": "Allow",
"Sid": "CloudFormationTransformWrite"
},
{
"Action": [
"s3:GetObject"
],
"Resource": [
"arn:aws:s3:us-east-1:111122223333:*-aws-parallelcluster/parallelcluster/*/api/ParallelCluster.openapi.yaml",
"arn:aws:s3:us-east-1:111122223333:*-aws-parallelcluster/parallelcluster/*/layers/aws-parallelcluster/lambda-layer.zip"
],
"Effect": "Allow",
"Sid": "S3ParallelClusterArtifacts"
},
{
"Action": [
"iam:CreateRole",
"iam:DeleteRole",
"iam:GetRole",
"iam:CreatePolicy",
"iam:DeletePolicy",
"iam:GetPolicy",
"iam:GetRolePolicy",
"iam:AttachRolePolicy",
"iam:DetachRolePolicy",
"iam:PutRolePolicy",
"iam:DeleteRolePolicy",
"iam:ListPolicyVersions"
],
"Resource": [
"arn:aws:iam::111122223333:role/*",
"arn:aws:iam::111122223333:policy/*"
],
"Effect": "Allow",
"Sid": "IAM"
},
{
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::111122223333:role/ParallelClusterLambdaRole-*",
"arn:aws:iam::111122223333:role/APIGatewayExecutionRole-*"
],
"Effect": "Allow",
"Sid": "IAMPassRole"
},
{
"Action": [
"lambda:CreateFunction",
"lambda:DeleteFunction",
"lambda:GetFunction",
"lambda:PublishLayerVersion",
"lambda:DeleteLayerVersion",
"lambda:GetLayerVersion",
"lambda:TagResource",
"lambda:UntagResource"
],
"Resource": [
"arn:aws:lambda:us-east-1:111122223333:layer:PCLayer-*",
"arn:aws:lambda:us-east-1:111122223333:function:*-ParallelClusterFunction-*"
],
"Effect": "Allow",
"Sid": "Lambda"
},
{
"Action": [
"logs:CreateLogGroup",
"logs:DeleteLogGroup",
"logs:DescribeLogGroups",
"logs:PutRetentionPolicy",
"logs:TagLogGroup",
"logs:UntagLogGroup"
],
"Resource": [
"arn:aws:logs:us-east-1:111122223333:log-group:/aws/lambda/*-ParallelClusterFunction-*"
],
"Effect": "Allow",
"Sid": "Logs"
},
{
"Action": [
"apigateway:DELETE",
"apigateway:GET",
"apigateway:PATCH",
"apigateway:POST",
"apigateway:PUT",
"apigateway:UpdateRestApiPolicy"
],
"Resource": [
"arn:aws:apigateway:us-east-1::/restapis",
"arn:aws:apigateway:us-east-1::/restapis/*",
"arn:aws:apigateway:us-east-1::/tags/*"
],
"Effect": "Allow",
"Sid": "APIGateway"
}
]
}
```
------
# Membuat cluster dengan Terraform
Saat menggunakan AWS ParallelCluster, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat**
+ Terraform v1.5.7\$1 diinstal.
+ [AWS ParallelCluster API](api-reference-v3.md)v3.8.0\$1 digunakan di akun Anda. Lihat [Terapkan ParallelCluster API dengan Terraform](tutorial-deploy-terraform.md).
+ Peran IAM dengan izin untuk memanggil API. ParallelCluster Lihat [Izin yang diperlukan]
# Tentukan proyek Terraform
Dalam tutorial ini, Anda akan mendefinisikan proyek Terraform sederhana untuk menyebarkan cluster.
1. Buat direktori yang disebut`my-clusters`.
Semua file yang Anda buat akan berada di dalam direktori ini.
1. Buat file `terraform.tf` untuk mengimpor ParallelCluster penyedia.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Buat file `providers.tf` untuk mengkonfigurasi ParallelCluster dan AWS penyedia.
```
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. Buat file `main.tf` untuk menentukan sumber daya menggunakan ParallelCluster modul.
```
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. Buat file `clusters.tf` untuk mendefinisikan beberapa cluster sebagai variabel lokal Terraform.
**catatan**
Anda dapat menentukan beberapa cluster dalam `cluster_config` elemen. Untuk setiap cluster, Anda dapat secara eksplisit mendefinisikan properti cluster dalam variabel lokal (lihat`DemoCluster01`) atau referensi file eksternal (lihat`DemoCluster02`).
Untuk meninjau properti cluster yang dapat Anda atur dalam elemen konfigurasi, lihat[File konfigurasi cluster](cluster-configuration-file-v3.md).
Untuk meninjau opsi yang dapat Anda atur untuk pembuatan klaster, lihat[`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. Buat file `config/clusters.yaml` untuk mendefinisikan beberapa cluster sebagai konfigurasi YAMG.
```
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. Buat file`config/cluster_config.yaml`, yang merupakan file ParallelCluster konfigurasi standar tempat variabel Terraform dapat disuntikkan.
Untuk meninjau properti cluster yang dapat Anda atur dalam elemen konfigurasi, lihat[File konfigurasi cluster](cluster-configuration-file-v3.md).
```
Region: ${region}
Image:
Os: alinux2
HeadNode:
InstanceType: t3.small
Networking:
SubnetId: ${subnet}
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue1
CapacityType: ONDEMAND
Networking:
SubnetIds:
- ${subnet}
Iam:
AdditionalIamPolicies:
- Policy: arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore
ComputeResources:
- Name: compute
InstanceType: t3.small
MinCount: 1
MaxCount: 5
SlurmSettings:
QueueUpdateStrategy: TERMINATE
```
1. Buat file `clusters_vars.tf` untuk menentukan variabel yang dapat disuntikkan ke dalam konfigurasi cluster.
File ini memungkinkan Anda untuk menentukan nilai dinamis yang dapat digunakan dalam konfigurasi cluster, seperti wilayah dan subnet.
Contoh ini mengambil nilai langsung dari variabel proyek, tetapi Anda mungkin perlu menggunakan logika khusus untuk menentukannya.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. Buat file `variables.tf` untuk menentukan variabel yang dapat disuntikkan untuk proyek ini.
```
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. Buat file `terraform.tfvars` untuk menetapkan nilai arbitrer untuk variabel.
File di bawah ini menyebarkan cluster di `eu-west-1` dalam subnet`subnet-123456789`, menggunakan ParallelCluster API 3.11.1 yang ada, yang sudah diterapkan dengan nama tumpukan. `us-east-1` `MyParallelClusterAPI-3111`
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
cluster_region = "eu-west-1"
subnet_id = "subnet-123456789"
```
1. Buat file `outputs.tf` untuk menentukan output yang dikembalikan oleh proyek ini.
```
output "clusters" {
value = module.pcluster.clusters
}
```
Direktori proyek adalah:
```
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.
```
# Menyebarkan cluster
Untuk menerapkan cluster, jalankan perintah Terraform standar secara berurutan.
**catatan**
Contoh ini mengasumsikan bahwa Anda telah menerapkan ParallelCluster API di akun Anda.
1. Membangun proyek:
```
terraform init
```
1. Tentukan rencana penyebaran:
```
terraform plan -out tfplan
```
1. Menyebarkan rencana:
```
terraform apply tfplan
```
## Menerapkan ParallelCluster API dengan cluster
Jika Anda belum menerapkan ParallelCluster API dan ingin menerapkannya dengan cluster, ubah file berikut:
+ `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
}
```
# Izin yang diperlukan
Anda memerlukan izin berikut untuk menerapkan cluster dengan Terraform:
+ asumsikan peran ParallelCluster API, yang bertugas berinteraksi dengan API ParallelCluster
+ jelaskan CloudFormation tumpukan ParallelCluster API untuk memverifikasi keberadaannya dan mengambil parameter dan outputnya
------
#### [ 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"
}
]
}
```
------
# Membuat AMI khusus dengan Terraform
Saat menggunakan AWS ParallelCluster, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat**
+ Terraform v1.5.7\$1 diinstal.
+ [AWS ParallelCluster API](api-reference-v3.md)v3.8.0\$1 digunakan di akun Anda. Lihat [Membuat cluster dengan Terraform](tutorial-create-cluster-terraform.md).
+ Peran IAM dengan izin untuk memanggil API. ParallelCluster Lihat [Izin yang diperlukan](tutorial-create-ami-terraform-permissions.md).
# Tentukan proyek Terraform
Dalam tutorial ini, Anda akan menentukan proyek Terraform sederhana untuk menerapkan AMI khusus ParallelCluster .
1. Buat direktori yang disebut`my-amis`.
Semua file yang Anda buat akan berada di dalam direktori ini.
1. Buat file `terraform.tf` untuk mengimpor ParallelCluster penyedia.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Buat file `providers.tf` untuk mengkonfigurasi ParallelCluster dan AWS penyedia.
```
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. Buat file `main.tf` untuk menentukan sumber daya menggunakan ParallelCluster modul.
Untuk meninjau properti gambar yang dapat Anda atur dalam `image_configuration` elemen, lihat[Membangun file konfigurasi gambar](image-builder-configuration-file-v3.md).
Untuk meninjau opsi yang dapat Anda atur untuk pembuatan gambar, misalnya `image_id` dan`rollback_on_failure`, lihat[`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. Buat file `variables.tf` untuk menentukan variabel yang dapat disuntikkan untuk proyek ini.
```
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. Buat file `terraform.tfvars` untuk mengatur nilai arbitrer Anda untuk variabel.
Dengan file di bawah ini, gunakan AMI kustom `us-east-1` berdasarkan Amazon Linux 2 untuk arsitektur x86\$164, menggunakan ParallelCluster API 3.11.1 yang ada yang sudah diterapkan dengan nama tumpukan. `us-east-1` `MyParallelClusterAPI-3111`
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
os = "alinux2"
architecture = "x86_64"
```
1. Buat file `outputs.tf` untuk menentukan output yang dikembalikan oleh proyek ini.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
Direktori proyek adalah:
```
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.
```
# Menyebarkan AMI
Untuk menerapkan AMI, jalankan perintah Terraform standar secara berurutan.
1. Membangun proyek:
```
terraform init
```
1. Tentukan rencana penyebaran:
```
terraform plan -out tfplan
```
1. Menyebarkan rencana:
```
terraform apply tfplan
```
# Izin yang diperlukan
Anda memerlukan izin berikut untuk menerapkan AMI khusus dengan Terraform:
+ asumsikan peran ParallelCluster API, yang bertugas berinteraksi dengan API ParallelCluster
+ jelaskan CloudFormation tumpukan ParallelCluster API, untuk memverifikasi itu ada dan mengambil parameter dan outputnya
------
#### [ 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 Integrasi UI dengan Pusat Identitas
Tujuan dari tutorial ini adalah untuk mendemonstrasikan cara mengintegrasikan AWS ParallelCluster UI dengan IAM Identity Center untuk solusi masuk tunggal yang menyatukan pengguna di Active Directory yang dapat dibagikan dengan cluster. AWS ParallelCluster
Saat menggunakan AWS ParallelCluster, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat:**
+ AWS ParallelCluster UI yang ada yang dapat diinstal mengikuti petunjuk di [sini.](install-pcui-v3.md)
+ Direktori Aktif Terkelola yang ada, lebih disukai yang juga akan Anda gunakan untuk [AWS ParallelCluster diintegrasikan](tutorials_05_multi-user-ad.md).
## Aktifkan Pusat Identitas IAM
Jika Anda sudah memiliki pusat identitas yang terhubung ke AWS Managed Microsoft AD (Direktori Aktif) Anda dapat digunakan dan Anda dapat melompat ke bagian **Menambahkan Aplikasi Anda ke Pusat Identitas IAM**.
Jika Anda belum memiliki pusat identitas yang terhubung ke sebuah AWS Managed Microsoft AD, ikuti langkah-langkah di bawah ini untuk mengaturnya.
**Mengaktifkan Pusat Identitas**
1. Di konsol, navigasikan ke Pusat Identitas IAM. (Pastikan Anda berada di wilayah di mana Anda memiliki AWS Managed Microsoft AD.)
1. Klik tombol **Aktifkan**, ini mungkin menanyakan apakah Anda ingin mengaktifkan organisasi, ini adalah persyaratan sehingga Anda dapat memilih untuk mengaktifkannya. **Catatan**: Ini akan mengirim email ke administrator akun Anda dengan email konfirmasi bahwa Anda harus mengikuti tautan untuk mengonfirmasi.
**Menghubungkan Pusat Identitas ke AD Terkelola**
1. Pada halaman berikutnya setelah mengaktifkan pusat identitas, Anda akan melihat Langkah Pengaturan yang Disarankan, di bawah Langkah 1, pilih **Pilih Sumber Identitas Anda**.
1. Di bagian Sumber Identitas, klik menu **tarik-turun Tindakan** (di kanan atas), lalu pilih **Ubah Sumber Identitas**.
1. Pilih **Active Directory**.
1. Di bawah **Direktori yang Ada**, pilih direktori Anda.
1. Klik Berikutnya.
1. Tinjau perubahan Anda, gulir ke bawah, ketik TERIMA ke dalam kotak teks untuk mengonfirmasi, lalu klik **Ubah Sumber Identitas**.
1. Tunggu perubahan selesai, maka Anda akan melihat spanduk hijau di bagian atas.
**Menyinkronkan pengguna dan grup ke Pusat Identitas**
1. Di spanduk hijau klik **Start Guided Setup** (tombol di kanan atas)
![\[Screenshot menyoroti tombol Start Guided Setup.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. **Dalam **Konfigurasi Pemetaan Atribut, klik** Berikutnya**
1. **Di bagian Konfigurasi cakupan sinkronisasi, ketik nama pengguna yang ingin disinkronkan ke pusat identitas, lalu klik Tambah**
1. Setelah selesai menambahkan pengguna dan grup, klik **Berikutnya**
![\[Screenshot menyoroti tombol Berikutnya.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. Tinjau perubahan Anda, lalu klik **Simpan konfigurasi**
1. Jika Anda melihat peringatan di layar berikutnya tentang pengguna yang tidak disinkronkan, pilih **tombol Lanjutkan sinkronisasi** di kanan atas.
1. Selanjutnya, untuk mengaktifkan pengguna, Di tab **Pengguna** di sebelah kiri, pilih pengguna dan kemudian klik **Aktifkan akses pengguna** > **Aktifkan akses pengguna**
**Catatan**: Anda mungkin perlu memilih Lanjutkan sinkronisasi jika Anda memiliki spanduk peringatan di bagian atas dan kemudian menunggu pengguna untuk menyinkronkan (coba tombol segarkan untuk melihat apakah mereka disinkronkan belum).
![\[Screenshot menyoroti tab Pengguna.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## Menambahkan Aplikasi Anda ke Pusat Identitas IAM
Setelah Anda menyinkronkan pengguna Anda dengan IAM Identity Center, Anda perlu menambahkan aplikasi baru. Ini mengonfigurasi aplikasi berkemampuan SSO mana yang akan tersedia dari portal Pusat Identitas IAM Anda. Dalam hal ini, kami akan menambahkan AWS ParallelCluster UI sebagai aplikasi sementara IAM Identity Center akan menjadi penyedia identitas.
Langkah selanjutnya akan menambahkan AWS ParallelCluster UI sebagai aplikasi di IAM Identity Center. AWS ParallelCluster UI adalah portal web yang membantu pengguna mengelola cluster mereka. Untuk informasi selengkapnya lihat [AWS ParallelCluster UI](pcui-using-v3.md).
**Menyiapkan aplikasi di Pusat Identitas**
1. Di bawah **Pusat Identitas IAM** > **Aplikasi** (ditemukan di bilah menu kiri, klik Aplikasi)
1. Klik **Tambah Aplikasi**
1. Pilih **Tambahkan aplikasi SAMP 2.0** khusus
1. Klik **Berikutnya**
1. Pilih nama tampilan dan deskripsi yang ingin Anda gunakan (misalnya PCUI dan AWS ParallelCluster UI)
1. Di bawah **metadata IAM Identity Center**, salin tautan untuk file metadata SAMP IAM Identity Center dan simpan untuk nanti, ini akan digunakan saat mengonfigurasi SSO di aplikasi web
1. Di bawah **properti Aplikasi**, di URL mulai Aplikasi, masukkan alamat PCUI Anda. **Ini dapat ditemukan dengan pergi ke CloudFormation konsol, memilih tumpukan yang sesuai dengan PCUI (misalnya parallelcluster-ui) dan pergi ke tab Outputs untuk menemukan** ParallelCluster UIUrl
mis. https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. Di bawah **Metadata aplikasi**, pilih **Ketik nilai metadata Anda secara manual**. Kemudian berikan nilai-nilai berikut.
1. **Penting**: Pastikan untuk mengganti nilai domain-prefix, region, dan userpool-id dengan informasi yang spesifik untuk lingkungan Anda.
1. ****Awalan domain, wilayah, dan userpool-id dapat diperoleh dengan membuka konsol Amazon Cognito > User pool****
![\[Screenshot menyoroti Nama Pool Pengguna di bawah kumpulan pengguna Cognito\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. Pilih kumpulan pengguna yang sesuai dengan PCUI (yang akan memiliki nama kumpulan Pengguna seperti PCUI-CD8A2-Cognito-153 EK3 TO45 S98-userPool)
1. Arahkan ke **Integrasi Aplikasi**
![\[Screenshot yang menyoroti Domain Cognito di tab Integrasi Aplikasi\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. URL Layanan Konsumen Pernyataan Aplikasi (ACS): https://.auth. .amazoncognito. com/saml2/idpresponse
Aplikasi SAMP audiens: urn:amazon:cognito:sp:
1. Pilih **Kirim**. Kemudian, buka halaman **Detail** untuk aplikasi yang Anda tambahkan.
1. Pilih daftar dropdown **Tindakan** dan pilih **Edit pemetaan atribut**. Kemudian, berikan atribut berikut.
1. Atribut pengguna dalam aplikasi: **subjek** (Catatan: **subjek** sudah diisi sebelumnya.) **→ Peta ke nilai string ini atau atribut pengguna di IAM Identity Center: **\$1 \$1user:email\$1**, Format: EmailAddress**
1. **Atribut pengguna dalam aplikasi: **email** → Peta ke nilai string ini atau atribut pengguna di IAM Identity Center: **\$1 \$1user:email\$1**, Format: unspecified**
![\[Screenshot menyoroti Pemetaan Atribut untuk bagian PCUI\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. Simpan perubahan Anda.
1. Pilih tombol **Tetapkan Pengguna** dan kemudian tetapkan pengguna Anda ke aplikasi. Ini adalah pengguna di Direktori Aktif Anda yang akan memiliki akses ke antarmuka PCUI.
![\[Screenshot menyoroti Tetapkan pengguna untuk aplikasi.\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**Konfigurasikan Pusat Identitas IAM sebagai IDP SAMP di kumpulan pengguna Anda**
1. Di setelan kumpulan pengguna, pilih **Pengalaman masuk** > **Tambahkan penyedia identitas**
![\[Screenshot menyoroti tab Pengalaman masuk\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. Pilih SAMP iDP
1. Untuk **nama Penyedia** berikan **IdentityCenter**
1. Di bawah **Sumber dokumen metadata** pilih **Masukkan URL titik akhir dokumen metadata dan berikan URL** yang disalin selama penyiapan Aplikasi Pusat Identitas
1. Di bawah **Atribut**, untuk email pilih email
![\[Screenshot menyoroti tab Pengalaman masuk\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. Pilih **Tambahkan penyedia identitas**.
**Integrasikan iDP dengan klien aplikasi kumpulan pengguna**
1. Selanjutnya, di bawah bagian **Integrasi Aplikasi** dari kumpulan pengguna Anda, pilih klien yang tercantum di bawah **Daftar klien Aplikasi**
![\[Screenshot menyoroti tab Pengalaman masuk\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. Di bawah **UI yang Dihosting** pilih **Edit**
1. Di bawah **penyedia Identitas** memilih **IdentityCenter**juga.
1. Pilih **Save changes (Simpan perubahan)**
**Validasi penyiapan Anda**
1. Selanjutnya kita akan memvalidasi pengaturan yang baru saja kita buat dengan masuk ke PCUI. Masuk ke portal PCUI Anda dan sekarang Anda akan melihat opsi untuk masuk dengan ID Perusahaan Anda:
![\[Screenshot menyoroti tab Pengalaman masuk\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. Mengklik **IdentityCenter**tombol akan membawa Anda ke IAM Identity Center iDP login diikuti oleh halaman dengan aplikasi Anda di dalamnya yang mencakup PCUI, buka aplikasi itu.
1. Setelah Anda masuk ke layar berikut, pengguna Anda akan ditambahkan ke kumpulan pengguna Cognito.
![\[Screenshot menyoroti tab Pengalaman masuk\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**Jadikan pengguna Anda administrator**
1. Sekarang navigasikan ke **konsol **Amazon Cognito** > User pool** dan pilih pengguna yang baru dibuat yang seharusnya memiliki awalan identitycenter
![\[Screenshot menyoroti tab Pengalaman masuk\]](http://docs.aws.amazon.com/id_id/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. Di bawah **Keanggotaan grup** pilih **Tambahkan pengguna ke grup**, pilih **admin** dan klik **Tambah**.
1. Sekarang ketika Anda mengklik **Lanjutkan dengan IdentityCenter** Anda akan dinavigasi ke halaman AWS ParallelCluster UI.
# Menjalankan pekerjaan kontainer dengan Pyxis
Pelajari cara membuat klaster yang dapat menjalankan tugas kontainer menggunakan Pyxis, yang merupakan plugin SPANK untuk mengelola pekerjaan kontainer di SLURM. Wadah di Pyxis dikelola oleh Enroot, yang merupakan alat untuk mengubah container/OS gambar tradisional menjadi kotak pasir yang tidak memiliki hak istimewa. Untuk informasi lebih lanjut, lihat [NVIDIA Pyxis](https://github.com/NVIDIA/pyxis) dan [NVIDIA](https://github.com/NVIDIA/enroot) Enroot.
**catatan**
Fitur ini tersedia dengan AWS ParallelCluster v3.11.1
Skrip dalam tutorial ini memindahkan (`mv`) beberapa file, yang menghapusnya dari lokasi aslinya. Jika Anda ingin menyimpan salinan file-file ini di lokasi aslinya, ubah skrip untuk menggunakan perintah copy (`cp`) sebagai gantinya.
Saat menggunakan AWS ParallelCluster, Anda hanya membayar AWS sumber daya yang dibuat saat Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
**Prasyarat:**
+ AWS CLI Itu [diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sebuah [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). .
+ Peran IAM dengan [izin](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) yang diperlukan untuk menjalankan CLI [pcluster](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
## Buat cluster
Dimulai dengan AWS ParallelCluster 3.11.1, semua resmi AMIs dilengkapi dengan Pyxis dan Enroot yang sudah diinstal sebelumnya. Secara khusus, SLURM dikompilasi ulang dengan dukungan Pyxis dan Enroot diinstal sebagai biner dalam sistem. Namun, Anda harus mengonfigurasinya sesuai dengan kebutuhan spesifik Anda. Folder yang digunakan oleh Enroot dan Pyxis akan memiliki dampak kritis pada kinerja cluster. Untuk informasi selengkapnya, lihat dokumentasi [Pyxis dan dokumentasi](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration) [Enroot](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example).
Untuk kenyamanan Anda, Anda dapat menemukan konfigurasi sampel untuk Pyxis, Enroot dan SPANK di dalamnya. `/opt/parallelcluster/examples/`
Untuk menyebarkan cluster menggunakan konfigurasi sampel yang telah kami sediakan, selesaikan tutorial berikut.
**Untuk membuat cluster dengan konfigurasi sampel**
Pyxis dan Enroot harus dikonfigurasi pada node kepala dengan terlebih dahulu membuat direktori persisten dan volatile untuk Enroot, kemudian membuat direktori runtime untuk Pyxis, dan akhirnya mengaktifkan Pyxis sebagai plugin SPANK di seluruh cluster.
1. Jalankan skrip di bawah ini sebagai tindakan [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured)khusus di node kepala untuk mengkonfigurasi Pyxis dan Enroot pada node kepala.
```
#!/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 dan Enroot harus dikonfigurasi pada armada komputasi dengan membuat direktori persisten dan volatile untuk Enroot dan direktori runtime untuk Pyxis. Jalankan skrip di bawah ini sebagai tindakan [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)kustom di node komputasi untuk mengonfigurasi Pyxis dan Enroot pada armada komputasi.
```
#!/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
```
## Kirim lowongan kerja
Sekarang Pyxis dikonfigurasi di cluster Anda, Anda dapat mengirimkan pekerjaan dalam wadah menggunakan perintah sbatch dan srun, yang sekarang diperkaya dengan opsi khusus container.
```
# 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'
```
# Membuat cluster dengan Lustre yang mendukung EFA FSx
Dalam tutorial ini, Anda akan membuat cluster yang menggunakan sistem file FSx Lustre yang diaktifkan EFA sebagai penyimpanan bersama. Menggunakan sistem file FSx Lustre dengan EFA diaktifkan dapat memberikan peningkatan kinerja hingga 8x. Untuk memverifikasi apakah sistem file berkemampuan EFA adalah yang Anda butuhkan, lihat [Bekerja dengan sistem file berkemampuan EFA](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html) di Panduan Pengguna *FSx for* Lustre.
Ketika Anda menggunakan AWS ParallelCluster, Anda hanya membayar untuk AWS sumber daya yang dibuat ketika Anda membuat atau memperbarui AWS ParallelCluster gambar dan cluster. Untuk informasi selengkapnya, lihat [AWS layanan yang digunakan oleh AWS ParallelCluster](aws-services-v3.md).
## Persyaratan
+ AWS CLI [diinstal dan dikonfigurasi](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ ParallelCluster CLI [diinstal dan dikonfigurasi](install-v3-parallelcluster.md).
+ Sebuah [key pair Amazon EC2](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) untuk login ke cluster.
+ Peran IAM dengan [izin](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) yang diperlukan untuk menjalankan CLI ParallelCluster .
## Buat Grup Keamanan
Buat dua grup keamanan di VPC yang sama di mana cluster dan sistem file akan digunakan: satu untuk klien yang berjalan pada node cluster dan satu untuk sistem file.
```
# 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
```
Dalam sisa tutorial, kita akan mengasumsikan `sg-client` dan `sg-file-system` merupakan id grup keamanan dari klien dan sistem file, masing-masing.
Konfigurasikan grup keamanan untuk klien untuk memungkinkan semua lalu lintas keluar ke sistem file, seperti yang [dipersyaratkan oleh 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
```
Konfigurasikan grup keamanan untuk sistem file untuk memungkinkan semua inbound/outbound lalu lintas di dalam dirinya sendiri dan semua lalu lintas masuk dari klien, seperti yang [dipersyaratkan oleh 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
```
## Buat sistem file
Buat sistem file dalam Availability Zone (AZ) yang sama di mana node komputasi akan berada; dan ganti `subnet-compute-nodes` dengan ID-nya dalam kode berikut. Ini diperlukan untuk memungkinkan EFA bekerja dengan sistem file Anda. Perhatikan bahwa, sebagai bagian dari pembuatan sistem file, kami mengaktifkan EFA menggunakan EfaEnable properti.
```
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
```
Perhatikan id sistem file yang dikembalikan oleh perintah sebelumnya. Di sisa tutorial, ganti `fs-id` dengan id sistem file ini.
## Buat cluster
1. Buat cluster dengan konfigurasi berikut yang diatur dalam file konfigurasi AWS ParallelCluster YAMAL:
1. AMI berdasarkan OS yang didukung, seperti Ubuntu 22.04.
1. Node komputasi harus menggunakan [tipe instans yang didukung EFA yang](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) memiliki [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html), seperti g6.16xlarge.
+ Node komputasi harus berada di AZ yang sama di mana sistem file berada.
+ Node komputasi harus memiliki [EFA/Enabled](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled) disetel ke true.
+ Node komputasi harus menjalankan skrip konfigurasi `configure-efa-fsx-lustre-client.sh` sebagai tindakan [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)khusus. Skrip, yang disediakan dalam [dokumentasi FSx resmi](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) dan ditawarkan di bucket publik kami untuk kenyamanan Anda, dimaksudkan untuk mengonfigurasi klien FSx Lustre pada node komputasi agar mereka dapat menggunakan EFA.
1. Buat file konfigurasi cluster`config.yaml`:
```
Region: region
Image:
Os: ubuntu2204
HeadNode:
InstanceType: c5.xlarge
Networking:
SubnetId: subnet-xxxxxxxxxx
AdditionalSecurityGroups:
- sg-client
Ssh:
KeyName: my-ssh-key
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: q1
ComputeResources:
- Name: cr1
Instances:
- InstanceType: g6.16xlarge
MinCount: 1
MaxCount: 3
Efa:
Enabled: true
Networking:
SubnetIds:
- subnet-xxxxxxxxxx # Subnet in the same AZ where the file system is
AdditionalSecurityGroups:
- sg-client
PlacementGroup:
Enabled: false
CustomActions:
OnNodeStart:
Script: https://us-east-1-aws-parallelcluster.s3.us-east-1.amazonaws.com/scripts/fsx-lustre-efa/configure-efa-fsx-lustre-client.sh
SharedStorage:
- MountDir: /fsx
Name: my-fsxlustre-efa-external
StorageType: FsxLustre
FsxLustreSettings:
FileSystemId: fs-id
```
Kemudian buat cluster menggunakan konfigurasi itu:
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## Validasi FSx dengan EFA berfungsi
Untuk memverifikasi bahwa lalu lintas jaringan Lustre menggunakan EFA, gunakan `lnetctl` alat Lustre yang dapat menunjukkan lalu lintas jaringan untuk antarmuka jaringan tertentu. Untuk tujuan ini, jalankan perintah berikut dalam node komputasi:
```
# 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
```
Jika fitur ini berfungsi, jumlah paket yang mengalir melalui antarmuka diperkirakan akan meningkat.
# Support NVIDIA-IMEX dengan instans p6e-gb200
Tutorial ini menunjukkan kepada Anda cara memulai AWS ParallelCluster di P6e-GB200, untuk memanfaatkan kinerja GPU tertinggi untuk pelatihan dan inferensi AI. [contoh p6e-gb200.36xlarge hanya tersedia melalui P6e- di GB200 UltraServers mana adalah Ukuran Ultraserver](https://aws.amazon.com/ec2/instance-types/p6/) dan merupakan yang membentuk ultraserver. `u-p6e-gb200x72` `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) Saat membeli Ultraserver `u-p6e-gb200x72` itu akan tersedia melalui [Blok Kapasitas EC2 untuk ML](https://aws.amazon.com/ec2/capacityblocks/) yang akan memiliki 18 instans. `p6e-gb200.36xlarge` Untuk mempelajari lebih lanjut, lihat [P6e-](https://aws.amazon.com/ec2/instance-types/p6/). GB200
AWS ParallelCluster versi 3.14.0:
+ menyediakan tumpukan perangkat lunak NVIDIA lengkap (driver, CUDA, EFA, NVIDIA-IMEX) yang diperlukan oleh jenis instance ini
+ membuat konfigurasi nvidia-imex untuk P6e- ultraserver GB200
+ memungkinkan dan memulai `nvidia-imex` layanan untuk P6e- ultraserver GB200
+ mengkonfigurasi plugin topologi Blok Slurm sehingga setiap Ultraserver P6e-GB200 (Blok Kapasitas EC2) adalah Blok Slurm dengan ukuran yang tepat (lihat entri untuk versi 3.14.0). [Catatan rilis dan riwayat dokumen](document_history.md)
Namun, GPU-to-GPU komunikasi melalui NVLink memerlukan konfigurasi tambahan, khususnya [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)file yang berisi alamat IP node komputasi dalam domain IMEX yang ParallelCluster tidak menghasilkan secara otomatis. Untuk membantu menghasilkan file ini, kami menyediakan skrip prolog yang secara otomatis menemukan node komputasi IPs dan mengonfigurasi rekomendasi Integrasi Job Scheduler NVIDIA [IMEX Slurm [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)](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration)berikut. Tutorial ini memandu Anda melalui cara membuat skrip prolog, menyebarkannya melalui tindakan HeadNode khusus, dan memvalidasi pengaturan IMEX.
**catatan**
P6e- GB200 didukung mulai dengan AWS ParallelCluster v3.14.0 di Amazon Linux 2023, Ubuntu 22.04, dan Ubuntu 24.04. Untuk versi perangkat lunak yang mendetail dan daftar distribusi yang didukung yang diperbarui, lihat [AWS ParallelCluster changelog](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md).
## Buat Skrip Prolog untuk mengelola NVIDIA-IMEX
**Batasan:**
+ Skrip prolog ini akan berjalan pada pengajuan pekerjaan eksklusif. Ini untuk memastikan bahwa mulai ulang IMEX tidak mengganggu pekerjaan yang berjalan pada node p6e-GB200 yang termasuk dalam domain IMEX.
Di bawah ini adalah `91_nvidia_imex_prolog.sh` skrip yang harus Anda konfigurasikan sebagai prolog di Slurm. Ini digunakan untuk memperbarui konfigurasi nvidia-imex secara otomatis pada node komputasi. Nama skrip memiliki awalan `91` untuk mematuhi konvensi [penamaan SchedMD](https://slurm.schedmd.com/prolog_epilog.html). Ini memastikan ia mengeksekusi sebelum skrip prolog lainnya dalam urutan. Skrip mengkonfigurasi ulang konfigurasi node NVIDIA IMEX saat pekerjaan dimulai dan memuat ulang daemon NVIDIA yang diperlukan.
**catatan**
Skrip ini tidak akan dieksekusi jika beberapa pekerjaan dimulai secara bersamaan pada node yang sama, oleh karena itu kami sarankan untuk menggunakan `--exclusive` flag pada pengiriman.
```
#!/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"
```
## Buat Skrip Tindakan HeadNode OnNodeStart Kustom
Buat tindakan `install_custom_action.sh` khusus yang akan mengunduh skrip prolog yang disebutkan di atas dalam direktori bersama `/opt/slurm/etc/scripts/prolog.d/` yang diakses oleh Compute Nodes dan menetapkan izin yang tepat untuk dieksekusi.
```
#!/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}"
```
## Buat cluster
Buat cluster termasuk instance P6e-GB200 . Di bawah ini Anda dapat menemukan konfigurasi contoh yang berisi SlurmQueues untuk jenis Ultraserver. `u-p6e-gb200x72`
P6e- GB200 saat ini hanya tersedia di Local Zones. Beberapa [Local Zones tidak mendukung NAT Gateway](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html), jadi silakan ikuti [opsi Konektivitas untuk Local Zones](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html) karena ParallelCluster perlu terhubung [Mengkonfigurasi grup keamanan untuk lingkungan terbatas](security-groups-configuration.md) ke AWS Layanan. Silakan ikuti [Luncurkan instans dengan Blok Kapasitas (CB)](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch) karena Ultraserver hanya tersedia sebagai Blok Kapasitas.
```
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:
-
```
## Validasi Pengaturan IMEX
`91_nvidia_imex_prolog.sh`Prolog akan berjalan saat Anda mengirimkan pekerjaan Slurm. Di bawah ini adalah contoh pekerjaan untuk memeriksa status domain 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"
```
Periksa output dari Job:
```
Connectivity Table Legend:
I - Invalid - Node wasn't reachable, no connection status available
N - Never Connected
R - Recovering - Connection was lost, but clean up has not yet been triggered.
D - Disconnected - Connection was lost, and clean up has been triggreed.
A - Authenticating - If GSSAPI enabled, client has initiated mutual authentication.
!V! - Version mismatch, communication disabled.
!M! - Node map mismatch, communication disabled.
C - Connected - Ready for operation
5/12/2025 06:08:10.580
Nodes:
Node #0 - 172.31.48.81 - READY - Version: 570.172
Node #1 - 172.31.48.98 - READY - Version: 570.172
Node #2 - 172.31.48.221 - READY - Version: 570.172
Node #3 - 172.31.49.228 - READY - Version: 570.172
Node #4 - 172.31.50.39 - READY - Version: 570.172
Node #5 - 172.31.50.44 - READY - Version: 570.172
Node #6 - 172.31.51.66 - READY - Version: 570.172
Node #7 - 172.31.51.157 - READY - Version: 570.172
Node #8 - 172.31.52.239 - READY - Version: 570.172
Node #9 - 172.31.53.80 - READY - Version: 570.172
Node #10 - 172.31.54.95 - READY - Version: 570.172
Node #11 - 172.31.54.183 - READY - Version: 570.172
Node #12 - 172.31.54.203 - READY - Version: 570.172
Node #13 - 172.31.54.241 - READY - Version: 570.172
Node #14 - 172.31.55.59 - READY - Version: 570.172
Node #15 - 172.31.55.187 - READY - Version: 570.172
Node #16 - 172.31.55.197 - READY - Version: 570.172
Node #17 - 172.31.56.47 - READY - Version: 570.172
Nodes From\To 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
0 C C C C C C C C C C C C C C C C C C
1 C C C C C C C C C C C C C C C C C C
2 C C C C C C C C C C C C C C C C C C
3 C C C C C C C C C C C C C C C C C C
4 C C C C C C C C C C C C C C C C C C
5 C C C C C C C C C C C C C C C C C C
6 C C C C C C C C C C C C C C C C C C
7 C C C C C C C C C C C C C C C C C C
8 C C C C C C C C C C C C C C C C C C
9 C C C C C C C C C C C C C C C C C C
10 C C C C C C C C C C C C C C C C C C
11 C C C C C C C C C C C C C C C C C C
12 C C C C C C C C C C C C C C C C C C
13 C C C C C C C C C C C C C C C C C C
14 C C C C C C C C C C C C C C C C C C
15 C C C C C C C C C C C C C C C C C C
16 C C C C C C C C C C C C C C C C C C
17 C C C C C C C C C C C C C C C C C C
Domain State: UP
```
# Sesuaikan antarmuka jaringan node komputasi dengan penggantian template peluncuran
Dimulai dengan AWS ParallelCluster 3.15.0, `LaunchTemplateOverrides` parameter memungkinkan Anda menyesuaikan antarmuka jaringan node komputasi dengan mengganti konfigurasi antarmuka jaringan default dengan konfigurasi dalam templat peluncuran yang direferensikan. Seluruh bagian antarmuka jaringan dari node komputasi ditimpa oleh bagian antarmuka jaringan dari template peluncuran yang digunakan untuk mengganti.
Tutorial ini berjalan melalui contoh penggantian konfigurasi jaringan default node `p6-b300.48xlarge` komputasi. Kustomisasi ini berguna ketika Anda memerlukan konfigurasi antarmuka jaringan tertentu yang berbeda dari apa yang AWS ParallelCluster dikonfigurasi secara default. [Dalam contoh ini, kami mengonfigurasi kasus penggunaan 2 untuk instance P6-B300 seperti yang diuraikan dalam dokumentasi jenis instans yang didukung EFA Amazon EC2.](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html)
**catatan**
Disarankan untuk menggunakan AWS CLI untuk membuat template peluncuran alih-alih konsol untuk fleksibilitas maksimum.
**catatan**
Template peluncuran seharusnya hanya berisi penggantian Antarmuka Jaringan. AWS ParallelCluster memiliki validasi yang mencegah mengesampingkan parameter lain.
**Awas**
Jika Anda menggunakan override untuk mengonfigurasi antarmuka jaringan dengan cara yang tidak didukung oleh jenis instance yang digunakan, maka instance akan gagal diluncurkan.
**Prasyarat**
+ AWS ParallelCluster [versi 3.15.0 atau yang lebih baru diinstal.](install-v3-parallelcluster.md)
+ AWS CLI [Itu diinstal dan dikonfigurasi.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Anda memiliki peran IAM dengan [izin](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) yang diperlukan untuk menjalankan CLI[`pcluster`](pcluster-v3.md).
## Langkah 1: Buat grup keamanan
Saat membuat template peluncuran untuk digunakan dalam penggantian, Anda harus mereferensikan grup keamanan. Grup AWS ParallelCluster keamanan default untuk sumber daya komputasi tidak ada sampai pembuatan klaster, jadi Anda harus membuat grup keamanan kustom. Grup keamanan ini kemudian harus direferensikan oleh grup keamanan node kepala untuk memungkinkan lalu lintas antara node kepala dan node komputasi.
Jika Anda memperbarui klaster yang ada untuk menyesuaikan kapasitas baru, Anda dapat menggunakan grup keamanan node AWS ParallelCluster komputasi default di template peluncuran alih-alih membuat yang kustom.
Buat dua grup keamanan berikut:
+ **Head node grup keamanan tambahan** (`sg-1234abcd`):
+ Ingress: semua lalu lintas dari grup keamanan komputasi
+ **Grup keamanan komputasi** (`sg-abcd1234`):
+ Ingress: semua lalu lintas dari grup keamanan node kepala
+ Ingress: semua lalu lintas dari self () compute-to-compute
+ Jalan keluar: default izinkan semua
## Langkah 2: Buat template peluncuran
Buat template peluncuran yang mendefinisikan konfigurasi antarmuka jaringan untuk node `p6-b300.48xlarge` komputasi. Untuk antarmuka jaringan utama (indeks kartu jaringan 0, indeks perangkat 0), gunakan antarmuka jaringan ENA (default). Untuk kartu jaringan yang tersisa, buat antarmuka khusus EFA (indeks kartu jaringan 1-16, indeks perangkat 0) dan antarmuka ENA (default) (indeks kartu jaringan 1-16, indeks perangkat 1).
Jalankan AWS CLI perintah berikut untuk membuat template peluncuran (`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"}
]
}'
```
## Langkah 3: Buat cluster dengan penggantian template peluncuran
Buat konfigurasi cluster yang menggunakan `LaunchTemplateOverrides` parameter untuk mereferensikan template peluncuran yang Anda buat.
```
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.
```