Freigeben über


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_groupverwendet. 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. Alternativ qrsh 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 azgefügt dem Cluster Hosts gemäß der Clusterkonfiguration hinzu. Die Vorgänge zur automatischen Skalierung führen die folgenden Aktionen aus.

  1. Lesen Sie die Auftragsressourcenanforderung, und suchen Sie nach einer geeigneten VM zum Starten.
  2. Starten Sie den virtuellen Computer, und warten Sie, bis sie bereit ist.
  3. Lesen der Warteschlange und parallelen Umgebung aus dem Auftrag
  4. Weisen Sie den Host basierend auf der Warteschlange/pe einer entsprechenden Hostgruppe zu.
  5. 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_freeautomatisch skalieren.

  1. Hinzufügen m_mem_free zur gridengine.relevant_resources in autoscale.json
  2. 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:

  1. 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].
  2. Verfügen Sie über ausreichende Ressourcen und ein Abonnementkontingent, um alle Auftragsressourcen bereitzustellen.
  3. 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:

  1. Konfigurieren Sie die Warteschlangen so, dass es keine Mehrdeutigkeiten gibt.
  2. Fügen Sie autoscale.json Einschränkungen hinzu.
  3. Lassen Sie CycleCloud die übereinstimmenden Hostgruppen in namensgeordneter Weise auswählen, indem Sie in der Planerkonfiguration anpassen weight_queue_host_sort < weight_queue_seqno .
  4. 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.

  1. Führen Sie aus azge validate , um Konfigurationen auf bekannte Probleme zu überprüfen.
  2. Führen Sie aus azge buckets , um zu untersuchen, welche Ressourcen Ihr CycleCloud-Cluster anbietet.
  3. Führen Sie aus azge jobs , um die Auftragsdetails in der Warteschlange zu überprüfen.
  4. 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.
  5. 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 = falsefestlegen 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.

  1. Erstellen Sie einen neuen gridengine-Cluster.
  2. Deaktivieren Sie den Rückgabeproxy.
  3. Ersetzen Sie /sched und /shared durch externe Dateisysteme.
  4. Speichern Sie den Cluster.
  5. Entfernen Sie den Planerknoten als Aktion auf der Benutzeroberfläche.
  6. Starten Sie den Cluster, und es werden zunächst keine Knoten gestartet.
  7. Konfigurieren mit cyclecloud-gridengineautoscale.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.

  1. Benutzer müssen UGE-Binärdateien bereitstellen
  • ge-8.6.x-bin-lx-amd64.tar.gz
  • ge-8.6.x-common.tar.gz
  1. 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.