CycleCloud GridEngine-Cluster
Open Grid Scheduler (Grid Engine) kann auf einfache Weise in einem Azure CycleCloud-Cluster aktiviert werden, indem der "run_list" in der Clusterdefinition geändert wird. Die beiden grundlegenden Komponenten eines Grid Engine-Clusters sind der Masterknoten, der ein freigegebenes Dateisystem bereitstellt, auf dem die Grid Engine-Software ausgeführt wird, und die "execute"-Knoten, die die Hosts sind, die das freigegebene Dateisystem einbinden und die übermittelten Aufträge ausführen. Ein einfacher Codeausschnitt für grid Engine-Clustervorlagen kann beispielsweise wie folgt aussehen:
[cluster grid-engine]
[[node master]]
ImageName = cycle.image.centos7
MachineType = Standard_A4 # 8 cores
[[[configuration]]]
run_list = role[sge_master_role]
[[nodearray execute]]
ImageName = cycle.image.centos7
MachineType = Standard_A1 # 1 core
[[[configuration]]]
run_list = role[sge_execute_role]
Hinweis
Die Rollennamen enthalten aus älteren Gründen "sge": Grid Engine war ein Produkt von Sun Microsystems.
Das Importieren und Starten eines Clusters mit Definition in CycleCloud führt zu einem einzelnen Masterknoten. Ausführungsknoten können dem Cluster über den cyclecloud add_node
Befehl hinzugefügt werden. So fügen Sie beispielsweise 10 weitere Ausführungsknoten hinzu:
cyclecloud add_node grid-engine -t execute -c 10
Automatische Skalierung der Raster-Engine
Azure CycleCloud unterstützt die automatische Skalierung für grid Engine. Dies bedeutet, dass die Software den Status Ihrer Warteschlange überwacht und Knoten bei Bedarf ein- und ausschaltet, um die Arbeit in einem optimalen Zeit-/Kostenaufwand abzuschließen. Sie können die automatische Skalierung für grid Engine aktivieren, indem Sie Ihrer Clusterdefinition hinzufügen Autoscale = true
:
[cluster grid-engine]
Autoscale = True
Standardmäßig werden alle Aufträge, die an die Grid-Engine-Warteschlange übermittelt werden, auf Computern vom Typ "execute" ausgeführt. Dabei handelt es sich um Computer, die durch das Knotenarray "execute" definiert werden. Sie sind nicht auf den Namen "execute" beschränkt, noch sind Sie auf einen einzelnen Computerkonfigurationstyp zum Ausführen von Aufträgen und zur automatischen Skalierung beschränkt.
Ein häufiger Fall kann beispielsweise sein, dass Sie über einen Cluster mit zwei unterschiedlichen Knotendefinitionen verfügen. Eine davon dient zum Ausführen von "normalen" Aufträgen, die die Standard-CPU nutzen, während ein anderer Auftragstyp GPU-Computer verwenden kann. In diesem Fall sollten Sie Ihre Warteschlange unabhängig sowohl nach normalen Aufträgen als auch nach GPU-Aufträgen skalieren, um sicherzustellen, dass sie über eine geeignete Anzahl von Computern verfügen, die die Arbeitswarteschlange nutzen können. Eine Beispieldefinition wäre etwa:
[cluster grid-engine]
Autoscale = True
[[node master]]
ImageName = cycle.image.centos7
MachineType = Standard_A3 # 4 cores
[[[configuration]]]
run_list = role[sge_master_role]
[[nodearray execute]]
ImageName = cycle.image.centos7
MachineType = Standard_A4 # 8 cores
[[[configuration]]]
run_list = role[sge_execute_role]
[[nodearray gpu]]
MachineType = Standard_NV12 # 2 GPUs
ImageName = cycle.image.centos7
# Set the number of cores to the number of GPUs for autoscaling purposes
CoreCount = 2
[[[configuration]]]
run_list = role[sge_execute_role]
gridengine.slot_type = gpu
gridengine.slots = 2
Im obigen Beispiel gibt es nun zwei Knotenarrays: Eines ist ein "Standard"-Ausführungsknotenarray, das zweite heißt "gpu", das einen MachineType mit zwei Nvidia-GPUs (Standard_NV12 in Azure) bereitstellt. Beachten Sie außerdem, dass neben dem "csge:sgeexec"-Rezept jetzt zwei neue Elemente im Konfigurationsabschnitt vorhanden sind. Das Hinzufügen gridengine.slot_type = gpu
teilt dem Grid Engine-Planer mit, dass diese Knoten "gpu"-Knoten heißen sollen und daher nur GPU-Aufträge ausführen sollten. Der Name "gpu" ist beliebig, aber ein Name, der den Knoten beschreibt, ist am nützlichsten. Legen Sie fest gridengine.slots = 2
, damit die Software sicherstellen muss, dass dieser Knotentyp nur zwei Aufträge gleichzeitig ausführen kann (Standard_NV12 nur über 2 GPUs verfügt). Standardmäßig entspricht die Anzahl der Slots pro Knoten in Grid Engine der Anzahl der CPUs im System, die in diesem Fall dazu führen würde, dass zu viele Aufträge gleichzeitig auf dem Knoten ausgeführt werden. Im obigen Beispiel ist auf das Nodearray festgelegt, CoreCount=2
um die Anzahl der auf machineType verfügbaren GPUs abzugleichen, sodass CycleCloud dieses Array bei gpu- und CPU-Anzahl ordnungsgemäß skalieren kann.
Sie können die Anzahl der Slots und slot_type Ihrer Computer überprüfen, indem Sie den Befehl ausführen:
-bash-4.1# qstat -F slot_type
queuename qtype resv/used/tot. load_avg arch states
---------------------------------------------------------------------------------
all.q@ip-0A000404 BIP 0/0/4 0.17 linux-x64
hf:slot_type=execute
---------------------------------------------------------------------------------
all.q@ip-0A000405 BIP 0/0/2 2.18 linux-x64
hf:slot_type=gpu
---------------------------------------------------------------------------------
all.q@ip-0A000406 BIP 0/0/4 0.25 linux-x64
Beachten Sie, dass es einen von jedem "slot_type" gibt, den wir angegeben haben (Execute und GPU), und die Anzahl der Slots für den "execute"-Slot beträgt 4, d. h. die Anzahl der CPUs auf dem Computer. Die Anzahl der Slots für den Slottyp "gpu" ist 2, die wir in unserer Clusterkonfigurationsvorlage angegeben haben. Der dritte Computer ist der Masterknoten, auf dem keine Aufträge ausgeführt werden.
Erweiterte Verwendung der Grid-Engine
Die oben genannten Konfigurationseinstellungen ermöglichen eine erweiterte Anpassung von Knoten und Knotenarrays. Wenn aufträge z. B. eine bestimmte Menge an Arbeitsspeicher erfordern, z. B. 10 GB, können Sie ein Nodearray zum Ausführen definieren, das Computer mit 60 GB Arbeitsspeicher startet, und dann die Konfigurationsoptionen gridengine.slots = 6
hinzufügen, um sicherzustellen, dass nur 6 Aufträge gleichzeitig auf diesem Knotentyp ausgeführt werden können (sicherstellen, dass jeder Auftrag über mindestens 10 GB Arbeitsspeicher verfügt).
Gruppierte Knoten in Grid-Engine
Wenn ein paralleler Auftrag an die Grid-Engine übermittelt wird, wird von CycleCloud standardmäßig ein Automatischeskalierungsverhalten verwendet, um jeden MPI-Auftrag als gruppierte Knotenanforderung zu behandeln. Gruppierte Knoten sind eng gekoppelt und eignen sich ideal für MPI-Workflows.
Wenn eine Gruppe von gruppierten Knoten einem Grid Engine-Cluster beitreten, wird die Gruppen-ID jedes Knotens als Wert des komplexen Werts affinity_group
verwendet. Wenn für Aufträge angegeben affinity_group
werden muss, kann der Grid Engine-Planer sicherstellen, dass Aufträge nur auf Computern landen, die sich in derselben Gruppe befinden.
Die CycleCloud-Automatisierung fordert automatisch gruppierte Knoten an und weist sie verfügbaren Affinitätsgruppen zu, wenn parallele Aufträge auftreten.
Übermitteln von Aufträgen an Grid-Engine
Die generischste Methode zum Übermitteln von Aufträgen an einen Grid Engine-Planer ist der Befehl:
qsub my_job.sh
Mit diesem Befehl wird ein Auftrag übermittelt, der auf einem Knoten vom Typ "execute" ausgeführt wird, d. h. auf einem Knoten, der durch das nodearray "execute" definiert wird. Damit ein Auftrag auf einem nodearray eines anderen Typs ausgeführt wird, z. B. dem oben genannten Knotentyp "gpu", ändern wir unsere Übermittlung:
qsub -l slot_type=gpu my_gpu_job.sh
Mit diesem Befehl wird sichergestellt, dass der Auftrag nur auf einem "slot_type" von "gpu" ausgeführt wird.
Wenn slot_type ausgelassen wird, wird dem Auftrag automatisch "execute" zugewiesen. Der Mechanismus, der aufträgen automatisch slot_type zuweist, kann vom Benutzer geändert werden. Ein Python-Skript unter /opt/cycle/jetpack/config/autoscale.py kann erstellt werden, das eine einzelne Funktion "sge_job_handler" definieren sollte. Diese Funktion empfängt eine Wörterbuchdarstellung des Auftrags, ähnlich der Ausgabe eines qstat -j JOB_ID
Befehls und sollte ein Wörterbuch mit harten Ressourcen zurückgeben, die für den Auftrag aktualisiert werden müssen. Unten sehen Sie beispielsweise ein Skript, das der "gpu" einen Auftrag zuweist, slot_type wenn der Auftragsname die Buchstaben "gpu" enthält. Dies würde es einem Benutzer ermöglichen, seine Aufträge aus einem automatisierten System zu übermitteln, ohne die Auftragsparameter ändern zu müssen, und die Aufträge weiterhin auf den richtigen Knoten ausführen und automatisch skalieren zu lassen:
#!/usr/env python
#
# File: /opt/cycle/jetpack/config/autoscale.py
#
def sge_job_handler(job):
# The 'job' parameter is a dictionary containing the data present in a 'qstat -j JOB_ID':
hard_resources = {'slot_type': 'execute', 'affinity_group' : 'default' }
# Don't modify anything if the job already has a slot type
# You could modify the slot type at runtime by not checking this
if 'hard_resources' in job and 'slot_type' in job['hard_resources']:
return hard_resources
# If the job's script name contains the string 'gpu' then it's assumed to be a GPU job.
# Return a dictionary containing the new job_slot requirement to be updated.
# For example: 'big_data_gpu.sh' would be run on a 'gpu' node.
if job['job_name'].find('gpu') != -1:
hard_resources {'slot_type': 'gpu'}
else:
return hard_resources
Der übergebene Parameter "job" ist ein Wörterbuch, das die Daten in einem qstat -j JOB_ID
Aufruf enthält:
{
"job_number": 5,
"job_name": "test.sh",
"script_file": "test.sh",
"account": "sge",
"owner": "cluster.user",
"uid": 100,
"group": "cluster.user",
"gid": 200,
"submission_time": "2013-10-09T09:09:09",
"job_args": ['arg1', 'arg2', 'arg3'],
"hard_resources": {
'mem_free': '15G',
'slot_type': 'execute'
}
}
Sie können diese Skriptfunktion verwenden, um slot_type automatisch basierend auf jedem parameter zuzuweisen, der im Auftrag definiert ist, z. B. Argumente, andere Ressourcenanforderungen wie Arbeitsspeicher, übermittelnder Benutzer usw.
Wenn Sie 5 Aufträge pro "slot_type" übermitteln würden:
qsub -t 1:5 gpu_job.sh
qsub -t 1:5 normal_job.sh
Es wären jetzt 10 Aufträge in der Warteschlange. Aufgrund des oben definierten Skripts würden die fünf Aufträge mit "gpu" im Namen automatisch so konfiguriert, dass sie nur auf Knoten von "slot_type=gpu" ausgeführt werden. Der CycleCloud-Autoskalierungsmechanismus erkennt, dass es 5 Gpu-Aufträge und 5 "Execute"-Aufträge gibt. Da das Nodearray "gpu" so definiert ist, dass er über 2 Slots pro Knoten verfügt, würde CycleCloud 3 dieser Knoten starten (5/2=2,5 aufgerundet auf 3). Es gibt 5 normale Aufträge, da der Computertyp für das Nodearray "execute" jeweils 4 CPU's aufweist, würde CycleCloud 2 dieser Knoten starten, um die Aufträge zu verarbeiten (5/4=1,25 aufgerundet auf 2). Nach kurzer Zeit, in der die neu gestarteten Knoten gestartet und konfiguriert wurden, würden alle 10 Aufträge bis zum Abschluss ausgeführt, und dann würden die fünf Knoten automatisch heruntergefahren, bevor Sie vom Cloudanbieter erneut in Rechnung gestellt werden.
Es wird davon ausgegangen, dass Aufträge eine Dauer von einer Stunde haben. Wenn die Auftragslaufzeit bekannt ist, kann der Algorithmus für die autoskalierte Skalierung von diesen Informationen profitieren. Informieren Sie die automatische Skalierung über die erwartete Auftragsausführungszeit, indem Sie sie dem Auftragskontext hinzufügen. Das folgende Beispiel teilt der autoskalierung mit, dass die Auftragslaufzeit durchschnittlich 10 Minuten beträgt:
qsub -ac average_runtime=10 job_with_duration_of_10m.sh
Referenz zur Grid-Engine-Konfiguration
Im Folgenden finden Sie die spezifischen Konfigurationsoptionen der Grid-Engine, die Sie zum Anpassen der Funktionalität umschalten können:
SGE-Specific-Konfigurationsoptionen | BESCHREIBUNG |
---|---|
gridengine.slots | Die Anzahl der Slots für einen bestimmten Knoten, der an die Grid-Engine gemeldet werden soll. Die Anzahl der Slots ist die Anzahl gleichzeitiger Aufträge, die ein Knoten ausführen kann. Dieser Wert ist standardmäßig die Anzahl der CPUs auf einem bestimmten Computer. Sie können diesen Wert in Fällen überschreiben, in denen Sie keine Aufträge basierend auf CPU, sondern auf Arbeitsspeicher, GPUs usw. ausführen. |
gridengine.slot_type | Der Name des Typs "Slot", den ein Knoten bereitstellt. Der Standardwert ist "execute". Wenn ein Auftrag mit der harten Ressource "slot_type=" gekennzeichnet ist, wird dieser Auftrag nur auf einem Computer desselben Slottyps ausgeführt. Dadurch können Sie unterschiedliche Software- und Hardwarekonfigurationen pro Knoten erstellen und sicherstellen, dass immer ein geeigneter Auftrag für den richtigen Knotentyp geplant ist. |
gridengine.ignore_fqdn | Standardwert: TRUE Legen Sie auf false fest, wenn alle Knoten in Ihrem Cluster nicht Teil einer einzelnen DNS-Domäne sind. |
gridengine.version | Standardwert: '2011.11'. Dies ist die zu installierende und auszuführende Grid-Engine-Version. Dies ist derzeit die Standardoption. In zukunft können zusätzliche Versionen der Grid Engine-Software unterstützt werden. |
gridengine.root | Standard: '/sched/sge/sge-2011.11' Hier wird die Grid-Engine auf jedem Knoten im System installiert und bereitgestellt. Es wird empfohlen, diesen Wert nicht zu ändern, aber wenn er der Fall ist, sollte er auf jedem Knoten im Cluster auf den gleichen Wert festgelegt werden. |
CycleCloud unterstützt einen Standardsatz von Autotop-Attributen für Planer:
attribute | BESCHREIBUNG |
---|---|
cyclecloud.cluster.autoscale.stop_enabled | Ist das automatische Beenden auf diesem Knoten aktiviert? [true/false] |
cyclecloud.cluster.autoscale.idle_time_after_jobs | Die Zeitspanne (in Sekunden), in der ein Knoten nach Abschluss von Aufträgen im Leerlauf bleibt, bevor er herunterskaliert wird. |
cyclecloud.cluster.autoscale.idle_time_before_jobs | Die Zeitspanne (in Sekunden), die ein Knoten vor dem Abschließen von Aufträgen im Leerlauf hat, bevor er herunterskaliert wird. |
Bekannte Probleme
-
qsh
der Befehl für die interaktive Sitzung funktioniert nicht. Alternativqrsh
verwenden. - Der
exclusive=1
Komplex wird durch die automatische Skalierung nicht berücksichtigt. Dadurch können weniger Knoten als erwartet gestartet werden.
Hinweis
Obwohl Windows eine offiziell unterstützte GridEngine-Plattform ist, unterstützt CycleCloud die Ausführung von GridEngine unter Windows derzeit nicht.
Diese Seite enthält Funktionen und Konfiguration der Verwendung von GridEngine (Altair) mit CycleCloud.
Konfigurieren von Ressourcen
Die cyclecloud-gridengine-Anwendung gleicht Sge-Ressourcen mit Azure-Cloudressourcen ab, um umfangreiche Tools für die automatische Skalierung und Clusterkonfiguration bereitzustellen. Die Anwendung wird automatisch für Cluster bereitgestellt, die über die CycleCloud-Benutzeroberfläche erstellt werden, oder sie kann auf einem beliebigen gridengine-Administratorhost auf einem vorhandenen Cluster installiert werden.
Installieren oder Aktualisieren von cyclecloud-gridengine
Das Bundle cyclecloud-gridengine ist in github als Releaseartefakt verfügbar. Das Installieren und Aktualisieren ist der gleiche Prozess. Die Anwendung erfordert python3 mit virtualenv.
tar xzf cyclecloud-gridengine-pkg-*.tar.gz
cd cyclecloud-gridengine
./install.sh
Wichtige Dateien
Die Anwendung analysiert die Sgekonfiguration jedes Mal, wenn sie aufgerufen wird – Aufträge, Warteschlangen, Komplexe. Informationen werden im stderr und stdout des Befehls sowie in einer Protokolldatei bereitgestellt, beide auf konfigurierbaren Ebenen. Alle gridengine-Verwaltungsbefehle mit Argumenten werden ebenfalls in der Datei protokolliert.
BESCHREIBUNG | Standort |
---|---|
Konfiguration für automatische Skalierung | /opt/cycle/gridengine/autoscale.json |
Protokoll automatisch skalieren | /opt/cycle/jetpack/logs/autoscale.log |
qconf-Ablaufverfolgungsprotokoll | /opt/cycle/jetpack/logs/qcmd.log |
SGE-Warteschlangen, Hostgruppen und parallele Umgebungen
Das Cyclecloud-gridengine-Autoskalierungs-Hilfsprogramm azge
fügt dem Cluster Hosts gemäß der Clusterkonfiguration hinzu. Die Vorgänge zur automatischen Skalierung führen die folgenden Aktionen aus.
- Lesen Sie die Auftragsressourcenanforderung, und suchen Sie nach einer geeigneten VM zum Starten.
- Starten Sie den virtuellen Computer, und warten Sie, bis sie bereit ist.
- Lesen der Warteschlange und parallelen Umgebung aus dem Auftrag
- Weisen Sie den Host basierend auf der Warteschlange/pe einer entsprechenden Hostgruppe zu.
- Hinzufügen des Hosts zum Cluster sowie zu jeder anderen Warteschlange, die die Hostgruppe enthält
Betrachten Sie die folgende Warteschlangendefinition für eine Warteschlange namens short.q
hostlist @allhosts @mpihg01 @mpihg02 @lowprio
...
seq_no 10000,[@lowprio=10],[@mpihg01=100],[@mpihg02=200]
pe_list NONE,[@mpihg01=mpi01], \
[@mpihg02=mpi02]
Das Übermitteln eines Auftrags von qsub -q short.q -pe mpi02 12 my-script.sh
beginnt beim Leasen eines virtuellen Computers. Wenn er dem Cluster hinzugefügt wird, wird er hostgroup @mpihg02 hinzugefügt, da dies die Hostgruppe ist, die sowohl für die Warteschlange als auch für die parallele Umgebung verfügbar ist. Sie wird auch @allhosts hinzugefügt, bei der es sich um eine spezielle Hostgruppe handelt.
Ohne angabe eines pe qsub -q short.q my-script.sh
wird die resultierende VM @allhosts hinzugefügt, und @lowpriority dies die Hostgruppen in der Warteschlange sind, denen kein pes zugewiesen ist.
Schließlich führt ein mit übermittelter qsub -q short.q -pe mpi0* 12 my-script.sh
Auftrag dazu, dass je nach CycleCloud-Zuordnungsvorhersagen eine VM entweder @mpihg01 oder @mpihg02 hinzugefügt wird.
Parallele Umgebungen entsprechen implizit der Platzierungsgruppe cyclecloud. VMs in einem PE sind darauf beschränkt, sich innerhalb desselben Netzwerks zu befinden. Wenn Sie ein PE verwenden möchten, das keine Platzierungsgruppe behält, verwenden Sie autoscale.json , um sich abzumelden.
Hier deaktivieren wir Platzierungsgruppen für die make pe:
"gridengine": {
"pes": {
"make": {
"requires_placement_groups": false
}
},
CycleCloud-Platzierungsgruppen
CycleCloud-Platzierungsgruppen ordnen Azure VMSS mit SinglePlacementGroup eins zu 1 zu: VMs in einer Platzierungsgruppe teilen sich ein Infiniband Fabric und geben nur für virtuelle Computer innerhalb der Platzierungsgruppe frei. Um diese Silos intuitiv zu erhalten, ordnen die Platzierungsgruppen 1:1 der parallelen Umgebung gridengine zu.
Wenn Sie eine parallele Umgebung für einen Auftrag angeben, wird die Ausführung des Auftrags in einer Platzierungsgruppe über eine intelligente Hostgruppenzuweisungslogik eingeschränkt. Sie können dieses Verhalten mit der oben genannten Konfiguration in autoscale.json deaktivieren: "required_placement_groups" : false
.
Konfiguration mit automatischer Skalierung
Dieses Plug-In skaliert das Raster automatisch, um die Anforderungen der Workload zu erfüllen. Die Konfigurationsdatei autoscale.json bestimmt das Verhalten der Automatischskalierung der Grid-Engine.
- Festlegen der Cyclecloud-Verbindungsdetails
- Festlegen des Terminierungszeitgebers für Knoten im Leerlauf
- Mehrdimensionale automatische Skalierung ist möglich, legen Sie fest, welche Attribute in der Auftragsverpackung verwendet werden sollen, z. B. Slots, Arbeitsspeicher
- Registrieren der zu verwaltenden Warteschlangen, parallelen Umgebungen und Hostgruppen
Konfiguration | type | Beschreibung |
---|---|---|
url | String | CC-URL |
Benutzername/Kennwort | String | CC-Verbindungsdetails |
cluster_name | String | CC-Clustername |
default_resources | Zuordnung | Verknüpfen einer Knotenressource mit einer Grid Engine-Hostressource für die automatische Skalierung |
idle_timeout | Int | Wartezeit vor dem Beenden von Knoten im Leerlauf |
boot_timeout | Int | Wartezeit vor dem Beenden von Knoten während langer Konfigurationsphasen |
gridengine.relevant_complexes | Liste (Zeichenfolge) | Bei der automatischen Skalierung zu berücksichtigende Rastermodulkomplexe, z. B. Slots, mem_free |
gridengine.logging | Datei | Speicherort der Protokollierungskonfigurationsdatei |
gridengine.pes | Struktur | Geben Sie das Verhalten von PEs an, z. B. requires_placement_group = false |
Das Programm zur automatischen Skalierung berücksichtigt nur die relevante Ressource.
Zusätzliche Ressource für die automatische Skalierung
Standardmäßig wird der Cluster mit Skalierung basierend auf der Anzahl von Slots, die von den Aufträgen angefordert werden, skaliert. Wir können der automatischen Skalierung eine weitere Dimension hinzufügen.
Angenommen, wir möchten die Anforderung der Auftragsressource für m_mem_free
automatisch skalieren.
- Hinzufügen
m_mem_free
zurgridengine.relevant_resources
in autoscale.json - Link
m_mem_free
zur Arbeitsspeicherressource auf Knotenebene in autoscale.json
Diese Attribute können Verweise mit node.*
als Wert in _default/Ressourcen sein.
Node | type | BESCHREIBUNG |
---|---|---|
nodearray | String | Name des Nodearrays "cyclecloud" |
placement_group | String | Name der Cyclecloud-Platzierungsgruppe in einem Nodearray |
vm_size | String | VM-Produktname, z. B. "Standard_F2s_v2" |
vcpu_count | Int | Virtuelle CPUs, die auf dem Knoten verfügbar sind, wie auf einzelnen Produktseiten angegeben |
pcpu_count | Int | Auf dem Knoten verfügbare physische CPUs |
Arbeitsspeicher | String | Ungefährer physischer Arbeitsspeicher auf dem virtuellen Computer mit Einheitenindikator, z. B. "8,0g" |
Zusätzliche Attribute befinden sich im node.resources.*
Namespace, z. B. "node.resources.
Node | type | Beschreibung |
---|---|---|
ncpus | String | Anzahl der cpUs, die in auf dem virtuellen Computer verfügbar sind |
pcpus | String | Anzahl der auf dem virtuellen Computer verfügbaren physischen CPUs |
ngpus | Integer | Anzahl der auf dem virtuellen Computer verfügbaren GPUs |
Memb | String | Ungefährer physischer Arbeitsspeicher auf dem virtuellen Computer mit Einheitenindikator, z. B. "8.0b" |
memkb | String | Ungefährer physischer Arbeitsspeicher auf dem virtuellen Computer mit Einheitenindikator, z. B. "8.0k" |
memmb | String | Ungefährer physischer Arbeitsspeicher auf dem virtuellen Computer mit Einheitenindikator, z. B. "8,0m" |
memgb | String | Ungefährer physischer Arbeitsspeicher auf dem virtuellen Computer mit Einheitenindikator, z. B. "8,0g" |
memtb | String | Ungefährer physischer Arbeitsspeicher auf dem virtuellen Computer mit Einheitenindikator, z. B. "8.0t" |
slots | Integer | Identisch mit ncpus |
slot_type | String | Additionsbezeichnung für Erweiterungen. Nicht allgemein verwendet. |
m_mem_free | String | Freier Arbeitsspeicher auf dem Ausführungshost erwartet, z. B. "3.0g" |
mfree | String | Identisch mit _m/_mem/free |
Ressourcenzuordnung
Dem default_resources stehen auch Berechnungen zur Verfügung: Reduzieren Sie die Slots auf einem bestimmten Knotenarray um zwei, und fügen Sie die Docker-Ressource allen Knoten hinzu:
"default_resources": [
{
"select": {"node.nodearray": "beegfs"},
"name": "slots",
"value": "node.vcpu_count",
"subtract": 2
},
{
"select": {},
"name": "docker",
"value": true
},
Das Zuordnen der Knoten-vCPUs zu den komplexen Slots und memmb
zu mem_free
sind häufig verwendete Standardwerte.
Die erste Zuordnung ist erforderlich.
"default_resources": [
{
"select": {},
"name": "slots",
"value": "node.vcpu_count"
},
{
"select": {},
"name": "mem_free",
"value": "node.resources.memmb"
}
],
Wenn ein Komplex über eine Verknüpfung verfügt, die nicht dem gesamten Wert entspricht, definieren Sie beide in default_resources wobei physical_cpu
der komplexe Name ist:
"default_resources": [
{
"select": {},
"name": "physical_cpu",
"value": "node.pcpu_count"
},
{
"select": {},
"name": "pcpu",
"value": "node.resources.physical_cpu"
}
]
Die Reihenfolge ist wichtig, wenn Sie ein bestimmtes Verhalten für ein bestimmtes Attribut wünschen. So weisen Sie einen einzelnen Slot für ein bestimmtes nodearray zu, während die Standardanzahl der Slots für alle anderen nodearrays beibehalten wird:
"default_resources": [
{
"select": {"node.nodearray": "FPGA"},
"name": "slots",
"value": "1",
},
{
"select": {},
"name": "slots",
"value": "node.vcpu_count"
},
]
Hostgruppen
Die Automatische Skalierung von CycleCloud zuordnen Knoten der entsprechenden Hostgruppe, um die Auftragsanforderungen zu erfüllen. Warteschlangen, parallele Umgebungen und Komplexe werden berücksichtigt. Ein Großteil der Logik entspricht dem entsprechenden Cyclecloud-Bucket (und der Knotenmenge) mit der entsprechenden Sge-Hostgruppe.
Für einen Auftrag, der als übermittelt wird: qsub -q "cloud.q" -l "m_mem_free=4g" -pe "mpi*" 48 ./myjob.sh
CycleCloud findet die Schnittmenge von Hostgruppen, die:
- Sind in der pe_list für cloud.q enthalten und stimmen mit dem pe-Namen überein, z. B.
pe_list [@allhosts=mpislots],[@hpc1=mpi]
. - Verfügen Sie über ausreichende Ressourcen und ein Abonnementkontingent, um alle Auftragsressourcen bereitzustellen.
- Werden nicht nach der Konfiguration der Hostgruppeneinschränkungen gefiltert.
Es ist möglich, dass mehrere Hostgruppen diese Anforderungen erfüllen. In diesem Fall muss die Logik auswählen. Es gibt drei Möglichkeiten, Mehrdeutigkeiten in der Hostgruppenmitgliedschaft zu beheben:
- Konfigurieren Sie die Warteschlangen so, dass es keine Mehrdeutigkeiten gibt.
- Fügen Sie autoscale.json Einschränkungen hinzu.
- Lassen Sie CycleCloud die übereinstimmenden Hostgruppen in namensgeordneter Weise auswählen, indem Sie in der Planerkonfiguration anpassen
weight_queue_host_sort < weight_queue_seqno
. - Legen Sie
seq_no 10000,[@hostgroup1=100],[@hostgroup2=200]
in der Warteschlangenkonfiguration fest, um eine Hostgruppenpräferenz anzugeben.
Hostgruppeneinschränkungen
Wenn mehrere Hostgruppen durch eine Warteschlange oder ein xproject definiert werden, können für alle diese Hostgruppen möglicherweise die Hosts hinzugefügt werden. Sie können einschränken, welche Arten von Hosts welchen Warteschlangen hinzugefügt werden können, indem Sie Hostgruppeneinschränkungen festlegen. Legen Sie eine Einschränkung basierend auf den Knoteneigenschaften fest.
"gridengine": {
"hostgroups": {
"@mpi": {
"constraints": {
"node.vm_size": "Standard_H44rs"
}
},
"@amd-mem": {
"constraints" : {
"node.vm_size": "Standard_D2_v3",
"node.nodearray": "hpc"
}
},
}
}
HINWEIS: Überprüfen Sie alle verfügbaren Knoteneigenschaften nach
azge buckets
.
azge
Dieses Paket enthält die Befehlszeile azge. Dieses Programm sollte für die automatische Skalierung verwendet werden und hat alle Unterprozesse unter der automatischen Skalierung aufgebrochen.
Diese Befehle basieren auf den festzulegenden gridengine-Umgebungsvariablen. Sie müssen in der Lage sein, und qsub
aus demselben Profil aufzurufenqconf
, in dem azge
aufgerufen wird.
azge-Befehle | Beschreibung |
---|---|
validate | Überprüft auf bekannte Konfigurationsfehler in der automatischen Skalierung oder gridengine |
jobs | Zeigt alle Aufträge in der Warteschlange an. |
buckets | Zeigt verfügbare Ressourcenpools für die automatische Skalierung an. |
nodes | Zeigt Clusterhosts und Eigenschaften an. |
demand | Entspricht den Auftragsanforderungen für Cyclecloud-Buckets und stellt Ergebnisse für die automatische Skalierung bereit. |
Automatische Skalierung | Führt die vollständige autoskalierte Skalierung durch, wobei Knoten gemäß den Konfigurationen gestartet und entfernt werden. |
Wenn Sie Planerkonfigurationen (qconf) oder Autoscale-Konfigurationen (autoscale.json) ändern oder sogar zum ersten Mal einrichten, kann azge verwendet werden, um zu überprüfen, ob das Verhalten der automatischen Skalierung den Erwartungen entspricht. Als Stamm können Sie die folgenden Vorgänge ausführen. Es ist ratsam, sich mit diesen vertraut zu machen, um das Verhalten der automatischen Skalierung zu verstehen.
- Führen Sie aus
azge validate
, um Konfigurationen auf bekannte Probleme zu überprüfen. - Führen Sie aus
azge buckets
, um zu untersuchen, welche Ressourcen Ihr CycleCloud-Cluster anbietet. - Führen Sie aus
azge jobs
, um die Auftragsdetails in der Warteschlange zu überprüfen. - Führen Sie
azge demand
den Auftrag ausführen aus, um den Bucketabgleich durchzuführen, und untersuchen Sie, welche Aufträge mit welchen Buckets und Hostgruppen übereinstimmen. - Führen Sie aus
azge autoscale
, um den Knotenzuordnungsprozess zu starten, oder fügen Sie Knoten hinzu, die bereit für die Verknüpfung sind.
Wenn sich diese Befehle dann wie erwartet verhalten, aktivieren Sie die fortlaufende automatische Skalierung, indem Sie den azge autoscale
Befehl zum Stammkrontab hinzufügen. (Zuordnen der Gridengine-Umgebungsvariablen)
* * * * * . $SGE_ROOT/common/settings.sh && /usr/local/bin/azge autoscale -c /opt/cycle/gridengine/autoscale.json
Erstellen eines Hybridclusters
CycleCloud unterstützt das Szenario des Bursts in die Cloud. Bei der Basiskonfiguration wird davon ausgegangen, dass das $SGE_ROOT
Verzeichnis für die Cloudknoten verfügbar ist. Diese Annahme kann gelockert werden, indem Sie gridengine.shared.spool = false
festlegen gridengine.shared.bin = false
und GridEngine lokal installieren.
Für einen einfachen Fall sollten Sie ein Dateisystem bereitstellen, das von den Ausführungsknoten eingebunden werden kann, die das $SGE_ROOT
Verzeichnis enthält, und dieses Einbinden in den optionalen Einstellungen konfigurieren. Wenn die Abhängigkeit der sched- und freigegebenen Verzeichnisse freigegeben wird, können Sie den Planerknoten, der teil des Clusters ist, standardmäßig herunterfahren und die Konfigurationen aus dem externen Dateisystem verwenden.
- Erstellen Sie einen neuen gridengine-Cluster.
- Deaktivieren Sie den Rückgabeproxy.
- Ersetzen Sie /sched und /shared durch externe Dateisysteme.
- Speichern Sie den Cluster.
- Entfernen Sie den Planerknoten als Aktion auf der Benutzeroberfläche.
- Starten Sie den Cluster, und es werden zunächst keine Knoten gestartet.
- Konfigurieren mit
cyclecloud-gridengine
autoscale.json für die Verwendung des neuen Clusters
Verwenden der Univa Grid Engine in CycleCloud
Das CycleCloud-Projekt für GridEngine verwendet standardmäßig sge-2011.11 . Sie können Ihre eigenen Altair GridEngine-Installationsprogramme gemäß Ihrem Altair-Lizenzvertrag verwenden.
In diesem Abschnitt wird die Verwendung von Altair GridEngine mit dem CycleCloud GridEngine-Projekt beschrieben.
Voraussetzungen
In diesem Beispiel wird die Demoversion 8.6.1 verwendet, aber alle Ge-Versionen > 8.4.0 werden unterstützt.
- Benutzer müssen UGE-Binärdateien bereitstellen
- ge-8.6.x-bin-lx-amd64.tar.gz
- ge-8.6.x-common.tar.gz
- Die CycleCloud CLI muss konfiguriert werden. Dokumentation finden Sie hier.
Kopieren der Binärdateien in das Cloudschließfach
Eine ergänzende Version von AGE (8.6.7-demo) wird mit CycleCloud verteilt. Um eine andere Version zu verwenden, laden Sie die Binärdateien in das Speicherkonto hoch, das CycleCloud verwendet.
$ azcopy cp ge-8.6.12-bin-lx-amd64.tar.gz https://<storage-account-name>.blob.core.windows.net/cyclecloud/gridengine/blobs/
$ azcopy cp ge-8.6.12-common.tar.gz https://<storage-account-name>.blob.core.windows.net/cyclecloud/gridengine/blobs/
Ändern von Konfigurationen für die Clustervorlage
Erstellen Sie eine lokale Kopie der gridengine-Vorlage, und ändern Sie sie so, dass die UGE-Installationsprogramme anstelle des Standardwerts verwendet werden.
wget https://raw.githubusercontent.com/Azure/cyclecloud-gridengine/master/templates/gridengine.txt
Suchen Sie in dergridengine.txt-Datei nach dem ersten Vorkommen von [[[configuration]]]
, und fügen Sie Text ein, sodass er mit dem folgenden Codeausschnitt übereinstimmt. Diese Datei ist nicht empfindlich gegenüber Einzug.
HINWEIS: Die Details in der Konfiguration, insbesondere die Version, sollten mit dem Dateinamen des Installationsprogramms übereinstimmen.
[[[configuration gridengine]]]
make = ge
version = 8.6.12-demo
root = /sched/ge/ge-8.6.12-demo
cell = "default"
sge_qmaster_port = "537"
sge_execd_port = "538"
sge_cluster_name = "grid1"
gid_range = "20000-20100"
qmaster_spool_dir = "/sched/ge/ge-8.6.12-demo/default/spool/qmaster"
execd_spool_dir = "/sched/ge/ge-8.6.12-demo/default/spool"
spooling_method = "berkeleydb"
shadow_host = ""
admin_mail = ""
idle_timeout = 300
managed_fs = true
shared.bin = true
ignore_fqdn = true
group.name = "sgeadmin"
group.gid = 536
user.name = "sgeadmin"
user.uid = 536
user.gid = 536
user.description = "SGE admin user"
user.home = "/shared/home/sgeadmin"
user.shell = "/bin/bash"
Diese Konfigurationen überschreiben die standardmäßige gridengine-Version und den Installationsspeicherort, wenn der Cluster gestartet wird.
Es ist nicht sicher, von der /sched
zu wechseln, da es sich um einen speziell freigegebenen nfs-Speicherort im Cluster handelt.