CycleCloud GridEngine Cluster

ReadME projektu clusteru CycleCloud GridEngine

Open Grid Scheduler (Grid Engine) je možné snadno povolit v clusteru Azure CycleCloud úpravou "run_list" v definici clusteru. Cluster Grid Engine se skládá ze dvou primárních komponent. První je hlavní uzel, který poskytuje sdílený systém souborů, ve kterém běží software Grid Engine. Druhá je sada uzlů execute, což jsou hostitelé, kteří připojují sdílený systém souborů a spouštějí odeslané úlohy. Například jednoduchý fragment šablony clusteru Grid Engine může vypadat takto:

[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]

Poznámka:

Názvy rolí obsahují "sge" ze starších důvodů: Grid Engine byl produktem Sun Microsystems.

Importem a spuštěním clusteru s definicí v CycleCloudu vznikne jeden hlavní uzel. Uzly execute je možné přidat do clusteru cyclecloud add_node pomocí příkazu. Pokud chcete například přidat 10 dalších uzlů execute:

cyclecloud add_node grid-engine -t execute -c 10

Automatické škálování Grid Engine

Azure CycleCloud podporuje automatické škálování pro gridový stroj. Toto chování znamená, že software nepřetržitě monitoruje stav vaší fronty a podle potřeby automaticky zapne nebo vypne uzly, aby se úlohy efektivně dokončily z hlediska času i nákladů. Automatické škálování pro gridový stroj můžete povolit přidáním Autoscale = true do definice clusteru:

[cluster grid-engine]
Autoscale = True

Ve výchozím nastavení se všechny úlohy odeslané do fronty Grid Engine spouštějí na počítačích typu 'Execute'. Tyto stroje jsou definované polem uzlů nazvaným 'execute'. Nejste omezeni na název execute, ani nejste omezeni na jeden typ konfigurace počítače pro spouštění úloh a automatického škálování.

Běžný scénář například zahrnuje cluster se dvěma různými definicemi uzlů. Jedna je určená pro spouštění "normálních" úloh, které používají standardní procesory. Druhá je určená pro úlohy, které vyžadují počítače s podporou GPU. V takovém případě byste chtěli nezávisle škálovat frontu podle běžných úloh i úloh GPU, abyste měli jistotu, že máte odpovídající množství každého počítače, který bude pracovní frontu využívat. Příklad definice by vypadala přibližně takto:

