Delen via

CycleCloud GridEngine-cluster

CycleCloud GridEngine Cluster-project README

Open Grid Scheduler (Grid Engine) kan eenvoudig worden ingeschakeld op een Azure CycleCloud-cluster door de 'run_list' in de clusterdefinitie te wijzigen. Een Grid Engine-cluster bestaat uit twee primaire onderdelen. De eerste is het hoofdknooppunt, dat een gedeeld bestandssysteem biedt waarin de Grid Engine-software wordt uitgevoerd. De tweede is de set uitvoeringsknooppunten, de hosts die het gedeelde bestandssysteem koppelen en de ingediende taken uitvoeren. Een eenvoudig clustersjabloonfragment van de grid-engine kan er bijvoorbeeld als volgt uitzien:

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

Opmerking

De rolnamen bevatten 'sge' om verouderde redenen: Grid Engine was een product van Sun Microsystems.

Het importeren en starten van een cluster met een definitie in CycleCloud resulteert in één hoofdknooppunt. 'execute'-knooppunten kunnen via de cyclecloud add_node opdracht aan het cluster worden toegevoegd. Als u bijvoorbeeld tien 'execute'-knooppunten wilt toevoegen:

cyclecloud add_node grid-engine -t execute -c 10

Grid Engine automatische schaalvergroting

Azure CycleCloud biedt ondersteuning voor automatisch schalen voor grid-engine. Dit gedrag betekent dat de software continu de status van uw wachtrij bewaakt en knooppunten indien nodig automatisch inschakelt of uitschakelt om de workload efficiënt te voltooien in termen van tijd en kosten. U kunt automatisch schalen inschakelen voor Grid Engine door Autoscale = true toe te voegen aan uw clusterdefinitie.

[cluster grid-engine]
Autoscale = True

Standaard worden alle taken die worden verzonden naar de Grid Engine-wachtrij uitgevoerd op machines van het type 'execute'. Deze machines zijn gedefinieerd door de knooppuntreeks met de naam 'execute'. U bent niet beperkt tot de naam 'execute', noch bent u beperkt tot één type machineconfiguratie om taken en automatische schaalaanpassing uit te voeren.

Een veelvoorkomend scenario omvat bijvoorbeeld een cluster met twee verschillende knooppuntdefinities. Een is ontworpen voor het uitvoeren van 'normale' taken die gebruikmaken van standaard-CPU's. De andere is bedoeld voor taken waarvoor GPU-machines zijn vereist. In dit geval wilt u uw wachtrij onafhankelijk schalen door zowel normale taken als GPU-taken om ervoor te zorgen dat u een juiste hoeveelheid van elke machine hebt om de werkwachtrij te gebruiken. Een voorbeelddefinitie zou er ongeveer als volgt uitzien:

[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

In het voorbeeld dat wordt weergegeven, zijn er nu twee knooppuntmatrices: Een is een 'standaard' 'execute'-knooppuntmatrix, de tweede heet gpu die een MachineType biedt met twee NVIDIA GPU's (Standard_NV12 in Azure). Houd er ook rekening mee dat er nu twee nieuwe items zijn in de configuratiesectie naast het recept 'csge:sgeexec'. Het toevoegen gridengine.slot_type = gpu vertelt de Grid Engine-planner dat deze knooppunten de naam GPU-knooppunten moeten hebben en dus alleen GPU-taken mogen uitvoeren. De naam gpu is willekeurig, maar een naam die het knooppunt beschrijft, is het handigst. Instellen gridengine.slots = 2, waarmee de software ervoor zorgt dat dit type knooppunt slechts twee taken tegelijk kan uitvoeren (Standard_NV12 slechts 2 GPU's heeft).

