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.

# Ausführung von Jobs in einem Cluster mit mehreren Warteschlangen
<a name="multi-queue-tutorial-v3"></a>

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
<a name="multi-queue-tutorial-v3-configure-cluster"></a>

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
<a name="multi-queue-tutorial-v3-create-cluster"></a>

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
<a name="multi-queue-tutorial-v3-log-into-head-node"></a>

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
<a name="multi-queue-tutorial-v3-running-job-mqm"></a>

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 <<EOF hellojob.sh
#!/bin/bash
sleep 30
echo "Hello World from \$(hostname)"
EOF

$ chmod +x hellojob.sh
$ ls -l hellojob.sh
-rwxrwxr-x 1 ec2-user ec2-user 57 Sep 23 21:57 hellojob.sh
```

Senden Sie den Job mit dem `sbatch` Befehl ab. Fordern Sie mit der `-N 2` Option zwei Knoten für diesen Job an und stellen Sie sicher, dass der Job erfolgreich gesendet wurde. Weitere Informationen `sbatch` dazu finden Sie [https://slurm.schedmd.com/sbatch.html](https://slurm.schedmd.com/sbatch.html)in der *Slurm-Dokumentation.*

```
$ sbatch -N 2 --wrap "srun hellojob.sh"
Submitted batch job 1
```

Sie können Ihre Warteschlange einsehen und den Status des Jobs mit dem `squeue` Befehl überprüfen. Da Sie keine bestimmte Warteschlange angegeben haben, wird die Standardwarteschlange (`spot`) verwendet. Weitere Informationen zu `squeue` finden Sie [https://slurm.schedmd.com/squeue.html](https://slurm.schedmd.com/squeue.html)in der *SlurmDokumentation*.

```
$ squeue
JOBID PARTITION     NAME     USER  ST      TIME  NODES NODELIST(REASON)
   1      spot     wrap ec2-user  R       0:10      2 spot-st-c5xlarge-1,spot-st-t2micro-1
```

Die Ausgabe zeigt, dass die Aufgabe zurzeit ausgeführt wird. Warten Sie, bis der Job abgeschlossen ist. Das dauert etwa 30 Sekunden. Dann lauf `squeue` noch einmal.

```
$ squeue
JOBID PARTITION     NAME     USER          ST       TIME  NODES NODELIST(REASON)
```

Nachdem alle Jobs in der Warteschlange abgeschlossen sind, suchen Sie nach der Ausgabedatei, die `slurm-1.out` in Ihrem aktuellen Verzeichnis benannt ist.

```
$ cat slurm-1.out
Hello World from spot-st-t2micro-1
Hello World from spot-st-c5xlarge-1
```

Die Ausgabe zeigt, dass der Job auf den `spot-st-c5xlarge-1` Knoten `spot-st-t2micro-1` und erfolgreich ausgeführt wurde.

Senden Sie nun denselben Job weiter, indem Sie Einschränkungen für bestimmte Instanzen mit den folgenden Befehlen angeben.

```
$ sbatch -N 3 -p spot -C "[c5.xlarge*1&t2.micro*2]" --wrap "srun hellojob.sh"
Submitted batch job 2
```

Sie haben diese Parameter verwendet für`sbatch`:
+ `-N 3`— fordert drei Knoten an.
+ `-p spot`— sendet den Job an die `spot` Warteschlange. Sie können einen Job auch an die `ondemand` Warteschlange senden, indem Sie Folgendes angeben`-p ondemand`.
+ `-C "[c5.xlarge*1&t2.micro*2]"`— gibt die spezifischen Knotenbeschränkungen für diesen Job an. Dies erfordert, dass ein `c5.xlarge` `t2.micro` Knoten und zwei Knoten für diesen Job verwendet werden.

Führen Sie den `sinfo` Befehl aus, um die Knoten und Warteschlangen anzuzeigen. Warteschlangen in AWS ParallelCluster werden Partitionen in genannt. Slurm

```
$ sinfo
PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
spot*        up   infinite      1  alloc# spot-dy-t2micro-1
spot*        up   infinite     17  idle~ spot-dy-c5xlarge-[2-10],spot-dy-t2micro-[2-9]
spot*        up   infinite      1  mix   spot-st-c5xlarge-1
spot*        up   infinite      1  alloc spot-st-t2micro-1
ondemand     up   infinite     10  idle~ ondemand-dy-c52xlarge-[1-10]
```

Die Knoten werden hochgefahren. Dies wird durch das `#` Suffix im Knotenstatus angezeigt. Führen Sie den squeue Befehl aus, um Informationen zu den Jobs im Cluster anzuzeigen.