[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

V uvedeném příkladu jsou teď dvě pole uzlů: Jedno je standardní pole uzlů pro vykonávání, druhé se jmenuje gpu a poskytuje typ stroje se dvěma grafickými procesory NVIDIA (Standard_NV12 v Azure). Všimněte si také, že v konfigurační části jsou teď dvě nové položky kromě receptu "csge:sgeexec". Přidání gridengine.slot_type = gpu říká plánovači modulu gridu, že tyto uzly by měly mít název "gpu" uzly, a proto by měly spouštět pouze úlohy GPU. Název "gpu" je libovolný, ale název, který popisuje uzel, je nejužitečnější. Nastavte gridengine.slots = 2, který zajistí, že tento typ uzlu může spouštět pouze dvě úlohy současně (Standard_NV12 má pouze 2 GPU).

Ve výchozím nastavení modul gridu přiřadí počet slotů na uzel na základě počtu procesorů systému. V takovém případě by výchozí chování mohlo vést k příliš velkému počtu úloh spuštěných současně na jednom uzlu. V uvedeném příkladu je na nodearray nastaveno CoreCount=2, aby odpovídal počtu GPU dostupných na MachineType, což umožňuje CycleCloud správně škálovat toto pole podle počtu GPU vs CPU.

Počet slotů a slot_type vašich počítačů můžete ověřit spuštěním příkazu:

    -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

Všimněte si, že každý 'slot_type' obsahuje 'execute' a 'gpu'. Slot_types se konfigurují jednotlivě a počet slotů pro slot execute je 4, což je počet procesorů na počítači. Počet slotů pro typ slotu GPU je 2, které jsme zadali v naší šabloně konfigurace clusteru. Třetí počítač je hlavní uzel, který nespouští úlohy.

Pokročilé využití Grid Engine

Tato nastavení konfigurace umožňují pokročilé přizpůsobení uzlů a polí uzlů. Pokud například úlohy vyžadují určitou velikost paměti, například 10 GB, můžete definovat "execute" nodearray, které spouští počítače s 60 GB paměti, pak přidejte do možností gridengine.slots = 6 konfigurace, aby se zajistilo, že na tomto typu uzlu může souběžně běžet jenom 6 úloh (zajistěte, aby každá úloha pracovala alespoň s 10 GB paměti).

Seskupené uzly v modulu gridu

Když se do grid engine odešle paralelní úloha, CycleCloud při výchozím automatickém škálování zachází s každou úlohou MPI jako s požadavkem na seskupení uzlů. Seskupené uzly jsou úzce propojené a ideálně vhodné pro pracovní postupy MPI.

Když se sada seskupených uzlů připojí ke clusteru Grid Engine, použije se ID skupiny každého uzlu jako hodnota složité hodnoty affinity_group. Vyžadováním affinity_group zadání pro úlohy umožňuje plánovači modulu mřížky zajistit, aby úlohy přistály pouze na počítačích, které jsou ve stejné skupině.

Automatizace CycleCloudu automaticky požaduje seskupené uzly a přiřazuje je dostupným skupinám spřažení, když dojde k paralelním úlohám.

Odesílání úloh do modulu Grid

Nejběžnějším způsobem odeslání úloh do plánovače gridového stroje je příkaz:

qsub my_job.sh

Tento příkaz odešle úlohu, která běží na uzlu typu execute, což je uzel definovaný příkazem nodearray execute. Aby se úloha spustila na nodearray jiného typu, například zobrazený typ uzlu GPU, upravíme naše zadání:

qsub -l slot_type=gpu my_gpu_job.sh

Tento příkaz zajistí, že se úloha spustí pouze na slot_type gpu.

Pokud slot_type vynecháte, funkce execute se k úloze automaticky přiřadí. Uživatel může změnit mechanismus, který automaticky přiřazuje slot_type úlohám. Je možné vytvořit skript Pythonu umístěný v umístění /opt/cycle/jetpack/config/autoscale.py , který by měl definovat jednu funkci "sge_job_handler". Tato funkce obdrží slovníkovou reprezentaci úlohy, podobně jako výstup qstat -j JOB_ID příkazu, a měla by vrátit slovník pevných prostředků, které je potřeba aktualizovat pro úlohu.

Například následující skript přiřadí úlohu slot_type gpu, pokud název úlohy obsahuje písmena gpu. Uživatelé mohou odesílat své úlohy automaticky beze změny parametrů úlohy a zároveň zajistit, aby se úlohy spouštěly a automaticky škálovaly správné uzly:

#!/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

'Job' je parametr, který je předán jako slovník obsahující data ve volání qstat -j JOB_ID.

{
    "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'
    }
}

Pomocí této funkce skriptování můžete automaticky přiřadit slot_type na základě libovolného definovaného parametru úlohy, jako jsou argumenty, požadavky na prostředky, jako je paměť nebo odesílající uživatel.

Předpokládejme, že pro každou slot_type odešlete 5 úloh:

qsub -t 1:5 gpu_job.sh
qsub -t 1:5 normal_job.sh

Ve frontě by teď bylo 10 úloh. Z důvodu definovaného skriptu by se pět úloh s gpu v názvu automaticky nakonfigurovalo tak, aby běželo jenom na uzlech slot_type=gpu. Mechanismus automatického škálování CycleCloudu zjistí, že existují 5 úloh GPU a 5 úloh spouštění. Vzhledem k tomu, že 'gpu' uzly jsou definovány jako mající 2 sloty na uzel, CycleCloud by spustil 3 z těchto uzlů (5/2=2,5 zaokrouhleno nahoru na 3).

Existuje 5 běžných úloh, protože typ počítače pro nodearray execute má každý 4 procesory, CycleCloud spustí 2 z těchto uzlů pro zpracování úloh (5/4=1,25 zaokrouhleno nahoru na 2). Po krátké době spuštění se nově spuštěné uzly spustí a nakonfigurují. Jakmile budou připraveny, všech 10 úloh proběhne až do dokončení. 5 uzlů se pak automaticky vypne, než začne jiný fakturační cyklus poskytovatelem cloudu.