Standaard wijst Grid Engine het aantal sleuven per knooppunt toe op basis van het CPU-aantal van het systeem. In dit geval kan dat standaardgedrag leiden tot te veel taken die gelijktijdig op één knooppunt worden uitgevoerd. In het weergegeven CoreCount=2 voorbeeld wordt ingesteld op de knooppuntmatrix zodat deze overeenkomt met het aantal GPU's dat beschikbaar is op het MachineType, zodat CycleCloud die matrix correct kan schalen op GPU versus CPU-aantal.

U kunt het aantal slots en slot_type van uw machines verifiëren door de opdracht uit te voeren:

    -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

U ziet dat er één van elke 'slot_type', namelijk 'execute' en 'gpu', is opgegeven. De slot_types worden individueel geconfigureerd en het aantal slots voor de 'execute'-slot is 4, wat overeenkomt met het aantal CPU's op de machine. Het aantal slots voor het type 'gpu'-slot is 2, zoals we hebben gespecificeerd in ons clusterconfiguratiesjabloon. De derde machine is het hoofdknooppunt dat geen taken uitvoert.

Geavanceerd gebruik van grid engine

Deze configuratie-instellingen maken geavanceerde aanpassing van knooppunten en knooppuntmatrices mogelijk. Als taken bijvoorbeeld een specifieke hoeveelheid geheugen vereisen, bijvoorbeeld 10 GB, kunt u een knooppuntarray 'uitvoeren' definiëren waarmee machines worden gestart met 60 GB geheugen, en vervolgens de configuratieopties gridengine.slots = 6 toevoegen om ervoor te zorgen dat slechts 6 taken gelijktijdig op dit type knooppunt kunnen worden uitgevoerd, waardoor elke taak ten minste 10 GB geheugen beschikbaar heeft.

Gegroepeerde knooppunten in rasterengine

Wanneer een parallelle taak wordt verzonden naar de Grid Engine, past CycleCloud standaard automatisch schaalaanpassingsgedrag toe door elke MPI-taak als een verzoek voor een gegroepeerde knooppunten te behandelen. Gegroepeerde knooppunten zijn nauw gekoppeld en ideaal voor MPI-werkstromen.

Wanneer een set gegroepeerde knooppunten lid wordt van een Grid Engine-cluster, wordt de groeps-id van elk knooppunt gebruikt als de waarde van de complexe waarde affinity_group. Door te vereisen dat een affinity_group taak moet worden opgegeven, kan de Grid Engine-planner ervoor zorgen dat taken alleen terechtkomen op machines die zich in dezelfde groep bevinden.

De automatisering van CycleCloud vraagt automatisch gegroepeerde knooppunten aan en wijst deze toe aan beschikbare affiniteitsgroepen wanneer parallelle taken worden aangetroffen.

Taken indienen bij de Grid Engine

De meest algemene manier om taken naar een Grid Engine-planner te verzenden, is de opdracht:

qsub my_job.sh

Met deze opdracht wordt een taak verzonden die wordt uitgevoerd op een knooppunt van het type 'execute'. Dit is een knooppunt dat is gedefinieerd door de nodearray 'execute'. Als u een taak wilt uitvoeren op een knooppuntmaarray van een ander type, bijvoorbeeld het type GPU-knooppunt dat wordt weergegeven, wijzigen we de inzending:

qsub -l slot_type=gpu my_gpu_job.sh

Met deze opdracht zorgt u ervoor dat de taak alleen wordt uitgevoerd op een 'slot_type' van 'gpu'.

Als slot_type wordt weggelaten, wijst 'uitvoeren' automatisch toe aan de taak. De gebruiker kan het mechanisme wijzigen dat automatisch slot_type aan taken toewijst. Er kan een Python-script worden gemaakt op /opt/cycle/jetpack/config/autoscale.py waarmee één functie sge_job_handler moet worden gedefinieerd. Deze functie ontvangt een woordenlijstweergave van de taak, vergelijkbaar met de uitvoer van een qstat -j JOB_ID opdracht en moet een woordenlijst retourneren van harde resources die moeten worden bijgewerkt voor de taak.

