Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Tutorials zur Verwendung AWS ParallelCluster
Die folgenden Tutorials zeigen Ihnen, wie Sie mit AWS ParallelCluster Version 3 beginnen können, und bieten Anleitungen zu bewährten Methoden für einige häufig auftretende Aufgaben.
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Topics**
+ [
# Du führst deinen ersten Job am AWS ParallelCluster
](tutorials-running-your-first-job-on-version-3.md)
+ [
# Ein benutzerdefiniertes AWS ParallelCluster AMI erstellen
](building-custom-ami-v3.md)
+ [
# Integrieren von Active Directory
](tutorials_05_multi-user-ad.md)
+ [
# Konfiguration der Verschlüsselung von gemeinsam genutztem Speicher mit einem AWS KMS Schlüssel
](tutorials_04_encrypted_kms_fs-v3.md)
+ [
# Ausführung von Jobs in einem Cluster mit mehreren Warteschlangen
](multi-queue-tutorial-v3.md)
+ [
# Die AWS ParallelCluster API verwenden
](tutorials_06_API_use.md)
+ [
# Einen Cluster erstellen mit Slurm Buchhaltung
](tutorials_07_slurm-accounting-v3.md)
+ [
# Erstellen eines Clusters mit einem externen Slurmdbd Buchhaltung
](external-slurmdb-accounting.md)
+ [
# Zu einer früheren AWS Systems Manager Manager-Dokumentversion zurückkehren
](tutorials_08_ssm-document-version-rev-v3.md)
+ [
# Einen Cluster erstellen mit CloudFormation
](tutorials_09_cfn-custom-resource-v3.md)
+ [
# ParallelCluster API mit Terraform bereitstellen
](tutorial-deploy-terraform.md)
+ [
# Einen Cluster mit Terraform erstellen
](tutorial-create-cluster-terraform.md)
+ [
# Erstellen eines benutzerdefinierten AMI mit Terraform
](tutorial-create-ami-terraform.md)
+ [
# AWS ParallelCluster UI-Integration mit Identity Center
](tutorials_10_pcui-aws-ic-integration-v3.md)
+ [Containerisierte Jobs mit Pyxis ausführen](tutorials_11_running-containerized-jobs-with-pyxis.md)
+ [
# Einen Cluster mit einem EFA-fähigen Lustre FSx erstellen
](tutorial-efa-enabled-fsx-lustre.md)
+ [
# Support NVIDIA-IMEX mit p6e-gb200-Instanz
](support-nvidia-imex-p6e-gb200-instance.md)
+ [
# Passen Sie die Netzwerkschnittstellen für Rechenknoten mit Überschreibungen für Startvorlagen an
](tutorial-network-customization-v3.md)
# Du führst deinen ersten Job am AWS ParallelCluster
Dieses Tutorial führt Sie durch die Ausführung Ihres ersten Hello World-Jobs auf AWS ParallelCluster
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen**
+ AWS ParallelCluster [ist installiert](install-v3-parallelcluster.md).
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den [für die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlichen Berechtigungen](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies).
## Überprüfen der Installation
Zunächst überprüfen wir, ob sie AWS ParallelCluster korrekt installiert und konfiguriert ist, einschließlich der Abhängigkeit von Node.js.
```
$ node --version
v16.8.0
$ pcluster version
{
"version": "3.15.0"
}
```
Dies gibt die laufende Version von zurück AWS ParallelCluster.
## Erstellen Sie Ihren ersten Cluster
Jetzt ist es an der Zeit, Ihren ersten Cluster zu erstellen. Da die Workload für dieses Tutorial nicht leistungsintensiv ist, können wir die Standard-Instance-Größe `t2.micro` verwenden. (Für Produktions-Workloads wählen Sie eine Instance-Größe, die Ihren Anforderungen am ehesten entspricht.) Rufen wir Ihren Cluster an`hello-world`.
```
$ pcluster create-cluster \
--cluster-name hello-world \
--cluster-configuration hello-world.yaml
```
**Anmerkung**
Der AWS-Region zu verwendende Befehl muss für die meisten `pcluster` Befehle angegeben werden. Wenn er nicht in der `AWS_DEFAULT_REGION` Umgebungsvariablen oder in der `region` Einstellung im `[default]` Abschnitt der `~/.aws/config` Datei angegeben ist, muss der `--region` Parameter in der `pcluster` Befehlszeile angegeben werden.
Wenn Sie in der Ausgabe eine Meldung zur Konfiguration erhalten, müssen Sie zur Konfiguration Folgendes ausführen AWS ParallelCluster:
```
$ pcluster configure --config hello-world.yaml
```
Wenn der [`pcluster create-cluster`](pcluster.create-cluster-v3.md) Befehl erfolgreich ist, erhalten Sie eine Ausgabe, die der folgenden ähnelt:
```
{
"cluster": {
"clusterName": "hello-world",
"cloudformationStackStatus": "CREATE_IN_PROGRESS",
"cloudformationStackArn": "arn:aws:cloudformation:xxx:stack/xxx",
"region": "...",
"version": "...",
"clusterStatus": "CREATE_IN_PROGRESS"
}
}
```
Sie überwachen die Erstellung des Clusters mithilfe von:
```
$ pcluster describe-cluster --cluster-name hello-world
```
Die `clusterStatus` Berichte "`CREATE_IN_PROGRESS`" während der Clustererstellung. Der `clusterStatus` Übergang zu "`CREATE_COMPLETE`" erfolgt, wenn der Cluster erfolgreich erstellt wurde. Die Ausgabe liefert uns auch das `publicIpAddress` Ende `privateIpAddress` unseres Kopfknotens.
## Loggen Sie sich in Ihren Headnode ein
Verwenden Sie Ihre OpenSSH-PEM-Datei, um sich bei Ihrem Headnode anzumelden.
```
$ pcluster ssh --cluster-name hello-world -i /path/to/keyfile.pem
```
Sobald Sie angemeldet sind, führen Sie den Befehl `sinfo` aus, um zu bestätigen, dass Ihre Datenverarbeitungsknoten eingerichtet und konfiguriert sind.
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
queue1* up infinite 10 idle~ queue1-dy-queue1t2micro-[1-10]
```
Die Ausgabe zeigt, dass wir in unserem Cluster eine Warteschlange mit bis zu zehn Knoten haben.
## Du führst deinen ersten Job mit Slurm aus
Als Nächstes erstellen wir eine Aufgabe, die einen Moment inaktiv ist und dann ihren eigenen Hostnamen ausgibt. Erstellen Sie eine Datei mit dem Namen `hellojob.sh` und den folgenden Inhalten:
```
#!/bin/bash
sleep 30
echo "Hello World from $(hostname)"
```
Als Nächstes übermitteln Sie die Aufgabe mit `sbatch` und überprüfen, dass sie ausgeführt wird.
```
$ sbatch hellojob.sh
Submitted batch job 2
```
Jetzt können Sie Ihre Warteschlange anzeigen und den Status der Aufgabe überprüfen. Die Bereitstellung einer neuen Amazon EC2 EC2-Instance wird im Hintergrund gestartet. Sie können den Status der Cluster-Instances mit dem `sinfo` Befehl überwachen.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
2 queue1 hellojob ec2-user CF 3:30 1 queue1-dy-queue1t2micro-1
```
Die Ausgabe zeigt, dass der Job an weitergeleitet wurde`queue1`. Warten Sie 30 Sekunden, bis die Aufgabe beendet wird, und führen Sie `squeue` dann erneut aus.
```
$ squeue
JOBID PARTITION NAME USER ST TIME NODES NODELIST(REASON)
```
Jetzt, wo sich keine Aufgaben in der Warteschlange befinden, können wir die Ausgabe in unserem aktuellen Verzeichnis überprüfen.
```
$ 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
```
In der Ausgabe sehen wir eine "`out`" -Datei. Wir können die Ergebnisse unseres Jobs sehen:
```
$ cat slurm-2.out
Hello World from queue1-dy-queue1t2micro-1
```
Die Ausgabe zeigt auch, dass die Aufgabe auf Instance `queue1-dy-queue1t2micro-1` erfolgreich ausgeführt wurde.
In dem Cluster, den Sie gerade erstellt haben, wird nur das Home-Verzeichnis von allen Knoten des Clusters gemeinsam genutzt.
Weitere Informationen zum Erstellen und Verwenden von Clustern finden Sie unter[Bewährte Methoden](best-practices-v3.md).
Wenn für Ihre Anwendung gemeinsam genutzte Software, Bibliotheken oder Daten erforderlich sind, sollten Sie die folgenden Optionen in Betracht ziehen:
+ Erstellen Sie ein AWS ParallelCluster aktiviertes benutzerdefiniertes AMI, das Ihre Software enthält, wie unter beschrieben[Ein benutzerdefiniertes AWS ParallelCluster AMI erstellen](building-custom-ami-v3.md).
+ Verwenden Sie die [StorageSettings](SharedStorage-v3.md)Option in der AWS ParallelCluster Konfigurationsdatei, um ein gemeinsam genutztes Dateisystem anzugeben und Ihre installierte Software am angegebenen Mount-Speicherort zu speichern.
+ Wird verwendet[Benutzerdefinierte Bootstrap-Aktionen](custom-bootstrap-actions-v3.md), um den Bootstrap-Vorgang für jeden Knoten Ihres Clusters zu automatisieren.
# Ein benutzerdefiniertes AWS ParallelCluster AMI erstellen
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Wichtig**
Wenn Sie ein benutzerdefiniertes AMI erstellen, müssen Sie die Schritte, die Sie zur Erstellung Ihres benutzerdefinierten AMI verwendet haben, mit jeder neuen AWS ParallelCluster Version wiederholen.
Bevor Sie weiterlesen, empfehlen wir Ihnen, zunächst den [Benutzerdefinierte Bootstrap-Aktionen](custom-bootstrap-actions-v3.md) Abschnitt zu lesen. Stellen Sie fest, ob die Änderungen, die Sie vornehmen möchten, skriptgesteuert werden können und in future AWS ParallelCluster Versionen unterstützt werden können.
Auch wenn die Erstellung eines benutzerdefinierten AMI im Allgemeinen nicht ideal ist, gibt es bestimmte Szenarien, für die die Erstellung eines benutzerdefinierten AMI erforderlich AWS ParallelCluster ist. In diesem Tutorial erfahren Sie, wie Sie ein benutzerdefiniertes AMI für diese Szenarien erstellen.
**Voraussetzungen**
+ AWS ParallelCluster [ist installiert](install-v3-parallelcluster.md).
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den erforderlichen [Berechtigungen](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies), um die [`pcluster`](pcluster-v3.md) CLI auszuführen und Images zu erstellen.
## So passen Sie das AWS ParallelCluster AMI an
Es gibt zwei Möglichkeiten, ein benutzerdefiniertes AWS ParallelCluster AMI zu erstellen. Eine dieser beiden Methoden besteht darin, mithilfe der AWS ParallelCluster CLI ein neues AMI zu erstellen. Bei einer anderen Methode müssen Sie manuelle Änderungen vornehmen, um ein neues AMI zu erstellen, das unter Ihrem verfügbar ist AWS-Konto.
## Erstellen Sie ein benutzerdefiniertes AWS ParallelCluster AMI
Wenn Sie über ein benutzerdefiniertes AMI und eine angepasste Software verfügen, können Sie die AWS ParallelCluster erforderlichen Änderungen zusätzlich anwenden. AWS ParallelCluster verlässt sich auf den EC2 Image Builder Builder-Service, um maßgeschneiderte AMIs zu erstellen. Weitere Informationen finden Sie im [Image Builder Builder-Benutzerhandbuch](https://docs.aws.amazon.com/imagebuilder/latest/userguide/what-is-image-builder.html).
Die wichtigsten Punkte:
+ Der Vorgang dauert etwa 1 Stunde. Diese Zeit kann variieren, wenn während der Erstellung weitere [`Build`](Build-v3.md)/[`Components`](Build-v3.md#Build-v3-Components)installiert werden müssen.
+ Das AMI ist mit den Versionen der Hauptkomponenten gekennzeichnet. Dazu gehören der Kernel, der Scheduler und der [EFA-Treiber](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html). Eine Teilmenge der Komponentenversionen wird auch in der AMI-Beschreibung angegeben.
+ Ab AWS ParallelCluster 3.0.0 kann ein neuer Satz von CLI-Befehlen verwendet werden, um den Lebenszyklus von Images zu verwalten. Dazu zählen [`build-image`](pcluster.build-image-v3.md), [`list-images`](pcluster.list-images-v3.md), [`describe-image`](pcluster.describe-image-v3.md) und [`delete-image`](pcluster.delete-image-v3.md).
+ Diese Methode ist wiederholbar. Sie können sie erneut ausführen, um auf dem AMIs neuesten Stand zu bleiben (z. B. Betriebssystemupdates), und sie dann verwenden, wenn Sie einen vorhandenen Cluster aktualisieren.
**Anmerkung**
Wenn Sie diese Methode in der AWS China-Partition verwenden, können Netzwerkfehler auftreten. Diese Fehler könnten Ihnen beispielsweise in dem `pcluster build-image` Befehl angezeigt werden, wenn er Pakete von GitHub oder aus einem Betriebssystem-Repository herunterlädt. In diesem Fall empfehlen wir Ihnen, eine der folgenden alternativen Methoden zu verwenden:
Folgen Sie dem [Ein AWS ParallelCluster AMI ändern](#modify-an-aws-parallelcluster-ami-v3) Ansatz, der diesen Befehl umgeht.
Erstellen Sie das Image in einer anderen Partition und Region`us-east-1`, z. B., und verschieben Sie store/restore es dann in die Region China. Weitere Informationen finden Sie unter [Speichern und Wiederherstellen eines AMI mit S3](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ami-store-restore.html) im *Benutzerhandbuch für Amazon EC2*.
Schritte:
1. Konfigurieren Sie Ihre AWS-Konto Anmeldeinformationen so, dass der AWS ParallelCluster Client in Ihrem Namen AWS API-Operationen aufrufen kann. Eine Liste der erforderlichen Berechtigungen finden Sie unter [AWS Identity and Access Management Berechtigungen in AWS ParallelCluster](iam-roles-in-parallelcluster-v3.md).
1. Erstellen Sie eine grundlegende *Build-Image-Konfigurationsdatei*. Geben Sie dazu die an, die [`InstanceType`](Build-v3.md#yaml-build-image-Build-InstanceType)zum Erstellen des Images verwendet werden sollen, und die [`ParentImage`](Build-v3.md#yaml-build-image-Build-ParentImage). Diese werden als Ausgangspunkt für die Erstellung des AMI verwendet. Weitere Informationen zu optionalen Build-Parametern finden Sie unter [Image-Konfiguration](image-builder-configuration-file-v3.md).
```
Build:
InstanceType:
ParentImage:
```
1. Verwenden Sie den CLI-Befehl [`pcluster build-image`](pcluster.build-image-v3.md), um ausgehend von dem AWS ParallelCluster AMI, das Sie als Basis angeben, ein AMI zu erstellen.
```
$ 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"
}
}
```
**Warnung**
`pcluster build-image`verwendet die Standard-VPC. Wenn Sie die Standard-VPC mit AWS Control Tower oder AWS Landing Zone löschen, muss die Subnetz-ID in der Image-Konfigurationsdatei angegeben werden. Weitere Informationen finden Sie unter [`SubnetId`](HeadNode-v3.md#yaml-HeadNode-Networking-SubnetId).
Eine Liste anderer Parameter finden Sie auf der [`pcluster build-image`](pcluster.build-image-v3.md)Befehlsreferenzseite. Die Ergebnisse des vorherigen Befehls lauten wie folgt:
+ Ein CloudFormation Stapel wird auf der Grundlage der Image-Konfiguration erstellt. Der Stack enthält alle EC2 Image Builder Builder-Ressourcen, die für den Build erforderlich sind.
+ Die erstellten Ressourcen enthalten die offiziellen Image Builder AWS ParallelCluster Builder-Komponenten, zu denen benutzerdefinierte Image Builder Builder-Komponenten hinzugefügt werden können. Weitere Informationen finden Sie unter [Erstellen einer benutzerdefinierten Komponente mit Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) im *EC2 Image Builder Builder-Benutzerhandbuch*.
+ EC2 Image Builder startet eine Build-Instance, wendet das AWS ParallelCluster Cookbook an, installiert den AWS ParallelCluster Software-Stack und führt die erforderlichen Konfigurationsaufgaben durch. Das AWS ParallelCluster Cookbook wird zum Erstellen und Bootstrap verwendet. AWS ParallelCluster
+ Die Instance wird gestoppt und daraus wird ein neues AMI erstellt.
+ Eine weitere Instance wird über das neu erstellte AMI gestartet. Während der Testphase führt EC2 Image Builder Tests aus, die in den Image Builder-Komponenten definiert sind.
+ Wenn der Build erfolgreich ist, wird der Stack gelöscht. Wenn der Build fehlschlägt, wird der Stack beibehalten und kann überprüft werden.
1. Sie können den Status des Build-Prozesses überwachen, indem Sie den folgenden Befehl ausführen. Nachdem der Build abgeschlossen ist, können Sie ihn ausführen, um die in der Antwort angegebene AMI-ID abzurufen.
```
$ 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. Um Ihren Cluster zu erstellen, geben Sie die AMI-ID in das [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)Feld in Ihrer Cluster-Konfiguration ein.
**Fehlerbehebung und Überwachung des AMI-Erstellungsprozesses**
Die Image-Erstellung ist in etwa einer Stunde abgeschlossen. Sie können den Prozess überwachen, indem Sie den [`pcluster describe-image`](pcluster.describe-image-v3.md)Befehl oder die Befehle zum Abrufen von Protokollen ausführen.
```
$ pcluster describe-image --image-id IMAGE_ID --region REGION
```
Der [`build-image`](pcluster.build-image-v3.md)Befehl erstellt einen CloudFormation Stapel mit allen Amazon EC2 EC2-Ressourcen, die zum Erstellen des Images erforderlich sind, und startet den EC2 Image Builder Builder-Prozess.
Nach der Ausführung des [`build-image`](pcluster.build-image-v3.md)Befehls ist es möglich, CloudFormation Stack-Ereignisse mithilfe von abzurufen. [`pcluster get-image-stack-events`](pcluster.get-image-stack-events-v3.md) Sie können die Ergebnisse mit dem `--query` Parameter filtern, um die neuesten Ereignisse zu sehen. Weitere Informationen finden Sie im *AWS Command Line Interface Benutzerhandbuch* unter [Filtern der AWS CLI Ausgabe](https://docs.aws.amazon.com/cli/latest/userguide/cli-usage-filter.html).
```
$ pcluster get-image-stack-events --image-id IMAGE_ID --region REGION --query "events[0]"
{
"eventId": "ParallelClusterImage-CREATE_IN_PROGRESS-2022-04-05T21:39:24.725Z",
"physicalResourceId": "arn:aws:imagebuilder:us-east-1:123456789012:image/parallelclusterimage-IMAGE_ID/3.15.0/1",
"resourceStatus": "CREATE_IN_PROGRESS",
"resourceStatusReason": "Resource creation Initiated",
"resourceProperties": "{\"InfrastructureConfigurationArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:infrastructure-configuration/parallelclusterimage-abcd1234-ef56-gh78-ij90-1234abcd5678\",\"ImageRecipeArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:image-recipe/parallelclusterimage-IMAGE_ID/3.15.0\",\"DistributionConfigurationArn\":\"arn:aws:imagebuilder:us-east-1:123456789012:distribution-configuration/parallelclusterimage-abcd1234-ef56-gh78-ij90-1234abcd5678\",\"Tags\":{\"parallelcluster:image_name\":\"IMAGE_ID\",\"parallelcluster:image_id\":\"IMAGE_ID\"}}",
"stackId": "arn:aws:cloudformation:us-east-1:123456789012:stack/IMAGE_ID/abcd1234-ef56-gh78-ij90-1234abcd5678",
"stackName": "IMAGE_ID",
"logicalResourceId": "ParallelClusterImage",
"resourceType": "AWS::ImageBuilder::Image",
"timestamp": "2022-04-05T21:39:24.725Z"
}
```
Nach etwa 15 Minuten werden die Stack-Ereignisse im Protokollereigniseintrag angezeigt, der sich auf die Erstellung von Image Builder bezieht. Sie können jetzt Image-Log-Streams auflisten und die Image Builder Builder-Schritte mithilfe von [`pcluster list-image-log-streams`[`pcluster get-image-log-events`](pcluster.get-image-log-events-v3.md)](pcluster.list-image-log-streams-v3.md)and-Befehlen überwachen.
```
$ 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"
}
]
}
```
Prüfen Sie mit dem [`describe-image`](pcluster.describe-image-v3.md)Befehl weiter, bis Sie den `BUILD_COMPLETE` Status sehen.
```
$ 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"
}
```
Wenn Sie ein Problem bei der Erstellung eines benutzerdefinierten AMIs beheben müssen, erstellen Sie ein Archiv der Image-Protokolle, wie in den folgenden Schritten beschrieben.
Je nach `--output` Parameter ist es möglich, die Protokolle in einem Amazon S3 S3-Bucket oder in einer lokalen Datei zu archivieren.
```
$ 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"
}
```
Das Archiv enthält die CloudWatch Logs-Streams, die sich auf den Image Builder Builder-Prozess und die CloudFormation Stack-Ereignisse beziehen. Die Ausführung des Befehls kann mehrere Minuten dauern.
**Benutzerdefiniert verwalten AMIs**
Ab AWS ParallelCluster Version 3.0.0 wurde der CLI ein neuer Befehlssatz hinzugefügt, um den Image-Lebenszyklus zu erstellen, zu überwachen und zu verwalten. Weitere Informationen zu den Befehlen finden Sie unter [pcluster-Befehle](pcluster-v3.md).
## Ein AWS ParallelCluster AMI ändern
Diese Methode besteht darin, ein offizielles AWS ParallelCluster AMI zu ändern, indem zusätzliche Anpassungen hinzugefügt werden. Die Basis AWS ParallelCluster AMIs wird mit neuen Versionen aktualisiert. Diese AMIs enthalten alle Komponenten, die für den Betrieb AWS ParallelCluster bei der Installation und Konfiguration erforderlich sind. Sie können mit einer davon als Basis beginnen.
Die wichtigsten Punkte:
+ Diese Methode ist schneller als der [`build-image`](pcluster.build-image-v3.md)Befehl. Es handelt sich jedoch um einen manuellen Vorgang, der nicht automatisch wiederholt werden kann.
+ Mit dieser Methode haben Sie keinen Zugriff auf die Befehle zum Abrufen von Protokollen und zur Verwaltung des Image-Lebenszyklus, die über die CLI verfügbar sind.
Schritte:
------
#### [ New Amazon EC2 console ]
1. Suchen Sie das AMI, das dem spezifischen entspricht AWS-Region , das Sie verwenden. Um es zu finden, verwenden Sie den [`pcluster list-official-images`](pcluster.list-official-images-v3.md)Befehl mit dem `--region` Parameter, um die spezifischen AWS-Region und- `--os` und `--architecture` Parameter auszuwählen, um nach dem gewünschten AMI mit dem Betriebssystem und der Architektur zu filtern, die Sie verwenden möchten. Rufen Sie aus der Ausgabe die Amazon EC2 EC2-Image-ID ab.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Images** und dann **AMIs**. Suchen Sie nach der abgerufenen EC2-Image-ID, wählen Sie das AMI aus und wählen Sie **Launch instance from AMI aus**.
1. Scrollen Sie nach unten und wählen Sie Ihren **Instance-Typ** aus.
1. Wählen Sie Ihr **Schlüsselpaar** und **starten Sie die Instance**.
1. Melden Sie sich mit dem Betriebssystembenutzer und Ihrem SSH Schlüssel bei Ihrer Instance an.
1. Passen Sie Ihre Instanz manuell an Ihre Anforderungen an.
1. Führen Sie den folgenden Befehl aus, um Ihre Instance für die AMI-Erstellung vorzubereiten.
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Wählen Sie in der Konsole **Instance State** und **Stop instance aus**.
Navigieren Sie zu **Instances**, wählen Sie die neue Instance aus, wählen Sie **Instance state** und **Stop instance** aus.
1. Erstellen Sie mithilfe der Amazon EC2 EC2-Konsole oder mit AWS CLI [Create-Image](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html) ein neues AMI aus der Instance.
**Von der Amazon EC2 EC2-Konsole**
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Wählen Sie die Instance aus, die Sie erstellt und geändert haben.
1. Wählen Sie **unter Aktionen** die Option **Image** und dann **Image erstellen** aus.
1. Wählen Sie **Image erstellen** aus.
1. Geben Sie die neue AMI-ID in das [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)Feld in Ihrer Cluster-Konfiguration ein und erstellen Sie einen Cluster.
------
#### [ Old Amazon EC2 console ]
1. Suchen Sie das AWS ParallelCluster AMI, das dem spezifischen entspricht AWS-Region , das Sie verwenden. Um es zu finden, können Sie den [`pcluster list-official-images`](pcluster.list-official-images-v3.md)Befehl mit dem `--region` Parameter verwenden, um die spezifischen AWS-Region und- `--os` und `--architecture` Parameter auszuwählen, um nach dem gewünschten AMI mit dem Betriebssystem und der Architektur zu filtern, die Sie verwenden möchten. Aus der Ausgabe können Sie die Amazon EC2 EC2-Image-ID abrufen.
1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die Amazon EC2 EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im Navigationsbereich **Images** und dann **AMIs**. Stellen Sie den Filter für **Öffentliche Images** ein und suchen Sie nach der abgerufenen EC2-Image-ID, wählen Sie das AMI aus und klicken Sie auf **Launch**.
1. Wählen Sie Ihren Instance-Typ und wählen Sie **Weiter: Instance-Details konfigurieren** oder **Überprüfen und starten**, um Ihre Instance zu starten.
1. Wählen Sie **Launch**, wählen Sie Ihr **Schlüsselpaar** und dann **Launch Instances** aus.
1. Melden Sie sich bei Ihrer Instance mithilfe des Betriebssystembenutzers und Ihres SSH-Schlüssels an. Für weitere Informationen navigieren Sie zu **Instances**, wählen Sie die neue Instance aus und klicken Sie auf **Connect**.
1. Passen Sie Ihre Instance manuell an Ihre Anforderungen an.
1. Führen Sie den folgenden Befehl aus, um Ihre Instance für die AMI-Erstellung vorzubereiten:
```
sudo /usr/local/sbin/ami_cleanup.sh
```
1. Wählen Sie in der Amazon EC2 EC2-Konsole im Navigationsbereich **Instances**, wählen Sie Ihre neue Instance aus und wählen Sie **Actions**, **Instance State** und **Stop**.
1. Erstellen Sie mithilfe der Amazon EC2 EC2-Konsole oder mit AWS CLI [Create-Image](https://docs.aws.amazon.com/cli/latest/reference/ec2/create-image.html) ein neues AMI aus der Instance.
**Von der Amazon EC2 EC2-Konsole**
1. Wählen Sie im Navigationsbereich **Instances** aus.
1. Wählen Sie die Instance aus, die Sie erstellt und geändert haben.
1. Wählen Sie unter **Aktionen** die Option **Image** und dann **Create Image** aus.
1. Wählen Sie **Image erstellen** aus.
1. Geben Sie die neue AMI-ID in das [`CustomAmi`](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-Image-CustomAmi)Feld in Ihrer Cluster-Konfiguration ein und erstellen Sie einen Cluster.
------
# Integrieren von Active Directory
In diesem Tutorial erstellen Sie eine Umgebung mit mehreren Benutzern. Diese Umgebung umfasst eine AWS ParallelCluster , die in ein AWS Managed Microsoft AD (Active Directory-) AT integriert ist`corp.example.com`. Sie konfigurieren einen `Admin` Benutzer für die Verwaltung des Verzeichnisses, einen `ReadOnly` Benutzer für das Lesen des Verzeichnisses und einen `user000` Benutzer für die Anmeldung am Cluster. Sie können entweder den automatisierten Pfad oder den manuellen Pfad verwenden, um die Netzwerkressourcen, ein Active Directory (AD) und die Amazon EC2 EC2-Instance zu erstellen, die Sie zur Konfiguration des AD verwenden. Unabhängig vom Pfad ist die Infrastruktur, die Sie erstellen, für die Integration AWS ParallelCluster mit einer der folgenden Methoden vorkonfiguriert:
+ LDAPS mit Zertifikatsüberprüfung (als sicherste Option empfohlen)
+ LDAPS ohne Zertifikatsverifizierung
+ LDAP
LDAP selbst bietet *keine Verschlüsselung*. Um eine sichere Übertragung potenziell sensibler Informationen zu gewährleisten, empfehlen wir dringend, LDAPS (LDAP über TLS/SSL) für integrierte Cluster zu verwenden. ADs *Weitere Informationen finden Sie unter [Aktivieren serverseitiger LDAPS](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/ms_ad_ldap_server_side.html) im Administratorhandbuch. AWS Managed Microsoft AD Directory Service *
Nachdem Sie diese Ressourcen erstellt haben, fahren Sie mit der Konfiguration und Erstellung Ihres Clusters fort, der in Ihr Active Directory (AD) integriert ist. Melden Sie sich nach der Erstellung des Clusters als der Benutzer an, den Sie erstellt haben. Weitere Informationen zu der Konfiguration, die Sie in diesem Tutorial erstellen, finden Sie unter [Zugriff mehrerer Benutzer auf Cluster](multi-user-v3.md) und im Abschnitt [`DirectoryService`](DirectoryService-v3.md)Konfiguration.
In diesem Tutorial wird beschrieben, wie Sie eine Umgebung erstellen, die den Zugriff mehrerer Benutzer auf Cluster unterstützt. In diesem Tutorial wird nicht behandelt, wie Sie ein Directory Service AD erstellen und verwenden. Die Schritte, die Sie AWS Managed Microsoft AD in diesem Tutorial zum Einrichten eines ausführen, dienen nur zu Testzwecken. Sie ersetzen *nicht* die offizielle Dokumentation und die Best Practices, die Sie unter [AWS Managed Microsoft AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_microsoft_ad.html)[Simple AD](https://docs.aws.amazon.com/directoryservice/latest/admin-guide/directory_simple_ad.html) im *Directory Service Administrationshandbuch* finden.
**Anmerkung**
Kennwörter von Verzeichnisbenutzern laufen gemäß den Eigenschaftsdefinitionen der Verzeichniskennwortrichtlinie ab. Informationen zum Zurücksetzen von Verzeichniskennwörtern mit AWS ParallelCluster finden Sie unter[Wie setze ich ein Benutzerpasswort und abgelaufene Passwörter zurück](troubleshooting-v3-multi-user.md#troubleshooting-v3-multi-user-reset-passwd).
**Anmerkung**
Die IP-Adressen der Verzeichnisdomänencontroller können sich aufgrund von Änderungen an den Domänencontrollern und der Verzeichnisverwaltung ändern. Wenn Sie die automatische Schnellerstellungsmethode zum Erstellen der Verzeichnisinfrastruktur gewählt haben, müssen Sie den Load Balancer manuell vor den Verzeichniscontrollern ausrichten, wenn sich die Verzeichnis-IP-Adressen ändern. Wenn Sie die Schnellerstellungsmethode verwenden, werden die Verzeichnis-IP-Adressen nicht automatisch an die Load Balancer angepasst.
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen**
+ AWS ParallelCluster [ist installiert](install-v3-parallelcluster.md).
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den [für die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlichen Berechtigungen](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies).
Ersetzen Sie beim Durcharbeiten des Tutorials `inputs highlighted in red` `d-abcdef01234567890` beispielsweise `region-id` und durch Ihre eigenen Namen und IDs. Ersetze es `0123456789012` durch deine AWS-Konto Nummer.
# Erstellen Sie die AD-Infrastruktur
Wählen Sie die Registerkarte *Automatisiert*, um die Active Directory (AD) -Infrastruktur mit einer CloudFormation Schnellerstellungsvorlage zu erstellen.
Wählen Sie die Registerkarte *Manuell*, um die AD-Infrastruktur manuell zu erstellen.
## Automatisiert
1. Melden Sie sich bei der an AWS-Managementkonsole.
1. Öffnen [Sie 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), um die folgenden Ressourcen in der CloudFormation Konsole zu erstellen:
+ Eine VPC mit zwei Subnetzen und Routing für den öffentlichen Zugriff, wenn keine VPC angegeben ist.
+ AWS Managed Microsoft AD Ein.
+ Eine Amazon EC2 EC2-Instance, die mit dem AD verknüpft ist und mit der Sie das Verzeichnis verwalten können.
1. Geben Sie im Abschnitt **Parameter** der **Quick Create-Stack-Seite** Passwörter für die folgenden Parameter ein:
+ **AdminPassword**
+ **ReadOnlyPassword**
+ **UserPassword**
Notieren Sie sich die Passwörter. Sie verwenden sie später in diesem Tutorial.
1. Geben Sie für **DomainName** den Wert **corp.example.com** ein.
1. Geben Sie für **Keypair** den Namen eines Amazon EC2 EC2-Schlüsselpaars ein.
1. Markieren Sie die Kästchen, um die einzelnen Zugriffsmöglichkeiten unten auf der Seite zu bestätigen.
1. Wählen Sie **Stack erstellen** aus.
1. Nachdem der CloudFormation Stapel den `CREATE_COMPLETE` Status erreicht hat, wählen Sie die Registerkarte **Ausgaben** des Stapels aus. Notieren Sie sich die Namen der Ausgaberessourcen und IDs warum Sie sie in späteren Schritten verwenden müssen. Die Ausgaben enthalten die Informationen, die für die Erstellung des Clusters benötigt werden.
![\[Ein Diagramm, das die erstellten Stack-Ausgaben in der zeigt AWS-Managementkonsole.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/ad-cfn.png)
1. Um die Übungen durchführen zu können[(Optional) AD-Benutzer und -Gruppen verwalten](tutorials_05_multi-user-ad-step2.md), benötigen Sie die Verzeichnis-ID. Wählen Sie **Ressourcen** und scrollen Sie nach unten, um sich die Verzeichnis-ID zu notieren.
1. Fahren Sie mit [(Optional) AD-Benutzer und -Gruppen verwalten](tutorials_05_multi-user-ad-step2.md) oder fort[Den Cluster erstellen](tutorials_05_multi-user-ad-step3.md).
## Manuell
Erstellen Sie eine VPC für den Verzeichnisdienst mit zwei Subnetzen in verschiedenen Availability Zones und einem. AWS Managed Microsoft AD
### Erstellen Sie das AD
**Anmerkung**
Das Verzeichnis und der Domainname sind`corp.example.com`. Der Kurzname ist`CORP`.
Ändern Sie das `Admin` Passwort im Skript.
Die Erstellung des Active Directory (AD) dauert mindestens 15 Minuten.
Verwenden Sie das folgende Python-Skript, um die VPC, Subnetze und AD-Ressourcen in Ihrem lokalen System zu erstellen. AWS-Region Speichern Sie diese Datei unter `ad.py` und führen Sie sie aus.
```
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})
```
Das Folgende ist eine Beispielausgabe aus dem Python-Skript.
```
{
"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"
}
```
Notieren Sie sich die Namen der Ausgaberessourcen und IDs. Sie verwenden sie in späteren Schritten.
Fahren Sie nach Abschluss des Skripts mit dem nächsten Schritt fort.
### Erstellen einer Amazon-EC2-Instance
------
#### [ New Amazon EC2 console ]
1. Melden Sie sich bei der an AWS-Managementkonsole.
1. Wenn Sie keine Rolle haben, der die in Schritt 4 aufgeführten Richtlinien zugeordnet sind, öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Fahren Sie andernfalls mit Schritt 5 fort.
1. Erstellen Sie die `ResetUserPassword` Richtlinie und ersetzen Sie den rot hervorgehobenen Inhalt durch Ihre AWS-Region ID, Konto-ID und die Verzeichnis-ID aus der Ausgabe des Skripts, das Sie zur Erstellung des AD ausgeführt haben.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Erstellen Sie eine IAM-Rolle mit den folgenden angehängten Richtlinien.
+ AWS verwaltete Richtlinie [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS verwaltete Richtlinie [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword Richtlinie
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im **Amazon EC2 EC2-Dashboard** **Launch Instance** aus.
1. Wählen Sie unter **Anwendungs- und Betriebssystemimages** ein aktuelles Amazon Linux 2-AMI aus.
1. Wählen Sie als **Instance-Typ** die Option t2.micro aus.
1. Wählen Sie für **key pair** ein Schlüsselpaar aus.
1. Wählen Sie für **Netzwerkeinstellungen** die Option **Bearbeiten** aus.
1. Wählen Sie für **VPC** das Verzeichnis VPC aus.
1. Scrollen Sie nach unten und wählen Sie **Erweiterte** Details aus.
1. Wählen Sie unter **Erweiterte Details** unter **Verzeichnis für Domänenbeitritt** die Option aus**corp.example.com**.
1. Wählen Sie für das **IAM-Instanzprofil** die Rolle aus, die Sie in Schritt 1 erstellt haben, oder eine Rolle, der die in Schritt 4 aufgeführten Richtlinien beigefügt sind.
1. Wählen Sie unter **Zusammenfassung** die Option **Launch instance** aus.
1. Notieren Sie sich die Instanz-ID (z. B. i-1234567890abcdef0) und warten Sie, bis der Start der Instance abgeschlossen ist.
1. Fahren Sie nach dem Start der Instance mit dem nächsten Schritt fort.
------
#### [ Old Amazon EC2 console ]
1. Melden Sie sich bei der an AWS-Managementkonsole.
1. Wenn Sie keine Rolle haben, der die in Schritt 4 aufgeführten Richtlinien zugeordnet sind, öffnen Sie die IAM-Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Fahren Sie andernfalls mit Schritt 5 fort.
1. Erstellen Sie die `ResetUserPassword` Richtlinie. Ersetzen Sie den rot hervorgehobenen Inhalt durch Ihre AWS-Region AWS-Konto ID, ID und die Verzeichnis-ID aus der Ausgabe des Skripts, das Sie zur Erstellung des Active Directory (AD) ausgeführt haben.
ResetUserPassword
```
{
"Statement": [
{
"Action": [
"ds:ResetUserPassword"
],
"Resource": "arn:aws:ds:region-id:123456789012:directory/d-abcdef01234567890",
"Effect": "Allow"
}
]
}
```
1. Erstellen Sie eine IAM-Rolle mit den folgenden angehängten Richtlinien.
+ AWS verwaltete Richtlinie [Amazon SSMManaged InstanceCore](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore)
+ AWS verwaltete Richtlinie [Amazon SSMDirectory ServiceAccess](https://console.aws.amazon.com/iam/home#/policies/arn:aws:iam::aws:policy/AmazonSSMDirectoryServiceAccess)
+ ResetUserPassword-Richtlinie
1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. Wählen Sie im **Amazon EC2 EC2-Dashboard** **Launch Instance** aus.
1. Wählen Sie unter **Anwendungs- und Betriebssystemimages** ein aktuelles Amazon Linux 2-AMI aus.
1. Wählen Sie für **Instance type** die Option t2.micro aus.
1. Wählen Sie für **key pair** ein Schlüsselpaar aus.
1. Wählen Sie für **Netzwerkeinstellungen** die Option **Bearbeiten** aus.
1. Wählen Sie unter **Netzwerkeinstellungen**, **VPC**, das Verzeichnis VPC aus.
1. Scrollen Sie nach unten und wählen Sie **Erweiterte** Details aus.
1. Wählen Sie unter **Erweiterte Details** unter **Verzeichnis für Domänenbeitritt** die Option aus**corp.example.com**.
1. Wählen Sie **unter Erweiterte Details**, **Instanzprofil**, die Rolle aus, die Sie in Schritt 1 erstellt haben, oder eine Rolle, der die in Schritt 4 aufgeführten Richtlinien beigefügt sind.
1. Wählen Sie unter **Zusammenfassung** die Option **Instanz starten** aus.
1. Notieren Sie sich die Instanz-ID (z. B.i-1234567890abcdef0) und warten Sie, bis der Start der Instance abgeschlossen ist.
1. Fahren Sie nach dem Start der Instance mit dem nächsten Schritt fort.
------
### Verbinden Sie Ihre Instance mit dem AD
1.
**Connect zu Ihrer Instance her und treten Sie dem AD-Realm als bei`admin`.**
Führen Sie die folgenden Befehle aus, um eine Verbindung mit der Instanz herzustellen.
```
$ 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.
**Installieren Sie die erforderliche Software und treten Sie dem Realm bei.**
```
$ sudo yum -y install sssd realmd oddjob oddjob-mkhomedir adcli samba-common samba-common-tools krb5-workstation openldap-clients policycoreutils-python
```
1.
**Ersetzen Sie das Admin-Passwort durch Ihr `admin` Passwort.**
```
$ ADMIN_PW="asdfASDF1234"
```
```
$ echo $ADMIN_PW | sudo realm join -U Admin corp.example.com
Password for Admin:
```
Wenn der vorherige Vorgang erfolgreich war, sind Sie dem Realm beigetreten und können mit dem nächsten Schritt fortfahren.
### Fügen Sie Benutzer zum AD hinzu
1.
**Erstellen Sie den ReadOnlyUser und einen weiteren Benutzer.**
In diesem Schritt verwenden Sie die Tools [adcli](https://www.mankier.com/package/adcli) und [openldap-Clients](https://www.mankier.com/package/openldap-clients), die Sie in einem vorherigen Schritt installiert haben.
```
$ 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. **Stellen Sie sicher, dass die Benutzer erstellt wurden:**
Die Verzeichnis-DNS-IP-Adressen sind Ausgaben des Python-Skripts.
```
$ 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"
```
Wenn Sie einen Benutzer mit dem erstellen`ad-cli`, ist der Benutzer standardmäßig deaktiviert.
1.
****Setzen Sie die Benutzerkennwörter von Ihrem lokalen Computer aus zurück und aktivieren Sie sie:****
Melden Sie sich von Ihrer Amazon EC2 EC2-Instance ab.
**Anmerkung**
`ro-p@ssw0rd`ist das Passwort von`ReadOnlyUser`, abgerufen von AWS Secrets Manager.
`user-p@ssw0rd`ist das Passwort eines Cluster-Benutzers, das angegeben wird, wenn Sie eine Verbindung (`ssh`) mit dem Cluster herstellen.
Das `directory-id` ist eine Ausgabe des Python-Skripts.
```
$ 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. **Fügen Sie das Passwort zu einem Secrets Manager Manager-Geheimnis hinzu.**
Nachdem Sie nun ein Passwort erstellt `ReadOnlyUser` und festgelegt haben, speichern Sie es in einem geheimen Ordner, der für die Validierung von Anmeldungen AWS ParallelCluster verwendet wird.
Verwenden Sie Secrets Manager, um ein neues Geheimnis zu erstellen, das das Passwort für `ReadOnlyUser` als Wert enthält. Das geheime Wertformat darf nur Klartext sein (kein JSON-Format). Notieren Sie sich den geheimen ARN für future Schritte.
```
$ 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
```
### Einrichtung von LDAPS mit Zertifikatsverifizierung (empfohlen)
Notieren Sie sich die Ressource IDs. Sie verwenden sie später schrittweise.
1.
**Generieren Sie lokal ein Domänenzertifikat.**
```
$ 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.
**Speichern Sie das Zertifikat in Secrets Manager, damit es später innerhalb des Clusters abgerufen werden kann.**
```
$ 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. Fügen Sie der IAM-Rolle, die Sie erstellt haben, um die Amazon EC2 EC2-Instance der AD-Domain hinzuzufügen, die folgende Richtlinie hinzu.
`PutDomainCertificateSecrets`
```
{
"Statement": [
{
"Action": [
"secretsmanager:PutSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:region-id:123456789012:secret:example-cert-123abc"
],
"Effect": "Allow"
}
]
}
```
1.
**Importieren Sie das Zertifikat nach 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.
**Erstellen Sie und den Load Balancer, der vor den Active Directory-Endpunkten platziert wird.**
```
$ 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.
**Erstellen Sie die Zielgruppe, die auf die Active Directory-Endpunkte abzielt.**
```
$ 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.
**Registrieren Sie die Active Directory (AD) -Endpunkte in der Zielgruppe.**
```
$ 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.
**Erstellen Sie den LB-Listener mit dem Zertifikat.**
```
$ 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.
**Erstellen Sie die Hosting-Zone, damit die Domain innerhalb der Cluster-VPC auffindbar ist.**
```
$ 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.
**Erstellen Sie eine Datei, die `recordset-change.json` den folgenden Inhalt hat. `HostedZoneId`ist die kanonische Hosting-Zonen-ID des Load Balancers.**
```
{
"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.
**Sendet die Änderung der Datensatzgruppe an die Hosting-Zone, diesmal unter Verwendung der Hosting-Zonen-ID.**
```
$ aws route53 change-resource-record-sets --hosted-zone-id Z09020002B5MZQNXMSJUB \
--change-batch file://recordset-change.json
{
"ChangeInfo": {
"Id": "/change/C0137926I56R3GC7XW2Y",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T13:40:36.553000+00:00"
}
}
```
1.
**Erstellen Sie ein Richtliniendokument `policy.json` mit dem folgenden Inhalt.**
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": [
"secretsmanager:GetSecretValue"
],
"Resource": [
"arn:aws:secretsmanager:us-east-1:123456789012:secret:example-cert-abc123"
],
"Effect": "Allow"
}
]
}
```
------
1.
**Erstellen Sie ein Richtliniendokument, das `policy.json` den folgenden Inhalt hat.**
```
$ 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. Folgen Sie weiterhin den Schritten unter [(Optional) AD-Benutzer und -Gruppen verwalten](tutorials_05_multi-user-ad-step2.md) oder[Den Cluster erstellen](tutorials_05_multi-user-ad-step3.md).
# (Optional) AD-Benutzer und -Gruppen verwalten
In diesem Schritt verwalten Sie Benutzer und Gruppen von einer Amazon EC2 Amazon Linux 2-Instance aus, die mit der Active Delivery (AD) -Domain verbunden ist.
Wenn Sie dem *automatisierten* Pfad gefolgt sind, starten Sie die AD-Joint-Instance, die im Rahmen der Automatisierung erstellt wurde, neu und melden Sie sich bei ihr an.
Wenn Sie dem *manuellen* Pfad gefolgt sind, starten Sie die Instanz neu und melden Sie sich bei der Instanz an, die Sie in den vorherigen Schritten erstellt und dem AD hinzugefügt haben.
In diesen Schritten verwenden Sie die Tools [adcli](https://www.mankier.com/package/adcli) und [openldap-clients](https://www.mankier.com/package/openldap-clients), die im Rahmen eines vorherigen Schritts in der Instanz installiert wurden.
**Melden Sie sich bei einer Amazon EC2 EC2-Instance an, die mit der AD-Domain verbunden ist**
1. Wählen Sie in der Amazon EC2 EC2-Konsole die Amazon EC2 EC2-Instance ohne Titel aus, die in den vorherigen Schritten erstellt wurde. **Der Instance-Status könnte „Gestoppt“ lauten.**
1. Wenn der Instanzstatus **Gestoppt** lautet, wählen Sie **Instanzstatus** und dann **Instanz starten**.
1. Nachdem die Statusprüfungen bestanden wurden, wählen Sie die Instance aus und klicken Sie auf **Connect** and SSH in the instance.
**Benutzer und Gruppen verwalten, wenn Sie bei einer Amazon EC2 Amazon Linux 2-Instance angemeldet sind, die dem AD beigetreten ist**
Wenn Sie die `adcli` Befehle mit der ` -U "Admin"` Option ausführen, werden Sie aufgefordert, das `Admin` AD-Passwort einzugeben. Sie geben das `Admin` AD-Passwort als Teil der `ldapsearch` Befehle an.
1.
**Erstellen eines Benutzers.**
```
$ adcli create-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Legen Sie ein Benutzerkennwort fest.**
```
$ aws --region "region-id" ds reset-user-password --directory-id "d-abcdef01234567890" --user-name "clusteruser" --new-password "new-p@ssw0rd"
```
1.
**Erstellen Sie eine Gruppe.**
```
$ adcli create-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
1.
**Fügt einen Benutzer zu einer Gruppe hinzu.**
```
$ adcli add-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Beschreiben Sie Benutzer und Gruppen.**
Beschreiben Sie alle Benutzer.
```
$ 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"
```
Beschreiben Sie einen bestimmten Benutzer.
```
$ 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"
```
Beschreiben Sie alle Benutzer mit einem Namensmuster.
```
$ 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"
```
Beschreiben Sie alle Benutzer, die Teil einer bestimmten Gruppe sind.
```
$ 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"
```
Beschreiben Sie alle Gruppen
```
$ 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"
```
Beschreiben Sie eine bestimmte Gruppe
```
$ 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.
**Einen Benutzer aus einer Gruppe entfernen.**
```
$ adcli remove-member "clusterteam" "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Einen Benutzer löschen.**
```
$ adcli delete-user "clusteruser" --domain "corp.example.com" -U "Admin"
```
1.
**Löscht eine Gruppe.**
```
$ adcli delete-group "clusterteam" --domain "corp.example.com" -U "Admin"
```
# Den Cluster erstellen
Wenn Sie die Amazon EC2 EC2-Instance nicht verlassen haben, tun Sie dies jetzt.
Die Umgebung ist so eingerichtet, dass ein Cluster erstellt wird, der Benutzer anhand des Active Directory (AD) authentifizieren kann.
Erstellen Sie eine einfache Clusterkonfiguration und geben Sie die Einstellungen an, die für die Verbindung mit dem AD relevant sind. Weitere Informationen finden Sie im Abschnitt [`DirectoryService`](DirectoryService-v3.md).
Wählen Sie eine der folgenden Clusterkonfigurationen aus und kopieren Sie sie in eine Datei mit dem Namen`ldaps_config.yaml`,`ldaps_nocert_config.yaml`, oder`ldap_config.yaml`.
Wir empfehlen Ihnen, die LDAPS-Konfiguration mit Zertifikatüberprüfung zu wählen. Wenn Sie diese Konfiguration wählen, müssen Sie auch das Bootstrap-Skript in eine Datei mit dem Namen kopieren. `active-directory.head.post.sh` Und Sie müssen es in einem Amazon S3 S3-Bucket speichern, wie in der Konfigurationsdatei angegeben.
## LDAPS mit Konfiguration zur Zertifikatsverifizierung (empfohlen)
**Anmerkung**
`KeyName`: Eines Ihrer Amazon EC2 EC2-Schlüsselpaare.
`SubnetId / SubnetIds`: Eines der Subnetze, die in der Ausgabe des CloudFormation Quick Create Stacks (automatisiertes Tutorial) oder des Python-Skripts (manuelles Tutorial) IDs angegeben wurden.
`Region`: Die Region, in der Sie die AD-Infrastruktur erstellt haben.
`DomainAddr`: Diese IP-Adresse ist eine der DNS-Adressen Ihres AD-Dienstes.
`PasswordSecretArn`: Der Amazon-Ressourcenname (ARN) des Geheimnisses, das das Passwort für den enthält`DomainReadOnlyUser`.
`BucketName`: Der Name des Buckets, der das Bootstrap-Skript enthält.
`AdditionalPolicies`/`Policy`: Der Amazon-Ressourcenname (ARN) der gelesenen Domain-Zertifizierungsrichtlinie ReadCertExample.
`CustomActions`/`OnNodeConfigured`/`Args`: Der geheime Amazon-Ressourcenname (ARN), der die Domain-Zertifizierungsrichtlinie enthält.
Aus Sicherheitsgründen empfehlen wir, die `AllowedIps` Konfiguration`HeadNode`/`Ssh`/zu verwenden, um den SSH-Zugriff auf den Hauptknoten zu beschränken.
Beachten Sie, dass das in angegebene Zertifikat für alle Clusterknoten zugänglich sein `LdapTlsCaCert` muss.
**Harte Anforderungen**
Das in angegebene Zertifikat `LdapTlsCaCert` muss für alle Clusterknoten zugänglich sein.
Ein Knoten ohne Zugriff auf das Zertifikat kann Benutzer aus dem Verzeichnis nicht auflösen.
```
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
```
**Bootstrap-Skript**
Nachdem Sie die Bootstrap-Datei erstellt haben und bevor Sie sie in Ihren S3-Bucket hochladen, führen Sie den Befehl aus, `chmod +x active-directory.head.post.sh` um die Ausführungsberechtigung zu erteilen AWS ParallelCluster .
```
#!/bin/bash
set -e
CERTIFICATE_SECRET_ARN="$1"
CERTIFICATE_PATH="$2"
[[ -z $CERTIFICATE_SECRET_ARN ]] && echo "[ERROR] Missing CERTIFICATE_SECRET_ARN" && exit 1
[[ -z $CERTIFICATE_PATH ]] && echo "[ERROR] Missing CERTIFICATE_PATH" && exit 1
source /etc/parallelcluster/cfnconfig
REGION="${cfn_region:?}"
mkdir -p $(dirname $CERTIFICATE_PATH)
aws secretsmanager get-secret-value --region $REGION --secret-id $CERTIFICATE_SECRET_ARN --query SecretString --output text > $CERTIFICATE_PATH
```
## LDAPS ohne Konfiguration zur Zertifikatsverifizierung
**Anmerkung**
`KeyName`: Eines Ihrer Amazon EC2 EC2-Schlüsselpaare.
`SubnetId / SubnetIds`: Eines der Subnetze IDs , das in der Ausgabe des CloudFormation Quick Create Stacks (automatisiertes Tutorial) oder des Python-Skripts (manuelles Tutorial) enthalten ist.
`Region`: Die Region, in der Sie die AD-Infrastruktur erstellt haben.
`DomainAddr`: Diese IP-Adresse ist eine der DNS-Adressen Ihres AD-Dienstes.
`PasswordSecretArn`: Der Amazon-Ressourcenname (ARN) des Geheimnisses, das das Passwort für den enthält`DomainReadOnlyUser`.
Aus Sicherheitsgründen empfehlen wir, die AllowedIps Konfiguration HeadNode /Ssh/ zu verwenden, um den SSH-Zugriff auf den Hauptknoten zu beschränken.
```
Region: region-id
Image:
Os: alinux2
HeadNode:
InstanceType: t2.micro
Networking:
SubnetId: subnet-abcdef01234567890
Ssh:
KeyName: keypair
Scheduling:
Scheduler: slurm
SlurmQueues:
- Name: queue0
ComputeResources:
- Name: queue0-t2-micro
InstanceType: t2.micro
MinCount: 1
MaxCount: 10
Networking:
SubnetIds:
- subnet-abcdef01234567890
DirectoryService:
DomainName: corp.example.com
DomainAddr: ldaps://corp.example.com
PasswordSecretArn: arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234
DomainReadOnlyUser: cn=ReadOnlyUser,ou=Users,ou=CORP,dc=corp,dc=example,dc=com
LdapTlsReqCert: never
```
## LDAP-Konfiguration
**Anmerkung**
`KeyName`: Eines Ihrer Amazon EC2 EC2-Schlüsselpaare.
`SubnetId / SubnetIds`: Eines der Subnetze, die in der Ausgabe des CloudFormation Quick Create Stacks (automatisiertes Tutorial) oder des Python-Skripts (manuelles Tutorial) IDs angegeben wurden.
`Region`: Die Region, in der Sie die AD-Infrastruktur erstellt haben.
`DomainAddr`: Diese IP-Adresse ist eine der DNS-Adressen Ihres AD-Dienstes.
`PasswordSecretArn`: Der Amazon-Ressourcenname (ARN) des Geheimnisses, das das Passwort für den enthält`DomainReadOnlyUser`.
Aus Sicherheitsgründen empfehlen wir, die AllowedIps Konfiguration HeadNode /Ssh/ zu verwenden, um den SSH-Zugriff auf den Hauptknoten zu beschränken.
```
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
```
Erstellen Sie den Cluster mit dem folgenden Befehl.
```
$ 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"
}
}
```
# Stellen Sie als Benutzer eine Connect zum Cluster her
Sie können den Status des Clusters mit den folgenden Befehlen ermitteln.
```
$ pcluster describe-cluster -n ad-cluster --region "region-id" --query "clusterStatus"
```
Die Ausgabe sieht wie folgt aus.
```
"CREATE_IN_PROGRESS" / "CREATE_COMPLETE"
```
Wenn der Status erreicht ist`"CREATE_COMPLETE"`, melden Sie sich mit dem erstellten Benutzernamen und Passwort an.
```
$ HEAD_NODE_IP=$(pcluster describe-cluster -n "ad-cluster" --region "region-id" --query headNode.publicIpAddress | xargs echo)
```
```
$ ssh user000@$HEAD_NODE_IP
```
Sie können sich auch ohne das Passwort anmelden, indem Sie den SSH Schlüssel angeben, der für den neuen Benutzer unter erstellt wurde`/home/user000@HEAD_NODE_IP/.ssh/id_rsa`.
Wenn der `ssh` Befehl erfolgreich war, haben Sie als Benutzer, der für die Verwendung von Active Directory (AD) authentifiziert wurde, erfolgreich eine Verbindung zum Cluster hergestellt.
# Bereinigen
1.
**Löschen Sie den Cluster von Ihrem lokalen Computer.**
```
$ 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.
**Überprüfen Sie den Fortschritt beim Löschen des Clusters.**
```
$ pcluster describe-cluster --cluster-name "ad-cluster" --region "region-id" --query "clusterStatus"
"DELETE_IN_PROGRESS"
```
Nachdem der Cluster erfolgreich gelöscht wurde, fahren Sie mit dem nächsten Schritt fort.
## Automatisiert
**Löschen Sie die Active Directory-Ressourcen**
1. Von [https://console.aws.amazon.com/cloudformation/](https://console.aws.amazon.com/cloudformation/).
1. Klicken Sie im Navigationsbereich auf **Stacks**.
1. Wählen Sie aus der Liste der Stacks den AD-Stack aus (z. B.`pcluster-ad`).
1. Wählen Sie **Löschen** aus.
## Manuell
1.
**Löschen Sie die Amazon EC2 EC2-Instance.**
1. Wählen Sie im Navigationsbereich unter **Instances** aus. [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/)
1. Wählen Sie aus der Liste der Instanzen die Instanz aus, die Sie erstellt haben, um dem Verzeichnis Benutzer hinzuzufügen.
1. Wählen Sie **Instanzstatus** und anschließend **Instanz beenden aus**.
1.
**Löschen Sie die gehostete Zone.**
1. Erstellen Sie eine `recordset-delete.json` mit dem folgenden Inhalt. In diesem Beispiel HostedZoneId ist dies die kanonische Hosting-Zonen-ID des Load Balancers.
```
{
"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. Übermitteln Sie die Änderung der Datensatzgruppe mithilfe der Hosting-Zonen-ID an die gehostete Zone.
```
$ 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. Löschen Sie die gehostete Zone.
```
$ aws route53 delete-hosted-zone --id Z09020002B5MZQNXMSJUB
{
"ChangeInfo": {
"Id": "/change/C0468051QFABTVHMDEG9",
"Status": "PENDING",
"SubmittedAt": "2022-05-05T14:26:13.814000+00:00"
}
}
```
1.
**Löschen Sie den LB-Listener.**
```
$ aws elbv2 delete-listener \
--listener-arn arn:aws:elasticloadbalancing:region-id:123456789012:listener/net/CorpExampleCom-NLB/3afe296bf4ba80d4/a8f9d97318743d4b --region region-id
```
1.
**Löschen Sie die Zielgruppe.**
```
$ aws elbv2 delete-target-group \
--target-group-arn arn:aws:elasticloadbalancing:region-id:123456789012:targetgroup/CorpExampleCom-Targets/44577c583b695e81 --region region-id
```
1.
**Löschen Sie den Load Balancer.**
```
$ aws elbv2 delete-load-balancer \
--load-balancer-arn arn:aws:elasticloadbalancing:region-id:123456789012:loadbalancer/net/CorpExampleCom-NLB/3afe296bf4ba80d4 --region region-id
```
1.
**Löschen Sie die Richtlinie, die der Cluster verwendet, um das Zertifikat aus Secrets Manager zu lesen.**
```
$ aws iam delete-policy --policy-arn arn:aws:iam::123456789012:policy/ReadCertExample
```
1.
**Löschen Sie das Geheimnis, das das Domänenzertifikat enthält.**
```
$ 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.
**Löschen Sie das Zertifikat aus ACM.**
```
$ aws acm delete-certificate \
--certificate-arn arn:aws:acm:region-id:123456789012:certificate/343db133-490f-4077-b8d4-3da5bfd89e72 --region region-id
```
1.
**Löschen Sie die Active Directory-Ressourcen (AD).**
1. Rufen Sie die folgende Ressource IDs aus der Ausgabe des Python-Skripts ab`ad.py`:
+ UND ID
+ AD-Subnetz IDs
+ UND VPC-ID
1. Löschen Sie das Verzeichnis, indem Sie den folgenden Befehl ausführen.
```
$ aws ds delete-directory --directory-id d-abcdef0123456789 --region region-id
{
"DirectoryId": "d-abcdef0123456789"
}
```
1. Listet die Sicherheitsgruppen in der VPC auf.
```
$ aws ec2 describe-security-groups --filters '[{"Name":"vpc-id","Values":["vpc-07614ade95ebad1bc"]}]' --region region-id
```
1. Löschen Sie die benutzerdefinierte Sicherheitsgruppe.
```
$ aws ec2 delete-security-group --group-id sg-021345abcdef6789 --region region-id
```
1. Löschen Sie die Subnetze.
```
$ aws ec2 delete-subnet --subnet-id subnet-1234567890abcdef --region region-id
```
```
$ aws ec2 delete-subnet --subnet-id subnet-021345abcdef6789 --region region-id
```
1. Beschreiben Sie das Internet-Gateway.
```
$ 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. Trennen Sie das Internet-Gateway.
```
$ aws ec2 detach-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Löschen Sie das Internet-Gateway.
```
$ aws ec2 delete-internet-gateway \
--internet-gateway-id igw-1234567890abcdef \
--region region-id
```
1. Löschen Sie die VPC.
```
$ aws ec2 delete-vpc \
--vpc-id vpc-021345abcdef6789 \
--region region-id
```
1. Löschen Sie das Geheimnis, das das `ReadOnlyUser` Passwort enthält.
```
$ aws secretsmanager delete-secret \
--secret-id arn:aws:secretsmanager:region-id:123456789012:secret:ADSecretPassword-1234" \
--region region-id
```
# Konfiguration der Verschlüsselung von gemeinsam genutztem Speicher mit einem AWS KMS Schlüssel
Erfahren Sie, wie Sie einen vom Kunden verwalteten AWS KMS Schlüssel einrichten, um Ihre Daten in den Cluster-Dateispeichersystemen zu verschlüsseln und zu schützen, für die sie konfiguriert sind. AWS ParallelCluster
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
AWS ParallelCluster unterstützt die folgenden Konfigurationsoptionen für gemeinsam genutzten Speicher:
+ [`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)
Sie können diese Optionen verwenden, um einen vom Kunden verwalteten AWS KMS Schlüssel für Amazon EBS, Amazon EFS und FSx für die Verschlüsselung von Lustre-Shared-Storage-Systemen bereitzustellen. Um sie verwenden zu können, müssen Sie eine IAM-Richtlinie für Folgendes erstellen und konfigurieren:
+ [`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)
**Voraussetzungen**
+ AWS ParallelCluster [ist installiert](install-v3-parallelcluster.md).
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
**Topics**
+ [
# Erstellen der -Richtlinie
](creating-the-role-v3.md)
+ [
# Konfigurieren und erstellen Sie den Cluster
](creating-the-cluster-v3.md)
# Erstellen der -Richtlinie
In diesem Tutorial erstellen Sie eine Richtlinie für die Konfiguration der Verschlüsselung von gemeinsam genutztem Speicher mit einem AWS KMS Schlüssel.
**Erstellen Sie eine Richtlinie.**
1. Gehen Sie zur IAM-Konsole: [https://console.aws.amazon.com/iam/Home](https://console.aws.amazon.com/iam/home).
1. Wählen Sie **Policies (Richtlinien)**.
1. Wählen Sie **Richtlinie erstellen** aus.
1. Wählen Sie die Registerkarte **JSON** und fügen Sie die folgende Richtlinie ein. Stellen Sie sicher, dass Sie alle Vorkommen von `123456789012` durch Ihre AWS-Konto ID und den Schlüssel Amazon Resource Name (ARN) sowie AWS-Region durch Ihren eigenen ersetzen.
------
#### [ 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. Geben Sie der Richtlinie `ParallelClusterKmsPolicy` für dieses Tutorial einen Namen und wählen Sie dann **Create Policy** aus.
1. Notieren Sie sich den ARN der Richtlinie. Sie benötigen es, um Ihren Cluster zu konfigurieren.
# Konfigurieren und erstellen Sie den Cluster
Im Folgenden finden Sie ein Beispiel für eine Cluster-Konfiguration, die ein gemeinsam genutztes Amazon Elastic Block Store-Dateisystem mit Verschlüsselung umfasst.
```
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
```
Ersetzen Sie die Elemente in rotem Text durch Ihre eigenen Werte. Erstellen Sie anschließend einen Cluster, der Ihren AWS KMS Schlüssel verwendet, um Ihre Daten in Amazon EBS zu verschlüsseln.
Die Konfiguration ist für Amazon EFS- und FSx Lustre-Dateisysteme ähnlich.
Die Amazon `SharedStorage` EFS-Konfiguration sieht wie folgt aus.
```
...
SharedStorage:
- MountDir: /shared/efs1
Name: shared-efs1
StorageType: Efs
EfsSettings:
Encrypted: True
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
Die `SharedStorage` Konfiguration von FSx for Lustre sieht wie folgt aus.
```
...
SharedStorage:
- MountDir: /shared/fsx1
Name: shared-fsx1
StorageType: FsxLustre
FsxLustreSettings:
StorageCapacity: 1200
DeploymentType: PERSISTENT_1
PerUnitStorageThroughput: 200
KmsKeyId: abcd1234-ef56-gh78-ij90-abcd1234efgh5678
```
# Ausführung von Jobs in einem Cluster mit mehreren Warteschlangen
In diesem Tutorial erfahren Sie, wie Sie Ihren ersten "Hello World" Job im [Modus AWS ParallelCluster mit mehreren Warteschlangen](configuration-of-multiple-queues-v3.md) ausführen.
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen**
+ AWS ParallelCluster [ist installiert](install-v3-parallelcluster.md).
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
## Konfigurieren Sie Ihren Cluster
Stellen Sie zunächst sicher, dass die Installation korrekt AWS ParallelCluster ist, indem Sie den folgenden Befehl ausführen.
```
$ pcluster version
```
Mehr über `pcluster version` erfahren Sie unter [`pcluster version`](pcluster.version-v3.md).
Dieser Befehl gibt die laufende Version von zurück AWS ParallelCluster.
Führen Sie als Nächstes den Befehl aus, `pcluster configure` um eine grundlegende Konfigurationsdatei zu generieren. Folgen Sie allen Anweisungen, die diesem Befehl folgen.
```
$ pcluster configure --config multi-queue-mode.yaml
```
Weitere Informationen zum Befehl `pcluster configure` finden Sie unter [`pcluster configure`](pcluster.configure-v3.md).
Nachdem Sie diesen Schritt abgeschlossen haben, wird eine grundlegende Konfigurationsdatei mit dem Namen `multi-queue-mode.yaml` angezeigt. Diese Datei enthält eine grundlegende Clusterkonfiguration.
Im nächsten Schritt ändern Sie Ihre neue Konfigurationsdatei und starten einen Cluster mit mehreren Warteschlangen.
**Anmerkung**
Für einige Instanzen, die in diesem Tutorial verwendet werden, gilt das kostenlose Kontingent nicht.
Ändern Sie für dieses Tutorial Ihre Konfigurationsdatei so, dass sie der folgenden Konfiguration entspricht. Die rot hervorgehobenen Elemente stellen die Werte Ihrer Konfigurationsdatei dar. Behalten Sie Ihre eigenen Werte bei.
```
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
```
## Erstellen Ihres -Clusters
Erstellen Sie einen Cluster, der auf der `multi-queue-cluster` Grundlage Ihrer Konfigurationsdatei benannt ist.
```
$ 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"
}
}
```
Weitere Informationen zum Befehl `pcluster create-cluster` finden Sie unter [`pcluster create-cluster`](pcluster.create-cluster-v3.md).
Führen Sie den folgenden Befehl aus, um den Status des Clusters zu überprüfen.
```
$ 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"
}
}
```
Wenn der Cluster erstellt wurde, wird das `clusterStatus` Feld angezeigt`CREATE_COMPLETE`.
## Melden Sie sich beim Hauptknoten an
Verwenden Sie Ihre private SSH-Schlüsseldatei, um sich beim Hauptknoten anzumelden.
```
$ pcluster ssh --cluster-name multi-queue-cluster -i ~/path/to/yourkeyfile.pem
```
Mehr über `pcluster ssh` erfahren Sie unter [`pcluster ssh`](pcluster.ssh-v3.md).
Führen Sie nach der Anmeldung den `sinfo` Befehl aus, um zu überprüfen, ob Ihre Scheduler-Warteschlangen eingerichtet und konfiguriert sind.
*Weitere Informationen zu `sinfo` finden Sie unter [sinfo in der Dokumentation](https://slurm.schedmd.com/sinfo.html). Slurm*
```
$ sinfo
PARTITION AVAIL TIMELIMIT NODES STATE NODELIST
spot* up infinite 18 idle~ spot-dy-c5xlarge-[1-9],spot-dy-t2micro-[1-9]
spot* up infinite 2 idle spot-st-c5xlarge-1,spot-st-t2micro-1
ondemand up infinite 10 idle~ ondemand-dy-c52xlarge-[1-10]
```
Die Ausgabe zeigt, dass Sie einen `t2.micro` und einen `c5.xlarge` Rechenknoten in dem `idle` Status haben, die in Ihrem Cluster verfügbar sind.
Andere Knoten befinden sich alle im Stromsparmodus, was durch das `~` Suffix im Knotenstatus gekennzeichnet ist, ohne dass sie von Amazon EC2 EC2-Instances unterstützt werden. Die Standardwarteschlange wird durch ein `*` Suffix hinter ihrem Warteschlangennamen angezeigt. `spot`ist Ihre Standard-Jobwarteschlange.
## Job im Modus mit mehreren Warteschlangen ausführen
Versuchen Sie als Nächstes, einen Job für eine Weile im Ruhezustand auszuführen. Der Job gibt später seinen eigenen Hostnamen aus. Stellen Sie sicher, dass dieses Skript vom aktuellen Benutzer ausgeführt werden kann.
```
$ tee <
In diesem Tutorial erstellen und testen Sie die API mit [Amazon API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html) und einer AWS ParallelCluster CloudFormation Vorlage. Anschließend verwenden Sie den Beispielclient, der auf verfügbar ist GitHub , um die API zu verwenden. Weitere Informationen zur Verwendung der API finden Sie unter [AWS ParallelCluster API](api-reference-v3.md).
Weitere Informationen finden Sie unter [Erstellen einer benutzerdefinierten Komponente mit Image Builder](https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-component.html) im *EC2 Image Builder Builder-Benutzerhandbuch*.
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen**
+ Das AWS CLI ist in Ihrer Computerumgebung [installiert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html) und konfiguriert.
+ AWS ParallelCluster ist in einer virtuellen Umgebung installiert. Weitere Informationen finden Sie unter [Installation AWS ParallelCluster in einer virtuellen Umgebung (empfohlen)](install-v3-virtual-environment.md).
+ Sie haben ein [ EC2 Amazon-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
## Schritt 1: Erstellen Sie die API mit Amazon API Gateway
**Bleiben Sie in Ihrem privaten Benutzerverzeichnis und aktivieren Sie Ihre virtuelle Umgebung:**
1. Installieren Sie einen hilfreichen JSON-Befehlszeilenprozessor.
```
$ sudo yum groupinstall -y "Development Tools"
sudo yum install -y jq python3-devel
```
1. Führen Sie den folgenden Befehl aus, um Ihre AWS ParallelCluster Version abzurufen und sie einer Umgebungsvariablen zuzuweisen.
```
$ PCLUSTER_VERSION=$(pcluster version | jq -r '.version')
echo "export PCLUSTER_VERSION=${PCLUSTER_VERSION}" |tee -a ~/.bashrc
```
1. Erstellen Sie eine Umgebungsvariable und weisen Sie ihr Ihre Region-ID zu.
```
$ export AWS_DEFAULT_REGION="us-east-1"
echo "export AWS_DEFAULT_REGION=${AWS_DEFAULT_REGION}" |tee -a ~/.bashrc
```
1. Führen Sie die folgenden Befehle aus, um die API bereitzustellen.
```
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"
}
```
Fahren Sie nach Abschluss des Vorgangs mit dem nächsten Schritt fort.
## Schritt 2: Testen Sie die API in der Amazon API Gateway Gateway-Konsole
1. Melden Sie sich bei der an AWS-Managementkonsole.
1. Navigieren Sie zur [Amazon API Gateway-Konsole](https://console.aws.amazon.com/apigateway/home).
1. Wählen Sie Ihre API-Bereitstellung.
![\[Amazon API Gateway Gateway-Konsole mit einer Liste Ihrer Gateways, aus denen Sie wählen können.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/gateway_choose.png)
1. Wählen Sie **Stufen** und wählen Sie eine Phase aus.
![\[Eine Konsolenansicht der Stufen, aus denen Sie wählen können. Sie können auch die URL anzeigen, die API Gateway für Ihre API bereitstellt.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/gateway_address.png)
1. Notieren Sie sich die URL, die API Gateway für den Zugriff auf oder den Aufruf Ihrer API bereitstellt. Sie ist blau hervorgehoben.
1. Wählen Sie **Ressourcen** und dann **`GET`**unter **`/clusters`**.
1. Wählen Sie das **TEST-Symbol**, scrollen Sie dann nach unten und wählen Sie das **TEST-Symbol**.
![\[Eine Konsolenansicht der API-Ressourcen und Testmechanismen.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/gateway_test.png)
Die Antwort auf Ihre `/clusters GET` wird angezeigt.
![\[Eine Konsolenansicht der API-Ressourcen, Testmechanismen und der Antwort auf Ihre Testanfrage.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/gateway.png)
## Schritt 3: Bereiten Sie einen Beispielclient vor und testen Sie ihn, um die API aufzurufen
Klonen Sie den AWS ParallelCluster Quellcode `cd` in das `api` Verzeichnis und installieren Sie die Python-Clientbibliotheken.
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. Navigieren Sie zurück zu Ihrem Home-Benutzerverzeichnis.
1. Exportieren Sie die API Gateway Gateway-Basis-URL, die der Client bei der Ausführung verwendet.
```
$ 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. Exportieren Sie einen Clusternamen, den der Client verwendet, um einen Cluster zu erstellen.
```
$ export CLUSTER_NAME="test-api-cluster"
echo "export CLUSTER_NAME=${CLUSTER_NAME}" |tee -a ~/.bashrc
```
1. Führen Sie die folgenden Befehle aus, um die Anmeldeinformationen zu speichern, die der Beispielclient für den Zugriff auf die API verwendet.
```
$ 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
```
## Schritt 4: Kopieren Sie das Client-Codeskript und führen Sie Clustertests aus
1. Kopieren Sie den folgenden Beispiel-Clientcode `test_pcluster_client.py` in Ihr Home-Benutzerverzeichnis. Der Client-Code fordert Folgendes auf:
+ Erstellen Sie den -Cluster.
+ Beschreiben Sie den Cluster.
+ Listet die Cluster auf.
+ Beschreiben Sie die Rechenflotte.
+ Beschreiben Sie die Cluster-Instanzen.
```
# 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. Erstellen Sie eine Clusterkonfiguration.
```
$ pcluster configure --config cluster-config.yaml
```
1. Die API-Clientbibliothek erkennt automatisch Konfigurationsdetails aus Ihren Umgebungsvariablen (z. B.`AWS_ACCESS_KEY_ID`,`AWS_SECRET_ACCESS_KEY`, oder`AWS_SESSION_TOKEN`) oder`$HOME/.aws`. Mit dem folgenden Befehl wird Ihre aktuelle IAM-Rolle auf die angegebene ParallelClusterApiUserRole umgestellt.
```
$ 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"')
```
**Fehler, auf den Sie achten sollten:**
Wenn Sie einen Fehler wie den folgenden sehen, haben Sie bereits davon ausgegangen, dass der ParallelClusterApiUserRole `AWS_SESSION_TOKEN` abgelaufen ist.
```
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
```
Löschen Sie die Rolle und führen Sie dann den `aws sts assume-role` Befehl erneut aus, um die ParallelClusterApiUserRole zu verwenden.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
Um Ihren aktuellen Benutzerberechtigungen für den API-Zugriff zu gewähren, müssen Sie [die Ressourcenrichtlinie erweitern](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-resource-policies.html).
1. Führen Sie den folgenden Befehl aus, um den Beispielclient zu testen.
```
$ 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!
```
## Schritt 5: Kopieren Sie das Client-Codeskript und löschen Sie den Cluster
1. Kopieren Sie den folgenden Beispiel-Clientcode in`delete_cluster_client.py`. Der Client-Code fordert das Löschen des Clusters an.
```
# 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. Führen Sie den folgenden Befehl aus, um den Cluster zu löschen.
```
$ 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. Wenn Sie mit dem Testen fertig sind, deaktivieren Sie die Umgebungsvariablen.
```
$ unset AWS_SESSION_TOKEN
unset AWS_SECRET_ACCESS_KEY
unset AWS_ACCESS_KEY_ID
```
## Schritt 6: Bereinigen
Sie können das AWS-Managementkonsole oder verwenden AWS CLI , um Ihre API zu löschen.
1. Wählen Sie in der CloudFormation Konsole den API-Stack und dann **Löschen** aus.
1. Führen Sie den folgenden Befehl aus, wenn Sie den verwenden AWS CLI.
Verwenden von CloudFormation.
```
$ aws cloudformation delete-stack --stack-name ${API_STACK_NAME}
```
# Einen Cluster erstellen mit Slurm Buchhaltung
Erfahren Sie, wie Sie einen Cluster konfigurieren und erstellen mit Slurm Buchhaltung. Weitere Informationen finden Sie unter [SlurmAbrechnung mit AWS ParallelCluster](slurm-accounting-v3.md).
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
In diesem Tutorial verwenden Sie eine [CloudFormation Schnellerstellungsvorlage (us-east-1)](https://us-east-1.console.aws.amazon.com/cloudformation/home?region=us-east-1#/stacks/create/review?stackName=pcluster-slurm-db&templateURL=https://us-east-1-aws-parallelcluster.s3.amazonaws.com/templates/1-click/serverless-database.yaml), um eine serverlose Datenbank [Amazon Aurora](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/CHAP_AuroraOverview.html)für MySQL zu erstellen. Die Vorlage weist CloudFormation an, alle erforderlichen Komponenten für die Bereitstellung einer Amazon Aurora serverlosen Datenbank auf derselben VPC wie der Cluster zu erstellen. Die Vorlage erstellt auch eine grundlegende Netzwerk- und Sicherheitskonfiguration für die Verbindung zwischen dem Cluster und der Datenbank.
**Anmerkung**
Ab Version 3.3.0 unterstützt AWS ParallelCluster Slurm Abrechnung mit dem Cluster-Konfigurationsparameter [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//[Database](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database).
**Anmerkung**
Die Vorlage für die Schnellerstellung dient als Beispiel. Diese Vorlage deckt nicht alle möglichen Anwendungsfälle für a ab Slurm Buchhaltungsdatenbankserver. Es liegt in Ihrer Verantwortung, einen Datenbankserver mit der Konfiguration und Kapazität zu erstellen, die für Ihre Produktionsworkloads geeignet sind.
**Voraussetzungen:**
+ AWS ParallelCluster [ist installiert](install-v3-parallelcluster.md).
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [ EC2 Amazon-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine IAM-Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
+ Die Region, in der Sie die Schnellerstellungsvorlage bereitstellen, unterstützt Amazon Aurora MySQL Serverless v2. Weitere Informationen finden Sie unter [Aurora Serverless v2 mit Aurora MySQL](https://docs.aws.amazon.com/AmazonRDS/latest/AuroraUserGuide/Concepts.Aurora_Fea_Regions_DB-eng.Feature.ServerlessV2.html#Concepts.Aurora_Fea_Regions_DB-eng.Feature.ServerlessV2.amy).
## Schritt 1: Erstellen Sie die VPC und die Subnetze für AWS ParallelCluster
Um die bereitgestellte CloudFormation Vorlage zu verwenden für Slurm Accounting-Datenbank, Sie müssen die VPC für den Cluster bereit haben. Sie können dies manuell oder als Teil des [Konfigurieren und erstellen Sie einen Cluster mit der Befehlszeilenschnittstelle AWS ParallelCluster](install-v3-configuring.md) Verfahrens tun. Wenn Sie es bereits verwendet haben AWS ParallelCluster, haben Sie möglicherweise eine VPC für die Bereitstellung des Clusters und des Datenbankservers bereit.
## Schritt 2: Erstellen Sie den Datenbank-Stack
Verwenden Sie die [CloudFormation Schnellerstellungsvorlage (us-east-1), um einen Datenbank-Stack](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) für zu erstellen Slurm Buchhaltung. Die Vorlage erfordert folgende Eingaben:
+ Anmeldeinformationen für den Datenbankserver, insbesondere den Admin-Benutzernamen und das Passwort.
+ Größe des Amazon Aurora serverlosen Clusters. Dies hängt von der erwarteten Clusterbelastung ab.
+ Netzwerkparameter, insbesondere die Ziel-VPC und die Subnetze oder CIDR-Blöcke für die Erstellung der Subnetze.
Wählen Sie die entsprechenden Anmeldeinformationen und die Größe für Ihren Datenbankserver aus. Für die Netzwerkoptionen müssen Sie dieselbe VPC verwenden, auf der der AWS ParallelCluster Cluster bereitgestellt wird. Sie können die Subnetze für die Datenbank erstellen und sie als Eingabe an die Vorlage übergeben. Oder stellen Sie zwei unzusammenhängende CIDR-Blöcke für die beiden Subnetze bereit und lassen Sie die CloudFormation Vorlage die beiden Subnetze für CIDR-Blöcke erstellen. Stellen Sie sicher, dass sich die CIDR-Blöcke nicht mit vorhandenen Subnetzen überschneiden. Wenn sich die CIDR-Blöcke mit vorhandenen Subnetzen überschneiden, kann der Stapel nicht erstellt werden.
Die Erstellung des Datenbankservers dauert mehrere Minuten.
## Schritt 3: Erstellen Sie einen Cluster mit Slurm Buchhaltung aktiviert
Die bereitgestellte CloudFormation Vorlage generiert einen CloudFormation Stapel mit einigen definierten Ausgaben. Von der AWS-Managementkonsole aus können Sie die Ausgaben auf der Registerkarte **Ausgaben** in der CloudFormation Stapelansicht anzeigen. Um das zu aktivieren Slurm Bei der Abrechnung müssen einige dieser Ausgaben in der AWS ParallelCluster Cluster-Konfigurationsdatei verwendet werden:
+ `DatabaseHost`: Wird für den [`Uri`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-Uri)Cluster-Konfigurationsparameter [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//verwendet.
+ `DatabaseAdminUser`: Wird für den [`UserName`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-UserName)Cluster-Konfigurationsparameterwert [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//verwendet.
+ `DatabaseSecretArn`: Wird für den [`PasswordSecretArn`](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-Database-PasswordSecretArn)Cluster-Konfigurationsparameter [`SlurmSettings`[`Database`](Scheduling-v3.md#Scheduling-v3-SlurmSettings-Database)](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//verwendet.
+ `DatabaseClientSecurityGroup`: Dies ist die Sicherheitsgruppe, die an den Hauptknoten des Clusters angehängt ist, der im [`SecurityGroups`](HeadNode-v3.md#yaml-HeadNode-Networking-SecurityGroups)Konfigurationsparameter [`HeadNode`](HeadNode-v3.md)/[`Networking`](HeadNode-v3.md#HeadNode-v3-Networking)/definiert ist.
Aktualisieren Sie die `Database` Parameter Ihrer Cluster-Konfigurationsdatei mit den Ausgabewerten. Verwenden Sie die [`pcluster`](pcluster-v3.md) CLI, um den Cluster zu erstellen.
```
$ pcluster create-cluster -n cluster-3.x -c path/to/cluster-config.yaml
```
Nachdem der Cluster erstellt wurde, können Sie mit der Verwendung beginnen Slurm Buchhaltungsbefehle wie `sacctmgr` oder`sacct`.
# Erstellen eines Clusters mit einem externen Slurmdbd Buchhaltung
Erfahren Sie, wie Sie einen Cluster mit externen Komponenten konfigurieren und erstellen Slurmdbd Buchhaltung. Weitere Informationen finden Sie unter [.Slurm Buchhaltung mit AWS ParallelCluster](slurm-accounting-v3.md).
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste, die von verwendet werden AWS ParallelCluster](aws-services-v3.md).
Die AWS ParallelCluster Benutzeroberfläche basiert auf einer serverlosen Architektur und Sie können sie innerhalb der AWS Free Tier Kategorie für die meisten Fälle. Weitere Informationen finden Sie unter [AWS ParallelCluster UI-Kosten](install-pcui-costs-v3.md).
In diesem Tutorial verwenden Sie eine AWS CloudFormation Schnellerstellungsvorlage, um die erforderlichen Komponenten für die Bereitstellung einer Slurmdbd-Instanz auf derselben VPC wie der Cluster zu erstellen. Die Vorlage erstellt eine grundlegende Netzwerk- und Sicherheitskonfiguration für die Verbindung zwischen dem Cluster und der Datenbank.
**Anmerkung**
Beginnend mit`version 3.10.0`, AWS ParallelCluster unterstützt externes Slurmdbd mit dem Cluster-Konfigurationsparameter. `SlurmSettings / ExternelSlurmdbd`
**Anmerkung**
Die Vorlage für die Schnellerstellung dient als Beispiel. Diese Vorlage deckt nicht alle möglichen Anwendungsfälle ab. Es liegt in Ihrer Verantwortung, eine externe Slurmdbd mit der Konfiguration und Kapazität zu erstellen, die für Ihre Produktionsworkloads geeignet sind.
**Voraussetzungen:**
+ AWS ParallelCluster [ist](install-v3-parallelcluster.md) installiert.
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Sie haben ein [Amazon Elastic Compute Cloud-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Sie haben eine AWS Identity and Access Management Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
+ Sie haben eine Slurm Buchhaltungsdatenbank. Um ein Tutorial zum Erstellen Schritt für Schritt durchzugehen Slurm Folgen Sie den Schritten 1 und 2 unter [Erstellen Sie den Slurm-Buchhaltungsdatenbank-Stack](tutorials_07_slurm-accounting-v3.md).
## Schritt 1: Erstellen Sie den Slurmdbd-Stack
Verwenden Sie in diesem Tutorial eine [CloudFormation Schnellerstellungsvorlage (`us-east-1`), um einen Slurmdbd-Stack zu erstellen](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). Die Vorlage erfordert folgende Eingaben:
**Netzwerk**
+ **VPCId**: Die VPC-ID zum Starten der Slurmdbd-Instanz.
+ **SubnetId**: Die Subnetz-ID zum Starten der Slurmdbd-Instanz.
+ **PrivatePrefix**: Das CIDR-Präfix der VPC.
+ **PrivateIp**: Eine sekundäre private IP, die der Slurmdbd-Instanz zugewiesen werden soll.
**Datenbankverbindungen**
+ **DBMSClientSG**: Die Sicherheitsgruppe, die an die Slurmdbd-Instanz angehängt werden soll. Diese Sicherheitsgruppe sollte Verbindungen zwischen dem Datenbankserver und der Slurmdbd-Instanz ermöglichen.
+ **DBMSDatabaseName**: Der Name der Datenbank.
+ **DBMSUsername**: Der Benutzername der Datenbank.
+ **DBMSPasswordSecretArn**: Das Geheimnis, das das Passwort für die Datenbank enthält.
+ **DBMSUri**: Die URI des Datenbankservers.
**Instance-Einstellungen**
+ **InstanceType**: Ein Instanztyp, der für die slurmdbd-Instanz verwendet werden soll.
+ **KeyName**: Ein EC2 Amazon-Schlüsselpaar, das für die Slurmdbd-Instance verwendet werden soll.
**Slurmdbd-Einstellungen**
+ **AMIID**: Ein AMI der Slurmdbd-Instanz. Das AMI sollte ein ParallelCluster AMI sein. Die Version des ParallelCluster AMI bestimmt die Version von Slurmdbd.
+ **MungeKeySecretArn**: Das Geheimnis, das den Munge-Schlüssel enthält, der für die Authentifizierung der Kommunikation zwischen Slurmdbd und Clustern verwendet wird.
+ **SlurmdbdPort**: Eine Portnummer, die die Slurmdbd verwendet.
+ **EnableSlurmdbdSystemService**: Aktiviert slurmdbd als Systemdienst und lässt ihn ausführen, wenn eine Instanz gestartet wird.
**Warnung**
Wenn die Datenbank mit einer anderen Version von erstellt wurde SlurmDB, verwende nicht Slurmdbd als Systemdienst.
Wenn die Datenbank eine große Anzahl von Einträgen enthält, Slurm Database Daemon (SlurmDBD) Die Aktualisierung der Datenbank kann mehrere zehn Minuten in Anspruch nehmen und reagiert während dieses Zeitintervalls nicht.
Vor dem Upgrade SlurmDB, erstellen Sie eine Sicherungskopie der Datenbank. Weitere Informationen finden Sie hier: [Slurm Dokumentation](https://slurm.schedmd.com/quickstart_admin.html#upgrade).
## Schritt 2: Erstellen Sie einen Cluster mit externen Slurmdbd aktiviert
Die bereitgestellte CloudFormation Vorlage generiert einen CloudFormation Stapel mit einigen definierten Ausgaben.
Rufen Sie von der aus die Registerkarte **Ausgaben** im CloudFormation Stapel auf AWS-Managementkonsole, um die erstellten Entitäten zu überprüfen. Um das zu aktivieren Slurm Bei der Buchhaltung müssen einige dieser Ausgaben in der AWS ParallelCluster Konfigurationsdatei verwendet werden:
+ **SlurmdbdPrivateIp**: Wird für den [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/[ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)/[Hostcluster-Konfigurationsparameter](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Host) verwendet.
+ **SlurmdbdPort**: Wird für den Wert des [ ExternalSlurmdbd](Scheduling-v3.md#Scheduling-v3-SlurmSettings-ExternalSlurmdbd)[Cluster-Konfigurationsparameters [ SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)//Port](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-ExternalSlurmdbd-Port) verwendet.
+ **AccountingClientSecurityGroup**[: Dies ist die Sicherheitsgruppe, die an den Hauptknoten des Clusters angehängt ist, der im Konfigurationsparameter/Networking [HeadNode](HeadNode-v3.md)/definiert ist. [AdditionalSecurityGroups](HeadNode-v3.md#yaml-HeadNode-Networking-AdditionalSecurityGroups)](HeadNode-v3.md#HeadNode-v3-Networking)
Zusätzlich können Sie auf der Registerkarte „**Parameter“ in der Stack-Ansicht Folgendes** tun: CloudFormation
+ **MungeKeySecretArn**: Wird für den [MungeKeySecretArn](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-MungeKeySecretArn)Cluster-Konfigurationsparameterwert [SlurmSettings](Scheduling-v3.md#Scheduling-v3-SlurmSettings)/verwendet.
Aktualisieren Sie die Datenbankparameter Ihrer Cluster-Konfigurationsdatei mit den Ausgabewerten. Verwenden Sie den pcluster, um den Cluster AWS CLI zu erstellen.
```
$ pcluster create-cluster -n cluster-3.x-c path/to/cluster-config.yaml
```
Nachdem der Cluster erstellt wurde, können Sie mit der Verwendung beginnen Slurm Buchhaltungsbefehle wie `sacctmgr` oder`sacct`.
**Warnung**
Verkehr zwischen `ParallelCluster` und nach außen SlurmDB ist nicht verschlüsselt. Es wird empfohlen, den Cluster und den externen SlurmDB in einem vertrauenswürdigen Netzwerk.
# Zu einer früheren AWS Systems Manager Manager-Dokumentversion zurückkehren
Erfahren Sie, wie Sie zu einer früheren AWS Systems Manager Manager-Dokumentversion zurückkehren können. Weitere Informationen zu SSM-Dokumenten finden Sie unter [AWS Systems Manager Manager-Dokumente](https://docs.aws.amazon.com/systems-manager/latest/userguide/sysman-ssm-docs.html) im *AWS Systems Manager Manager-Benutzerhandbuch*.
Wenn Sie die AWS ParallelCluster Befehlszeilenschnittstelle (CLI) oder API verwenden, zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen:**
+ Und AWS-Konto mit Berechtigungen zur Verwaltung von SSM-Dokumenten.
+ Das AWS CLI [ist installiert und konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
## Kehren Sie zu einer früheren SSM-Dokumentversion zurück
1. Führen Sie in Ihrem Terminal den folgenden Befehl aus, um die Liste der vorhandenen SSM-Dokumente abzurufen, die Sie besitzen.
```
$ aws ssm list-documents --document-filter "key=Owner,value=Self"
```
1. Stellen Sie ein SSM-Dokument auf eine frühere Version zurück. In diesem Beispiel kehren wir zu einer früheren Version des Dokuments zurück. `SessionManagerRunShell` Sie können das `SessionManagerRunShell` SSM-Dokument verwenden, um jede SSM-Shell-Sitzung, die Sie initiieren, anzupassen.
1. Suchen Sie den `DocumentVersion` Parameter für, `SessionManagerRunShell` indem Sie den folgenden Befehl ausführen:
```
$ 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": []
}
}
```
Die neueste Version ist `2`.
1. Kehren Sie zur vorherigen Version zurück, indem Sie den folgenden Befehl ausführen:
```
$ aws ssm delete-document --name "SSM-SessionManagerRunShell" --document-version 2
```
1. Stellen Sie sicher, dass die Dokumentversion wiederhergestellt wurde, indem Sie den `describe-document` Befehl erneut ausführen:
```
$ 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": []
}
}
```
Die neueste Version ist `1`.
# Einen Cluster erstellen mit CloudFormation
Erfahren Sie, wie Sie einen Cluster mit einer AWS ParallelCluster CloudFormation benutzerdefinierten Ressource erstellen. Weitere Informationen finden Sie unter [AWS CloudFormation benutzerdefinierte Ressource](cloudformation-v3.md).
Bei der Nutzung AWS ParallelCluster zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen:**
+ Das AWS CLI [ist installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html).
+ Eine IAM-Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
## Clustererstellung mit einem CloudFormation Schnellerstellungsstapel
In diesem Tutorial verwenden Sie einen Schnellerstellungsstapel, um eine CloudFormation Vorlage bereitzustellen, die einen Cluster und die folgenden Ressourcen erstellt: AWS
+ Ein CloudFormation Root-Stack, der mithilfe eines CloudFormation Schnellerstellungsstapels erstellt wurde.
+ Verschachtelte CloudFormation Stacks, die Standardrichtlinien, eine Standard-VPC-Einrichtung und einen benutzerdefinierten Ressourcenanbieter enthalten.
+ Ein Beispiel für einen AWS ParallelCluster Cluster-Stack und einen Cluster, bei dem Sie sich anmelden und Jobs ausführen können.
**Erstellen Sie einen Cluster mit AWS CloudFormation**
1. Melden Sie sich bei der an AWS-Managementkonsole.
1. Öffnen Sie den [Link zur CloudFormation Schnellerstellung](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), um die folgenden Ressourcen in der CloudFormation Konsole zu erstellen:
+ Ein verschachtelter CloudFormation Stack mit einer VPC mit einem öffentlichen und einem privaten Subnetz für den Betrieb des Cluster-Kopfknotens bzw. der Rechenknoten.
+ Ein verschachtelter CloudFormation Stack mit einer AWS ParallelCluster benutzerdefinierten Ressource für die Verwaltung des Clusters.
+ Ein verschachtelter CloudFormation Stack mit den Standardrichtlinien für die Verwaltung des Clusters.
+ Ein CloudFormation Root-Stack für die verschachtelten Stacks.
+ Ein AWS ParallelCluster Cluster mit dem Slurm Scheduler und einer definierten Anzahl von Rechenknoten.
![\[Die CloudFormation schnell zu erstellende Benutzeroberfläche der Konsole.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/cfn-quick-create.png)
1. Geben Sie im Abschnitt ****Stack-Parameter** für die Schnellerstellung** Werte für die folgenden Parameter ein:
1. Geben Sie für **KeyName**den Namen Ihres Amazon EC2 EC2-Schlüsselpaars key pair.
1. Wählen Sie für **AvailabilityZone**eine AZ für Ihre Clusterknoten, zum Beispiel. `us-east-1a`
1. Markieren Sie die Kästchen, um die einzelnen Zugriffsmöglichkeiten unten auf der Seite zu bestätigen.
1. Wählen Sie **Stack erstellen** aus.
1. Warten Sie, bis der CloudFormation Stack den `CREATE_COMPLETE` Status erreicht hat.
## Clustererstellung mit der CloudFormation Befehlszeilenschnittstelle (CLI)
In diesem Tutorial verwenden Sie die AWS Befehlszeilenschnittstelle (CLI) CloudFormation , um eine CloudFormation Vorlage bereitzustellen, die einen Cluster erstellt.
**Erstellen Sie die folgenden AWS Ressourcen:**
+ Ein CloudFormation Root-Stack, der mithilfe eines CloudFormation Schnellerstellungsstapels erstellt wurde.
+ Verschachtelte CloudFormation Stacks, die Standardrichtlinien, Standard-VPC-Setup und einen benutzerdefinierten Ressourcenanbieter enthalten.
+ Ein Beispiel für einen AWS ParallelCluster Cluster-Stack und einen Cluster, bei dem Sie sich anmelden und Jobs ausführen können.
Ersetzen Sie *inputs highlighted in red* z. *keypair* B. durch Ihre eigenen Werte.
**Erstellen Sie einen Cluster mit AWS CloudFormation**
1. Erstellen Sie eine CloudFormation Vorlage `cluster_template.yaml` mit dem folgenden Namen:
```
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. Führen Sie den folgenden AWS CLI-Befehl aus, um den CloudFormation Stack für die Clustererstellung und -verwaltung bereitzustellen.
```
$ aws cloudformation deploy --template-file ./cluster_template.yaml \
--stack-name mycluster \
--parameter-overrides KeyName=keypair \
AvailabilityZone=us-east-2b \
--capabilities CAPABILITY_NAMED_IAM CAPABILITY_AUTO_EXPAND
```
## CloudFormation Cluster-Ausgabe anzeigen
Sehen Sie sich die CloudFormation Cluster-Ausgabe an, um nützliche Cluster-Details zu erhalten. Die hinzugefügte `ValidationMessages` Eigenschaft ermöglicht den Zugriff auf Bestätigungsmeldungen aus Clustererstellungs- und -aktualisierungsvorgängen.
1. Navigieren Sie zur [CloudFormation Konsole](https://console.aws.amazon.com/cloudformation/home) und wählen Sie den Stack aus, der Ihre AWS ParallelCluster benutzerdefinierte Ressource enthält.
1. Wählen Sie **Stack-Details** und dann die Registerkarte **Ausgaben** aus.
![\[Die Konsole CloudFormation gibt eine Tabelle mit Werten für HeadNodeIp und aus ValidationMessages.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/cfn-outputs.png)
Bestätigungsnachrichten werden möglicherweise gekürzt. Weitere Informationen zum Abrufen von Protokollen finden Sie unter[AWS ParallelCluster Problembehandlung](troubleshooting-v3.md).
## Greifen Sie auf Ihren Cluster zu
Greifen Sie auf den Cluster zu.
**`ssh`in den Cluster-Kopfknoten**
1. Rufen Sie nach Abschluss der CloudFormation Stack-Bereitstellung die IP-Adresse des Hauptknotens mit dem folgenden Befehl ab:
```
$ HEAD_NODE_IP=$(aws cloudformation describe-stacks --stack-name=mycluster --query "Stacks|[0].Outputs[?OutputKey=='HeadNodeIp']|[0].OutputValue" --output=text)
```
Sie können die IP-Adresse des Hauptknotens auch über den **HeadNodeIp**Parameter auf der Registerkarte **Cluster-Stack-Ausgaben** in der CloudFormation Konsole abrufen.
Die IP-Adresse des Hauptknotens finden Sie hier, da sie im `Outputs` Abschnitt der CloudFormation Clustervorlage speziell für diesen Beispielcluster hinzugefügt wurde.
1. Connect zum Cluster-Kopfknoten her, indem Sie den folgenden Befehl ausführen:
```
$ ssh -i keyname.pem ec2-user@$HEAD_NODE_IP
```
## Bereinigen
Löschen Sie den Cluster.
1. Führen Sie den folgenden AWS CLI-Befehl aus, um den CloudFormation Stack und den Cluster zu löschen.
```
$ aws cloudformation delete-stack --stack-name=mycluster
```
1. Überprüfen Sie den Status des Stack-Löschvorgangs, indem Sie den folgenden Befehl ausführen.
```
$ aws cloudformation describe-stacks --stack-name=mycluster
```
# ParallelCluster API mit Terraform bereitstellen
In diesem Tutorial definieren Sie ein einfaches Terraform-Projekt zur Bereitstellung einer API. ParallelCluster
**Voraussetzungen**
+ Terraform v1.5.7\$1 ist installiert.
+ IAM-Rolle mit den Berechtigungen zur Bereitstellung der API. ParallelCluster Siehe [Erforderliche Berechtigungen](tutorial-deploy-terraform-permissions.md).
# Definieren Sie ein Terraform-Projekt
In diesem Tutorial definieren Sie ein Terraform-Projekt.
1. Erstellen Sie ein Verzeichnis namens. `my-pcluster-api`
Alle Dateien, die Sie erstellen, befinden sich in diesem Verzeichnis.
1. Erstellen Sie die Datei`provider.tf`, um den AWS Anbieter zu konfigurieren.
```
provider "aws" {
region = var.region
profile = var.profile
}
```
1. Erstellen Sie die Datei`main.tf`, um die Ressourcen mithilfe des ParallelCluster Moduls zu definieren.
```
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. Erstellen Sie die Datei`variables.tf`, um die Variablen zu definieren, die für dieses Projekt eingefügt werden können.
```
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. Erstellen Sie die Datei`terraform.tfvars`, um beliebige Werte für die Variablen festzulegen.
Die folgende Datei stellt eine ParallelCluster API 3.11.1 unter `us-east-1` Verwendung des Stack-Namens bereit. `MyParallelClusterAPI-3111` Sie können diese ParallelCluster API-Bereitstellung anhand ihres Stack-Namens referenzieren.
**Anmerkung**
Die `api_version` Zuweisung im folgenden Code kann durch jede unterstützte AWS ParallelCluster Version ersetzt werden.
```
region = "us-east-1"
api_stack_name = "MyParallelClusterAPI-3111"
api_version = "3.11.1"
```
1. Erstellen Sie die Datei`outputs.tf`, um die von diesem Projekt zurückgegebenen Ausgaben zu definieren.
```
output "pcluster_api_stack_outputs" {
value = module.parallelcluster_pcluster_api.stack_outputs
}
```
Das Projektverzeichnis ist:
```
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.
```
# Bereitstellen der API
Um die API bereitzustellen, führen Sie die Terraform-Standardbefehle der Reihe nach aus.
1. Erstellen Sie das Projekt:
```
terraform init
```
1. Definieren Sie den Bereitstellungsplan:
```
terraform plan -out tfplan
```
1. Stellen Sie den Plan bereit:
```
terraform apply tfplan
```
# Erforderliche Berechtigungen
Sie benötigen die folgenden Berechtigungen, um die ParallelCluster API mit Terraform bereitzustellen:
------
#### [ 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"
}
]
}
```
------
# Einen Cluster mit Terraform erstellen
Bei der Nutzung AWS ParallelCluster zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen**
+ Terraform v1.5.7\$1 ist installiert.
+ [AWS ParallelCluster API](api-reference-v3.md)v3.8.0\$1 ist in Ihrem Konto bereitgestellt. Siehe [ParallelCluster API mit Terraform bereitstellen](tutorial-deploy-terraform.md).
+ IAM-Rolle mit den Berechtigungen zum Aufrufen der API. ParallelCluster Siehe [Erforderliche Berechtigungen]
# Definieren Sie ein Terraform-Projekt
In diesem Tutorial definieren Sie ein einfaches Terraform-Projekt zur Bereitstellung eines Clusters.
1. Erstellen Sie ein Verzeichnis namens. `my-clusters`
Alle Dateien, die Sie erstellen, befinden sich in diesem Verzeichnis.
1. Erstellen Sie die Datei`terraform.tf`, um den ParallelCluster Anbieter zu importieren.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Erstellen Sie die Datei`providers.tf`, um die AWS Anbieter ParallelCluster und zu konfigurieren.
```
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. Erstellen Sie die Datei`main.tf`, um die Ressourcen mithilfe des ParallelCluster Moduls zu definieren.
```
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. Erstellen Sie die Datei`clusters.tf`, um mehrere Cluster als lokale Terraform-Variablen zu definieren.
**Anmerkung**
Sie können mehrere Cluster innerhalb des `cluster_config` Elements definieren. Für jeden Cluster können Sie die Cluster-Eigenschaften innerhalb der lokalen Variablen explizit definieren (siehe`DemoCluster01`) oder auf eine externe Datei verweisen (siehe`DemoCluster02`).
Informationen zu den Clustereigenschaften, die Sie innerhalb des Konfigurationselements festlegen können, finden Sie unter[Cluster-Konfigurationsdatei](cluster-configuration-file-v3.md).
Informationen zu den Optionen, die Sie für die Clustererstellung festlegen können, finden Sie unter[`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. Erstellen Sie die Datei`config/clusters.yaml`, um mehrere Cluster als YAML-Konfiguration zu definieren.
```
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. Erstellen Sie die Datei`config/cluster_config.yaml`, bei der es sich um eine ParallelCluster Standardkonfigurationsdatei handelt, in die Terraform-Variablen eingefügt werden können.
Informationen zu den Cluster-Eigenschaften, die Sie innerhalb des Konfigurationselements festlegen können, finden Sie unter. [Cluster-Konfigurationsdatei](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. Erstellen Sie die Datei`clusters_vars.tf`, um die Variablen zu definieren, die in Clusterkonfigurationen eingefügt werden können.
Mit dieser Datei können Sie dynamische Werte definieren, die in Clusterkonfigurationen verwendet werden können, z. B. Region und Subnetz.
In diesem Beispiel werden Werte direkt aus den Projektvariablen abgerufen. Möglicherweise müssen Sie jedoch benutzerdefinierte Logik verwenden, um sie zu ermitteln.
```
locals {
config_vars = {
subnet = var.subnet_id
region = var.cluster_region
}
}
```
1. Erstellen Sie die Datei`variables.tf`, um die Variablen zu definieren, die für dieses Projekt eingefügt werden können.
```
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. Erstellen Sie die Datei`terraform.tfvars`, um beliebige Werte für die Variablen festzulegen.
In der folgenden Datei werden die Cluster `eu-west-1` innerhalb des `subnet-123456789` Subnetzes mithilfe der vorhandenen ParallelCluster API 3.11.1 bereitgestellt, die bereits mit dem Stacknamen bereitgestellt wurde. `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. Erstellen Sie die Datei`outputs.tf`, um die von diesem Projekt zurückgegebenen Ausgaben zu definieren.
```
output "clusters" {
value = module.pcluster.clusters
}
```
Das Projektverzeichnis ist:
```
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.
```
# Bereitstellen des Clusters
Um den Cluster bereitzustellen, führen Sie die Terraform-Standardbefehle der Reihe nach aus.
**Anmerkung**
In diesem Beispiel wird davon ausgegangen, dass Sie die ParallelCluster API bereits in Ihrem Konto bereitgestellt haben.
1. Erstellen Sie das Projekt:
```
terraform init
```
1. Definieren Sie den Bereitstellungsplan:
```
terraform plan -out tfplan
```
1. Stellen Sie den Plan bereit:
```
terraform apply tfplan
```
## Stellen Sie die ParallelCluster API mit Clustern bereit
Wenn Sie die ParallelCluster API nicht bereitgestellt haben und sie mit den Clustern bereitstellen möchten, ändern Sie die folgenden Dateien:
+ `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
}
```
# Erforderliche Berechtigungen
Sie benötigen die folgenden Berechtigungen, um einen Cluster mit Terraform bereitzustellen:
+ übernehme die ParallelCluster API-Rolle, die für die Interaktion mit der API zuständig ist ParallelCluster
+ Beschreiben Sie den CloudFormation ParallelCluster API-Stack, um zu überprüfen, ob er existiert, und rufen Sie seine Parameter und Ausgaben ab
------
#### [ 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"
}
]
}
```
------
# Erstellen eines benutzerdefinierten AMI mit Terraform
Bei der Nutzung AWS ParallelCluster zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern erstellt werden. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen**
+ Terraform v1.5.7\$1 ist installiert.
+ [AWS ParallelCluster API](api-reference-v3.md)v3.8.0\$1 ist in Ihrem Konto bereitgestellt. Siehe [Einen Cluster mit Terraform erstellen](tutorial-create-cluster-terraform.md).
+ IAM-Rolle mit den Berechtigungen zum Aufrufen der API. ParallelCluster Siehe [Erforderliche Berechtigungen](tutorial-create-ami-terraform-permissions.md).
# Definieren Sie ein Terraform-Projekt
In diesem Tutorial definieren Sie ein einfaches Terraform-Projekt zur Bereitstellung eines ParallelCluster benutzerdefinierten AMI.
1. Erstellen Sie ein Verzeichnis namens. `my-amis`
Alle Dateien, die Sie erstellen, befinden sich in diesem Verzeichnis.
1. Erstellen Sie die Datei`terraform.tf`, um den ParallelCluster Anbieter zu importieren.
```
terraform {
required_version = ">= 1.5.7"
required_providers {
aws-parallelcluster = {
source = "aws-tf/aws-parallelcluster"
version = "~> 1.0"
}
}
}
```
1. Erstellen Sie die Datei`providers.tf`, um die AWS Anbieter ParallelCluster und zu konfigurieren.
```
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. Erstellen Sie die Datei`main.tf`, um die Ressourcen mithilfe des ParallelCluster Moduls zu definieren.
Informationen zu den Bildeigenschaften, die Sie innerhalb des `image_configuration` Elements festlegen können, finden Sie unter[Image-Konfigurationsdateien erstellen](image-builder-configuration-file-v3.md).
Informationen zu den Optionen, die Sie für die Image-Erstellung festlegen können, z. B. `image_id` und`rollback_on_failure`, finden Sie unter[`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. Erstellen Sie die Datei`variables.tf`, um die Variablen zu definieren, die für dieses Projekt eingefügt werden können.
```
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. Erstellen Sie die Datei`terraform.tfvars`, um Ihre beliebigen Werte für die Variablen festzulegen.
Stellen Sie mit der folgenden Datei das benutzerdefinierte AMI bereit, das auf der Architektur Amazon Linux 2 für x86\$164 `us-east-1` basiert, und verwenden Sie dabei die vorhandene ParallelCluster API 3.11.1, die bereits mit dem Stacknamen bereitgestellt wurde. `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. Erstellen Sie die Datei`outputs.tf`, um die von diesem Projekt zurückgegebenen Ausgaben zu definieren.
```
output "parent_image" {
value = data.aws-parallelcluster_list_official_images.parent_image.official_images[0]
}
output "custom_image" {
value = aws-parallelcluster_image.demo01
}
```
Das Projektverzeichnis ist:
```
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.
```
# Stellen Sie das AMI bereit
Um das AMI bereitzustellen, führen Sie die Terraform-Standardbefehle der Reihe nach aus.
1. Erstellen Sie das Projekt:
```
terraform init
```
1. Definieren Sie den Bereitstellungsplan:
```
terraform plan -out tfplan
```
1. Stellen Sie den Plan bereit:
```
terraform apply tfplan
```
# Erforderliche Berechtigungen
Sie benötigen die folgenden Berechtigungen, um ein benutzerdefiniertes AMI mit Terraform bereitzustellen:
+ übernehme die ParallelCluster API-Rolle, die für die Interaktion mit der API zuständig ist ParallelCluster
+ Beschreiben Sie den CloudFormation ParallelCluster API-Stack, um zu überprüfen, ob er existiert, und rufen Sie seine Parameter und Ausgaben ab
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Action": "sts:AssumeRole",
"Resource": "arn:aws:sts::111122223333:role/PCAPIUserRole-*",
"Effect": "Allow",
"Sid": "AssumePCAPIUserRole"
},
{
"Action": [
"cloudformation:DescribeStacks"
],
"Resource": "arn:aws:cloudformation:us-east-1:111122223333:stack/*",
"Effect": "Allow",
"Sid": "CloudFormation"
}
]
}
```
------
# AWS ParallelCluster UI-Integration mit Identity Center
Ziel dieses Tutorials ist es, zu demonstrieren, wie die AWS ParallelCluster Benutzeroberfläche in IAM Identity Center integriert werden kann, um eine Single-Sign-On-Lösung zu schaffen, die Benutzer in Active Directory vereint und mit Clustern gemeinsam genutzt werden kann. AWS ParallelCluster
Bei der Nutzung AWS ParallelCluster zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern entstehen. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen:**
+ Eine vorhandene AWS ParallelCluster Benutzeroberfläche, die gemäß den Anweisungen [hier installiert werden kann.](install-pcui-v3.md)
+ Ein vorhandenes verwaltetes Active Directory, vorzugsweise eines, das Sie auch für die [Integration](tutorials_05_multi-user-ad.md) verwenden werden AWS ParallelCluster.
## IAM Identity Center aktivieren
Wenn Sie bereits über ein Identity Center verfügen, das mit Ihrem AWS Managed Microsoft AD (Active Directory) verbunden ist, können Sie dieses verwenden und mit dem Abschnitt **Hinzufügen Ihrer Anwendung zu IAM Identity Center fortfahren**.
Wenn Sie noch kein Identity Center mit einem verbunden haben AWS Managed Microsoft AD, gehen Sie wie folgt vor, um es einzurichten.
**Identity Center aktivieren**
1. Navigieren Sie in der Konsole zu IAM Identity Center. (Stellen Sie sicher, dass Sie sich in der Region befinden, in der Sie Ihre haben AWS Managed Microsoft AD.)
1. Klicken Sie auf die Schaltfläche **Aktivieren**. Möglicherweise werden Sie gefragt, ob Sie Organisationen aktivieren möchten. Dies ist eine Voraussetzung, damit Sie sie aktivieren können. **Hinweis**: Dadurch erhalten Sie eine E-Mail an den Administrator Ihres Kontos mit einer Bestätigungs-E-Mail. Folgen Sie zur Bestätigung dem Link.
**Identity Center mit Managed AD verbinden**
1. Auf der nächsten Seite sollten Sie nach der Aktivierung von Identity Center die empfohlenen Einrichtungsschritte sehen. Wählen Sie unter Schritt 1 die Option **Wählen Sie Ihre Identitätsquelle** aus.
1. Klicken Sie im Abschnitt Identitätsquelle auf das Dropdownmenü **Aktionen** (oben rechts) und wählen Sie dann **Identitätsquelle ändern** aus.
1. Wählen Sie **Active Directory** aus.
1. Wählen Sie unter **Existierende Verzeichnisse** Ihr Verzeichnis aus.
1. Klicken Sie auf Weiter.
1. Überprüfen Sie Ihre Änderungen, scrollen Sie nach unten, geben Sie zur Bestätigung ACCEPT in das Textfeld ein und klicken Sie dann auf **Identitätsquelle ändern**.
1. Warte, bis die Änderungen abgeschlossen sind. Dann solltest du oben ein grünes Banner sehen.
**Synchronisieren von Benutzern und Gruppen mit Identity Center**
1. Klicken Sie im grünen Banner auf **Geführte Installation starten** (Schaltfläche oben rechts)
![\[Screenshot, der die Schaltfläche „Geführte Installation starten“ hervorhebt.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_start_guided_setup_1.png)
1. **Klicken **Sie unter Attributzuordnungen konfigurieren** auf Weiter**
1. **Geben Sie im Abschnitt Synchronisierungsbereich konfigurieren die Namen der Benutzer ein, die mit Identity Center synchronisiert werden sollen, und klicken Sie dann auf Hinzufügen**
1. **Wenn Sie mit dem Hinzufügen von Benutzern und Gruppen fertig sind, klicken Sie auf Weiter**
![\[Screenshot, in dem die Schaltfläche Weiter hervorgehoben wird.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_guided_setup_add_users_groups_2.png)
1. Überprüfen Sie Ihre Änderungen und klicken Sie dann auf **Konfiguration speichern**
1. Wenn auf dem nächsten Bildschirm eine Warnung angezeigt wird, dass Benutzer nicht synchronisiert werden, wählen Sie oben rechts die **Schaltfläche Synchronisierung fortsetzen** aus.
1. Um Benutzer zu aktivieren, wählen Sie als Nächstes auf der linken Seite auf der Registerkarte **Benutzer** einen Benutzer aus und klicken Sie dann auf **Benutzerzugriff aktivieren** > **Benutzerzugriff aktivieren**
**Hinweis**: Möglicherweise müssen Sie Synchronisierung fortsetzen auswählen, wenn oben ein Warnbanner angezeigt wird, und dann warten, bis die Benutzer synchronisiert sind (versuchen Sie mit der Schaltfläche „Aktualisieren“, ob sie bereits synchronisiert sind).
![\[Screenshot, der den Tab „Benutzer“ hervorhebt.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_enable_user_access_3.png)
## Ihre Anwendung zum IAM Identity Center hinzufügen
Sobald Sie Ihre Benutzer mit IAM Identity Center synchronisiert haben, müssen Sie eine neue Anwendung hinzufügen. Dadurch wird konfiguriert, welche SSO-fähigen Anwendungen in Ihrem IAM Identity Center-Portal verfügbar sein werden. In diesem Fall fügen wir AWS ParallelCluster UI als Anwendung hinzu, während IAM Identity Center der Identitätsanbieter ist.
Im nächsten Schritt wird die AWS ParallelCluster Benutzeroberfläche als Anwendung in IAM Identity Center hinzugefügt. AWS ParallelCluster UI ist ein Webportal, das dem Benutzer hilft, seine Cluster zu verwalten. Weitere Informationen finden Sie unter [AWS ParallelCluster UI](pcui-using-v3.md).
**Einrichtung der Anwendung in Identity Center**
1. Unter **IAM Identity Center** > **Anwendungen** (klicken Sie in der linken Menüleiste auf Anwendungen)
1. Klicken Sie auf **Anwendung hinzufügen**
1. Wählen Sie **Benutzerdefinierte SAML 2.0-Anwendung hinzufügen**
1. **Klicken Sie auf Weiter**
1. Wählen Sie den Anzeigenamen und die Beschreibung aus, die Sie verwenden möchten (z. B. PCUI und AWS ParallelCluster UI)
1. Kopieren Sie unter **IAM Identity Center-Metadaten** den Link für die IAM Identity Center SAML-Metadatendatei und speichern Sie ihn für später. Diese wird bei der Konfiguration von SSO in der Web-App verwendet
1. Geben Sie unter **Anwendungseigenschaften** in der Start-URL der Anwendung Ihre PCUI-Adresse ein. **Diese finden Sie, indem Sie zur CloudFormation Konsole gehen, den Stack auswählen, der der PCUI entspricht (z. B. parallelcluster-ui), und auf der Registerkarte Outputs nach** ParallelCluster UIUrl
z. B. https://m2iwazsi1j.execute-api.us-east-1.amazonaws.com
1. Wählen Sie unter **Anwendungsmetadaten** die Option **Manuelles Eingeben Ihrer Metadatenwerte** aus. Geben Sie dann die folgenden Werte ein.
1. **Wichtig**: Achten Sie darauf, die Werte für das Domänenpräfix, die Region und die Benutzerpool-ID durch Informationen zu ersetzen, die für Ihre Umgebung spezifisch sind.
1. **Das Domain-Präfix, die Region und die Benutzerpool-ID erhalten Sie, indem Sie die Konsole **Amazon Cognito** > Benutzerpools öffnen**
![\[Screenshot, in dem der Name des Benutzerpools unter Cognito-Benutzerpools hervorgehoben wird\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_4.png)
1. Wählen Sie den Benutzerpool aus, der PCUI entspricht (der einen Benutzerpoolnamen wie EK3 TO45 PCUI-CD8A2-Cognito-153 S98-UserPool haben wird)
1. **Navigieren Sie zu App Integration**
![\[Screenshot, der die Cognito-Domain auf der Registerkarte „App-Integration“ hervorhebt\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_app_integration_5.png)
1. URL des Application Assertion Consumer Service (ACS): https://.auth. .amazoncognito. com/saml2/idpresponse
SAML-Anwendungszielgruppe: urn:amazon:cognito:sp:
1. Wählen Sie **Absenden** aus. Rufen Sie dann die **Detailseite** für die Anwendung auf, die Sie hinzugefügt haben.
1. Wählen Sie die Dropdownliste **Aktionen** aus und wählen Sie **Attributzuordnungen bearbeiten** aus. Geben Sie dann die folgenden Attribute an.
1. Benutzerattribut in der Anwendung: **Betreff** (Hinweis: **Betreff** ist vorausgefüllt.) **→ Ordnet diesem Zeichenkettenwert oder Benutzerattribut in IAM Identity Center zu: **\$1 \$1user:email\$1, Format: emailAddress****
1. **Benutzerattribut in der Anwendung: **E-Mail** → Ordnet diesem Zeichenfolgenwert oder Benutzerattribut in IAM Identity Center zu: **\$1 \$1user:email**\$1, Format: nicht spezifiziert**
![\[Screenshot, der den Abschnitt „Attributzuordnungen für PCUI“ hervorhebt\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_attribute_mappings_PCUI_6.png)
1. Speichern Sie Ihre Änderungen.
1. Wählen Sie die Schaltfläche „**Benutzer zuweisen**“ und weisen Sie dann Ihren Benutzer der Anwendung zu. Dies sind die Benutzer in Ihrem Active Directory, die Zugriff auf die PCUI-Schnittstelle haben werden.
![\[Screenshot, in dem Benutzer für die Anwendung zuweisen hervorgehoben werden.\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/IAC_PCUI_App_7.png)
**Konfigurieren Sie IAM Identity Center als SAML-IdP in Ihrem Benutzerpool**
1. **Wählen Sie in Ihren Benutzerpool-Einstellungen die Option **Anmeldeerfahrung** > Identitätsanbieter hinzufügen aus**
![\[Screenshot, in dem der Tab „Anmeldeerfahrung“ hervorgehoben wird\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_sign_in_expereince_8.png)
1. Wählen Sie einen SAML-IdP
1. Geben Sie als **Anbieternamen** an **IdentityCenter**
1. Wählen Sie unter **Metadaten-Dokumentquelle** die Option **URL für den Endpunkt des Metadatendokuments eingeben** aus und geben Sie die URL ein, die Sie bei der Einrichtung der Anwendung von Identity Center kopiert haben
1. Wählen Sie unter **„Attribute“** für E-Mail die Option E-Mail aus
![\[Screenshot, in dem der Tab „Anmeldeerfahrung“ hervorgehoben wird\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazonw_cognito_SAML_9.png)
1. Wählen Sie **Identitätsanbieter hinzufügen** aus.
**Integrieren Sie den IdP in den Benutzerpool-App-Client**
1. Wählen Sie als Nächstes im Bereich **App-Integration** Ihres Benutzerpools den Client aus, der unter **App-Client-Liste** aufgeführt ist
![\[Screenshot, in dem der Tab „Anmeldeerfahrung“ hervorgehoben wird\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pool_app_client_10.png)
1. **Wählen Sie unter **Gehostete Benutzeroberfläche** die Option Bearbeiten**
1. Wählen Sie unter **Identitätsanbieter **IdentityCenter****ebenfalls aus.
1. Wählen Sie **Save Changes (Änderungen speichern)**
**Bestätigen Sie Ihr Setup**
1. Als Nächstes validieren wir das Setup, das wir gerade erstellt haben, indem wir uns bei PCUI anmelden. Melden Sie sich bei Ihrem PCUI-Portal an und Sie sollten nun eine Option sehen, mit der Sie sich mit Ihrer Unternehmens-ID anmelden können:
![\[Screenshot, der den Tab „Anmeldeerfahrung“ hervorhebt\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_validate_step_11.png)
1. Wenn Sie auf die **IdentityCenter**Schaltfläche klicken, gelangen Sie zur IAM Identity Center IdP-Anmeldung, gefolgt von einer Seite mit Ihren Anwendungen, die auch PCUI enthält. Öffnen Sie diese Anwendung.
1. Sobald Sie zum folgenden Bildschirm gelangen, wurde Ihr Benutzer dem Cognito-Benutzerpool hinzugefügt.
![\[Screenshot, in dem der Tab „Anmeldeerfahrung“ hervorgehoben wird\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_continue_with_IC_12.png)
**Machen Sie Ihren Benutzer zum Administrator**
1. Navigieren Sie nun zur **Konsole **Amazon Cognito** > Benutzerpools** und wählen Sie den neu erstellten Benutzer aus, der das Präfix identitycenter haben soll.
![\[Screenshot, der den Tab „Anmeldeerfahrung“ hervorhebt\]](http://docs.aws.amazon.com/de_de/parallelcluster/latest/ug/images/tutorials/pcui_awsic_integration/Amazon_cognito_user_pools_new_created_user_13.png)
1. **Wählen Sie unter **Gruppenmitgliedschaften** die Option **Benutzer zur Gruppe hinzufügen** aus, wählen Sie **Administrator** und klicken Sie auf Hinzufügen.**
1. Wenn Sie nun auf **Weiter mit** klicken, werden IdentityCenter Sie zur AWS ParallelCluster UI-Seite weitergeleitet.
# Containerisierte Jobs mit Pyxis ausführen
Erfahren Sie, wie Sie mit Pyxis, einem SPANK-Plugin zur Verwaltung containerisierter Jobs in SLURM, einen Cluster erstellen, der containerisierte Jobs ausführen kann. Container in Pyxis werden von Enroot verwaltet, einem Tool, mit dem herkömmliche Images in Sandboxen ohne Zugriffsrechte umgewandelt werden können. container/OS [Weitere Informationen finden Sie unter [NVIDIA Pyxis und NVIDIA Enroot](https://github.com/NVIDIA/pyxis).](https://github.com/NVIDIA/enroot)
**Anmerkung**
Diese Funktion ist mit Version 3.11.1 verfügbar AWS ParallelCluster
Die Skripte in diesem Tutorial verschieben (`mv`) einige Dateien, wodurch sie von ihren ursprünglichen Speicherorten gelöscht werden. Wenn Sie Kopien dieser Dateien an ihren ursprünglichen Speicherorten behalten möchten, ändern Sie die Skripten so, dass sie stattdessen den Befehl copy (`cp`) verwenden.
Bei der Nutzung AWS ParallelCluster zahlen Sie nur für die AWS Ressourcen, die beim Erstellen oder Aktualisieren von AWS ParallelCluster Images und Clustern entstehen. Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
**Voraussetzungen:**
+ Das AWS CLI ist [installiert und konfiguriert.](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html)
+ Ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html). .
+ Eine IAM-Rolle mit den [Berechtigungen, die für](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) die Ausführung der [pcluster-CLI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) erforderlich sind.
## Den Cluster erstellen
Ab AWS ParallelCluster 3.11.1 sind auf allen offiziellen Versionen Pyxis und AMIs Enroot vorinstalliert. Insbesondere wird SLURM mit Pyxis-Unterstützung neu kompiliert und Enroot wird als Binärdatei im System installiert. Sie müssen sie jedoch entsprechend Ihren spezifischen Bedürfnissen konfigurieren. Die von Enroot und Pyxis verwendeten Ordner werden sich entscheidend auf die Cluster-Leistung auswirken. [Weitere Informationen finden Sie in der [Pyxis-Dokumentation und in der Enroot-Dokumentation](https://github.com/NVIDIA/pyxis/wiki/Setup#slurm-plugstack-configuration).](https://github.com/NVIDIA/pyxis/wiki/Setup#enroot-configuration-example)
Der Einfachheit halber finden Sie darin Beispielkonfigurationen für Pyxis, Enroot und SPANK. `/opt/parallelcluster/examples/`
Um einen Cluster mithilfe der von uns bereitgestellten Beispielkonfigurationen bereitzustellen, führen Sie das folgende Tutorial durch.
**Um den Cluster mit der Beispielkonfiguration zu erstellen**
Pyxis und Enroot müssen auf dem Hauptknoten konfiguriert werden, indem zuerst die persistenten und flüchtigen Verzeichnisse für Enroot erstellt werden, dann das Laufzeitverzeichnis für Pyxis erstellt und schließlich Pyxis als SPANK-Plugin im gesamten Cluster aktiviert wird.
1. Führen Sie das folgende Skript als [OnNodeConfigured](HeadNode-v3.md#yaml-HeadNode-CustomActions-OnNodeConfigured)benutzerdefinierte Aktion im Hauptknoten aus, um Pyxis und Enroot auf dem Hauptknoten zu konfigurieren.
```
#!/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 und Enroot müssen auf der Rechenflotte konfiguriert werden, indem die persistenten und flüchtigen Verzeichnisse für Enroot und das Laufzeitverzeichnis für Pyxis erstellt werden. Führen Sie das folgende Skript als [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)benutzerdefinierte Aktion in Rechenknoten aus, um Pyxis und Enroot auf der Rechenflotte zu konfigurieren.
```
#!/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
```
## Jobs einreichen
Nachdem Pyxis nun in Ihrem Cluster konfiguriert ist, können Sie containerisierte Jobs mit den Befehlen sbatch und srun einreichen, die jetzt um containerspezifische Optionen erweitert wurden.
```
# 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'
```
# Einen Cluster mit einem EFA-fähigen Lustre FSx erstellen
In diesem Tutorial erstellen Sie einen Cluster, der ein EFA-fähiges FSx Lustre-Dateisystem als gemeinsam genutzten Speicher verwendet. Die Verwendung eines FSx Lustre-Dateisystems mit aktiviertem EFA kann zu einer bis zu 8-fachen Leistungssteigerung führen. *Um zu überprüfen, ob Sie ein EFA-fähiges Dateisystem benötigen, schauen Sie sich den Abschnitt [Arbeiten mit EFA-fähigen Dateisystemen](https://docs.aws.amazon.com/fsx/latest/LustreGuide/efa-file-systems.html) im for Lustre-Benutzerhandbuch an. FSx *
Bei der Nutzung zahlen Sie nur für die AWS Ressourcen AWS ParallelCluster, die beim Erstellen oder Aktualisieren von Images und Clustern entstehen. AWS ParallelCluster Weitere Informationen finden Sie unter [AWS Dienste verwendet von AWS ParallelCluster](aws-services-v3.md).
## Voraussetzungen
+ Die AWS CLI ist [installiert und konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Die ParallelCluster CLI ist [installiert und konfiguriert](install-v3-parallelcluster.md).
+ Ein [Amazon EC2 EC2-Schlüsselpaar](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) für die Anmeldung beim Cluster.
+ Eine IAM-Rolle mit den [Berechtigungen, die für](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-key-pairs.html) die Ausführung der ParallelCluster CLI erforderlich sind.
## Erstellen von Sicherheitsgruppen
Erstellen Sie zwei Sicherheitsgruppen in derselben VPC, in der der Cluster und das Dateisystem bereitgestellt werden: eine für den Client, der auf Clusterknoten ausgeführt wird, und eine für das Dateisystem.
```
# 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
```
Im weiteren Verlauf des Tutorials gehen `sg-client` wir von den Sicherheitsgruppen-IDs des Clients bzw. des Dateisystems aus. `sg-file-system`
Konfigurieren Sie die Sicherheitsgruppe für den Client so, dass der gesamte ausgehende Datenverkehr zum Dateisystem zugelassen wird, wie [von EFA gefordert](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
```
Konfigurieren Sie die Sicherheitsgruppe für das Dateisystem so, dass der gesamte inbound/outbound Datenverkehr innerhalb des Dateisystems und der gesamte eingehende Datenverkehr vom Client zugelassen werden, wie von EFA [gefordert](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
```
## Erstellen Sie das Dateisystem
Erstellen Sie das Dateisystem in derselben Availability Zone (AZ), in der sich die Rechenknoten befinden werden, und `subnet-compute-nodes` ersetzen Sie es im folgenden Code durch seine ID. Dies ist erforderlich, damit EFA mit Ihrem Dateisystem arbeiten kann. Beachten Sie, dass wir EFA im Rahmen der Erstellung des Dateisystems mithilfe der EfaEnable Eigenschaft aktivieren.
```
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
```
Notieren Sie sich die vom vorherigen Befehl zurückgegebene Dateisystem-ID. Ersetzen Sie diese Datei im Rest des Tutorials `fs-id` durch diese Dateisystem-ID.
## Den Cluster erstellen
1. Erstellen Sie den Cluster mit den folgenden Konfigurationen, die in der AWS ParallelCluster YAML-Konfigurationsdatei festgelegt sind:
1. AMI basiert auf einem unterstützten Betriebssystem wie Ubuntu 22.04.
1. Rechenknoten müssen einen von [EFA unterstützten Instance-Typ](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html#efa-instance-types) mit [Nitro v4\$1](https://docs.aws.amazon.com/ec2/latest/instancetypes/ec2-nitro-instances.html) verwenden, z. B. g6.16xlarge.
+ Rechenknoten müssen sich in derselben AZ befinden, in der sich das Dateisystem befindet.
+ Für Rechenknoten muss [Efa/Enabled auf true gesetzt sein](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-Efa-Enabled).
+ Rechenknoten müssen das Konfigurationsskript `configure-efa-fsx-lustre-client.sh` als [OnNodeStart](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-CustomActions-OnNodeStart)benutzerdefinierte Aktion ausführen. Das Skript, das in der [FSx offiziellen Dokumentation enthalten](https://docs.aws.amazon.com/fsx/latest/LustreGuide/configure-efa-clients.html) ist und der Einfachheit halber in unserem öffentlichen Bucket angeboten wird, dient dazu, den FSx Lustre-Client auf Rechenknoten so zu konfigurieren, dass sie EFA verwenden können.
1. Erstellen Sie eine Cluster-Konfigurationsdatei: `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
```
Erstellen Sie dann einen Cluster mit dieser Konfiguration:
```
pcluster create-cluster \
--cluster-name fsx-efa-tutorial \
--cluster-configuration config.yaml \
--region region
```
## Die Überprüfung FSx mit EFA funktioniert
Um zu überprüfen, ob der Lustre-Netzwerkverkehr EFA verwendet, verwenden Sie das `lnetctl` Lustre-Tool, das den Netzwerkverkehr für eine bestimmte Netzwerkschnittstelle anzeigen kann. Führen Sie zu diesem Zweck die folgenden Befehle in einem Rechenknoten aus:
```
# 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
```
Wenn die Funktion funktioniert, wird die Anzahl der Pakete, die über die Schnittstelle fließen, voraussichtlich zunehmen.
# Support NVIDIA-IMEX mit p6e-gb200-Instanz
Dieses Tutorial zeigt Ihnen, wie Sie mit AWS ParallelCluster P6e- beginnen könnenGB200, um die höchste GPU-Leistung für KI-Training und Inferenz zu nutzen. [p6e-gb200.36xlarge-Instances sind nur über P6e- GB200 UltraServers verfügbar, wobei](https://aws.amazon.com/ec2/instance-types/p6/) der Wert für die Größe des Ultraservers steht und der Name ist, aus dem der Ultraserver besteht. `u-p6e-gb200x72` `p6e-gb200.36xlarge` [InstanceType](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-InstanceType) [Beim Kauf eines Ultraservers wird dieser über einen EC2 Capacity Blocks for ML mit 18 Instances erhältlich `u-p6e-gb200x72` sein.](https://aws.amazon.com/ec2/capacityblocks/) `p6e-gb200.36xlarge` [Weitere Informationen finden Sie unter P6e-. GB200](https://aws.amazon.com/ec2/instance-types/p6/)
AWS ParallelCluster Version 3.14.0:
+ stellt den kompletten NVIDIA-Softwarestack (Treiber, CUDA, EFA, NVIDIA-IMEX) bereit, der für diesen Instance-Typ erforderlich ist
+ erstellt nvidia-imex-Konfigurationen für P6e-Ultraserver GB200
+ aktiviert und startet den Dienst für P6e-Ultraserver `nvidia-imex` GB200
+ konfiguriert das Slurm-Block-Topologie-Plugin so, dass jeder P6e-GB200-Ultraserver (ein EC2-Kapazitätsblock) ein Slurm-Block mit der richtigen Größe ist (siehe den Eintrag für Version 3.14.0). [Versionshinweise und Dokumentenverlauf](document_history.md)
Für die GPU-to-GPU Kommunikation sind jedoch zusätzliche Konfigurationen NVLink erforderlich, insbesondere eine [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)Datei, die die IP-Adressen von Rechenknoten in einer IMEX-Domäne enthält, die nicht automatisch generiert wird. ParallelCluster Um bei der Generierung dieser Datei zu helfen, stellen wir ein Prolog-Skript bereit, das den Rechenknoten automatisch erkennt IPs und die [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)folgenden Empfehlungen für die [NVIDIA IMEX Slurm](https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/deployment.html#job-scheduler-integration) Job Scheduler-Integration konfiguriert. In diesem Tutorial erfahren Sie, wie Sie das Prolog-Skript erstellen, es über eine HeadNode benutzerdefinierte Aktion bereitstellen und das IMEX-Setup validieren.
**Anmerkung**
P6e- GB200 wird ab Version AWS ParallelCluster 3.14.0 auf Amazon Linux 2023, Ubuntu 22.04 und Ubuntu 24.04 unterstützt. [Detaillierte Softwareversionen und eine aktualisierte Liste der unterstützten Distributionen finden Sie im Changelog.AWS ParallelCluster](https://github.com/aws/aws-parallelcluster/blob/develop/CHANGELOG.md)
## Erstellen Sie ein Prolog-Skript zur Verwaltung von NVIDIA-IMEX
**Einschränkung:**
+ Dieses Prolog-Skript wird bei Einreichung eines exklusiven Jobs ausgeführt. Dadurch soll sichergestellt werden, dass ein IMEX-Neustart keine laufenden Jobs auf P6e-GB200-Knoten unterbricht, die zu einer IMEX-Domain gehören.
Im Folgenden finden Sie das `91_nvidia_imex_prolog.sh` Skript, das Sie als Prolog in Slurm konfigurieren sollten. Es wird verwendet, um die nvidia-imex-Konfiguration auf Rechenknoten automatisch zu aktualisieren. [Der Name des Skripts hat das Präfix von, um der Namenskonvention von `91` SchedMD zu entsprechen.](https://slurm.schedmd.com/prolog_epilog.html) Dadurch wird sichergestellt, dass es vor allen anderen Prolog-Skripten in der Sequenz ausgeführt wird. Das Skript konfiguriert die Konfiguration des NVIDIA Imex-Knotens neu, wenn ein Job gestartet wird, und lädt die erforderlichen NVIDIA-Daemons neu.
**Anmerkung**
Dieses Skript wird nicht ausgeführt, falls mehrere Jobs gleichzeitig auf denselben Knoten gestartet werden. Wir empfehlen daher, das Flag bei der Einreichung zu verwenden. `--exclusive`
```
#!/usr/bin/env bash
# This prolog script configures the NVIDIA IMEX on compute nodes involved in the job execution.
#
# In particular:
# - Checks whether the job is executed exclusively.
# If not, it exits immediately because it requires jobs to be executed exclusively.
# - Checks if it is running on a p6e-gb200 instance type.
# If not, it exits immediately because IMEX must be configured only on that instance type.
# - Checks if the IMEX service is enabled.
# If not, it exits immediately because IMEX must be enabled to get configured.
# - Creates the IMEX default channel.
# For more information about IMEX channels, see https://docs.nvidia.com/multi-node-nvlink-systems/imex-guide/imexchannels.html
# - Writes the private IP addresses of compute nodes into /etc/nvidia-imex/nodes_config.cfg.
# - Restarts the IMEX system service.
#
# REQUIREMENTS:
# - This prolog assumes to be run only with exclusive jobs.
LOG_FILE_PATH="/var/log/parallelcluster/nvidia-imex-prolog.log"
SCONTROL_CMD="/opt/slurm/bin/scontrol"
IMEX_START_TIMEOUT=60
IMEX_STOP_TIMEOUT=15
ALLOWED_INSTANCE_TYPES="^(p6e-gb200)"
IMEX_SERVICE="nvidia-imex"
IMEX_NODES_CONFIG="/etc/nvidia-imex/nodes_config.cfg"
function info() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [INFO] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function warn() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [WARN] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function error() {
echo "$(date "+%Y-%m-%dT%H:%M:%S.%3N") [ERROR] [PID:$$] [JOB:${SLURM_JOB_ID}] $1"
}
function error_exit() {
error "$1" && exit 1
}
function prolog_end() {
info "PROLOG End JobId=${SLURM_JOB_ID}: $0"
info "----------------"
exit 0
}
function get_instance_type() {
local token=$(curl -X PUT -s "http://169.254.169.254/latest/api/token" -H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -s -H "X-aws-ec2-metadata-token: ${token}" http://169.254.169.254/latest/meta-data/instance-type
}
function return_if_unsupported_instance_type() {
local instance_type=$(get_instance_type)
if [[ ! ${instance_type} =~ ${ALLOWED_INSTANCE_TYPES} ]]; then
info "Skipping IMEX configuration because instance type ${instance_type} does not support it"
prolog_end
fi
}
function return_if_imex_disabled() {
if ! systemctl is-enabled "${IMEX_SERVICE}" &>/dev/null; then
warn "Skipping IMEX configuration because system service ${IMEX_SERVICE} is not enabled"
prolog_end
fi
}
function return_if_job_is_not_exclusive() {
if [[ "${SLURM_JOB_OVERSUBSCRIBE}" =~ ^(NO|TOPO)$ ]]; then
info "Job is exclusive, proceeding with IMEX configuration"
else
info "Skipping IMEX configuration because the job is not exclusive"
prolog_end
fi
}
function get_ips_from_node_names() {
local _nodes=$1
${SCONTROL_CMD} -ao show node "${_nodes}" | sed 's/^.* NodeAddr=\([^ ]*\).*/\1/'
}
function get_compute_resource_name() {
local _queue_name_prefix=$1
local _slurmd_node_name=$2
echo "${_slurmd_node_name}" | sed -E "s/${_queue_name_prefix}(.+)-[0-9]+$/\1/"
}
function reload_imex() {
info "Stopping IMEX"
timeout ${IMEX_STOP_TIMEOUT} systemctl stop ${IMEX_SERVICE}
pkill -9 ${IMEX_SERVICE}
info "Restarting IMEX"
timeout ${IMEX_START_TIMEOUT} systemctl start ${IMEX_SERVICE}
}
function create_default_imex_channel() {
info "Creating IMEX default channel"
MAJOR_NUMBER=$(cat /proc/devices | grep nvidia-caps-imex-channels | cut -d' ' -f1)
if [ ! -d "/dev/nvidia-caps-imex-channels" ]; then
sudo mkdir /dev/nvidia-caps-imex-channels
fi
# Then check and create device node
if [ ! -e "/dev/nvidia-caps-imex-channels/channel0" ]; then
sudo mknod /dev/nvidia-caps-imex-channels/channel0 c $MAJOR_NUMBER 0
info "IMEX default channel created"
else
info "IMEX default channel already exists"
fi
}
{
info "PROLOG Start JobId=${SLURM_JOB_ID}: $0"
return_if_job_is_not_exclusive
return_if_unsupported_instance_type
return_if_imex_disabled
create_default_imex_channel
IPS_FROM_CR=$(get_ips_from_node_names "${SLURM_NODELIST}")
info "Node Names: ${SLURM_NODELIST}"
info "Node IPs: ${IPS_FROM_CR}"
info "IMEX Nodes Config: ${IMEX_NODES_CONFIG}"
info "Updating IMEX nodes config ${IMEX_NODES_CONFIG}"
echo "${IPS_FROM_CR}" > "${IMEX_NODES_CONFIG}"
reload_imex
prolog_end
} 2>&1 | tee -a "${LOG_FILE_PATH}" | logger -t "91_nvidia_imex_prolog"
```
## Erstellen Sie das HeadNode OnNodeStart benutzerdefinierte Aktionsskript
Erstellen Sie eine `install_custom_action.sh` benutzerdefinierte Aktion, die das oben genannte Prolog-Skript in ein gemeinsam genutztes Verzeichnis herunterlädt, auf `/opt/slurm/etc/scripts/prolog.d/` das Compute Nodes zugreifen, und die entsprechenden Berechtigungen für die Ausführung festlegt.
```
#!/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}"
```
## Den Cluster erstellen
Erstellen Sie einen Cluster mit P6e-Instanzen. GB200 Im Folgenden finden Sie eine Beispielkonfiguration, die den Typ SlurmQueues Ultraserver enthält. `u-p6e-gb200x72`
P6e- GB200 ist derzeit nur in Local Zones verfügbar. Einige [Local Zones unterstützen kein NAT-Gateway](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity-nat.html). Folgen Sie daher bei ParallelCluster Bedarf den [Verbindungsoptionen für Local Zones](https://docs.aws.amazon.com/local-zones/latest/ug/local-zones-connectivity.html), [Konfiguration von Sicherheitsgruppen für eingeschränkte Umgebungen](security-groups-configuration.md) um eine Verbindung zu den AWS Diensten herzustellen. Bitte folgen Sie den Anweisungen [Starten Sie Instances mit Capacity Blocks (CB)](launch-instances-capacity-blocks.md) (AWS ParallelClusterLaunch), da Ultraserver nur als Kapazitätsblöcke verfügbar sind.
```
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:
-
```
## Überprüfen Sie das IMEX-Setup
Der `91_nvidia_imex_prolog.sh` Prolog wird ausgeführt, wenn Sie einen Slurm-Job einreichen. Im Folgenden finden Sie einen Beispieljob zur Überprüfung des Status der NVIDIA-IMEX-Domain.
```
#!/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"
```
Überprüfen Sie die Ausgabe des 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
```
# Passen Sie die Netzwerkschnittstellen für Rechenknoten mit Überschreibungen für Startvorlagen an
Ab AWS ParallelCluster 3.15.0 können Sie mit diesem `LaunchTemplateOverrides` Parameter die Netzwerkschnittstellen von Rechenknoten anpassen, indem Sie die standardmäßige Netzwerkschnittstellenkonfiguration mit der Konfiguration in einer referenzierten Startvorlage überschreiben. Der gesamte Netzwerkschnittstellenbereich der Rechenknoten wird durch den Netzwerkschnittstellenbereich der Startvorlage überschrieben, der zum Überschreiben verwendet wird.
In diesem Tutorial wird ein Beispiel für das Überschreiben der standardmäßigen Netzwerkkonfiguration von `p6-b300.48xlarge` Rechenknoten beschrieben. Diese Anpassung ist nützlich, wenn Sie eine bestimmte Netzwerkschnittstellenkonfiguration benötigen, die sich von der AWS ParallelCluster Standardkonfiguration unterscheidet. In diesem Beispiel konfigurieren wir Anwendungsfall 2 für P6-B300-Instances, wie in der Dokumentation zu den von [Amazon EC2 EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-acc-inst-types.html) unterstützten Instance-Typen beschrieben.
**Anmerkung**
Es wird empfohlen, für die Erstellung der Startvorlage anstelle der AWS CLI Konsole die zu verwenden, um maximale Flexibilität zu erzielen.
**Anmerkung**
Die Startvorlage sollte nur Netzwerkschnittstellen-Overrides enthalten. AWS ParallelCluster hat eine Validierung, die das Überschreiben anderer Parameter verhindert.
**Warnung**
Wenn Sie die Überschreibung verwenden, um Netzwerkschnittstellen auf eine Weise zu konfigurieren, die vom verwendeten Instance-Typ nicht unterstützt wird, können die Instances nicht gestartet werden.
**Voraussetzungen**
+ AWS ParallelCluster Version 3.15.0 oder höher [ist](install-v3-parallelcluster.md) installiert.
+ Die AWS CLI [ist installiert und konfiguriert](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Sie haben eine IAM-Rolle mit den [Berechtigungen, die für](iam-roles-in-parallelcluster-v3.md#iam-roles-in-parallelcluster-v3-example-user-policies) die Ausführung der [`pcluster`](pcluster-v3.md) CLI erforderlich sind.
## Schritt 1: Sicherheitsgruppen erstellen
Wenn Sie die Startvorlage erstellen, die beim Override verwendet werden soll, müssen Sie auf eine Sicherheitsgruppe verweisen. Die AWS ParallelCluster Standardsicherheitsgruppe für die Rechenressource ist erst bei der Clustererstellung vorhanden. Sie müssen also eine benutzerdefinierte Sicherheitsgruppe erstellen. Diese Sicherheitsgruppe muss dann von der Sicherheitsgruppe des Hauptknotens referenziert werden, um den Datenverkehr zwischen dem Hauptknoten und den Rechenknoten zu ermöglichen.
Wenn Sie einen vorhandenen Cluster aktualisieren, um neue Kapazitäten anzupassen, können Sie die standardmäßige Sicherheitsgruppe für AWS ParallelCluster Rechenknoten in der Startvorlage verwenden, anstatt eine benutzerdefinierte zu erstellen.
Erstellen Sie die folgenden zwei Sicherheitsgruppen:
+ **Zusätzliche Sicherheitsgruppe des Kopfknotens** (`sg-1234abcd`):
+ Eingang: gesamter Datenverkehr von der Computersicherheitsgruppe
+ **Sicherheitsgruppe für die Datenverarbeitung** (`sg-abcd1234`):
+ Eingang: gesamter Datenverkehr von der Sicherheitsgruppe des Hauptknotens
+ Eingang: gesamter Verkehr von self () compute-to-compute
+ Ausgang: Standardeinstellung „Alles zulassen“
## Schritt 2: Erstellen Sie die Startvorlage
Erstellen Sie eine Startvorlage, die die Netzwerkschnittstellenkonfiguration für `p6-b300.48xlarge` Rechenknoten definiert. Verwenden Sie für die primäre Netzwerkschnittstelle (Netzwerkkartenindex 0, Geräteindex 0) eine ENA-Netzwerkschnittstelle (Standard). Erstellen Sie für die übrigen Netzwerkkarten eine reine EFA-Schnittstelle (Netzwerkkartenindizes 1—16, Geräteindex 0) und eine ENA-Schnittstelle (Standard) (Netzwerkkartenindizes 1—16, Geräteindex 1).
Führen Sie den folgenden AWS CLI Befehl aus, um die Startvorlage () zu erstellen: `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"}
]
}'
```
## Schritt 3: Erstellen Sie den Cluster mit Überschreibungen der Startvorlage
Erstellen Sie eine Clusterkonfiguration, die den `LaunchTemplateOverrides` Parameter verwendet, um auf die von Ihnen erstellte Startvorlage zu verweisen.
```
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.
```