Předpokládá se, že úlohy mají dobu trvání jedné hodiny. Pokud je znám čas běhu úlohy, algoritmus automatického škálování z těchto informací může těžit. Uveďte očekávanou dobu běhu úlohy pro automatické škálování tím, že ji přidáte do kontextu úlohy. Následující příklad nastaví dobu běhu úlohy pro automatické škálování na 10 minut:

qsub -ac average_runtime=10 job_with_duration_of_10m.sh

Referenční informace ke konfiguraci modulu gridu

Níže jsou uvedené možnosti konfigurace specifické pro gridový stroj, které můžete přepnout a přizpůsobit funkce:

možnosti konfigurace SGE-Specific Popis
gridengine.slots Počet slotů pro daný uzel, který se má hlásit systému Grid Engine. Počet slotů je počet souběžných úloh, které může uzel spustit. Tato hodnota je ve výchozím nastavení rovna počtu procesorů na daném zařízení. Tuto hodnotu můžete přepsat v případech, kdy úlohy nespouštíte na základě procesoru, ale na paměť, GPU a další.
gridengine.slot_type Název typu slotu, který uzel poskytuje. Výchozí hodnota je execute. Pokud je úloha označená pevným prostředkem "slot_type=", tato úloha se spustí pouze na počítači stejného typu slotu. Toto označování umožňuje vytvořit různé konfigurace softwaru a hardwaru pro každý uzel a zajistit, aby odpovídající úloha byla vždy naplánována na správný typ uzlu.
gridengine.ignore_fqdn Výchozí hodnota: true. Pokud všechny uzly v clusteru nejsou součástí jedné domény DNS, nastavte na hodnotu false.
gridengine.version Výchozí hodnota: 2011.11. Tato možnost konfigurace určuje verzi modulu gridu, která se má nainstalovat a spustit. V současné době se jedná o výchozí a jedinou dostupnou možnost. Další verze softwaru Grid Engine mohou být v budoucnu podporovány.
gridengine.root Výchozí hodnota: /sched/sge/sge-2011.11 Toto umístění je místo, kde modul gridu instaluje a připojuje na každý uzel v systému. Nejlepší je zachovat tuto hodnotu beze změny. Pokud ale upravíte, nezapomeňte nastavit stejnou hodnotu na všech uzlech v clusteru.

CycleCloud podporuje standardní sadu atributů pro automatické zastavení mezi plánovači.

Vlastnost Popis
cyclecloud.cluster.autoscale.stop_enabled (možnost zastavení automatického škálování) Povolí automatické zastavení na tomto uzlu. [pravda/nepravda]
cyclecloud.cluster.autoscale.doba_nečinnosti_po_dokončení_prací Časový úsek (v sekundách), po který uzel čeká nečinně po dokončení úloh před automatickým zastavením.
cyclecloud.cluster.autoscale.nečinný_čas_před úlohami Doba (v sekundách) nečinnosti uzlu před jeho automatickým zastavením po dokončení úloh.

Známé problémy

  • qsh příkaz pro interaktivní relaci nefunguje. Použijte qrsh jako alternativu.
  • Automatické škálování nerespektuje exclusive=1 komplex, což může způsobit, že se spustí méně uzlů, než se očekávalo.

Poznámka:

I když je Windows oficiálně podporovanou platformou GridEngine, v současné době CycleCloud nepodporuje spouštění GridEngine ve Windows.

Tato stránka se týká možností a konfigurace použití (Altair) GridEngine s CycleCloudem.

Konfigurace prostředků

Aplikace cyclecloud-gridengine přiřazuje prostředky sge k prostředkům Azure cloud, aby poskytla rozsáhlé nástroje pro automatické škálování a konfiguraci klastrů. Aplikace se nasadí automaticky pro clustery vytvořené prostřednictvím uživatelského rozhraní CycleCloud nebo ji můžete nainstalovat na libovolného hostitele správce GridEngine v existujícím clusteru.

Instalace nebo upgrade CycleCloud-Gridengine

Sada cyclecloud-gridengine je k dispozici na GitHubu jako release artefakt. Instalace a upgrade se řídí stejným procesem. Aplikace vyžaduje Python3 s virtualenv.

tar xzf cyclecloud-gridengine-pkg-*.tar.gz
cd cyclecloud-gridengine
./install.sh

Důležité soubory