Als voorbeeld wijst het volgende script een taak toe aan de GPU-slot_type als de naam van de taken de letters GPU bevat. Gebruikers mogen hun taken automatisch verzenden zonder de taakparameters te wijzigen, terwijl ze ervoor zorgen dat de taken op de juiste knooppunten worden uitgevoerd en automatisch worden geschaald:

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

De parameter 'job' die wordt doorgegeven, is een woordenlijst die de gegevens in een qstat -j JOB_ID aanroep bevat:

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

U kunt deze scriptfunctionaliteit gebruiken om slot_type automatisch toe te wijzen op basis van elke taakparameter die is gedefinieerd, zoals argumenten, resourcevereisten zoals geheugen of de verzendende gebruiker.

Stel dat u vijf taken verzendt voor elke 'slot_type':

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

Er staan nu 10 taken in de wachtrij. Vanwege het gedefinieerde script worden de vijf taken met gpu in de naam automatisch geconfigureerd om alleen te worden uitgevoerd op knooppunten van 'slot_type=gpu'. Het mechanisme voor automatische schaalaanpassing van CycleCloud detecteert dat er vijf GPU-taken en 5 'execute'-taken zijn. Omdat de 'gpu' nodearray is gedefinieerd als 2 slots per knooppunt te hebben, zou CycleCloud 3 van deze knooppunten starten (5/2=2,5 afgerond naar boven tot 3).

Er zijn vijf normale taken, omdat het machinetype voor de 'execute' nodearray elk 4 CPU's heeft, CycleCloud zou 2 van deze knooppunten starten om de taken af te handelen (5/4=1,25 afgerond tot 2). Na een korte opstartperiode worden de zojuist gestarte knooppunten opgestart en zichzelf geconfigureerd. Zodra alles gereed is, worden alle 10 taken uitgevoerd. De vijf knooppunten worden vervolgens automatisch afgesloten voordat een andere factureringscyclus begint met de cloudprovider.

Taken worden verondersteld een duur van één uur te hebben. Als de taakruntime bekend is, kan het algoritme voor automatische schaalaanpassing profiteren van deze informatie. Stel autoscale op de hoogte van de verwachte uitvoeringstijd van de job door deze toe te voegen aan de jobcontext. In het volgende voorbeeld wordt de taakduur voor autoscale ingesteld op 10 minuten.

qsub -ac average_runtime=10 job_with_duration_of_10m.sh

Configuratiereferentie voor Grid-engine

Hieronder vindt u de configuratieopties voor de rasterengine die u kunt in- of uitschakelen om de functionaliteit aan te passen:

Configuratieopties voor SGE-Specific Beschrijving
gridengine.slots Het aantal slots voor een gegeven knooppunt dat wordt gerapporteerd aan Grid Engine. Het aantal sites is het aantal gelijktijdige taken dat een knooppunt kan uitvoeren. Deze waarde wordt standaard ingesteld op het aantal CPU's op een bepaalde computer. U kunt deze waarde overschrijven in gevallen waarin u geen taken uitvoert op basis van CPU, maar op geheugen, GPU's, enzovoort.
gridengine.slot_type De naam van het type 'sleuf' dat een knooppunt biedt. De standaardwaarde is 'execute'. Wanneer een taak wordt gelabeld met de hard resource 'slot_type=', wordt die taak alleen uitgevoerd op een machine van hetzelfde slot type. Met deze tagging kunt u verschillende software- en hardwareconfiguraties per knooppunt maken en ervoor zorgen dat een geschikte taak altijd wordt gepland op het juiste type knooppunt.
gridengine.ignore_fqdn Standaard: waar. Ingesteld op false als alle knooppunten in uw cluster geen deel uitmaken van één DNS-domein.
gridengine.version Standaard: '2011.11'. Met deze configuratieoptie geeft u de grid engine-versie op die moet worden geïnstalleerd en uitgevoerd. Op dit moment is dit de standaardinstelling en de enige beschikbare optie. Andere versies van de Grid Engine-software kunnen in de toekomst worden ondersteund.
gridengine.root Standaard: '/sched/sge/sge-2011.11' Op deze locatie wordt de Grid Engine op elk knooppunt in het systeem geïnstalleerd en gemonteerd. U kunt deze waarde het beste ongewijzigd laten. Als u echter wijzigt, moet u ervoor zorgen dat u dezelfde waarde instelt op elk knooppunt in het cluster.

