Automatikus képlet létrehozása számítási csomópontok skálázására egy Batch-készletben

  • Cikk
  • 28 perc alatt elolvasható

Azure Batch automatikusan skálázhatja a készleteket a megadott paraméterek alapján, így időt és pénzt takaríthat meg. Az automatikus skálázással a Batch dinamikusan hozzáad csomópontokat a készlethez a tevékenységigény növekedésével, és eltávolítja a számítási csomópontokat a tevékenységigény csökkenésével.

Ha engedélyezni szeretné az automatikus skálázást a számítási csomópontok készletén, társítja a készletet egy Ön által megadott automatikus skálázási képlettel . A Batch szolgáltatás az automatikus skálázási képlet használatával határozza meg, hogy hány csomópontra van szükség a számítási feladat végrehajtásához. Ezek a csomópontok lehetnek dedikált csomópontok vagy Azure-beli kihasználatlan csomópontok. A Batch ezután rendszeres időközönként áttekinti a szolgáltatásmetrikák adatait, és felhasználja a készletben lévő csomópontok számának a képlet és az Ön által megadott időköz alapján történő módosítására.

Készlet létrehozásakor vagy meglévő készletre való alkalmazásakor engedélyezheti az automatikus skálázást. A Batch lehetővé teszi, hogy kiértékelje a képleteket, mielőtt készletekhez rendeli őket, és figyelje az automatikus skálázási futtatások állapotát. Miután automatikus méretezéssel konfigurált egy készletet, később módosíthatja a képletet.

Fontos

Batch-fiók létrehozásakor megadhatja a készletfoglalási módot, amely meghatározza, hogy a készletek egy Batch-szolgáltatás-előfizetésben (alapértelmezett) vagy a felhasználói előfizetésben vannak-e lefoglalva. Ha a Batch-fiókot az alapértelmezett Batch-szolgáltatáskonfigurációval hozta létre, akkor a fiók a feldolgozáshoz használható magok maximális számára korlátozódik. A Batch szolgáltatás csak az adott magkorlátig skálázza a számítási csomópontokat. Emiatt előfordulhat, hogy a Batch szolgáltatás nem éri el az automatikus skálázási képlet által meghatározott számítási csomópontok célszámát. A fiókkvóták megtekintésével és növelésével kapcsolatos információkért tekintse meg a Azure Batch szolgáltatás kvótái és korlátai című témakört.

Ha felhasználói előfizetési módban hozta létre a fiókját, akkor a fiókja az előfizetés magkvótajában osztozik. További információkért lásd az Azure-előfizetésekre és -szolgáltatásokra vonatkozó korlátozásokat, kvótákat és megkötéseket ismertető témakör a virtuális gépek korlátaira vonatkozó részét.

Képletek automatikus méretezése

Az automatikus skálázási képletek olyan sztringértékek, amelyek egy vagy több utasítást tartalmaznak. Az automatikus skálázási képlet egy készlet autoScaleFormula eleméhez (Batch REST) vagy CloudPool.AutoScaleFormula tulajdonsághoz (Batch .NET) van rendelve. A Batch szolgáltatás a képlet használatával határozza meg a készletben lévő számítási csomópontok célszámát a következő feldolgozási időközhöz. A képletsztring nem haladhatja meg a 8 KB-ot, legfeljebb 100 pontosvesszővel elválasztott utasítást tartalmazhat, valamint sortöréseket és megjegyzéseket is tartalmazhat.

Az automatikus skálázási képletek a Batch automatikus skálázási "nyelvének" tekinthetők. A képlet utasítások szabad formátumú kifejezések, amelyek a szolgáltatás által definiált változókat (a Batch szolgáltatás által definiált) és a felhasználó által definiált változókat is tartalmazhatják. A képletek különböző műveleteket hajthatnak végre ezeken az értékeken beépített típusok, operátorok és függvények használatával. Egy utasítás például a következő formát öltheti:

$myNewVariable = function($ServiceDefinedVariable, $myCustomVariable);

A képletek általában több utasítást tartalmaznak, amelyek műveleteket hajtanak végre az előző utasításokban lekért értékeken. Először például beszerzünk egy értéket a következőhöz variable1, majd átadjuk egy függvénynek, hogy feltöltsük variable2:

$variable1 = function1($ServiceDefinedVariable);
$variable2 = function2($OtherServiceDefinedVariable, $variable1);

Vegye fel ezeket az utasításokat az automatikus skálázási képletbe a számítási csomópontok célszámának eléréséhez. A dedikált csomópontok és a kihasználatlan csomópontok mindegyike saját célbeállításokkal rendelkezik. Az automatikus skálázási képletek tartalmazhatnak célértéket a dedikált csomópontokhoz, a kihasználatlan csomópontok célértékét vagy mindkettőt.

A csomópontok célszáma magasabb, alacsonyabb vagy megegyezhet a készletben található ilyen típusú csomópontok aktuális számával. A Batch egy készlet automatikus skálázási képletét értékeli ki adott automatikus skálázási időközönként. A Batch a készletben lévő csomóponttípusok célszámát az automatikus skálázási képlet által a kiértékeléskor megadott számhoz igazítja.

Minta automatikus skálázási képletek

Az alábbiakban két automatikus skálázási képletet láthat, amelyek a legtöbb forgatókönyvhöz igazíthatók. A változók startingNumberOfVMs és maxNumberofVMs a példaképletek igény szerint módosíthatók.

Függőben lévő tevékenységek

Ezzel az automatikus skálázási képlettel a készlet kezdetben egyetlen virtuális géppel jön létre. A $PendingTasks metrika a futó vagy várólistán lévő tevékenységek számát határozza meg. A képlet megkeresi a függőben lévő tevékenységek átlagos számát az elmúlt 180 másodpercben, és ennek megfelelően állítja be a változót $TargetDedicatedNodes . A képlet biztosítja, hogy a dedikált csomópontok célszáma soha ne haladja meg a 25 virtuális gépet. Az új tevékenységek elküldésekor a készlet automatikusan növekszik. Ahogy a feladatok befejeződnek, a virtuális gépek szabadok lesznek, és az automatikus skálázási képlet zsugorítja a készletet.

Ez a képlet skálázza a dedikált csomópontokat, de módosítható úgy, hogy a kihasználatlan csomópontok méretezésére is alkalmazható legyen.

startingNumberOfVMs = 1;
maxNumberofVMs = 25;
pendingTaskSamplePercent = $PendingTasks.GetSamplePercent(180 * TimeInterval_Second);
pendingTaskSamples = pendingTaskSamplePercent < 70 ? startingNumberOfVMs : avg($PendingTasks.GetSample(180 * TimeInterval_Second));
$TargetDedicatedNodes=min(maxNumberofVMs, pendingTaskSamples);
$NodeDeallocationOption = taskcompletion;

