Poznámka:
Přístup k této stránce vyžaduje autorizaci. Můžete se zkusit přihlásit nebo změnit adresáře.
Přístup k této stránce vyžaduje autorizaci. Můžete zkusit změnit adresáře.
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
-
qshpříkaz pro interaktivní relaci nefunguje. Použijteqrshjako alternativu. - Automatické škálování nerespektuje
exclusive=1komplex, 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.
- Přečtěte si žádost o prostředek úlohy a vyhledejte odpovídající virtuální počítač pro spuštění.
- Spusťte virtuální počítač a počkejte, až bude připravený.
- Přečíst frontu a paralelní prostředí z úlohy
- Na základě fronty nebo prostředí přiřaďte hostitele k příslušné skupině hostitelů.
- 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.
- Přidejte
m_mem_freedogridengine.relevant_resourcesv autoscale.json - Propojení
m_mem_frees 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é:
- Jsou součástí pe_list pro cloud.q a odpovídají názvu pe,
pe_list [@allhosts=mpislots],[@hpc1=mpi]například . - Máte dostatečné prostředky a limity předplatného, abyste mohli poskytnout všechny prostředky pro úlohy.
- 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:
- Nakonfigurujte fronty, aby nedocházelo k nejednoznačnostem.
- Přidejte omezení do autoscale.json.
- Nechte CycleCloud zvolit odpovídající skupiny hostitelů seřazené podle názvu úpravou parametru
weight_queue_host_sort < weight_queue_seqnov konfiguraci plánovače. - 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.
- Spusťte
azge validatepro ověření konfigurací pro známé problémy. - Spusťte
azge buckets, abyste zkontrolovali prostředky nabízené clusterem CycleCloud. - Spuštěním zkontrolujte
azge jobspodrobnosti úlohy ve frontě. - Spusťte
azge demanda 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ů. - Spusťte
azge autoscaleproces 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ů.
- Vytvořte nový klastr Grid Engine.
- Zakažte návratový proxy server.
- Nahraďte soubory /sched a /shared externími systémy souborů.
- Uložte klastr.
- Odeberte uzel plánovače jako akci v uživatelském rozhraní.
- Spusťte cluster, zpočátku se nespustí žádné uzly.
- Nakonfigurujte
cyclecloud-gridengines 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.
- Uživatelé musí zadat binární soubory UGE.
- ge-8.6.x-bin-lx-amd64.tar.gz
- ge-8.6.x-common.tar.gz
- 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.