CycleCloud ondersteunt een standaardset autostopkenmerken voor schedulers:

Eigenschap Beschrijving
cyclecloud.cluster.autoscale.stop_enabled - "stop_enabled" verwijst naar een functie waarmee het stoppen van autoscaling is ingeschakeld. Hiermee schakelt u autostop in op dit knooppunt. [waar/onwaar]
cyclecloud.cluster.autoscale.wachttijd_na_taken De hoeveelheid tijd (in seconden) voor een knooppunt dat inactief is na het voltooien van taken voordat het automatisch stopt.
cyclecloud.cluster.autoscale.idle_tijd_voor_taken De hoeveelheid tijd (in seconden) dat een knooppunt inactief blijft, voordat het taken voltooit en automatisch stopt.

Bekende problemen

  • qsh de opdracht voor interactieve sessie werkt niet. Als qrsh alternatief gebruiken.
  • De automatische schaalaanpassing respecteert het exclusive=1 complex niet, wat ertoe kan leiden dat er minder knooppunten worden gestart dan verwacht.

Opmerking

Hoewel Windows een officieel ondersteund GridEngine-platform is, biedt CycleCloud momenteel geen ondersteuning voor het uitvoeren van GridEngine in Windows.

Deze pagina bevat mogelijkheden en configuratie van het gebruik van (Altair) GridEngine met CycleCloud.

Het configureren van resources

De CycleCloud-GridEngine-toepassing stemt SGE-resources af op Azure-cloudresources om krachtige hulpprogramma's voor automatische schaalaanpassing en clusterconfiguratie te bieden. De toepassing wordt automatisch geïmplementeerd voor clusters die zijn gemaakt via de CycleCloud-gebruikersinterface of kan worden geïnstalleerd op elke GridEngine-beheerhost op een bestaand cluster.

Cyclecloud-gridengine installeren of upgraden

De cyclecloud-gridengine-bundel is beschikbaar in GitHub als release-artefact. Installeren en upgraden volgt hetzelfde proces. Voor de toepassing is Python3 met virtualenv vereist.

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

Belangrijke bestanden

De toepassing parseert de sge-configuratie telkens wanneer deze wordt uitgevoerd: taken, wachtrijen, complexen. Informatie wordt verstrekt in de stderr en stdout van de opdracht en in een logboekbestand, beide op configureerbare niveaus. Alle GridEngine-beheeropdrachten met argumenten worden ook vastgelegd in het bestand.

Beschrijving Locatie
Configuratie voor automatisch schalen /opt/cycle/gridengine/autoscale.json
Log automatisch schalen /opt/cycle/jetpack/logs/autoscale.log
qconf-traceringslogboek /opt/cycle/jetpack/logs/qcmd.log

SGE-wachtrijen, hostgroepen en parallelle omgevingen

Het hulpprogramma cyclecloud-gridengine voor het automatisch schalen, azge, voegt hosts toe aan het cluster volgens de clusterconfiguratie. De bewerkingen voor automatisch schalen voeren de volgende acties uit.

  1. Lees de taakresourceaanvraag en zoek een geschikte VM om te starten
  2. Start de VIRTUELE machine en wacht tot deze gereed is
  3. De wachtrij en parallelle omgeving van de taak lezen
  4. Op basis van de wachtrij/pe wijst u de host toe aan een geschikte hostgroep
  5. Voeg de host toe aan het cluster en aan een andere wachtrij met de hostgroep

Bekijk de volgende wachtrijdefinitie voor een wachtrij met de naam short.q

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