Előre átszerkesztett csomópontok

Ez a példa egy 25 kihasználatlan csomóponttal kezdődő készletet hoz létre. Minden alkalommal, amikor egy kihasználatlan csomópontot felülírnak, egy dedikált csomópont váltja fel. Az első példához hasonlóan a maxNumberofVMs változó megakadályozza, hogy a készlet túllépje a 25 virtuális gépet. Ez a példa akkor hasznos, ha kihasználja a kihasználatlan virtuális gépeket, ugyanakkor biztosítja, hogy a készlet élettartama során csak meghatározott számú preemptálás történjen.

maxNumberofVMs = 25;
$TargetDedicatedNodes = min(maxNumberofVMs, $PreemptedNodeCount.GetSample(180 * TimeInterval_Second));
$TargetLowPriorityNodes = min(maxNumberofVMs , maxNumberofVMs - $TargetDedicatedNodes);
$NodeDeallocationOption = taskcompletion;

Az automatikus skálázási képletek létrehozásáról és az automatikus skálázási képletek további példáiról a jelen témakör későbbi részében olvashat bővebben.

Változók

Az automatikus skálázási képletekben szolgáltatás által definiált és felhasználó által definiált változókat is használhat.

A szolgáltatás által definiált változók a Batch szolgáltatásba vannak beépítve. Egyes szolgáltatás által definiált változók írás-olvasás, mások írásvédettek.

A felhasználó által definiált változók ön által definiált változók. A fenti $TargetDedicatedNodes$PendingTasks példaképletben szolgáltatás által definiált változók, míg startingNumberOfVMsmaxNumberofVMs a felhasználó által definiált változók.

Megjegyzés

A szolgáltatás által definiált változókat mindig dollárjel ($) előzi meg. A felhasználó által definiált változók esetében a dollárjel megadása nem kötelező.

Az alábbi táblázatok a Batch szolgáltatás által definiált írásvédett és írásvédett változókat mutatják be.

Olvasási-írási szolgáltatás által definiált változók

Ezeknek a szolgáltatás által definiált változóknak az értékeit lekérheti és beállíthatja a készletben lévő számítási csomópontok számának kezeléséhez.

Változó Leírás
$TargetDedicatedNodes A készlethez tartozó dedikált számítási csomópontok célszáma. Ez azért van megadva célként, mert előfordulhat, hogy egy készlet nem mindig éri el a kívánt számú csomópontot. Ha például a dedikált csomópontok célszámát egy automatikus skálázási értékelés módosítja, mielőtt a készlet elérte volna a kezdeti célt, előfordulhat, hogy a készlet nem éri el a célt.

Előfordulhat, hogy egy Batch szolgáltatás módban létrehozott fiók készlete nem éri el a célját, ha a cél túllép egy Batch-fiókcsomópontot vagy magkvótát. Előfordulhat, hogy egy felhasználói előfizetési módban létrehozott fiókkészlet nem éri el a célját, ha a cél túllépi az előfizetés megosztott magkvótáit.
$TargetLowPriorityNodes A készlet kihasználatlan számítási csomópontjainak célszáma. Ez azért van megadva célként, mert előfordulhat, hogy egy készlet nem mindig éri el a kívánt számú csomópontot. Ha például a kihasználatlan csomópontok célszámát egy automatikus skálázási értékelés módosítja, mielőtt a készlet elérte volna a kezdeti célt, előfordulhat, hogy a készlet nem éri el a célt. Előfordulhat, hogy egy készlet nem éri el a célját, ha a cél túllép egy Batch-fiókcsomópontot vagy magkvótát.

A kihasználatlan számítási csomópontokkal kapcsolatos további információkért lásd: Kihasználatlan virtuális gépek használata a Batch szolgáltatással.
$NodeDeallocationOption A számítási csomópontok készletből való eltávolításakor előforduló művelet. Lehetséges értékek:
  • requeue: Az alapértelmezett érték. Azonnal befejezi a tevékenységeket, és visszateszi őket a feladatsorba, hogy azok újra legyenek ütemezve. Ez a művelet biztosítja, hogy a csomópontok célszáma a lehető leggyorsabban elérhető legyen. Ez azonban kevésbé hatékony lehet, mivel a futó tevékenységek megszakadnak, és teljesen újra kell indítani.
  • megszakítás: Azonnal befejezi a tevékenységeket, és eltávolítja őket a feladatsorból.
  • taskcompletion: Megvárja, amíg az aktuálisan futó tevékenységek befejeződnek, majd eltávolítja a csomópontot a készletből. Ezzel a beállítással elkerülheti a tevékenységek megszakítását és ismételt lekérdezését, és a tevékenység által végzett munka elsiklását.
  • retaineddata: Megvárja, amíg a csomóponton lévő összes helyi feladat által megőrzött adat törlődik, mielőtt eltávolítaná a csomópontot a készletből.

Megjegyzés

A $TargetDedicatedNodes változó az alias $TargetDedicatedhasználatával is megadható. Hasonlóképpen, a $TargetLowPriorityNodes változó az alias $TargetLowPriorityhasználatával is megadható. Ha a képlet mind a teljes névvel ellátott változót, mind az aliasát beállítja, a teljes névvel ellátott változóhoz rendelt érték elsőbbséget élvez.

Írásvédett szolgáltatás által definiált változók

Ezeknek a szolgáltatás által definiált változóknak az értékét lekérheti, hogy a Batch szolgáltatás metrikái alapján végezze el a módosításokat.

Fontos

A feladatkiadási tevékenységek jelenleg nem szerepelnek a tevékenységek számát biztosító változókban, például $ActiveTasks és $PendingTasks. Az automatikus skálázási képlettől függően ez azt eredményezheti, hogy a csomópontok el lesznek távolítva, és nincsenek elérhető csomópontok a feladatkiadási feladatok futtatásához.

Tipp

Ezek az írásvédett szolgáltatás által definiált változók olyan objektumok , amelyek különböző módszereket biztosítanak az egyes objektumokhoz társított adatok elérésére. További információ: Mintaadatok beszerzése a cikk későbbi részében.

