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. # Slurm Workload Manager (`slurm`) ## Größe und Aktualisierung der Clusterkapazität Die Kapazität des Clusters wird durch die Anzahl der Rechenknoten definiert, die der Cluster skalieren kann. Rechenknoten werden von Amazon EC2 EC2-Instances unterstützt, die in der AWS ParallelCluster Konfiguration innerhalb von Rechenressourcen definiert sind`(Scheduling/SlurmQueues/`ComputeResources`)`, und sind in Warteschlangen organisiert, `(Scheduling/SlurmQueues)` die Partitionen 1:1 zugeordnet Slurm sind. Innerhalb einer Rechenressource ist es möglich, die Mindestanzahl von Rechenknoten (Instances), die immer im Cluster laufen müssen (`MinCount`), und die maximale Anzahl von Instances, auf die die Rechenressource skaliert werden kann, zu konfigurieren ([`MaxCount`3](Scheduling-v3.md#yaml-Scheduling-SlurmQueues-ComputeResources-MaxCount)). AWS ParallelCluster Startet bei der Clustererstellung oder bei einem Cluster-Update so viele Amazon EC2 EC2-Instances, wie `MinCount` für jede im Cluster definierte Rechenressource (`Scheduling/SlurmQueues/ ComputeResources`) konfiguriert sind. Die Instances, die gestartet werden, um die minimale Anzahl von Knoten für Rechenressourcen im Cluster abzudecken, werden als ***statische Knoten*** bezeichnet. Einmal gestartet, sollen statische Knoten im Cluster persistent sein und werden nicht vom System beendet, es sei denn, ein bestimmtes Ereignis oder eine bestimmte Bedingung tritt ein. Zu diesen Ereignissen gehören beispielsweise der Ausfall von Slurm Amazon EC2 EC2-Zustandsprüfungen und die Änderung des Slurm Knotenstatus auf DRAIN oder DOWN. Die Amazon EC2 EC2-Instances im Bereich von `1` bis `‘MaxCount - MinCount’` (`MaxCount `*minus*)` MinCount)`, die bei Bedarf gestartet werden, um die erhöhte Last des Clusters zu bewältigen, werden als ***dynamische Knoten*** bezeichnet. Sie sind kurzlebig, sie werden gestartet, um ausstehende Jobs zu bearbeiten, und werden beendet, sobald sie für einen `Scheduling/SlurmSettings/ScaledownIdletime` in der Cluster-Konfiguration definierten Zeitraum inaktiv bleiben (Standard: 10 Minuten). Statische Knoten und dynamische Knoten entsprechen dem folgenden Benennungsschema: + Statische Knoten `-st--` wo ` = 1..ComputeResource/MinCount` + Dynamische Knoten `-dy--` wo ` = 1..(ComputeResource/MaxCount - ComputeResource/MinCount)` Zum Beispiel bei der folgenden AWS ParallelCluster Konfiguration: ``` Scheduling: Scheduler: Slurm SlurmQueues: - Name: queue1 ComputeResources: - Name: c5xlarge Instances: - InstanceType: c5.xlarge MinCount: 100 MaxCount: 150 ``` Die folgenden Knoten werden definiert in Slurm ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` Wenn es sich bei einer Rechenressource um statische Rechenknoten handelt`MinCount == MaxCount`, sind alle zugehörigen Rechenknoten statisch und alle Instanzen werden zur creation/update Clusterzeit gestartet und am Laufen gehalten. Beispiel: ``` Scheduling: Scheduler: slurm SlurmQueues: - Name: queue1 ComputeResources: - Name: c5xlarge Instances: - InstanceType: c5.xlarge MinCount: 100 MaxCount: 100 ``` ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` ## Aktualisierung der Clusterkapazität Die Aktualisierung der Clusterkapazität umfasst das Hinzufügen oder Entfernen von Warteschlangen, Rechenressourcen oder das Ändern `MinCount/MaxCount` einer Rechenressource. Ab AWS ParallelCluster Version 3.9.0 muss zur Reduzierung der Größe einer Warteschlange die Rechenflotte gestoppt oder auf TERMINATE [QueueUpdateStrategy](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-QueueUpdateStrategy)gesetzt werden, bevor ein Cluster-Update stattfinden kann. In folgenden Fällen ist es nicht erforderlich, die Rechenflotte zu beenden oder auf [QueueUpdateStrategy](Scheduling-v3.md#yaml-Scheduling-SlurmSettings-QueueUpdateStrategy)TERMINATE zu setzen: + Neue Warteschlangen zu Scheduling hinzufügen/ [`SlurmQueues`](Scheduling-v3.md#Scheduling-v3-SlurmQueues) + Neue Rechenressourcen `Scheduling/SlurmQueues/ComputeResources` zu einer Warteschlange hinzufügen + Erhöhung der `MaxCount` Anzahl einer Rechenressource + Erhöhung MinCount einer Rechenressource und Erhöhung MaxCount derselben Rechenressource um mindestens die gleiche Menge ## Überlegungen und Einschränkungen In diesem Abschnitt sollen alle wichtigen Faktoren, Einschränkungen oder Einschränkungen beschrieben werden, die bei der Größenänderung der Clusterkapazität berücksichtigt werden sollten. + Beim Entfernen einer Warteschlange aus `Scheduling/SlurmQueues` allen Rechenknoten mit Namen`-*`, sowohl statische als auch dynamische, werden sie aus der Slurm Konfiguration entfernt und die entsprechenden Amazon EC2 EC2-Instances werden beendet. + Beim Entfernen einer Rechenressource `Scheduling/SlurmQueues/ComputeResources` aus einer Warteschlange werden alle Rechenknoten mit Namen`-*--*`, sowohl statisch als auch dynamisch, aus der Slurm Konfiguration entfernt und die entsprechenden Amazon EC2 EC2-Instances werden beendet. Wenn wir den `MinCount` Parameter einer Rechenressource ändern, können wir zwei verschiedene Szenarien unterscheiden: ob gleich gehalten `MaxCount` wird `MinCount` (nur statische Kapazität) und ob größer als `MinCount` (gemischte statische und dynamische Kapazität) `MaxCount` ist. ### Die Kapazität ändert sich nur bei statischen Knoten + Wenn `MinCount == MaxCount` beim Erhöhen `MinCount` (und`MaxCount`) der Cluster konfiguriert wird, indem die Anzahl der statischen Knoten auf den neuen Wert von erhöht wird `MinCount` `-st--` und das System weiterhin versucht, Amazon EC2 EC2-Instances zu starten, um die neue erforderliche statische Kapazität zu erfüllen. + Wenn `MinCount == MaxCount` beim Verringern `MinCount` (und`MaxCount`) der Menge N der Cluster konfiguriert wird, indem die letzten N statischen Knoten entfernt werden, `-st--...]` und das System beendet die entsprechenden Amazon EC2 EC2-Instances. + Ursprünglicher Zustand `MinCount = MaxCount = 100` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Update `-30` am `MinCount` und `MaxCount: MinCount = MaxCount = 70` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 70 idle queue1-st-c5xlarge-[1-70] ``` ### Kapazitätsänderungen bei gemischten Knoten Wenn der Cluster um einen Betrag N erhöht `MinCount` `MaxCount` wird (vorausgesetzt`MinCount < MaxCount`, dass er unverändert bleibt), wird der Cluster konfiguriert, indem die Anzahl der statischen Knoten auf den neuen Wert von `MinCount` (`old_MinCount + N`): erweitert wird, `-st--` und das System versucht weiterhin, Amazon EC2 EC2-Instances zu starten, um die neue erforderliche statische Kapazität zu erfüllen. Um der `MaxCount` Kapazität der Rechenressource Rechnung zu tragen, wird die Cluster-Konfiguration außerdem aktualisiert, *indem die letzten N dynamischen Knoten* entfernt werden. Das System beendet dann die entsprechenden Amazon EC2 EC2-Instances. `-dy--[...]` + Ausgangszustand: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Aktualisieren Sie \$130 auf `MinCount : MinCount = 130 (MaxCount = 150)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 20 idle~ queue1-dy-c5xlarge-[1-20] queue1* up infinite 130 idle queue1-st-c5xlarge-[1-130] ``` Wenn `MinCount < MaxCount` bei Erhöhung `MinCount` und gleichem Wert N `MaxCount` der Cluster konfiguriert wird, indem die Anzahl der statischen Knoten auf den neuen Wert von `MinCount` (`old_MinCount + N`): erweitert wird, `-st--` und das System versucht weiterhin, Amazon EC2 EC2-Instances zu starten, um die neue erforderliche statische Kapazität zu erfüllen. Darüber hinaus werden keine Änderungen an der Anzahl der dynamischen Knoten vorgenommen, um den neuen Anforderungen gerecht zu werden `MaxCount` Wert. + Ausgangszustand: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Aktualisieren Sie \$130 auf `MinCount : MinCount = 130 (MaxCount = 180)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 20 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 130 idle queue1-st-c5xlarge-[1-130] ``` Wenn die `MinCount` Anzahl N verringert `MaxCount` wird (vorausgesetzt`MinCount < MaxCount`, dass sie unverändert bleibt), wird der Cluster konfiguriert, indem die letzten N statischen Knoten entfernt werden, `-st--[...` und das System beendet die entsprechenden Amazon EC2 EC2-Instances. Um der `MaxCount` Kapazität der Rechenressource Rechnung zu tragen, wird außerdem die Cluster-Konfiguration aktualisiert, indem die Anzahl der dynamischen Knoten erhöht wird, um die Lücke zu schließen. `MaxCount - new_MinCount: -dy--[1..]` In diesem Fall, da es sich um dynamische Knoten handelt, werden keine neuen Amazon EC2 EC2-Instances gestartet, es sei denn, der Scheduler hat Jobs auf den neuen Knoten ausstehend. + Ausgangszustand: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Update -30 am `MinCount : MinCount = 70 (MaxCount = 120)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 80 idle~ queue1-dy-c5xlarge-[1-80] queue1* up infinite 70 idle queue1-st-c5xlarge-[1-70] ``` Wenn `MinCount < MaxCount` `MaxCount` der Wert abnimmt `MinCount` und die gleiche Menge N beträgt, wird der Cluster konfiguriert, indem die letzten N statischen Knoten entfernt werden, `-st--...]` und das System beendet die entsprechenden Amazon EC2 EC2-Instances. Darüber hinaus werden keine Änderungen an der Anzahl der dynamischen Knoten vorgenommen, um dem neuen `MaxCount` Wert Rechnung zu tragen. + Ausgangszustand: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Update -30 am `MinCount : MinCount = 70 (MaxCount = 120)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 80 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 70 idle queue1-st-c5xlarge-[1-70] ``` Wenn die `MaxCount` Anzahl N verringert wird (vorausgesetzt`MinCount < MaxCount`, dass sie unverändert bleibt), `MinCount` wird der Cluster konfiguriert, indem die letzten N dynamischen Knoten entfernt werden, `-dy--]` und das System beendet die entsprechenden Amazon EC2 EC2-Instances, falls sie ausgeführt wurden. Es werden keine Auswirkungen auf die statischen Knoten erwartet. + Ursprünglicher Zustand: `MinCount = 100; MaxCount = 150` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 50 idle~ queue1-dy-c5xlarge-[1-50] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` + Update -30 am `MaxCount : MinCount = 100 (MaxCount = 120)` + ``` $ sinfo PARTITION AVAIL TIMELIMIT NODES STATE NODELIST queue1* up infinite 20 idle~ queue1-dy-c5xlarge-[1-20] queue1* up infinite 100 idle queue1-st-c5xlarge-[1-100] ``` ## Auswirkungen auf die Arbeitsplätze In allen Fällen, in denen Knoten entfernt und Amazon EC2 EC2-Instances beendet werden, wird ein Sbatch-Job, der auf den entfernten Knoten ausgeführt wird, erneut in die Warteschlange gestellt, es sei denn, es gibt keine anderen Knoten, die die Auftragsanforderungen erfüllen. Im letzten Fall schlägt der Job mit dem Status NODE\$1FAIL fehl und verschwindet aus der Warteschlange. Er muss manuell erneut eingereicht werden. Wenn Sie planen, ein Update zur Änderung der Clustergröße durchzuführen, können Sie verhindern, dass Jobs auf den Knoten ausgeführt werden, die während des geplanten Updates entfernt werden. Dies ist möglich, indem Sie festlegen, dass die Knoten im Rahmen der Wartung entfernt werden. Bitte beachten Sie, dass die Einstellung eines Knotens zur Wartung keine Auswirkungen auf Jobs hat, die eventuell bereits auf dem Knoten ausgeführt werden. Nehmen wir an, dass Sie mit dem geplanten Update zur Änderung der Clustergröße den Knoten entfernen werden`qeueu-st-computeresource-[9-10`]. Sie können eine Slurm Reservierung mit dem folgenden Befehl erstellen ``` sudo -i scontrol create reservation ReservationName=maint_for_update user=root starttime=now duration=infinite flags=maint,ignore_jobs nodes=qeueu-st-computeresource-[9-10] ``` Dadurch wird eine Slurm Reservierung erstellt, die `maint_for_update` auf den Knoten benannt ist`qeueu-st-computeresource-[9-10]`. Ab dem Zeitpunkt, an dem die Reservierung erstellt wird, können keine Jobs mehr auf den Knoten ausgeführt werden`qeueu-st-computeresource-[9-10]`. Bitte beachten Sie, dass die Reservierung nicht verhindert, dass Jobs irgendwann auf den Knoten zugewiesen werden`qeueu-st-computeresource-[9-10]`. Wenn die Slurm Reservierung nach der Aktualisierung der Clustergröße nur für Knoten festgelegt wurde, die während der Aktualisierung der Clustergröße entfernt wurden, wird die Wartungsreservierung automatisch gelöscht. Wenn Sie stattdessen eine Slurm Reservierung für Knoten erstellt haben, die nach der Aktualisierung der Clustergröße noch vorhanden sind, möchten wir möglicherweise die Wartungsreservierung auf den Knoten nach der Aktualisierung der Größe entfernen. Verwenden Sie dazu den folgenden Befehl ``` sudo -i scontrol delete ReservationName=maint_for_update ``` [Weitere Informationen zur Slurm Reservierung finden Sie im offiziellen SchedMD-Dokument hier.](https://slurm.schedmd.com/reservations.html) ## Cluster-Aktualisierung bei Kapazitätsänderungen Bei einer Änderung der Scheduler-Konfiguration werden während des Cluster-Aktualisierungsvorgangs die folgenden Schritte ausgeführt: + Stoppen AWS ParallelCluster `clustermgtd (supervisorctl stop clustermgtd)` + Generieren Sie die aktualisierte Slurm Partitionskonfiguration anhand der AWS ParallelCluster Konfiguration + Neustart `slurmctld` (erfolgt über das Chef-Dienstrezept) + `slurmctld`Status überprüfen `(systemctl is-active --quiet slurmctld.service)` + Konfiguration neu laden Slurm `(scontrol reconfigure)` + `clustermgtd (supervisorctl start clustermgtd)` starten Weitere Informationen zu Slurm finden Sie unter [https://slurm.schedmd.com](https://slurm.schedmd.com). Downloads finden Sie unter [https://github.com/SchedMD/slurm/tags](https://github.com/SchedMD/slurm/tags). [Den Quellcode finden Sie unter slurm. https://github.com/SchedMD/](https://github.com/SchedMD/slurm) ## Unterstützte Cluster- und SLURM-Versionen In der folgenden Tabelle sind die AWS ParallelCluster Slurm Versionen aufgeführt, die AWS unterstützt werden. | AWS ParallelCluster Version (en) | Unterstützte Slurm-Version | | --- | --- | | 3.13.0 | 24.05.07 | | 3.12.0 | 23.11.10 | | 3.11.0 | 23.11.10 | | 3.9.2, 3.9.3, 3.10.0 | 23,11,7 | | 3,9,0, 3,9,1 | 23,11,4 | | 3.8.0 | 23.02,7 | | 3.7.2 | 23.02,6 | | 3.7.1 | 23,02,5 | | 3.7.0 | 23,02,4 | | 3.6.0, 3.6.1 | 23,02,2 | | 3,5.0, 3,5.1 | 22.05.8 | | 3,4,0, 3,4,1 | 22.05.7 | | 3.3.0, 3.3.1 | 22.05.5 | | 3.1.4, 3.1.5, 3.2.0, 3.2.1 | 21.08.8-2 | | 3.1.2, 3.1.3 | 21,08,6 | | 3.1.1 | 21,08,5 | | 3.0.0 | 20,11,8 | **Topics** + [Größe und Aktualisierung der Clusterkapazität](#cluster-capacity-size-and-update) + [Aktualisierung der Clusterkapazität](#cluster-capacity-update) + [Überlegungen und Einschränkungen](#considerations-limitations) + [Auswirkungen auf die Arbeitsplätze](#impacts-on-jobs) + [Cluster-Aktualisierung bei Kapazitätsänderungen](#cluster-update-process) + [Unterstützte Cluster- und SLURM-Versionen](#cluster-slurm-version-table) + [Konfiguration mehrerer Warteschlangen](configuration-of-multiple-queues-v3.md) + [SlurmLeitfaden für den Modus mit mehreren Warteschlangen](multiple-queue-mode-slurm-user-guide-v3.md) + [Slurm geschützter Cluster-Modus](slurm-protected-mode-v3.md) + [Slurmschneller Cluster-Failover mit unzureichender Kapazität](slurm-short-capacity-fail-mode-v3.md) + [Slurm speicherbasierte Terminplanung](slurm-mem-based-scheduling-v3.md) + [Zuweisung mehrerer Instanztypen mit Slurm](slurm-multiple-instance-allocation-v3.md) + [Cluster-Skalierung für dynamische Knoten](scheduler-node-allocation-v3.md) + [SlurmAbrechnung mit AWS ParallelCluster](slurm-accounting-v3.md) + [Slurm Anpassung der Konfiguration](slurm-configuration-settings-v3.md) + [Slurm und `prolog` `epilog`](slurm-prolog-epilog-v3.md) + [Größe und Aktualisierung der Clusterkapazität](slurm-cluster-capacity-size-and-update.md)