Het indienen van een taak via qsub -q short.q -pe mpi02 12 my-script.sh start ten minste één virtuele machine. Wanneer het cluster wordt toegevoegd, wordt het gekoppeld aan de @mpihg02 hostgroep, omdat dit de hostgroep is die zowel beschikbaar is voor de wachtrij als voor de parallelle omgeving. Het wordt ook lid van @allhosts, een speciale hostgroep.

Als u een taak verzendt met qsub -q short.q my-script.sh en geen parallelle omgeving (PE) opgeeft, wordt de resulterende VM onderdeel van de @allhosts en @lowpriority hostgroepen die zijn gekoppeld aan de wachtrij waaraan geen PEs zijn toegewezen.

Ten slotte leidt een taak die is verzonden met qsub -q short.q -pe mpi0* 12 my-script.sh tot een virtuele machine die is toegevoegd aan @mpihg01 of @mpihg02, afhankelijk van CycleCloud-toewijzingsvoorspellingen.

Parallelle omgevingen zijn impliciet gelijk aan een cyclecloud-plaatsingsgroep. VM's in een PE zijn beperkt tot binnen hetzelfde netwerk. Als u een PE wilt gebruiken die geen plaatsingsgroep behoudt, gebruik dan de autoscale.json om u daarvoor uit te schrijven.

Hier melden we ons af van plaatsingsgroepen voor make pe.

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

CycleCloud-plaatsingsgroepen

CycleCloud-plaatsingsgroepen wijzen een-op-een toe aan Azure VMSS met SinglePlacementGroup: VM's in een plaatsingsgroep delen een Infiniband Fabric en delen alleen met VM's binnen de plaatsingsgroep. Om deze silo's intuïtief te behouden, wijzen de plaatsingsgroepen ook 1:1 toe met een parallelle omgeving van GridEngine.

Als u een parallelle omgeving voor een taak opgeeft, wordt de taak beperkt tot uitvoering in een plaatsingsgroep via slimme logica voor hostgroeptoewijzing. U kunt dit gedrag uitschakelen via de bijbehorende configuratie in autoscale.json: "required_placement_groups" : false.

Configuratie voor automatisch schalen

Met deze plug-in wordt het rooster automatisch geschaald om te voldoen aan de vereisten van de workload. Het autoscale.json configuratiebestand bepaalt het gedrag van de automatische schaalaanpassing van de grid-engine.

  • De details van de cyclecloud-verbinding instellen
  • De beëindigingstimer instellen voor niet-actieve knooppunten
  • Multidimensionale automatische schaalaanpassing wordt ondersteund. U kunt configureren welke kenmerken u in de jobverpakking wilt gebruiken, bijvoorbeeld sleuven of geheugen
  • Registreer de wachtrijen, parallelle omgevingen en hostgroepen die moeten worden beheerd
Configuratie Typologie Beschrijving
URL Snaar / Touwtje CC-URL
gebruikersnaam/wachtwoord Snaar / Touwtje Details van CC-verbinding
clusternaam Snaar / Touwtje CC-clusternaam
standaardmiddelen Kaart Een knooppuntresource koppelen aan een Grid Engine-hostresource voor automatisch schalen
inactiviteitstijdlimiet Integer Wachttijd voor het beëindigen van niet-actieve knooppunten (s)
boot_timeout Integer Wachttijd voor het beëindigen van knooppunten tijdens lange configuratiefasen (s)
gridengine.relevante_complexen Lijst (tekenreeks) Rasterenginecomplexen die van belang zijn bij automatisch schalen, bijvoorbeeld slots, mem_free
gridengine.logging Bestand Locatie van logboekconfiguratiebestand
gridengine.pes Structuur Gedrag van PE's specificeren, bijvoorbeeld requires_placement_group = false

Het programma voor automatisch schalen houdt alleen rekening met relevante resource

Een ander hulpmiddel voor automatisch schalen