Változó Leírás
$CPUPercent A processzorhasználat átlagos százalékos aránya.
$WallClockSeconds A felhasznált másodpercek száma.
$MemoryBytes A felhasznált megabájtok átlagos száma.
$DiskBytes A helyi lemezeken használt gigabájtok átlagos száma.
$DiskReadBytes Az olvasási bájtok száma.
$DiskWriteBytes A megírt bájtok száma.
$DiskReadOps Az elvégzett olvasási lemezműveletek száma.
$DiskWriteOps Az elvégzett írási lemezműveletek száma.
$NetworkInBytes A bejövő bájtok száma.
$NetworkOutBytes A kimenő bájtok száma.
$SampleNodeCount A számítási csomópontok száma.
$ActiveTasks Azon feladatok száma, amelyek készen állnak a végrehajtásra, de még nem hajtanak végre. Ide tartoznak az aktív állapotban lévő és a függőségeket kielégítő tevékenységek. Az aktív állapotban lévő, de a függőségeket nem kielégítő tevékenységek ki lesznek zárva a $ActiveTasks számából. Többpéldányos feladat esetén $ActiveTasks tartalmazni fogja a feladathoz beállított példányok számát.
$RunningTasks A futó állapotban lévő tevékenységek száma.
$PendingTasks A $ActiveTasks és a $RunningTasks összege.
$SucceededTasks A sikeresen befejezett tevékenységek száma.
$FailedTasks A sikertelen tevékenységek száma.
$TaskSlotsPerNode Az egyidejű tevékenységek a készlet egyetlen számítási csomópontján való futtatásához használható feladathelyek száma.
$CurrentDedicatedNodes A dedikált számítási csomópontok aktuális száma.
$CurrentLowPriorityNodes A kihasználatlan számítási csomópontok aktuális száma, beleértve az előre megadott csomópontokat is.
$PreemptedNodeCount A készletben lévő, előre megadott állapotban lévő csomópontok száma.

Figyelmeztetés

$PreemptedNodeCount jelenleg nem érhető el, és értékes adatokat ad vissza 0 .

Megjegyzés

Akkor használható $RunningTasks , ha az adott időpontban futó tevékenységek száma alapján skáláz, és $ActiveTasks ha a skálázás a várólistán lévő feladatok száma alapján történik.

Típusok

Az automatikus skálázási képletek a következő típusokat támogatják:

  • double
  • doubleVec
  • doubleVecList
  • sztring
  • timestamp - egy összetett struktúra, amely a következő tagokat tartalmazza:
    • év
    • hónap (1-12)
    • nap (1-31)
    • hétköznap (számformátumban, például hétfő 1)
    • óra (24 órás számformátumban; például a 13 azt jelenti, hogy 13 óra)
    • perc (00-59)
    • második (00-59)
  • timeinterval
    • TimeInterval_Zero
    • TimeInterval_100ns
    • TimeInterval_Microsecond
    • TimeInterval_Millisecond
    • TimeInterval_Second
    • TimeInterval_Minute
    • TimeInterval_Hour
    • TimeInterval_Day
    • TimeInterval_Week
    • TimeInterval_Year

Üzemeltetés

Ezek a műveletek engedélyezettek az előző szakaszban felsorolt típusok esetében.

Művelet Támogatott operátorok Eredmény típusa
dupla operátor dupla +, -, *, / double
dupla operátor timeinterval * timeinterval
doubleVec operátor dupla +, -, *, / doubleVec
doubleVec operátor doubleVec +, -, *, / doubleVec
timeinterval operátor dupla *, / timeinterval
timeinterval operátor timeinterval +, - timeinterval
timeinterval operátor időbélyege + időbélyeg
timetamp operátor timeinterval + időbélyeg
időbélyegző operátor időbélyege - timeinterval
operátor dupla -, ! double
operátor timeinterval - timeinterval
dupla operátor dupla <, <=, ==, >=, >, != double
sztring operátor sztringje <, <=, ==, >=, >, != double
időbélyegző operátor időbélyege <, <=, ==, >=, >, != double
timeinterval operátor timeinterval <, <=, ==, >=, >, != double
dupla operátor dupla &&, || double

Ha egy dupla karaktert egy ternáris operátorral (double ? statement1 : statement2) tesztel, a nonzero igaz, a nulla pedig hamis.

Functions

Ezeket az előre definiált függvényeket használhatja automatikus skálázási képletek definiálásakor.

Függvény Visszatérési típus Description
átlag(doubleVecList) double A doubleVecList összes értékének átlagértékét adja vissza.
len(doubleVecList) double A doubleVecList-ből létrehozott vektor hosszát adja vissza.
lg(dupla) double A dupla napló alap 2-ét adja vissza.
lg(doubleVecList) doubleVec A doubleVecList 2. összetevő-alapú naplóbázisát adja vissza. A paraméterhez explicit módon meg kell adni a vec(double) paramétert. Ellenkező esetben a dupla lg(dupla) verziót feltételezzük.
ln(dupla) double A dupla természetes naplóját adja vissza.
ln(doubleVecList) doubleVec A dupla természetes naplóját adja vissza.
log(double) double A kettős napló alapjának 10-ét adja vissza.
log(doubleVecList) doubleVec A doubleVecList 10 összetevőre vonatkozó naplóbázisát adja vissza. A vec(double) paramétert explicit módon kell megadni az egyetlen dupla paraméterhez. Ellenkező esetben a rendszer a kettős napló(dupla) verzióját feltételezi.
max(doubleVecList) double A doubleVecList maximális értékét adja vissza.
min(doubleVecList) double A doubleVecList minimális értékét adja vissza.
norm(doubleVecList) double A doubleVecList-ből létrehozott vektor két normát adja vissza.
percentilis(doubleVec v, double p) double A v vektor percentiliselemét adja vissza.
rand() double 0,0 és 1,0 közötti véletlenszerű értéket ad vissza.
range(doubleVecList) double A doubleVecList minimális és maximális értékei közötti különbséget adja vissza.
std(doubleVecList) double A doubleVecList értékeinek mintaszabványát adja vissza.
stop() Leállítja az automatikus skálázási kifejezés kiértékelését.
sum(doubleVecList) double A doubleVecList összes összetevőjének összegét adja vissza.
time(string dateTime="") időbélyeg Az aktuális idő időbélyegét adja vissza, ha nem adnak át paramétereket, vagy a dateTime sztring időbélyegét, ha az átadott. A támogatott dateTime formátumok a W3C-DTF és az RFC 1123.
val(doubleVec v, double i) double A v vektorban az i helyen található elem értékét adja vissza nullával kezdődő indexkel.

Az előző táblázatban ismertetett függvények némelyike argumentumként elfogad egy listát. A vesszővel tagolt lista a dupla és a doubleVec bármilyen kombinációja. Például:

doubleVecList := ( (double | doubleVec)+(, (double | doubleVec) )* )?

A doubleVecList érték a kiértékelés előtt egyetlen doubleVec értékké lesz konvertálva. Ha például az v = [1,2,3], akkor a hívás avg(v) egyenértékű a hívással avg(1,2,3). A hívás avg(v, 7) egyenértékű a hívással avg(1,2,3,7).

Mérőszámok

Képlet definiálásakor erőforrás- és tevékenységmetrikákat is használhat. A készletben lévő dedikált csomópontok célszámát a lekért és kiértékelt metrikák adatai alapján módosíthatja. Az egyes metrikákkal kapcsolatos további információkért tekintse meg a fenti Változók szakaszt .

Metric Leírás
Erőforrás