Aplikace analyzuje konfiguraci SGE při každém spuštění – úlohy, fronty, komplexy. Informace jsou k dispozici ve stderr a stdout příkazu a v souboru protokolu, vše na konfigurovatelných úrovních. Všechny příkazy pro správu GridEngine s argumenty se protokolují také do souboru.

Popis Umístění
Konfigurace automatického škálování /opt/cycle/gridengine/autoscale.json
Protokol automatického škálování /opt/cycle/jetpack/logs/autoscale.log
protokol trasování qconf /opt/cycle/jetpack/logs/qcmd.log

Fronty SGE, skupiny hostitelů a paralelní prostředí

Nástroj pro automatické škálování cyclecloud-gridengine, azge, přidá hostitele do klastru podle konfigurace clusteru. Operace automatického škálování provádějí následující akce.

  1. Přečtěte si žádost o prostředek úlohy a vyhledejte odpovídající virtuální počítač pro spuštění.
  2. Spusťte virtuální počítač a počkejte, až bude připravený.
  3. Přečíst frontu a paralelní prostředí z úlohy
  4. Na základě fronty nebo prostředí přiřaďte hostitele k příslušné skupině hostitelů.
  5. Přidejte hostitele do clusteru a do jakékoli jiné fronty obsahující hostgroup.

Zvažte následující definici fronty pro frontu s názvem short.q.

hostlist              @allhosts @mpihg01 @mpihg02 @lowprio 
...
seq_no                10000,[@lowprio=10],[@mpihg01=100],[@mpihg02=200]
pe_list               NONE,[@mpihg01=mpi01], \
                      [@mpihg02=mpi02]

Odesláním úlohy pomocí qsub -q short.q -pe mpi02 12 my-script.sh se pronajme alespoň jeden virtuální počítač. Po přidání clusteru se připojí ke skupině hostitelů @mpihg02, protože je to skupina hostitelů dostupná pro frontu i pro paralelní prostředí. Spojuje také @allhosts, speciální skupinu hostitelů.

Pokud odešlete úlohu s qsub -q short.q my-script.sh a nezadáte paralelní prostředí pe, výsledný virtuální počítač se připojí ke skupinám hostitelů @allhosts a @lowpriority, které jsou propojeny s frontou, jež nemá přiřazené žádné pe.

Nakonec úloha odeslaná s qsub -q short.q -pe mpi0* 12 my-script.sh povede k tomu, že virtuální počítač bude přidán do @mpihg01 nebo @mpihg02, v závislosti na předpovědích přidělení CycleCloudu.

Paralelní prostředí implicitně se shodují se skupinou umístění cyclecloudu. Virtuální počítače v prostředí PE jsou omezené tak, aby byly ve stejné síti. Pokud chcete použít prostředí PE, které skupinu umístění neudržuje, použijte k odhlášeníautoscale.json .

Tady se odhlásíme ze skupin umístění pro make pe:

"gridengine": {
    "pes": {
      "make": {
        "requires_placement_groups": false
      }
    },

Skupiny umístění CycleCloud

Skupiny umístění CycleCloud mapují 1:1 na Azure VMSS se SinglePlacementGroup – virtuální počítače ve skupině umístění sdílejí Infiniband Fabric a sdílejí pouze s ostatními virtuálními počítači v rámci stejné skupiny umístění. K intuitivnímu zachování těchto silo se skupiny umístění mapují 1:1 s paralelním prostředím GridEngine.

Určení paralelního prostředí pro úlohu omezuje její spuštění v umístěné skupině prostřednictvím logiky přiřazování chytré skupiny hostitelů. Toto chování můžete zakázat prostřednictvím odpovídající konfigurace v autoscale.json: "required_placement_groups" : false.

Konfigurace automatického škálování

Tento modul plug-in automaticky škáluje mřížku tak, aby splňovala požadavky úlohy. Konfigurační soubor autoscale.json určuje chování autoscaleru Grid Engine.

  • Nastavení podrobností o připojení cyclecloudu
  • Nastavení časovače ukončení pro nečinné uzly
  • Podporuje se vícerozměrné automatické škálování. Můžete nakonfigurovat, které atributy se mají použít v balení úloh, například sloty nebo paměť.
  • Zaregistrujte fronty, paralelní prostředí a skupiny hostitelů, které se mají spravovat.
Konfigurace Typ Popis
adresa URL Řetězec Creative Commons URL
uživatelské jméno a heslo Řetězec Podrobnosti o připojení CC
název klastru Řetězec Název clusteru CC
výchozí_zdroje Mapa Propojení prostředku uzlu s hostitelským prostředkem modulu Grid Engine pro automatické škálování
časový_limit_pro_nečinnost int Doba čekání před ukončením nečinných uzlů (s)
prodleva při spuštění int Doba čekání před ukončením uzlů během dlouhých fází konfigurace
gridengine.relevant_complexes Seznam (řetězec) Komplexy gridového enginu, které je potřeba zvážit při automatickém škálování, například sloty, mem_free
gridengine.logging Soubor Umístění konfiguračního souboru protokolování
gridengine.pes Struktura Zadejte chování PE, například requires_placement_group = false

Program automatického škálování bere v úvahu pouze relevantní prostředek.

Jiný prostředek automatického škálování

Úlohy ve výchozím nastavení požadují mnoho slotů a cluster se škáluje na základě těchto požadavků.

Řekněme, že chceme automatické škálování dle žádosti o prostředky pro úlohu m_mem_free.

  1. Přidejte m_mem_free do gridengine.relevant_resources v autoscale.json
  2. Propojení m_mem_free s prostředkem paměti na úrovni uzlu v autoscale.json

Tyto atributy mohou být odkazy pomocí node.* jako hodnoty v _default/resources.

Node Typ Popis
nodearray Řetězec Název nodearray v Cyclecloud
skupina umístění Řetězec Název skupiny umístění cyclecloud v rámci nodearray
velikost_vm Řetězec Název produktu virtuálního počítače, například "Standard_F2s_v2"
počet_vcpu int Virtuální procesory dostupné na uzlu, jak je uvedeno na jednotlivých stránkách produktu
pcpu_count int Fyzické procesory dostupné na uzlu
paměť Řetězec Přibližná fyzická paměť dostupná ve virtuálním počítači s indikátorem jednotky, například "8,0g"

Jiné atributy jsou v node.resources.* jmenném prostoru, například node.resources.

Node Typ Popis
ncpus Řetězec Počet procesorů dostupných na virtuálním počítači
pcpus Řetězec Počet fyzických procesorů dostupných na virtuálním počítači
ngpus Celé číslo Počet grafických procesorů dostupných na virtuálním počítači
člen Řetězec Přibližná fyzická paměť dostupná na virtuálním počítači s indikátorem jednotky, například 8,0b
memkb Řetězec Přibližná fyzická paměť dostupná na virtuálním počítači s indikátorem jednotky, například "8,0k"
memmb Řetězec Přibližná fyzická paměť dostupná ve virtuálním počítači s indikátorem jednotky, například "8,0 min".
memgb Řetězec Přibližná fyzická paměť dostupná ve virtuálním počítači s indikátorem jednotky, například "8,0g"
memtb Řetězec Přibližná fyzická paměť dostupná na virtuálním počítači s indikátorem jednotky, například 8,0t
otvory Celé číslo Stejné jako ncpus
typ_slotu Řetězec Označení přidání pro rozšíření Nepoužívá se.
m_mem_free Řetězec Očekávaná volná paměť na hostiteli spuštění, například 3,0g
mfree Řetězec Stejné jako _m/_mem/free

Mapování prostředků

Pro default_resources jsou k dispozici také matematické operace – snižte sloty na konkrétním poli uzlů o dva a přidejte prostředek Dockeru do všech uzlů:

    "default_resources": [
    {
      "select": {"node.nodearray": "beegfs"},
      "name": "slots",
      "value": "node.vcpu_count",
      "subtract": 2
    },
    {
      "select": {},
      "name": "docker",
      "value": true
    },

Mapování vCPUs uzlu na komplex slotů a memmb na mem_free jsou běžně používanými výchozími hodnotami. Je vyžadováno první přidružení.

    "default_resources": [
    {
      "select": {},
      "name": "slots",
      "value": "node.vcpu_count"
    },
    {
      "select": {},
      "name": "mem_free",
      "value": "node.resources.memmb"
    }
 ],

Pokud má komplex zkratku, která se nerovná celé hodnotě, definujte oboje v default_resources, kde physical_cpu je název komplexu:

"default_resources": [
    {
      "select": {},
      "name": "physical_cpu",
      "value": "node.pcpu_count"
    },
    {
      "select": {},
      "name": "pcpu",
      "value": "node.resources.physical_cpu"
    }
]

Řazení je důležité, pokud chcete konkrétní chování konkrétního atributu. Přidělení jednoho slotu pro konkrétní nodearray při zachování výchozího počtu slotů pro všechny ostatní uzly:

    "default_resources": [
    {
      "select": {"node.nodearray": "FPGA"},
      "name": "slots",
      "value": "1",
    },
    {
      "select": {},
      "name": "slots",
      "value": "node.vcpu_count"
    },
]

Skupiny hostitelů

Automatické škálovátko CycleCloud se při pokusu splnit požadavky úloh snaží mapovat uzly na příslušnou skupinu hostitelů. Fronty, paralelní prostředí a komplexy jsou všechny zohledněny. Velká část logiky spárovává příslušný bucket CycleCloud (a množství uzlů) s příslušnou skupinou hostitelů SGE.

Pro úlohu odeslanou jako: qsub -q "cloud.q" -l "m_mem_free=4g" -pe "mpi*" 48 ./myjob.sh

CycleCloud najde průnik skupin hostitelů, které:

  1. Jsou součástí pe_list pro cloud.q a odpovídají názvu pe, pe_list [@allhosts=mpislots],[@hpc1=mpi]například .
  2. Máte dostatečné prostředky a limity předplatného, abyste mohli poskytnout všechny prostředky pro úlohy.
  3. Konfigurace omezení skupiny hostitelů je nefiltruje.

Tyto požadavky může splňovat několik skupin hostitelů. V takovém případě se systém musí rozhodnout, který z nich se má použít. Konflikty členství ve skupině hostitelů můžete vyřešit třemi způsoby:

  1. Nakonfigurujte fronty, aby nedocházelo k nejednoznačnostem.
  2. Přidejte omezení do autoscale.json.
  3. Nechte CycleCloud zvolit odpovídající skupiny hostitelů seřazené podle názvu úpravou parametru weight_queue_host_sort < weight_queue_seqno v konfiguraci plánovače.
  4. Nastavte seq_no 10000,[@hostgroup1=100],[@hostgroup2=200] v konfiguraci fronty k označení přednosti skupiny hostitelů.

Omezení skupiny hostitelů

Když fronta nebo projekt xproject definuje více skupin hostitelů, může každá z těchto skupin potenciálně přijímat nové hostitele. Pokud chcete řídit, kteří hostitelé mají nárok na fronty, můžete použít omezení skupiny hostitelů na základě vlastností uzlu.

"gridengine": {
    "hostgroups": {
      "@mpi": {
        "constraints": {
          "node.vm_size": "Standard_H44rs"
        }
      },
      "@amd-mem": {
        "constraints" : { 
            "node.vm_size": "Standard_D2_v3",
            "node.nodearray": "hpc" 
            }
        },
    }
  }

NÁPOVĚDA: Zkontrolujte všechny dostupné vlastnosti uzlu pomocí azge buckets.

azge

Tento balíček se dodává s příkazovým řádkem azge. Tento program slouží k automatickému škálování a rozdělí všechny podprocesy v rámci automatického škálování do samostatných komponent. Tyto příkazy spoléhají na proměnné prostředí GridEngine, které musí být nastaveny – musíte být schopni volat qconf a qsub ze stejného profilu, kde se volá azge.

azge příkazy Popis
ověřit Kontroluje známé chyby konfigurace v automatickém škálovači nebo GridEngine.
pracovní místa Zobrazí všechny úlohy ve frontě.
vědra Zobrazuje dostupné fondy zdrojů pro automatické škálování.
uzly Zobrazuje hostitele a vlastnosti clusteru.
poptávka Přiřazuje požadavky úloh k cyclecloud buckets a poskytuje výsledek automatického škálování.
atuomatické škálování Provede úplné automatické škálování, spouštění a odebírání uzlů podle konfigurací.

Při úpravě konfigurací plánovače (qconf) nebo konfigurací automatického škálování (autoscale.json) nebo dokonce při prvním nastavení je možné použít azge ke kontrole chování automatického škálování, které odpovídá očekáváním. Jako kořen můžete spustit následující operace. Abyste pochopili, jak automatické škálování funguje, je důležité se seznámit s těmito koncepty.

  1. Spusťte azge validate pro ověření konfigurací pro známé problémy.
  2. Spusťte azge buckets, abyste zkontrolovali prostředky nabízené clusterem CycleCloud.
  3. Spuštěním zkontrolujte azge jobs podrobnosti úlohy ve frontě.
  4. Spusťte azge demand a proveďte úlohu odpovídání kategorie na kbelík. Pak zkontrolujte, které úlohy jsou přiřazeny ke skupinám úloh a skupinám hostů.
  5. Spusťte azge autoscale proces přidělování uzlů nebo přidejte uzly, které jsou připravené k připojení.

Jakmile příkazy fungují podle očekávání, povolte průběžné automatické škálování přidáním azge autoscale příkazu do kořenové crontab. Nezapomeňte předem vytvořit zdroj proměnných prostředí GridEngine.

* * * * * . $SGE_ROOT/common/settings.sh && /usr/local/bin/azge autoscale -c /opt/cycle/gridengine/autoscale.json

Vytvoření hybridního clusteru

CycleCloud podporuje scénář shlukování cloudu. Základní konfigurace předpokládá, že $SGE_ROOT adresář je dostupný pro cloudové uzly. Tento předpoklad může být uvolněn nastavením gridengine.shared.spool = false, gridengine.shared.bin = falsea instalací GridEngine místně.

V případě jednoduchého případu byste měli poskytnout systém souborů, který lze připojit uzly execute. Tento systém souborů musí obsahovat ... adresář, a připojení nakonfigurujete ve volitelných nastaveních. Když se uvolní závislosti schedovaných a sdílených adresářů, můžete ve výchozím nastavení vypnout uzel plánovače, který je součástí clusteru, a použít konfigurace z externího systému souborů.

  1. Vytvořte nový klastr Grid Engine.
  2. Zakažte návratový proxy server.
  3. Nahraďte soubory /sched a /shared externími systémy souborů.
  4. Uložte klastr.
  5. Odeberte uzel plánovače jako akci v uživatelském rozhraní.
  6. Spusťte cluster, zpočátku se nespustí žádné uzly.
  7. Nakonfigurujte cyclecloud-gridengine s autoscale.json pro použití nového clusteru

Použití modulu Univa Grid v CycleCloudu

Projekt CycleCloud pro GridEngine ve výchozím nastavení používá sge-2011.11 . Podle své licenční smlouvy s Altair můžete použít vlastní instalační programy pro Altair GridEngine. Tato část popisuje, jak používat Altair GridEngine s projektem CycleCloud GridEngine.

Požadavky

Tento příklad používá verzi 8.6.1 demo, ale všechny verze GE větší než 8.4.0 jsou podporovány.

  1. Uživatelé musí zadat binární soubory UGE.
  • ge-8.6.x-bin-lx-amd64.tar.gz
  • ge-8.6.x-common.tar.gz
  1. Rozhraní příkazového řádku CycleCloud musí být nakonfigurované. Dokumentace je k dispozici tady.

Zkopírujte binární soubory do cloudového úložiště

Doplňková verze AGE (8.6.7-demo) se distribuuje s CycleCloudem. Pokud chcete použít jinou verzi, nahrajte binární soubory do účtu úložiště, který Používá CycleCloud.


$ 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/

Úprava konfigurací šablony clusteru

Vytvořte místní kopii šablony GridEngine a upravte ji tak, aby používala instalační programy UGE místo výchozího nastavení.

wget https://raw.githubusercontent.com/Azure/cyclecloud-gridengine/master/templates/gridengine.txt

V souboru gridengine.txt vyhledejte první výskyt [[[configuration]]] a vložte text tak, aby odpovídal následujícímu fragmentu kódu. Soubor není citlivý na odsazení.

Poznámka:

Podrobnosti v konfiguraci, zejména verze, by se měly shodovat s názvem instalačního souboru.

[[[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"

Tato konfigurace GridEngine přepíše výchozí verzi GridEngine a umístění instalace při startu clusteru. Není bezpečné se přesunout mimo cluster /sched , protože se jedná o sdílené umístění NFS v clusteru.