Taken vragen standaard veel slots aan, en het cluster past zich aan op basis van deze aanvragen.

Stel dat we automatisch willen schalen op basis van de taakresourceaanvraag voor m_mem_free.

  1. Voeg m_mem_free toe aan de gridengine.relevant_resources in autoscale.json
  2. Koppelen m_mem_free aan de geheugenresource op knooppuntniveau in autoscale.json

Deze kenmerken kunnen verwijzingen zijn met node.* als de waarde in _default/resources.

Knooppunt Typologie Beschrijving
nodearray Snaar / Touwtje Naam van de cyclecloud-knooppuntmaarray
Plaatsingsgroep Snaar / Touwtje Naam van de Cyclecloud-plaatsingsgroep binnen een knooppuntgroep
vm_grootte Snaar / Touwtje VM-productnaam, bijvoorbeeld 'Standard_F2s_v2'
aantal vCPU's Integer Virtuele CPU's die beschikbaar zijn op het knooppunt, zoals aangegeven op afzonderlijke productpagina's
pcpu_count Integer Fysieke CPU's die beschikbaar zijn op het knooppunt
geheugen Snaar / Touwtje Geschat fysiek geheugen dat beschikbaar is in de VIRTUELE machine met eenheidsindicator, bijvoorbeeld '8,0g'

Andere kenmerken bevinden zich in de node.resources.* naamruimte, bijvoorbeeld node.resources.

Knooppunt Typologie Beschrijving
ncpus Snaar / Touwtje Aantal CPU's dat beschikbaar is in de VM
pcpus Snaar / Touwtje Aantal fysieke CPU's dat beschikbaar is in de VIRTUELE machine
ngpu's Geheel getal Aantal GPU's dat beschikbaar is in de VIRTUELE machine
lid Snaar / Touwtje Fysiek geheugen dat beschikbaar is in de virtuele machine met eenheidsindicator, bijvoorbeeld '8.0b'
memkb Snaar / Touwtje Geschat fysiek geheugen beschikbaar in de virtuele machine met eenheidsindicator, bijvoorbeeld "8,0k"
memmb Snaar / Touwtje Geschat fysiek geheugen dat beschikbaar is in de virtuele machine met een eenheidsindicator, bijvoorbeeld "8,0m"
memgb Snaar / Touwtje Geschat fysiek geheugen dat beschikbaar is in de VIRTUELE machine met eenheidsindicator, bijvoorbeeld '8,0g'
memtb Snaar / Touwtje Fysiek geheugen dat beschikbaar is op de VM met eenheidsindicator, bijvoorbeeld '8.0t'
Slots Geheel getal Hetzelfde als ncpus
slot_type Snaar / Touwtje Toevoegingslabel voor extensies. Niet gebruikt.
m_mem_free Snaar / Touwtje Verwacht vrij geheugen op de uitvoeringshost, bijvoorbeeld '3.0g'
m-vrij Snaar / Touwtje Hetzelfde als _m/_mem/gratis

Resourcetoewijzing

Er zijn ook wiskundige berekeningen beschikbaar voor de default_resources: verminder de sleuven op een bepaalde knooppuntmatrix met twee en voeg de docker-resource toe aan alle knooppunten:

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

Toewijzing van de vCPU's van het knooppunt aan de sleuven, en memmb aan mem_free, zijn vaak gebruikte standaarden. De eerste koppeling is vereist.

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

Als een complex een snelkoppeling heeft die niet gelijk is aan de volledige waarde, definieert u beide in default_resources waar physical_cpu de complexe naam zich bevindt:

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

Ordenen is belangrijk wanneer u een bepaald gedrag voor een specifiek kenmerk wilt. Als u één sleuf wilt toewijzen voor een specifieke knooppuntarray terwijl het standaardaantal sleuven behouden blijft voor alle andere knooppuntarrays:

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

Hostgroepen