Az erőforrás-metrikák a processzoron, a sávszélességen, a számítási csomópontok memóriahasználatán és a csomópontok számán alapulnak.

Ezek a szolgáltatás által definiált változók hasznosak a csomópontok száma alapján végrehajtott módosításokhoz:

  • $TargetDedicatedNodes
  • $TargetLowPriorityNodes
  • $CurrentDedicatedNodes
  • $CurrentLowPriorityNodes
  • $PreemptedNodeCount
  • $SampleNodeCount

Ezek a szolgáltatás által definiált változók hasznosak a csomóponterőforrás-használat alapján végrehajtott módosításokhoz:

  • $CPUPercent
  • $WallClockSeconds
  • $MemoryBytes
  • $DiskBytes
  • $DiskReadBytes
  • $DiskWriteBytes
  • $DiskReadOps
  • $DiskWriteOps
  • $NetworkInBytes
  • $NetworkOutBytes

Feladat

A tevékenységmetrikák a tevékenységek állapotán alapulnak, például Aktív, Függőben és Befejezve. A következő szolgáltatás által definiált változók hasznosak a készletméretnek a tevékenységmetrikák alapján történő módosításához:

  • $ActiveTasks
  • $RunningTasks
  • $PendingTasks
  • $SucceededTasks
  • $FailedTasks

Mintaadatok beszerzése

Az automatikus skálázási képletek alapvető művelete a tevékenység- és erőforrásmetrikaadatok (minták) lekérése, majd a készlet méretének módosítása az adatok alapján. Ezért fontos, hogy tisztában legyen azzal, hogyan működnek együtt az automatikus skálázási képletek a mintákkal.

Metódusok

Az automatikus skálázási képletek a Batch szolgáltatás által biztosított metrikaadatok mintáin működnek. A képletek a kapott értékek alapján megnövekszik vagy csökken a készlet mérete. A szolgáltatás által definiált változók olyan objektumok, amelyek metódusokat biztosítanak az adott objektumhoz társított adatok elérésére. Az alábbi kifejezés például egy kérést jelenít meg a cpu-használat utolsó öt percének lekérésére:

$CPUPercent.GetSample(TimeInterval_Minute * 5)

A szolgáltatás által definiált változók mintaadatainak lekéréséhez az alábbi módszerek használhatók.

Metódus Leírás
GetSample() A GetSample() metódus adatminták egy vektorát adja vissza.

A minta 30 másodpercnyi metrikaadatot jelent. Más szóval a mintákat 30 másodpercenként kapják meg. Az alábbiakban azonban látható, hogy késés van a minta összegyűjtése és a képletek számára való rendelkezésre állása között. Így előfordulhat, hogy nem minden minta érhető el egy adott időszakra egy képlet általi kiértékeléshez.
  • doubleVec GetSample(double count): A legutóbb gyűjtött mintákból beszerezni kívánt minták számát határozza meg. GetSample(1) A az utolsó elérhető mintát adja vissza. Az olyan metrikák esetében azonban, mint $CPUPercentpéldául, nem szabad használni, GetSample(1) mert lehetetlen megállapítani, hogy mikor lett összegyűjtve a minta. Lehet, hogy friss, vagy rendszerproblémák miatt sokkal régebbi. Ilyen esetekben érdemesebb az alábbiak szerint időintervallumot használni.
  • doubleVec GetSample((timestamp or timeinterval) startTime [, double samplePercent]): Megadja a mintaadatok gyűjtésének időkeretét. Opcionálisan azt is megadja, hogy a minták hány százalékának kell rendelkezésre állnia a kért időkeretben. Például 20 mintát adna vissza, $CPUPercent.GetSample(TimeInterval_Minute * 10) ha az elmúlt 10 percben szereplő összes minta szerepel az CPUPercent előzményekben. Ha a történelem utolsó perce nem lenne elérhető, csak 18 mintát adna vissza. Ebben az esetben $CPUPercent.GetSample(TimeInterval_Minute * 10, 95) sikertelen lenne, mert a mintáknak csak 90 százaléka áll rendelkezésre, de $CPUPercent.GetSample(TimeInterval_Minute * 10, 80) sikerrel járna.
  • doubleVec GetSample((timestamp or timeinterval) startTime, (timestamp or timeinterval) endTime [, double samplePercent]): Az adatgyűjtés időkeretét adja meg a kezdési és a befejezési időponttal együtt. Ahogy fentebb említettük, késés van a minta összegyűjtése és a képletek számára való elérhetővé válása között. A metódus használatakor vegye figyelembe ezt a késleltetést GetSample . Lásd GetSamplePercent alább.
GetSamplePeriod() Az előzményadat-készletben vett minták időtartamát adja vissza.
Darabszám() A metrikaelőzményekben szereplő minták teljes számát adja vissza.
HistoryBeginTime() A metrika legrégebbi elérhető adatmintájának időbélyegét adja vissza.
GetSamplePercent() Az adott időintervallumban rendelkezésre álló minták százalékos arányát adja vissza. Például: doubleVec GetSamplePercent( (timestamp or timeinterval) startTime [, (timestamp or timeinterval) endTime] ). Mivel a GetSample metódus meghiúsul, ha a visszaadott minták százalékos aránya kisebb a samplePercent megadottnál, a GetSamplePercent módszerrel ellenőrizheti először. Ezután alternatív műveletet hajthat végre, ha nincs elegendő minta a skálázás automatikus kiértékelése nélkül.

Példák

A Batch szolgáltatás rendszeres időközönként mintát vesz a tevékenység- és erőforrásmetrikákból, és elérhetővé teszi őket az automatikus skálázási képletek számára. Ezeket a mintákat a Batch szolgáltatás 30 másodpercenként rögzíti. Általában azonban késés van a minták rögzítése és az automatikus skálázási képletek számára való elérhetővé tett (és az általuk olvasható) között. Emellett előfordulhat, hogy a minták nem rögzíthetők egy adott időszakra olyan tényezők miatt, mint például a hálózati vagy egyéb infrastruktúraproblémák.

Minta százalékos aránya

Amikor samplePercent a rendszer átadja a GetSample() metódust vagy meghívja a metódust, a GetSamplePercent()százalék a Batch szolgáltatás által rögzített minták teljes száma és az automatikus skálázási képlethez elérhető minták száma összehasonlítására utal.

Lássunk például egy 10 perces időhosszt. Mivel a minták rögzítése 30 másodpercenként történik a 10 perces időkereten belül, a Batch által rögzített minták maximális száma 20 minta lenne (percenként 2). A jelentéskészítési mechanizmus eredendő késése és az Azure-on belüli egyéb problémák miatt azonban csak 15 minta áll rendelkezésre az automatikus skálázási képlet olvasásához. Így például ebben a 10 perces időszakban a rögzített minták teljes számának csak 75%-a lehet elérhető a képletben.

