CycleCloud GridEngine Cluster
Open Grid Scheduler (Grid Engine) je možné v clusteru Azure CycleCloud snadno povolit úpravou run_list v definici clusteru. Dvě základní komponenty clusteru gridového modulu jsou "hlavní" uzel, který poskytuje sdílený systém souborů, na kterém běží software Grid Engine, a uzly spouštění, což jsou hostitelé, kteří připojují sdílený systém souborů a provádějí odeslané úlohy. Například jednoduchý fragment kódu š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 společnosti Sun Microsystems.
Importem a spuštěním clusteru s definicí v CycleCloudu se vytvoří jeden hlavní uzel. Uzly spuštění je možné přidat do clusteru cyclecloud add_node
pomocí příkazu . Pokud chcete například přidat dalších 10 uzlů, spusťte ho takto:
cyclecloud add_node grid-engine -t execute -c 10
Automatické škálování modulu mřížky
Azure CycleCloud podporuje automatické škálování pro Grid Engine, což znamená, že software bude monitorovat stav fronty a podle potřeby zapínat a vypínat uzly, aby se práce dokončila v optimálním čase a nákladech. Automatické škálování pro gridový modul 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 gridového modulu spustí na počítačích typu "execute", jedná se o počítače definované polem uzlů s názvem "execute". Nejste omezeni na název "execute", ani nejste omezeni na jeden typ konfigurace počítače, na které se spouštějí úlohy a automatické škálování.
Běžným případem může být například cluster se dvěma různými definicemi uzlů, jedna slouží ke spouštění "normálních" úloh, které spotřebovávají standardní procesor, zatímco jiný typ úlohy může používat počítače GPU. V takovém případě byste chtěli nezávisle škálovat frontu podle normálních úloh i úloh GPU, abyste měli jistotu, že máte odpovídající množství každého počítače pro využití pracovní fronty. Příklad definice by vypadal 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
Ve výše uvedeném příkladu jsou teď dvě pole uzlů: jedno je pole uzlu s "standardním" spuštěním, druhé je pojmenované "gpu" a poskytuje MachineType, který má dvě gpu Nvidia GPU (Standard_NV12 v Azure). Všimněte si také, že kromě receptu csge:sgeexec jsou teď v části konfigurace dvě nové položky. Přidání gridengine.slot_type = gpu
říká plánovači modulu mřížky, ž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 nejužitečnější je název, který popisuje uzel. Nastavte gridengine.slots = 2
, která dává softwaru pokyn, aby zajistil, že tento typ uzlu může spustit jenom dvě úlohy najednou (Standard_NV12 má jenom 2 GPU). Ve výchozím nastavení počet slotů na uzel v gridovém modulu bude počet procesorů v systému, což by v tomto případě způsobilo souběžné spuštění příliš velkého počtu úloh na uzlu. Ve výše uvedeném příkladu je vlastnost nastavená na nodearray tak, CoreCount=2
aby odpovídala počtu gpu dostupných na MachineType, což umožňuje Službě CycleCloud správně škálovat pole na GPU a počtu procesorů.
Počet slotů a slot_type, které vaše počítače mají, 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, který jsme zadali (execute a GPU), 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.
Rozšířené využití modulu mřížky
Výše uvedená 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 spuštění uzluarray, které spustí počítače s 60 GB paměti, a pak přidejte možnosti gridengine.slots = 6
konfigurace, které zajistí, že na tomto typu uzlu může souběžně běžet jenom 6 úloh (zajistíte, aby každá úloha měla alespoň 10 GB paměti pro práci).
Seskupené uzly v modulu mřížky
Když je paralelní úloha odeslána do modulu mřížky, výchozí chování automatického škálování, které CycleCloud použije, je považovat každou úlohu MPI za seskupený požadavek uzlu. Seskupené uzly jsou úzce svázané a ideálně se hodí pro pracovní postupy MPI.
Když se sada seskupených uzlů připojí ke clusteru Grid Engine, ID skupiny každého uzlu se použije jako hodnota komplexní hodnoty affinity_group
. Tím, affinity_group
že se vyžaduje zadání pro úlohy, umožňuje plánovači gridového modulu zajistit, aby úlohy přistály pouze na počítačích, které jsou ve stejné skupině.
Automatizace CycleCloudu automaticky požádá o seskupené uzly a přiřadí je k dostupným skupinám vztahů, když dojde k paralelním úlohám.
Odesílání úloh do modulu gridu
Nejběžnějším způsobem odeslání úloh do plánovače modulu mřížky je příkaz:
qsub my_job.sh
Tento příkaz odešle úlohu, která se spustí na uzlu typu "execute", což je uzel definovaný uzlemarray 'execute'. Pokud chcete, aby se úloha spustila v poli nodearray jiného typu, například na výše uvedeném typu uzlu GPU, upravíme odeslá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, k úloze se automaticky přiřadí příkaz execute. Mechanismus, který automaticky přiřazuje slot_type úlohám, může uživatel upravit. 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 pro úlohu aktualizovat. Jako příklad níže je skript, který přiřadí úlohu slot_type gpu, pokud název úlohy obsahuje písmena "gpu". To by uživateli umožnilo odesílat úlohy z automatizovaného systému, aniž by musel upravovat parametry úlohy, a přesto by úlohy spouštět na správných uzlech a automaticky škálovat:
#!/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
Předaný parametr job je slovník, který obsahuje data ve qstat -j JOB_ID
volání:
{
"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'
}
}
Tuto skriptovací funkci můžete použít k automatickému přiřazení slot_type na základě libovolného parametru definovaného v úloze, jako jsou argumenty, další požadavky na prostředky, jako je paměť, odesílající uživatel atd.
Pokud byste odeslali 5 úloh z každé slot_type:
qsub -t 1:5 gpu_job.sh
qsub -t 1:5 normal_job.sh
Ve frontě by teď bylo 10 úloh. Kvůli výše definovanému skriptu by se pět úloh s gpu v názvu automaticky konfigurovalo tak, aby běžely pouze na uzlech slot_type=gpu. Mechanismus automatického škálování CycleCloud by zjistil, že existuje 5 úloh gpu a 5 úloh spuštění. Vzhledem k tomu, že nodearray 'gpu' je definována tak, že má 2 sloty na jeden uzel, CycleCloud spustí 3 z těchto uzlů (5/2 = 2,5 zaokrouhleno nahoru na 3). Existuje 5 normální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ě, než se nově spuštěné uzly spustí a nakonfigurují, se všech 10 úloh dokončí a 5 uzlů se automaticky vypne, než vám poskytovatel cloudu znovu naúčtuje poplatky.
Předpokládá se, že úlohy mají dobu trvání jednu hodinu. Pokud je modul runtime úloh známý, může z těchto informací těžit algoritmus automatického škálování. Informujte automatické škálování o očekávané době běhu úlohy tím, že ho přidáte do kontextu úlohy. Následující příklad říká automatickému škálování, že modul runtime úlohy je v průměru 10 minut:
qsub -ac average_runtime=10 job_with_duration_of_10m.sh
Referenční dokumentace ke konfiguraci modulu mřížky
Níže jsou uvedené možnosti konfigurace specifické pro gridový modul, které můžete přepnout a přizpůsobit funkce:
Možnosti konfigurace SGE-Specific | Description |
---|---|
gridengine.slots | Počet slotů pro daný uzel, který se má hlásit modulu mřížky. Počet slotů je počet souběžných úloh, které může uzel spustit. Tato hodnota ve výchozím nastavení odpovídá počtu procesorů na daném počítači. Tuto hodnotu můžete přepsat v případech, kdy nespouštíte úlohy na základě procesoru, ale paměti, grafických procesorů atd. |
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=", spustí se pouze na počítači se stejným typem slotu. To vám umožní vytvořit různé konfigurace softwaru a hardwaru pro jednotlivé uzly a zajistit, aby byla odpovídající úloha vždy naplánovaná na správném typu uzlu. |
gridengine.ignore_fqdn | Výchozí hodnota: true. Pokud všechny uzly v clusteru nejsou součástí jedné domény DNS, nastavte hodnotu false. |
gridengine.version | Výchozí hodnota: 2011.11. Toto je verze gridového modulu, která se má nainstalovat a spustit. Toto je aktuálně výchozí a jediná možnost. V budoucnu mohou být podporovány další verze softwaru Grid Engine. |
gridengine.root | Výchozí nastavení: /sched/sge/sge-2011.11 To je místo, kde se modul gridu nainstaluje a připojí na každý uzel v systému. Doporučuje se, aby se tato hodnota nezměnila, ale pokud ano, měla by být nastavená na stejnou hodnotu na všech uzlech v clusteru. |
CycleCloud podporuje standardní sadu atributů automatického plánování napříč plánovači:
Atribut | Popis |
---|---|
cyclecloud.cluster.autoscale.stop_enabled | Je na tomto uzlu povolené automatické řešení? [true/false] |
cyclecloud.cluster.autoscale.idle_time_after_jobs | Doba (v sekundách) nečinnosti uzlu po dokončení úloh před vertikálním snížením kapacity. |
cyclecloud.cluster.autoscale.idle_time_before_jobs | Doba (v sekundách), po kterou má uzel před dokončením úloh sedět v nečinnosti, než dojde k vertikálnímu snížení kapacity. |
Známé problémy
-
qsh
příkaz pro interaktivní relaci nefunguje. Jako alternativu použijteqrsh
. - Automatické
exclusive=1
škálování nerespektuje komplex. Výsledkem může být méně uzlů, než se čekalo.
Poznámka
I když je Windows oficiálně podporovanou platformou GridEngine, CycleCloud v tuto chvíli nepodporuje spouštění GridEngine ve Windows.
Tato stránka se zabývá možnostmi a konfigurací použití (Altair) GridEngine s CycleCloudem.
Konfigurace prostředků
Aplikace cyclecloud-gridengine porovnává prostředky sge s cloudovými prostředky Azure, aby poskytovala bohaté nástroje pro automatické škálování a konfiguraci clusteru. Aplikace se nasadí automaticky pro clustery vytvořené prostřednictvím uživatelského rozhraní CycleCloud nebo ji lze 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 artefakt vydané verze. Instalace a upgrade bude stejný proces. 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 pokaždé, když je volána – úlohy, fronty, komplexy. Informace jsou uvedeny v stderr a stdout příkazu a také v souboru protokolu, a to jak na konfigurovatelných úrovních. Všechny příkazy pro správu gridengine s argumenty jsou také protokolovány do souboru.
Description | 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 azge
automatického škálování cyclecloud-gridengine přidá hostitele do clusteru 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 vhodný virtuální počítač, který chcete spustit.
- Spusťte virtuální počítač a počkejte, až bude připravený.
- Čtení fronty a paralelního 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 také do jakékoli jiné fronty obsahující skupinu hostitelů.
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í úlohy do začne zapůjčením qsub -q short.q -pe mpi02 12 my-script.sh
jednoho virtuálního počítače, a když se přidá do clusteru, připojí se ke skupině hostitelů @mpihg02 , protože je to skupina hostitelů dostupná pro frontu i pro paralelní prostředí. Přidá se také do @allhosts, což je speciální skupina hostitelů.
Bez zadání prostředí se qsub -q short.q my-script.sh
výsledný virtuální počítač přidá do @allhosts a @lowpriority to jsou skupiny hostitelů ve frontě, které nemají přiřazené pes.
Nakonec úloha odeslaná pomocí qsub -q short.q -pe mpi0* 12 my-script.sh
způsobí přidání virtuálního počítače do @mpihg01 nebo @mpihg02 v závislosti na předpovědích přidělení CycleCloudu.
Paralelní prostředí se implicitně rovna skupině umístění v cyklcloudu. Virtuální počítače v pe jsou omezené tak, aby byly ve stejné síti. Pokud chcete použít prostředí PE, které nezachovává skupinu umístění, použijte k odhlášení použití souboru 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 VMSS Azure s SinglePlacementGroup – virtuální počítače ve skupině umístění sdílejí prostředky infrastruktury Infiniband a sdílejí je jenom s virtuálními počítači v rámci skupiny umístění. Aby se tato sila intuitivně zachovala, mapují skupiny umístění 1:1 také s paralelním prostředím gridengine.
Zadání paralelního prostředí pro úlohu omezí spuštění úlohy ve skupině umístění prostřednictvím logiky přiřazení skupiny inteligentních hostitelů. Z tohoto chování se můžete odhlásit pomocí výše uvedené konfigurace v souboru 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 úloh. Konfigurační soubor autoscale.json určuje chování automatického škálování modulu mřížky.
- Nastavení podrobností o připojení k cyclecloudu
- Nastavení časovače ukončení pro nečinné uzly
- Je možné provést vícerozměrné automatické škálování, které atributy se mají použít v balení úloh, jako jsou sloty, paměť.
- Registrace front, paralelních prostředí a skupin hostitelů ke správě
Konfigurace | Typ | Description |
---|---|---|
url | Řetězec | Adresa URL kopie |
uživatelské jméno a heslo | Řetězec | Podrobnosti o připojení cc |
cluster_name | Řetězec | Název clusteru CC |
default_resources | Mapa | Propojení prostředku uzlu s hostitelským prostředkem modulu mřížky pro automatické škálování |
idle_timeout | Int | Doba čekání před ukončením nečinných uzlů |
boot_timeout | Int | Doba čekání před ukončením uzlů během dlouhých fází konfigurace |
gridengine.relevant_complexes | Seznam (řetězec) | Komplexy modulu mřížky, které je potřeba vzít v úvahu při automatickém škálování, jako jsou sloty, mem_free |
gridengine.logging | Soubor | Umístění konfiguračního souboru protokolování |
gridengine.pes | Struktura | Určete chování PE, např. requires_placement_group = false |
Program automatického škálování bude brát v úvahu pouze relevantní prostředek.
Další prostředek automatického škálování
Ve výchozím nastavení se cluster škáluje na základě počtu slotů požadovaných úlohami. Automatickému škálování můžeme přidat další dimenzi.
Řekněme, že chceme automaticky škálovat podle žádosti o prostředek úlohy pro m_mem_free
.
- Přidání
m_mem_free
do souborugridengine.relevant_resources
autoscale.json - Propojení
m_mem_free
s prostředkem paměti na úrovni uzlu v souboru autoscale.json
Tyto atributy můžou být odkazy na node.*
hodnotu v _default/resources.
Uzel | Typ | Description |
---|---|---|
nodearray | Řetězec | Název uzlu cycleclouduarray |
placement_group | Řetězec | Název skupiny umístění v cyklcloudu v rámci nodearray |
vm_size | Řetězec | Název produktu virtuálního počítače, například "Standard_F2s_v2" |
vcpu_count | Int | Virtuální procesory dostupné na uzlu, jak je uvedeno na stránkách jednotlivých produktů |
pcpu_count | Int | Fyzické procesory dostupné na uzlu |
paměť | Řetězec | Přibližná fyzická paměť dostupná na virtuálním počítači s indikátorem jednotky, například 8,0 g |
Další atributy jsou v node.resources.*
oboru názvů, například node.resources.
Uzel | Typ | Description |
---|---|---|
ncpus | Řetězec | Počet procesorů dostupných ve virtuálním počítači |
pcpus | Řetězec | Počet fyzických procesorů dostupných na virtuálním počítači |
ngpus | Integer | Počet grafických procesorů (GPU) dostupných na virtuálním počítači |
memb | Ř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á na virtuálním počítači s indikátorem jednotky, například "8,0 m" |
memgb | Řetězec | Přibližná fyzická paměť dostupná na virtuálním počítači s indikátorem jednotky, například 8,0 g |
memtb | Řetězec | Přibližná fyzická paměť dostupná na virtuálním počítači s indikátorem jednotky, například 8,0t |
Sloty | Integer | Stejné jako ncpus |
slot_type | Řetězec | Popisek přidání pro rozšíření. Obecně se nepoužívá. |
m_mem_free | Řetězec | Očekávaná volná paměť na hostiteli spouštění, například "3,0g" |
mfree | Řetězec | Stejné jako _m/_mem/free |
Mapování prostředků
K dispozici jsou také matematiky pro default_resources – zmenšete sloty konkrétního pole 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í virtuálních procesorů uzlů na komplexní sloty a memmb
na mem_free
jsou běžně používané výchozí hodnoty.
Vyžaduje se první přidružení.
"default_resources": [
{
"select": {},
"name": "slots",
"value": "node.vcpu_count"
},
{
"select": {},
"name": "mem_free",
"value": "node.resources.memmb"
}
],
Všimněte si, že pokud má komplex zástupce, který se nerovná celé hodnotě, definujte obě hodnoty 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 mít konkrétní chování pro konkrétní atribut. Přidělení jednoho slotu pro konkrétní nodearray při zachování výchozího počtu slotů pro všechny ostatní nodearray:
"default_resources": [
{
"select": {"node.nodearray": "FPGA"},
"name": "slots",
"value": "1",
},
{
"select": {},
"name": "slots",
"value": "node.vcpu_count"
},
]
Skupiny hostitelů
Automatické škálování CycleCloud při pokusu o splnění požadavků úlohy namapuje uzly na příslušnou skupinu hostitelů. Zvažují se fronty, paralelní prostředí a komplexy. Velká část logiky odpovídá příslušnému kontejneru cyklcloudu (a množství uzlu) 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 mezi skupinami hostitelů, které:
- Jsou součástí pe_list pro cloud.q a odpovídají názvu pe, například
pe_list [@allhosts=mpislots],[@hpc1=mpi]
. - Mít odpovídající prostředky a kvótu předplatného, abyste mohli poskytnout všechny prostředky úloh.
- Nejsou filtrovány konfigurací omezení skupiny hostitelů.
Je možné, že tyto požadavky bude splňovat více skupin hostitelů. V takovém případě bude potřeba zvolit logiku. Existují tři způsoby, jak vyřešit nejednoznačnost členství ve skupině hostitelů:
- Nakonfigurujte fronty tak, aby nebyly nejednoznačné.
- Přidejte omezení do souboru autoscale.json.
- Nechte CycleCloud zvolit odpovídající skupiny hostitelů v názvovém pořadí úpravou
weight_queue_host_sort < weight_queue_seqno
v konfiguraci plánovače. - Nastavením
seq_no 10000,[@hostgroup1=100],[@hostgroup2=200]
v konfiguraci fronty označíte předvolbu skupiny hostitelů.
Omezení skupiny hostitelů
Pokud je více skupin hostitelů definováno frontou nebo xprojectem, všechny tyto skupiny hostitelů mohou být potenciálně přidány do těchto hostitelů. Nastavením omezení skupin hostitelů můžete omezit, jaké druhy hostitelů je možné přidat do kterých front. Nastavte omezení 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"
}
},
}
}
HINT: Zkontrolujte všechny dostupné vlastnosti uzlu pomocí
azge buckets
.
azge
Tento balíček se dodává s příkazovým řádkem azge. Tento program by se měl použít k automatickému škálování a rozložil všechny podprocesy v rámci automatického škálování.
Tyto příkazy závisí na nastavení proměnných prostředí gridengine – musíte být schopni volat qconf
a qsub
ze stejného profilu, ve kterém azge
se volá.
příkazy azge | Description |
---|---|
ověření | Kontroluje známé chyby konfigurace v automatickém škálování nebo gridengine. |
Úlohy | Zobrazí všechny úlohy ve frontě. |
Kbelíky | Zobrazuje dostupné fondy zdrojů pro automatické škálování. |
Uzly | Zobrazuje hostitele a vlastnosti clusteru. |
Poptávky | Odpovídá požadavkům úloh s kontejnery cyklcloudu a poskytuje výsledek automatického škálování. |
automatické škálování | Probíhá úplné automatické škálování, spouštění a odebírání uzlů podle konfigurací |
Při úpravě konfigurací plánovače (qconf) nebo konfigurace automatického škálování (autoscale.json) nebo dokonce při prvním nastavení můžete pomocí azge zkontrolovat, že chování automatického škálování odpovídá očekáváním. Jako root můžete spustit následující operace. Doporučujeme se s nimi seznámit, abyste porozuměli chování automatického škálování.
- Spuštěním příkazu
azge validate
ověřte konfigurace známých problémů. - Spuštěním příkazu
azge buckets
zkontrolujte, jaké prostředky nabízí cluster CycleCloud. - Spuštěním příkazu
azge jobs
zkontrolujte podrobnosti úlohy ve frontě. - Spuštěním
azge demand
příkazu proveďte úlohu a zkontrolujte, které úlohy se spárují s kontejnery a skupinami hostitelů. - Spuštěním příkazu
azge autoscale
zahájíte proces přidělování uzlů nebo přidáte uzly, které jsou připravené k připojení.
Když se pak tyto příkazy chovají podle očekávání, povolte průběžné automatické škálování přidáním azge autoscale
příkazu do kořenového crontab. (Souce s proměnnými 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 bude podporovat scénář shlukování do cloudu. Základní konfigurace předpokládá, že $SGE_ROOT
adresář je dostupný pro cloudové uzly. Tento předpoklad lze uvolnit nastavením gridengine.shared.spool = false
gridengine.shared.bin = false
a místní instalací GridEngine.
V jednoduchém případě byste měli zadat systém souborů, který lze připojit pomocí uzlů spouštění obsahujících $SGE_ROOT
adresář, a nakonfigurovat toto připojení v volitelném nastavení. Po uvolnění závislosti adresářů sched 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ý cluster gridengine.
- Zakažte proxy pro vrácení.
- Nahraďte /sched a /shared externími systémy souborů.
- Uložte cluster.
- Odeberte uzel plánovače jako akci v uživatelském rozhraní.
- Spusťte cluster. Zpočátku se nespustí žádné uzly.
- Konfigurace
cyclecloud-gridengine
pomocí souboru 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 . Můžete používat vlastní instalační programy Altair GridEngine podle vaší licenční smlouvy Altair.
Tato část popisuje, jak používat Altair GridEngine s projektem CycleCloud GridEngine.
Požadavky
V tomto příkladu se použije demo verze 8.6.1, ale podporují se všechny verze > 8.4.0.
- Uživatelé musí zadat binární soubory UGE.
- ge-8.6.x-bin-lx-amd64.tar.gz
- ge-8.6.x-common.tar.gz
- Musí být nakonfigurované rozhraní příkazového řádku CycleCloud. Dokumentace je k dispozici tady.
Zkopírování binárních souborů do cloudového zámku
Doplňková verze AGE (8.6.7 demo) je distribuovaná 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 místo výchozího používala instalační programy UGE.
wget https://raw.githubusercontent.com/Azure/cyclecloud-gridengine/master/templates/gridengine.txt
V souborugridengine.txt vyhledejte první výskyt [[[configuration]]]
a vložte text tak, aby odpovídal následujícímu fragmentu kódu. Tento 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"
Tyto konfigurace přepíšou výchozí verzi gridengine a umístění instalace při spuštění clusteru.
Není bezpečné přejít z objektu /sched
, protože se jedná o konkrétně sdílené umístění nfs v clusteru.