```
$ squeue
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
   2      spot     wrap ec2-user CF       0:04      3 spot-dy-c5xlarge-1,spot-dy-t2micro-1,spot-st-t2micro-1
```

Ihr Job befindet sich im Status `CF` (CONFIGURING) und wartet darauf, dass Instances skaliert werden und dem Cluster beitreten.

Nach etwa drei Minuten sind die Knoten verfügbar und der Job wechselt in den Status `R` (RUNNING).

```
$ squeue
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
   2      spot     wrap ec2-user  R       0:07      3 spot-dy-t2micro-1,spot-st-c5xlarge-1,spot-st-t2micro-1
```

Der Job ist beendet und alle drei Knoten befinden sich im `idle` Status.

```
$ squeue
JOBID PARTITION     NAME     USER ST       TIME  NODES NODELIST(REASON)
$ sinfo
PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
spot*        up   infinite     17  idle~ spot-dy-c5xlarge-[1-9],spot-dy-t2micro-[2-9]
spot*        up   infinite      3  idle  spot-dy-t2micro-1,spot-st-c5xlarge-1,spot-st-t2micro-1
ondemand     up   infinite     10  idle~ ondemand-dy-c52xlarge-[1-10]
```

Wenn sich keine Jobs mehr in der Warteschlange befinden, suchen Sie `slurm-2.out` in Ihrem lokalen Verzeichnis nach.

```
$ cat slurm-2.out 
Hello World from spot-st-t2micro-1
Hello World from spot-dy-t2micro-1
Hello World from spot-st-c5xlarge-1
```

Dies ist der endgültige Status des Clusters.

```
$ sinfo
PARTITION AVAIL  TIMELIMIT  NODES  STATE NODELIST
spot*        up   infinite     17  idle~ spot-dy-c5xlarge-[1-9],spot-dy-t2micro-[2-9]
spot*        up   infinite      3  idle  spot-dy-t2micro-1,spot-st-c5xlarge-1,spot-st-t2micro-1
ondemand     up   infinite     10  idle~ ondemand-dy-c52xlarge-[1-10]
```

Nachdem Sie sich vom Cluster abgemeldet haben, können Sie den Vorgang durch folgenden Befehl bereinigen`pcluster delete-cluster`. Weitere Informationen erhalten Sie unter [`pcluster list-clusters`](pcluster.list-clusters-v3.md) und [`pcluster delete-cluster`](pcluster.delete-cluster-v3.md).

```
$ pcluster list-clusters
{
 "clusters": [
   {
     "clusterName": "multi-queue-cluster",
     "cloudformationStackStatus": "CREATE_COMPLETE",
     "cloudformationStackArn": "arn:aws:cloudformation:eu-west-1:123456789012:stack/multi-queue-cluster/1234567-abcd-0123-def0-abcdef0123456",
     "region": "eu-west-1",
     "version": "3.1.4",
     "clusterStatus": "CREATE_COMPLETE"
   }
 ]
}
$ pcluster delete-cluster -n multi-queue-cluster
{
 "cluster": {
   "clusterName": "multi-queue-cluster",
   "cloudformationStackStatus": "DELETE_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.1.4",
   "clusterStatus": "DELETE_IN_PROGRESS"
 }
}
```