GetSample() és mintatartományok

Az automatikus skálázási képletek csomópontok hozzáadásával vagy eltávolításával növelhetik és zsugorodnak a készletek. Mivel a csomópontok pénzbe kerülnek, győződjön meg arról, hogy a képletek olyan intelligens elemzési módszert használnak, amely elegendő adaton alapul. Javasoljuk, hogy a képletekben használjon felkapott típusú elemzést. Ez a típus az összegyűjtött minták széles választéka alapján növekszik és zsugorítja a készleteket.

Ehhez mintavektort kell visszaadnia GetSample(interval look-back start, interval look-back end) :

$runningTasksSample = $RunningTasks.GetSample(1 * TimeInterval_Minute, 6 * TimeInterval_Minute);

Amikor a fenti sort a Batch kiértékeli, egy mintatartományt ad vissza értékvektorként. Például:

$runningTasksSample=[1,1,1,1,1,1,1,1,1,1];

Miután begyűjtötte a mintavektort, a következőhöz max()hasonló min()függvényeket használhat, és avg() értelmes értékeket származtathat az összegyűjtött tartományból.

A további biztonság érdekében kényszerítheti a képletek kiértékelését, ha egy adott időszakra kevesebb mint egy bizonyos százalékos minta érhető el. Amikor a képletek kiértékelésének sikertelenségére kényszeríti, utasítja a Batch-t, hogy szüntesse meg a képlet további kiértékelését, ha a minták megadott százaléka nem érhető el. Ebben az esetben a készlet mérete nem változik. Ha meg szeretné adni a minták kötelező százalékos arányát a sikeres értékeléshez, adja meg azt a harmadik paraméterként.GetSample() Itt a minták 75%-ának követelménye van megadva:

$runningTasksSample = $RunningTasks.GetSample(60 * TimeInterval_Second, 120 * TimeInterval_Second, 75);

Mivel előfordulhat, hogy a minta rendelkezésre állása késik, mindig adjon meg egy olyan időtartományt, amelyben a visszatekintés kezdési időpontja egy percnél régebbi. A minták a rendszeren keresztüli propagálása körülbelül egy percet vesz igénybe, ezért előfordulhat, hogy a tartományban (0 * TimeInterval_Second, 60 * TimeInterval_Second) lévő minták nem lesznek elérhetők. Ismét használhatja a százalékparamétert GetSample() egy adott százalékos mintakövetelmény kényszerítéséhez.

Fontos

Határozottan javasoljuk, hogy ne támaszkodjon csakGetSample(1) az automatikus skálázási képletekre. Ennek az az oka GetSample(1) , hogy lényegében azt mondja a Batch szolgáltatásnak: "Adja meg az utolsó mintáját, függetlenül attól, hogy milyen régen lekérte." Mivel ez csak egyetlen minta, és lehet, hogy régebbi minta, nem feltétlenül reprezentatív a legutóbbi tevékenység vagy erőforrás állapotának nagyobb képére. Ha ezt használja GetSample(1), győződjön meg arról, hogy az egy nagyobb utasítás része, és nem az egyetlen adatpont, amelyen a képlet támaszkodik.

Automatikus skálázási képlet írása

Automatikus skálázási képletet úgy hozhat létre, hogy a fenti összetevőket használó utasításokat alkot, majd ezeket az utasításokat egy teljes képletben egyesíti. Ebben a szakaszban egy automatikus skálázási képletet hozunk létre, amely valós skálázási döntéseket hozhat és módosításokat hajthat végre.

Először határozzuk meg az új automatikus skálázási képlet követelményeit. A képletnek a következőnek kell lennie:

  • Ha magas a processzorhasználat, növelje a készletben lévő dedikált számítási csomópontok célszámát.
  • Csökkentse a készletben lévő dedikált számítási csomópontok célszámát, ha a processzorhasználat alacsony.
  • Mindig korlátozza a dedikált csomópontok maximális számát 400-ra.
  • A csomópontok számának csökkentésekor ne távolítsa el a tevékenységeket futtató csomópontokat; ha szükséges, várjon, amíg a tevékenységek befejeződnek, mielőtt eltávolítaná a csomópontokat.

A képlet első utasítása növeli a csomópontok számát a magas cpu-használat során. Meghatározunk egy utasítást, amely feltölt egy felhasználó által definiált változót ($totalDedicatedNodes) egy olyan értékkel, amely a dedikált csomópontok aktuális célszámának 110%-a, de csak akkor, ha az elmúlt 10 percben a minimális átlagos CPU-használat 70% felett volt. Ellenkező esetben a dedikált csomópontok aktuális számának értékét használja.

$totalDedicatedNodes =
    (min($CPUPercent.GetSample(TimeInterval_Minute * 10)) > 0.7) ?
    ($CurrentDedicatedNodes * 1.1) : $CurrentDedicatedNodes;

Ha csökkenteni szeretné a dedikált csomópontok számát alacsony processzorhasználat esetén, a képlet következő utasítása ugyanezt $totalDedicatedNodes a változót a dedikált csomópontok aktuális célszámának 90 százalékára állítja, ha az átlagos CPU-használat az elmúlt 60 percben 20% alatt volt. Ellenkező esetben a fenti utasításban megadott aktuális értéket $totalDedicatedNodes használja.

$totalDedicatedNodes =
    (avg($CPUPercent.GetSample(TimeInterval_Minute * 60)) < 0.2) ?
    ($CurrentDedicatedNodes * 0.9) : $totalDedicatedNodes;

Most legfeljebb 400-ra korlátozzuk a dedikált számítási csomópontok célszámát.

$TargetDedicatedNodes = min(400, $totalDedicatedNodes)

Végül biztosítjuk, hogy a csomópontok ne legyenek eltávolítva, amíg a tevékenységek be nem fejeződnek.

$NodeDeallocationOption = taskcompletion;

A teljes képlet a következő:

$totalDedicatedNodes =
    (min($CPUPercent.GetSample(TimeInterval_Minute * 10)) > 0.7) ?
    ($CurrentDedicatedNodes * 1.1) : $CurrentDedicatedNodes;
$totalDedicatedNodes =
    (avg($CPUPercent.GetSample(TimeInterval_Minute * 60)) < 0.2) ?
    ($CurrentDedicatedNodes * 0.9) : $totalDedicatedNodes;
$TargetDedicatedNodes = min(400, $totalDedicatedNodes)
$NodeDeallocationOption = taskcompletion;

Megjegyzés

Ha úgy dönt, megjegyzéseket és sortöréseket is felvehet a képletsztringekbe. Vegye figyelembe azt is, hogy a hiányzó pontosvesszők kiértékelési hibákat eredményezhetnek.

Automatikus méretezési időköz