De CycleCloud-automatische schaalaanpassing, bij een poging om te voldoen aan taakvereisten, wijst knooppunten toe aan de juiste hostgroep. Wachtrijen, parallelle omgevingen en complexe omgevingen worden allemaal in overweging genomen. Het grootste deel van de logica is het matchen van de juiste Cyclecloud-bucket (en aantal knooppunten) met de juiste SGE-hostgroep.

Voor een opdracht die is ingediend als: qsub -q "cloud.q" -l "m_mem_free=4g" -pe "mpi*" 48 ./myjob.sh

CycleCloud bepaalt het snijpunt van hostgroepen die:

  1. Zijn opgenomen in de pe_list voor cloud.q en komen overeen met de pe-naam, bijvoorbeeld pe_list [@allhosts=mpislots],[@hpc1=mpi].
  2. Zorg voor voldoende middelen en voldoende abonnementsquota om alle hulpmiddelen voor taken te bieden.
  3. De configuratie van hostgroepbeperkingen filtert deze niet.

Meerdere hostgroepen voldoen mogelijk aan deze vereisten. Wanneer dat gebeurt, moet het systeem bepalen welke te gebruiken. Er zijn drie manieren om conflicten met hostgroup-lidmaatschap op te lossen:

  1. Configureer de wachtrijen om dubbelzinnigheden te voorkomen.
  2. Beperkingen toevoegen aan autoscale.json.
  3. Laat CycleCloud de overeenkomende hostgroepen in alfabetische volgorde kiezen door weight_queue_host_sort < weight_queue_seqno aan te passen in de scheduler-configuratie.
  4. Stel seq_no 10000,[@hostgroup1=100],[@hostgroup2=200] in de wachtrijconfiguratie in om een hostgroepvoorkeur aan te geven.

Beperkingen voor hostgroepen

Wanneer een wachtrij of xproject meerdere hostgroepen definieert, kan elk van deze groepen mogelijk nieuwe hosts ontvangen. Als u wilt bepalen welke hosts in aanmerking komen voor welke wachtrijen, kunt u hostgroepbeperkingen toepassen op basis van knooppunteigenschappen.

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

HINT: Inspecteer alle beschikbare knooppunteigenschappen per azge buckets.

azge

Dit pakket wordt geleverd met een opdrachtregel, azge. Dit programma wordt gebruikt voor autoscaling en splitst alle subprocessen onder autoscaling op in afzonderlijke componenten. Deze opdrachten zijn afhankelijk van de omgevingsvariabelen GridEngine die ingesteld moeten zijn. U moet qconf en qsub kunnen oproepen vanuit hetzelfde profiel waar azge wordt aangeroepen.

azge opdrachten Beschrijving
valideren Controleert op bekende configuratiefouten in de autoscaler of GridEngine
Banen Geeft alle taken in de wachtrij weer
Emmers Toont beschikbare resourcepools voor automatisch schalen
Knooppunten Toont clusterhosts en -eigenschappen
eisen Vervult de taakvereisten in overeenstemming met Cyclecloud-buckets en levert resultaten voor automatisch schalen.
automatisch schalen Doet volledige automatische schaalaanpassing, het starten en verwijderen van knooppunten volgens configuraties

Wanneer u scheduler-configuraties (qconf) of configuraties voor automatische schaalaanpassing (autoscale.json) wijzigt of zelfs voor de eerste keer instelt, kan azge worden gebruikt om te controleren of het gedrag van automatische schaalaanpassing overeenkomt met de verwachtingen. Als root kunt u de volgende bewerkingen uitvoeren. Als u wilt weten hoe automatische schaalaanpassing werkt, is het belangrijk om vertrouwd te raken met deze concepten.

  1. Voer deze opdracht uit azge validate om configuraties te controleren op bekende problemen.
  2. Voer deze opdracht uit azge buckets om de resources te controleren die worden aangeboden door het CycleCloud-cluster.
  3. Voer azge jobs uit om de details van de taak in de wachtrij te controleren.
  4. Voer azge demand de taak uit om de buckets te koppelen. Controleer vervolgens welke taken overeenkomen met welke buckets en hostgroepen.
  5. Voer azge autoscale uit om het knooppunttoewijzingsproces te starten of voeg knooppunten toe die klaar zijn om deel te nemen.

