Sdílet prostřednictvím


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žijte qrsh .
  • 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 azgeautomatické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.

  1. Přečtěte si žádost o prostředek úlohy a vyhledejte vhodný virtuální počítač, který chcete spustit.
  2. Spusťte virtuální počítač a počkejte, až bude připravený.
  3. Čtení fronty a paralelního 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 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.

  1. Přidání m_mem_free do souboru gridengine.relevant_resourcesautoscale.json
  2. 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é:

  1. Jsou součástí pe_list pro cloud.q a odpovídají názvu pe, například pe_list [@allhosts=mpislots],[@hpc1=mpi].
  2. Mít odpovídající prostředky a kvótu předplatného, abyste mohli poskytnout všechny prostředky úloh.
  3. 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ů:

  1. Nakonfigurujte fronty tak, aby nebyly nejednoznačné.
  2. Přidejte omezení do souboru autoscale.json.
  3. 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.
  4. 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í.

  1. Spuštěním příkazu azge validate ověřte konfigurace známých problémů.
  2. Spuštěním příkazu azge buckets zkontrolujte, jaké prostředky nabízí cluster CycleCloud.
  3. Spuštěním příkazu azge jobs zkontrolujte podrobnosti úlohy ve frontě.
  4. Spuštěním azge demand příkazu proveďte úlohu a zkontrolujte, které úlohy se spárují s kontejnery a skupinami hostitelů.
  5. 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 = falsegridengine.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ů.

  1. Vytvořte nový cluster gridengine.
  2. Zakažte proxy pro vrácení.
  3. Nahraďte /sched a /shared externími systémy souborů.
  4. Uložte cluster.
  5. Odeberte uzel plánovače jako akci v uživatelském rozhraní.
  6. Spusťte cluster. Zpočátku se nespustí žádné uzly.
  7. 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.

  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. 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.