Alapértelmezés szerint a Batch szolgáltatás 15 percenként módosítja a készlet méretét az automatikus skálázási képletnek megfelelően. Ez az időköz a következő készlettulajdonságok használatával konfigurálható:

A minimális időköz öt perc, a maximális pedig 168 óra. Ha a tartományon kívül eső intervallum van megadva, a Batch szolgáltatás hibás kérés (400) hibát ad vissza.

Megjegyzés

Az automatikus skálázás jelenleg nem arra szolgál, hogy kevesebb mint egy perc alatt reagáljon a változásokra, hanem inkább a készlet méretét szeretné fokozatosan módosítani a számítási feladatok futtatásakor.

Automatikus skálázást engedélyező készlet létrehozása Batch SDK-kkal

A készlet automatikus skálázása a Batch SDK-k, a Batch RESTAPIBatch PowerShell-parancsmagok és a Batch parancssori felület használatával konfigurálható. Ebben a szakaszban a .NET-hez és a Pythonhoz is láthat példákat.

.NET

Ha olyan készletet szeretne létrehozni, amelyben engedélyezve van az automatikus skálázás a .NET-ben, kövesse az alábbi lépéseket:

  1. Hozza létre a készletet a BatchClient.PoolOperations.CreatePool használatával.
  2. Állítsa a CloudPool.AutoScaleEnabled tulajdonságot a következőre true: .
  3. Állítsa be a CloudPool.AutoScaleFormula tulajdonságot az automatikus skálázási képlettel.
  4. (Nem kötelező) Állítsa be a CloudPool.AutoScaleEvaluationInterval tulajdonságot (alapértelmezés szerint 15 perc).
  5. Véglegesítse a készletet a CloudPool.Commit vagy a CommitAsync használatával.

Az alábbi példa egy automatikus skálázást engedélyező készletet hoz létre a .NET-ben. A készlet automatikus skálázási képlete a dedikált csomópontok célszámát 5-re állítja hétfőnként, és 1-et a hét minden második napján. Az automatikus skálázási időköz 30 percre van állítva. Ebben és a cikkben szereplő többi C#- myBatchClient kódrészlet a BatchClient osztály megfelelően inicializált példánya.