Zodra de opdrachten werken zoals verwacht, schakelt u doorlopende automatische schaalaanpassing in door de azge autoscale opdracht toe te voegen aan de hoofdmap crontab. Zorg ervoor dat u de GridEngine-omgevingsvariabelen van tevoren instelt.

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

Een hybride cluster maken

CycleCloud biedt ondersteuning voor cloud-burstingscenario's. Bij de basisconfiguratie wordt ervan uitgegaan dat de $SGE_ROOT map beschikbaar is voor de cloudknooppunten. Deze aanname kan worden versoepeld door het instellen gridengine.shared.spool = falseen gridengine.shared.bin = falseinstalleren van GridEngine lokaal.

Voor een eenvoudig geval moet u een bestandssysteem opgeven dat de 'execute'-knooppunten kunnen koppelen. Dit bestandssysteem moet de ... "directory, en u configureert de koppeling in de optionele instellingen." Wanneer de afhankelijkheden van de sched- en gedeelde mappen worden vrijgegeven, kunt u het scheduler-knooppunt afsluiten dat standaard deel uitmaakt van het cluster en de configuraties van het externe bestandssysteem gebruiken.

  1. Maak een nieuw gridengine-cluster.
  2. Schakel de retourproxy uit.
  3. Vervang /sched en /shared door externe bestandssysteemen.
  4. Sla het cluster op.
  5. Verwijder het scheduler-knooppunt als een actie in de gebruikersinterface.
  6. Start het cluster, er worden in eerste instantie geen knooppunten gestart.
  7. Configureren cyclecloud-gridengine met autoscale.json om het nieuwe cluster te gebruiken

Univa Grid Engine gebruiken in CycleCloud

CycleCloud-project voor GridEngine maakt standaard gebruik van sge-2011.11 . U mag uw eigen Altair GridEngine-installateurs gebruiken volgens uw Altair-gebruiksrechtovereenkomst. In deze sectie wordt beschreven hoe u Altair GridEngine gebruikt met het project CycleCloud GridEngine.

Vereiste voorwaarden

In dit voorbeeld wordt de demoversie 8.6.1 gebruikt, maar alle GE-versies die groter zijn dan 8.4.0 worden ondersteund.

  1. Gebruikers moeten binaire UGE-bestanden opgeven
  • ge-8.6.x-bin-lx-amd64.tar.gz
  • ge-8.6.x-common.tar.gz
  1. De CycleCloud CLI moet worden geconfigureerd. Documentatie is hier beschikbaar

De binaire bestanden kopiëren naar de cloudkluis

Een aanvullende versie van AGE (8.6.7-demo) wordt gedistribueerd met CycleCloud. Als u een andere versie wilt gebruiken, uploadt u de binaire bestanden naar het opslagaccount dat CycleCloud gebruikt.


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

Configuraties aanpassen van de clustersjabloon

Maak een lokale kopie van de GridEngine-sjabloon en wijzig deze om de UGE-installatieprogramma's te gebruiken in plaats van de standaardinstelling.

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

Zoek in het gridengine.txt bestand het eerste exemplaar van [[[configuration]]] en voeg tekst in die overeenkomt met het volgende fragment. Het bestand is niet gevoelig voor inspringing.

Opmerking

De details in de configuratie, met name versie, moeten overeenkomen met de bestandsnaam van het installatieprogramma.

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

Deze GridEngine-configuraties overschrijven de standaardversie en installatielocatie van GridEngine wanneer het cluster wordt gestart. Het is niet veilig om van de /sched locatie te gaan omdat het een gedeelde NFS-locatie in het cluster is.

  • Last updated on