CloudPool pool = myBatchClient.PoolOperations.CreatePool(
                    poolId: "mypool",
                    virtualMachineSize: "standard_d1_v2",
                    VirtualMachineConfiguration: new VirtualMachineConfiguration(
                        imageReference: new ImageReference(
                                            publisher: "MicrosoftWindowsServer",
                                            offer: "WindowsServer",
                                            sku: "2019-datacenter-core",
                                            version: "latest"),
                        nodeAgentSkuId: "batch.node.windows amd64");
pool.AutoScaleEnabled = true;
pool.AutoScaleFormula = "$TargetDedicatedNodes = (time().weekday == 1 ? 5:1);";
pool.AutoScaleEvaluationInterval = TimeSpan.FromMinutes(30);
await pool.CommitAsync();

Fontos

Automatikus skálázást engedélyező készlet létrehozásakor ne adja meg a targetDedicatedNodes paramétert vagy a targetLowPriorityNodes paramétert a CreatePool hívásához. Ehelyett adja meg a készlet AutoScaleEnabled és AutoScaleFormula tulajdonságát. Ezeknek a tulajdonságoknak az értékei határozzák meg az egyes csomóponttípusok célszámát.

Ha manuálisan szeretne átméretezni egy automatikus méretezést engedélyező készletet (például a BatchClient.PoolOperations.ResizePoolAsync használatával), először le kell tiltania az automatikus méretezést a készleten, majd át kell méreteznie.

Python

Automatikus skálázást engedélyező készlet létrehozása a Python SDK-val:

  1. Hozzon létre egy készletet, és adja meg annak konfigurációját.
  2. Adja hozzá a készletet a szolgáltatásügyfélhez.
  3. Automatikus skálázás engedélyezése a készleten egy ön által írt képlettel.

Az alábbi példa ezeket a lépéseket szemlélteti.

# Create a pool; specify configuration
new_pool = batch.models.PoolAddParameter(
    id="autoscale-enabled-pool",
    virtual_machine_configuration=batchmodels.VirtualMachineConfiguration(
        image_reference=batchmodels.ImageReference(
          publisher="Canonical",
          offer="UbuntuServer",
          sku="18.04-LTS",
          version="latest"
            ),
        node_agent_sku_id="batch.node.ubuntu 18.04"),
    vm_size="STANDARD_D1_v2",
    target_dedicated_nodes=0,
    target_low_priority_nodes=0
)
batch_service_client.pool.add(new_pool) # Add the pool to the service client

formula = """$curTime = time();
             $workHours = $curTime.hour >= 8 && $curTime.hour < 18;
             $isWeekday = $curTime.weekday >= 1 && $curTime.weekday <= 5;
             $isWorkingWeekdayHour = $workHours && $isWeekday;
             $TargetDedicated = $isWorkingWeekdayHour ? 20:10;""";

# Enable autoscale; specify the formula
response = batch_service_client.pool.enable_auto_scale(pool_id, auto_scale_formula=formula,
                                            auto_scale_evaluation_interval=datetime.timedelta(minutes=10),
                                            pool_enable_auto_scale_options=None,
                                            custom_headers=None, raw=False)

Tipp

A Python SDK használatára további példákat talál a Batch Python gyorsindítási adattárában GitHub.

Automatikus skálázás engedélyezése meglévő készleten

Minden Batch SDK lehetővé teszi az automatikus skálázást. Például:

Ha egy meglévő készleten engedélyezi az automatikus skálázást, vegye figyelembe a következőket:

  • Ha az automatikus skálázás jelenleg le van tiltva a készleten, érvényes automatikus skálázási képletet kell megadnia a kérés kiadásakor. Igény szerint megadhat egy automatikus skálázási időközt. Ha nem ad meg időközt, a rendszer az alapértelmezett 15 perces értéket használja.
  • Ha az automatikus skálázás jelenleg engedélyezve van a készleten, megadhat egy új képletet, egy új időközt vagy mindkettőt. Ezen tulajdonságok közül legalább egyet meg kell adnia.
    • Ha új automatikus skálázási időközt ad meg, a meglévő ütemezés leáll, és elindul egy új ütemezés. Az új ütemezés kezdési időpontja az az időpont, amikor az automatikus skálázás engedélyezésére vonatkozó kérést kiadták.
    • Ha kihagyja az automatikus skálázási képletet vagy időközt, a Batch szolgáltatás továbbra is ennek a beállításnak az aktuális értékét fogja használni.

Megjegyzés

Ha értékeket adott meg a CreatePool metódus targetDedicatedNodes vagy targetLowPriorityNodes paramétereihez a készlet .NET-ben való létrehozásakor vagy más nyelven összehasonlítható paraméterekhez, akkor a rendszer figyelmen kívül hagyja ezeket az értékeket az automatikus skálázási képlet kiértékelésekor.

Ez a C#-példa a Batch .NET-kódtár használatával engedélyezi az automatikus skálázást egy meglévő készleten.

// Define the autoscaling formula. This formula sets the target number of nodes
// to 5 on Mondays, and 1 on every other day of the week
string myAutoScaleFormula = "$TargetDedicatedNodes = (time().weekday == 1 ? 5:1);";

// Set the autoscale formula on the existing pool
await myBatchClient.PoolOperations.EnableAutoScaleAsync(
    "myexistingpool",
    autoscaleFormula: myAutoScaleFormula);

Automatikus skálázási képlet frissítése

Ha egy meglévő automatikus skálázást használó készleten szeretné frissíteni a képletet, hívja meg a műveletet, hogy az új képlettel ismét engedélyezze az automatikus skálázást. Ha például az automatikus skálázás már engedélyezve myexistingpool van a következő .NET-kód végrehajtásakor, az automatikus skálázási képletet a rendszer a következő tartalomra cseréli myNewFormula: .

await myBatchClient.PoolOperations.EnableAutoScaleAsync(
    "myexistingpool",
    autoscaleFormula: myNewFormula);

Az automatikus skálázási időköz frissítése

Egy meglévő automatikus méretezést engedélyező készlet automatikus skálázási kiértékelési időközének frissítéséhez hívja meg a műveletet, hogy az új időközzel ismét engedélyezze az automatikus skálázást. Ha például az automatikus skálázás kiértékelési időközét 60 percre szeretné állítani a .NET-ben már automatikusan engedélyezett készlet esetében:

await myBatchClient.PoolOperations.EnableAutoScaleAsync(
    "myexistingpool",
    autoscaleEvaluationInterval: TimeSpan.FromMinutes(60));

Automatikus skálázási képlet kiértékelése

A képleteket kiértékelheti, mielőtt alkalmazva lenne egy készletre. Ez lehetővé teszi a képlet eredményeinek tesztelését, mielőtt éles környezetbe helyezené.

Az automatikus skálázási képlet kiértékelése előtt engedélyeznie kell az automatikus skálázást a készleten érvényes képlettel, például az egysoros képlettel $TargetDedicatedNodes = 0. Ezután az alábbiak egyikével értékelje ki a tesztelni kívánt képletet:

Ez a Batch .NET-példa kiértékel egy automatikus skálázási képletet. Ha a készlet még nem használja az automatikus skálázást, először engedélyezzük.

// First obtain a reference to an existing pool
CloudPool pool = await batchClient.PoolOperations.GetPoolAsync("myExistingPool");

// If autoscaling isn't already enabled on the pool, enable it.
// You can't evaluate an autoscale formula on a non-autoscale-enabled pool.
if (pool.AutoScaleEnabled == false)
{
    // We need a valid autoscale formula to enable autoscaling on the
    // pool. This formula is valid, but won't resize the pool:
    await pool.EnableAutoScaleAsync(
        autoscaleFormula: "$TargetDedicatedNodes = $CurrentDedicatedNodes;",
        autoscaleEvaluationInterval: TimeSpan.FromMinutes(5));

    // Batch limits EnableAutoScaleAsync calls to once every 30 seconds.
    // Because we want to apply our new autoscale formula below if it
    // evaluates successfully, and we *just* enabled autoscaling on
    // this pool, we pause here to ensure we pass that threshold.
    Thread.Sleep(TimeSpan.FromSeconds(31));

    // Refresh the properties of the pool so that we've got the
    // latest value for AutoScaleEnabled
    await pool.RefreshAsync();
}

// We must ensure that autoscaling is enabled on the pool prior to
// evaluating a formula
if (pool.AutoScaleEnabled == true)
{
    // The formula to evaluate - adjusts target number of nodes based on
    // day of week and time of day
    string myFormula = @"
        $curTime = time();
        $workHours = $curTime.hour >= 8 && $curTime.hour < 18;
        $isWeekday = $curTime.weekday >= 1 && $curTime.weekday <= 5;
        $isWorkingWeekdayHour = $workHours && $isWeekday;
        $TargetDedicatedNodes = $isWorkingWeekdayHour ? 20:10;
    ";

    // Perform the autoscale formula evaluation. Note that this code does not
    // actually apply the formula to the pool.
    AutoScaleRun eval =
        await batchClient.PoolOperations.EvaluateAutoScaleAsync(pool.Id, myFormula);

    if (eval.Error == null)
    {
        // Evaluation success - print the results of the AutoScaleRun.
        // This will display the values of each variable as evaluated by the
        // autoscale formula.
        Console.WriteLine("AutoScaleRun.Results: " +
            eval.Results.Replace("$", "\n    $"));

        // Apply the formula to the pool since it evaluated successfully
        await batchClient.PoolOperations.EnableAutoScaleAsync(pool.Id, myFormula);
    }
    else
    {
        // Evaluation failed, output the message associated with the error
        Console.WriteLine("AutoScaleRun.Error.Message: " +
            eval.Error.Message);
    }
}

Az ebben a kódrészletben látható képlet sikeres kiértékelése a következőhöz hasonló eredményeket eredményez:

AutoScaleRun.Results:
    $TargetDedicatedNodes=10;
    $NodeDeallocationOption=requeue;
    $curTime=2016-10-13T19:18:47.805Z;
    $isWeekday=1;
    $isWorkingWeekdayHour=0;
    $workHours=0

Információk az automatikus skálázási futtatásokról

Annak érdekében, hogy a képlet a várt módon működjön, javasoljuk, hogy rendszeresen ellenőrizze a Batch által a készleten végrehajtott automatikus skálázási futtatások eredményeit. Ehhez szerezze be (vagy frissítse) a készletre mutató hivatkozást, majd vizsgálja meg a legutóbbi automatikus skálázási futtatás tulajdonságait.

A Batch .NET-ben a CloudPool.AutoScaleRun tulajdonság számos olyan tulajdonsággal rendelkezik, amelyek információt nyújtanak a készleten végrehajtott legújabb automatikus skálázási futtatásról:

A REST API-ban a készletkérelmekre vonatkozó információk lekérése a készletre vonatkozó információkat adja vissza, amelyek tartalmazzák az automatikus skálázási futtatás legújabb információit az automatikusScaleRun tulajdonságban.

Az alábbi C#-példa a Batch .NET-kódtár használatával nyomtatja ki a myPool készlet legutóbbi automatikus skálázási futtatásával kapcsolatos információkat.

await Cloud pool = myBatchClient.PoolOperations.GetPoolAsync("myPool");
Console.WriteLine("Last execution: " + pool.AutoScaleRun.Timestamp);
Console.WriteLine("Result:" + pool.AutoScaleRun.Results.Replace("$", "\n  $"));
Console.WriteLine("Error: " + pool.AutoScaleRun.Error);

Mintakimenet az előző példából:

Last execution: 10/14/2016 18:36:43
Result:
  $TargetDedicatedNodes=10;
  $NodeDeallocationOption=requeue;
  $curTime=2016-10-14T18:36:43.282Z;
  $isWeekday=1;
  $isWorkingWeekdayHour=0;
  $workHours=0
Error:

Automatikus skálázási futtatási előzmények lekérése készlet automatikus skálázási eseményeinek használatával

Az automatikus méretezési előzményeket a PoolAutoScaleEvent lekérdezésével is ellenőrizheti. Ezt az eseményt a Batch szolgáltatás bocsátja ki az automatikus skálázású képletek kiértékelésének és végrehajtásának minden előfordulásának rögzítéséhez, ami hasznos lehet a lehetséges problémák elhárításához.

Mintaesemény a PoolAutoScaleEventhez:

{
    "id": "poolId",
    "timestamp": "2020-09-21T23:41:36.750Z",
    "formula": "...",
    "results": "$TargetDedicatedNodes=10;$NodeDeallocationOption=requeue;$curTime=2016-10-14T18:36:43.282Z;$isWeekday=1;$isWorkingWeekdayHour=0;$workHours=0",
    "error": {
        "code": "",
        "message": "",
        "values": []
    }
}

Példa automatikus skálázási képletekre

Tekintsünk meg néhány képletet, amelyek különböző módszereket mutatnak be a készletben lévő számítási erőforrások mennyiségének módosítására.

1. példa: Időalapú kiigazítás

Tegyük fel, hogy a készlet méretét a hét napja és a nap időpontja alapján szeretné módosítani. Ez a példa bemutatja, hogyan növelheti vagy csökkentheti a készletben lévő csomópontok számát ennek megfelelően.

A képlet először az aktuális időpontot szerzi be. Ha hétköznap (1-5) és munkaidőn belül (8:00 és 18:00 között) van, a célkészlet mérete 20 csomópontra van állítva. Ellenkező esetben 10 csomópontra van beállítva.

$curTime = time();
$workHours = $curTime.hour >= 8 && $curTime.hour < 18;
$isWeekday = $curTime.weekday >= 1 && $curTime.weekday <= 5;
$isWorkingWeekdayHour = $workHours && $isWeekday;
$TargetDedicatedNodes = $isWorkingWeekdayHour ? 20:10;
$NodeDeallocationOption = taskcompletion;

$curTime A helyi időzónát úgy lehet módosítani, hogy hozzáadja time() a termékhez TimeZoneInterval_Hour és az UTC-eltoláshoz. Használja például a hegyi nyári idő (MDT) használatára $curTime = time() + (-6 * TimeInterval_Hour); . Ne feledje, hogy az eltolást a nyári időszámítás kezdetén és végén kell módosítani (ha van).

2. példa: Tevékenységalapú kiigazítás

Ebben a C#-példában a készlet mérete a várólistán lévő tevékenységek száma alapján van módosítva. A képletsztringek megjegyzéseket és sortöréseket is tartalmaztak.

// Get pending tasks for the past 15 minutes.
$samples = $PendingTasks.GetSamplePercent(TimeInterval_Minute * 15);
// If we have fewer than 70 percent data points, we use the last sample point,
// otherwise we use the maximum of last sample point and the history average.
$tasks = $samples < 70 ? max(0,$PendingTasks.GetSample(1)) : max( $PendingTasks.GetSample(1), avg($PendingTasks.GetSample(TimeInterval_Minute * 15)));
// If number of pending tasks is not 0, set targetVM to pending tasks, otherwise
// half of current dedicated.
$targetVMs = $tasks > 0? $tasks:max(0, $TargetDedicatedNodes/2);
// The pool size is capped at 20, if target VM value is more than that, set it
// to 20. This value should be adjusted according to your use case.
$TargetDedicatedNodes = max(0, min($targetVMs, 20));
// Set node deallocation mode - let running tasks finish before removing a node
$NodeDeallocationOption = taskcompletion;

3. példa: Párhuzamos tevékenységek könyvelése

Ez a C#-példa a tevékenységek száma alapján módosítja a készlet méretét. Ez a képlet a készlethez beállított TaskSlotsPerNode értéket is figyelembe veszi. Ez a módszer olyan helyzetekben hasznos, amikor engedélyezve van a párhuzamos feladatvégrehajtás a készletben.

// Determine whether 70 percent of the samples have been recorded in the past
// 15 minutes; if not, use last sample
$samples = $ActiveTasks.GetSamplePercent(TimeInterval_Minute * 15);
$tasks = $samples < 70 ? max(0,$ActiveTasks.GetSample(1)) : max( $ActiveTasks.GetSample(1),avg($ActiveTasks.GetSample(TimeInterval_Minute * 15)));
// Set the number of nodes to add to one-fourth the number of active tasks
// (the TaskSlotsPerNode property on this pool is set to 4, adjust
// this number for your use case)
$cores = $TargetDedicatedNodes * 4;
$extraVMs = (($tasks - $cores) + 3) / 4;
$targetVMs = ($TargetDedicatedNodes + $extraVMs);
// Attempt to grow the number of compute nodes to match the number of active
// tasks, with a maximum of 3
$TargetDedicatedNodes = max(0,min($targetVMs,3));
// Keep the nodes active until the tasks finish
$NodeDeallocationOption = taskcompletion;

4. példa: Kezdeti készletméret beállítása

Ez a példa egy C#-példát mutat be egy automatikus skálázási képlettel, amely a készlet méretét megadott számú csomópontra állítja egy kezdeti időszakra. Ezt követően a futó és aktív tevékenységek száma alapján módosítja a készlet méretét.

Ez a képlet a következőket teszi:

  • A kezdeti készlet méretét négy csomópontra állítja be.
  • Nem állítja be a készlet méretét a készlet életciklusának első 10 percében.
  • 10 perc elteltével beolvashatja a futó és aktív tevékenységek számának maximális értékét az elmúlt 60 percben.
    • Ha mindkét érték 0 (ami azt jelzi, hogy az elmúlt 60 percben nem futott vagy nem aktív tevékenység), a készlet mérete 0.
    • Ha bármelyik érték nagyobb nullánál, nem történik módosítás.
string now = DateTime.UtcNow.ToString("r");
string formula = string.Format(@"
    $TargetDedicatedNodes = {1};
    lifespan         = time() - time(""{0}"");
    span             = TimeInterval_Minute * 60;
    startup          = TimeInterval_Minute * 10;
    ratio            = 50;

    $TargetDedicatedNodes = (lifespan > startup ? (max($RunningTasks.GetSample(span, ratio), $ActiveTasks.GetSample(span, ratio)) == 0 ? 0 : $TargetDedicatedNodes) : {1});
    ", now, 4);

Következő lépések