Képlet létrehozása számítási csomópontok automatikus skálázásához a Batch-készletben

Az 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 egy készlethez a tevékenységigények növekedésével, és eltávolítja a számítási csomópontokat a tevékenységigények csökkenésével.

Ha engedélyezni szeretné az automatikus skálázást a számítási csomópontok készletén, a készletet egy ön által definiált automatikus skálázási képlethez kell társítania. 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 Spot csomópontok. A Batch rendszeres időközönként áttekinti a szolgáltatásmetrikák adatait, és a képlet alapján és az Ön által meghatározott időközönként módosítja a készlet csomópontjainak számát.

A készlet létrehozásakor vagy meglévő készletre alkalmazva engedélyezheti az automatikus skálázást. A Batch segítségével kiértékelheti a képleteket, mielőtt készletekhez rendelené őket, és figyelheti 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 legfeljebb 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 megadott számítási csomópontok célszámát. A fiókkvóták megtekintéséről és növeléséről az Azure Batch szolgáltatás kvótáiról és korlátairól olvashat.

Ha felhasználói előfizetési módban hozta létre a fiókját, akkor a fiókja az előfizetés alapvető kvótájá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.

Automatikus skálázási képletek

Egy automatikus skálázási képlet egy általad meghatározott karakterlánc, amely egy vagy több utasítást tartalmaz. Az automatikus skálázási képlet egy készlet autoScaleFormula eleméhez (Batch REST) vagy BatchPool.AutoScaleFormula tulajdonsághoz (Batch .NET) van hozzá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épletkivonatok olyan szabad formátumú kifejezések, amelyek a Batch szolgáltatás által definiált szolgáltatás által definiált változókat é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 kapott értékeken. Először például beolvas egy értéket variable1, majd adja át egy függvénynek a kitöltéshez 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 Spot csomópontok mindegyiknek megvannak a saját célbeállításai. 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 azonos lehet a készletben található ilyen típusú csomópontok aktuális számával. A Batch adott automatikus skálázási időközökkel értékeli ki a készlet automatikus méretezési képletét. A Batch a készlet egyes csomóponttípusainak 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ábbi példák két automatikus skálázási képletet mutatnak be, amelyek a legtöbb forgatókönyv esetében módosíthatók. A példaképletekben szereplő változók, startingNumberOfVMs és maxNumberofVMs, szükség szerint módosíthatók.

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

Ezzel az automatikus méretezési képlettel az erőforráskészlet kezdetben egyetlen virtuális géppel alakul ki. A $PendingTasks metrika határozza meg a futó vagy várólistára helyezett tevékenységek számát. A képlet megkeresi a függőben lévő tevékenységek átlagos számát az elmúlt 15 percben, é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 feladatok elküldésekor az erőforrás készlet automatikusan növekszik. A feladatok befejezésekor a virtuális gépek ingyenessé válnak, és az automatikus skálázási képlet csökkenti a készletet.

Ez a képlet a dedikált csomópontok skálázására szolgál, de módosítható a Spot csomópontok méretezésére is.

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

Fontos

A Batch szolgáltatás jelenleg korlátozásokkal rendelkezik a függőben lévő tevékenységek megoldására. Amikor egy feladatot hozzáadnak a munkához, az a Batch szolgáltatás által ütemezéshez használt belső sorba is bekerül. Ha a feladat mielőtt ütemezhető lenne kerül törlésre, előfordulhat, hogy a feladat a sorban marad, és így továbbra is beleszámít a $PendingTasks-ba. Ez a törölt feladat végül törlődik a sorból, amikor a Batch lehetőséget kap arra, hogy lekérje a feladatokat a sorból, és ütemezze őket a Batch-készlet üresjárati csomópontjaival.

Előre megszakított csomópontok

Ez a példa létrehoz egy készletet, amely 25 Spot csomóponttal indul. Minden alkalommal, amikor egy Spot csomópont kiszorításra kerül, egy dedikált csomóponttal lesz helyettesítve. Az első példához hasonlóan a maxNumberofVMs változó megakadályozza, hogy a készlet meghaladja a 25 virtuális gépet. Ez a példa hasznos a Spot virtuális gépek előnyeinek kihasználásához, miközben biztosítja, hogy a csoport élettartama alatt csak egy meghatározott számú megszakítás történjen.

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

A cikk későbbi részében többet is megtudhat az automatikus skálázási képletek létrehozásáról, és további példákat talál az automatikus skálázási képletekre .

Változók

A szolgáltatás által definiált és a felhasználó által definiált változókat is használhatja az automatikus skálázási képletekben.

A szolgáltatás által definiált változók a Batch szolgáltatásba vannak beépítve. A szolgáltatás által definiált változók egy része olvasható és írható, míg mások írásvédettek.

A felhasználó által definiált változók ön által definiált változók. Az előző példában $TargetDedicatedNodes$PendingTasks szolgáltatás által definiált változók, míg startingNumberOfVMsmaxNumberofVMs a felhasználó által definiált változók.

Feljegyzés

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

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

Olvasási és í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észlet számítási csomópontjainak számának kezeléséhez.

Változó	Leírás
$TargetDedicatedNodes	A készlet dedikált számítási csomópontjainak célszáma. Célként van megadva, 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ók készlete nem éri el a célját, ha a cél meghaladja az előfizetés megosztott magkvóta-számát.
CélozniAlacsonyPrioritásúCsomópontok	A készlet Spot számítási csomópontjainak célszáma. Célként van megadva, mert előfordulhat, hogy egy készlet nem mindig éri el a kívánt számú csomópontot. Ha például a Spot csomópontok célszámát egy automatikus skálázási értékelés módosítja, mielőtt a készlet elérné az eredeti célt, előfordulhat, hogy a készlet nem éri el a kitűzött célt. Előfordulhat, hogy egy készlet akkor sem éri el a célját, ha a cél túlterhel egy Batch-fiókcsomópontot vagy meghaladja a magkvótát. A Spot számítási csomópontokról további információért lásd: Spot 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. A lehetséges értékek a következők: - requeue: Az alapértelmezett érték. Azonnal befejezi a feladatokat, és visszateszi őket a feladatsorba, hogy át legyenek ütemezve. Ez a művelet biztosítja, hogy a csomópontok célszáma a lehető leggyorsabban elérhető legyen. Előfordulhat azonban, hogy kevésbé hatékony, mert a futó tevékenységek megszakadnak, majd újra kell indítani. - megszüntetés: Azonnal befejezi a tevékenységeket, és eltávolítja őket a feladatsorból. - feladatbefejezés: Megvárja, amíg az éppen futó feladatok befejeződnek, majd eltávolítja a csomópontot a távból. Ezzel a beállítással elkerülheti a feladatok megszakítását és újrasorolását, valamint a feladat által végzett munka kárba veszé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.

Feljegyzé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 a Batch szolgáltatásból származó metrikákon alapuló módosítások elvégzéséhez.

Fontos

A feladatkiadási feladatok jelenleg nem szerepelnek az olyan változókban, amelyek feladatszámokat biztosítanak, például ilyenek $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 nem érhetők el csomópontok a feladatkiadási feladatok futtatásához.

Tipp

Ezek az írásvédett, szolgáltatás által meghatározott változók olyan objektumok, amelyek különféle módszereket biztosítanak a hozzájuk tartozó adatok eléréséhez. 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.
$ActiveTasks	Azon feladatok száma, amelyek készen állnak a végrehajtásra, de még nem hajtják végre. Ez magában foglalja az aktív állapotban lévő összes tevékenységet, amelyeknek a függőségei teljesültek. Minden olyan tevékenység, amely aktív állapotban van, de a függőségei nem teljesültek, ki lesz zárva a $ActiveTasks darabszámból. Többpéldányos tevékenység $ActiveTasks esetén tartalmazza a tevékenységen beállított példányok számát.
$RunningTasks	A futó állapotban lévő tevékenységek száma.
$PendingTasks	Az $ActiveTasks és $RunningTasks összege.
$SikeresFeladatok	A sikeresen befejezett tevékenységek száma.
$SikertelenFeladatok	A sikertelen tevékenységek száma.
$TaskSlotsPerNode	A készlet egyetlen számítási csomópontján egyidejű feladatok futtatásához használható feladathelyek száma.
$AktuálisDedikáltCsomópontok	A dedikált számítási csomópontok aktuális száma.
$CurrentLowPriorityNodes	A Spot számítási csomópontok aktuális száma, beleértve a megszakított csomópontokat is.
$HasználhatóCsomópontSzám	A használható számítási csomópontok száma.
$PreemptedNodeCount	A készletben lévő, előre megadott állapotban lévő csomópontok száma.

Feljegyzés

A $RunningTasks címkét akkor használja, amikor az időpontban futó feladatok száma alapján skáláz, és a $ActiveTasks címkét akkor, amikor a futtatásra váró feladatok száma alapján történik a skálázás.

Típusok

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

• kettő
• doubleVec
• doubleVecList
• karakterlánc
• timestamp - egy összetett struktúra, amely a következő tagokat tartalmazza:
  • év
  • hónap (1-12)
  • a hónap napja (1-31)
  • hétköznap (számformátumban, például hétfő esetén 1)
  • óra (24 órás számformátumban, például 13:00 délután 1 órát jelent)
  • perc (00-59)
  • második (00-59)
• időintervallum
  • Időtartam_Nulla
  • Időintervallum_100ns
  • Időintervallum_Mikroszekundum
  • Időtartam_Milliszekundum
  • Időintervallum_Másodperc
  • Időtartam_Perc
  • Időintervallum_Óra
  • Időintervallum_Nap
  • IdőIntervallum_Hét
  • Időintervallum_Év

Üzemeltetés

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

Művelet	Támogatott operátorok	Eredmény típusa
kétszeres operátor kétszeres	+, -, *, /	kettő
kettős operátor időintervallum	*	időintervallum
doubleVec operátor double	+, -, *, /	doubleVec
doubleVec operátor doubleVec	+, -, *, /	doubleVec
timeinterval operátor double	*, /	időintervallum
időintervallum operátor időintervallum	+, -	időintervallum
időintervallum operátor időbélyeg	+	timestamp
időbélyeg operátor időintervallum	+	timestamp
időbélyeg operátor időbélyeg	-	időintervallum
operátor dupla	-, !	kettő
operátor időintervallum	-	időintervallum
kétszeres operátor kétszeres	<, <=, ==, >=, >, !=	kettő
sztring operátor sztring	<, <=, ==, >=, >, !=	kettő
időbélyeg operátor időbélyeg	<, <=, ==, >=, >, !=	kettő
időintervallum operátor időintervallum	<, <=, ==, >=, >, !=	kettő
kétszeres operátor kétszeres	&&, ||	kettő

Egy kettős tesztelése ternáris operátorral (double ? statement1 : statement2) olyan eredményt ad, hogy a nem nulla szám igaz, míg a nulla hamis.

Functions

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

Függvény	Visszatérési típus	Leírás
avg(doubleVecList)	kettő	A doubleVecList összes értékének átlagértékét adja vissza.
ceil(double)	kettő	A legkisebb egész számértéket adja vissza, amely nem kisebb a dupla értéknél.
ceil(doubleVecList)	doubleVec	A doubleVecList elemenkénti ceil-ját adja vissza.
emelet(dupla)	kettő	A legnagyobb egész számot adja vissza, amely nem nagyobb a dupla értéknél.
floor(doubleVecList)	doubleVec	A doubleVecList elemenkénti floor-ját adja vissza.
len(doubleVecList)	kettő	A doubleVecListből létrehozott vektor hosszát adja vissza.
lg(dupla)	kettő	A szám alap 2-es logaritmusát adja vissza.
lg(doubleVecList)	doubleVec	A doubleVecList elemenkénti lg-ját adja vissza.
ln(dupla)	kettő	A double természetes logaritmusát adja vissza.
ln(doubleVecList)	doubleVec	A doubleVecList elemenkénti ln-ját adja vissza.
log(double)	kettő	A dupla tizedik alapú logaritmusát adja vissza.
log(doubleVecList)	doubleVec	A doubleVecList elemenkénti log-ját adja vissza.
max(doubleVecList)	kettő	A doubleVecList maximális értékét adja vissza.
min(doubleVecList) – a doubleVecList minimális értéke	kettő	A doubleVecList minimális értékét adja vissza.
norm(doubleVecList)	kettő	A doubleVecList-ből létrehozott vektor két normát adja vissza.
percentilis(doubleVec v, double p)	kettő	A vektor v percentilis elemét adja vissza.
rand()	kettő	Véletlenszerű értéket ad vissza 0,0 és 1,0 között.
range(doubleVecList)	kettő	A doubleVecList minimális és maximális értékei közötti különbséget adja vissza.
kerek(dupla)	kettő	A legközelebbi egész számot adja vissza a dupla értékhez (lebegőpontos formátumban), a köztes értékek nullától távolabbi irányba való kerekítésével.
round(doubleVecList)	doubleVec	A doubleVecList elemenkénti round-ját adja vissza.
std(doubleVecList)	kettő	A doubleVecList értékeinek minta szórását adja vissza.
állj()		Leállítja az automatikus skálázási kifejezés kiértékelését.
összeg(duplaVektorLista)	kettő	A doubleVecList összes összetevőjének összegét adja vissza.
time(string dateTime="")	timestamp	Az aktuális idő időbélyegét adja vissza, ha nem adunk át paramétereket, vagy a megadott dátum/idő sztring időbélyegét, ha azt adtuk meg. A támogatott dateTime formátumok a W3C-DTF és az RFC 1123.
val(doubleVec v, double i)	kettő	Az i helyen lévő elem értékét adja vissza a v vektorban, nulla kezdőindexkel.

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

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

A doubleVecList érték a kiértékelés előtt egyetlen doubleVec értékké lesz konvertálva. Például, ha a v = [1,2,3], akkor a avg(v) hívás egyenértékű a avg(1,2,3) hívással. 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 beszerzett é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 Változók szakaszt .

Metrika	Leírás
Erőforrás	Az erőforrásmetriká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 történő módosításhoz: - $CélzottDedikáltCsomópontok - $TargetLowPriorityNodes - $CurrentDedicatedNodes - $CurrentLowPriorityNodes (jelenlegi alacsony prioritású csomópontok) - $MegszakítottNodeSzám - HasználhatóCsomópontSzám Ezek a szolgáltatás által definiált változók hasznosak a csomóponterőforrás-használat alapján történő módosításhoz: - $CPUPercent
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éretek tevékenységmetrikák alapján történő módosításához: - $ActiveTasks - $RunningTasks - Folyamatban lévő feladatok ($PendingTasks) - $SikeresFeladatok - $SikertelenFeladatok

Mintaadatok lekérése

Az automatikus skálázási képletek alapvető művelete a tevékenység- és erőforrásmetrikák adatainak (mintáinak) beszerzése, majd a készlet méretének ezen adatok alapján történő módosítása. 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 méretezési képletek a Batch szolgáltatás által biztosított metrikaadatok mintáin működnek. Egy képlet a beszerzett értékek alapján növeli vagy zsugorítja a készlet számítási csomópontjait. 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 processzorhaszná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 vektorát adja vissza. A minta 30 másodpercnyi metrikaadat. Más szóval a mintákat 30 másodpercenként kapjuk meg. Az alábbiakban azonban megjegyezzük, 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. Ilyen esetben előfordulhat, hogy nem minden minta áll rendelkezésre egy adott időszakra vonatkozóan egy képlet alapján történő kiértékeléshez. - doubleVec GetSample(double count): Megadja a legutóbb gyűjtött mintákból lekért minták számát. GetSample(1) 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 jobb, ha az alábbiak szerint időintervallumot használ. - doubleVec GetSample((timestamp or timeinterval) startTime [, double samplePercent]): Megadja a mintaadatok gyűjtésének időkeretét. Opcionálisan meghatározza a kért időkeretben elérhető minták százalékos arányát is. Például 20 mintát adna vissza, $CPUPercent.GetSample(TimeInterval_Minute * 10) ha az elmúlt 10 percre vonatkozó összes minta szerepel az CPUPercent előzményekben. Ha a történelem utolsó perce nem áll rendelkezésre, csak 18 mintát ad 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) sikeres lenne. - doubleVec GetSample((timestamp or timeinterval) startTime, (timestamp or timeinterval) endTime [, double samplePercent]): Az adatok gyűjtésére szolgáló időkeretet határoz meg, amelynek kezdő és záró időpontja is van. 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. Vegye figyelembe ezt a késleltetést a GetSample módszer használatakor. Lásd GetSamplePercent alább.
MintavételiIdőszakLekérése()	Az előzményadat-készletben vett minták időtartamát adja vissza.
Darabszám()	A metrikák előzményeiben szereplő minták teljes számát adja vissza.
TörténelemKezdésiIdő()	A metrika legrégebbi elérhető adatmintájának időbélyegét adja vissza.
GetSamplePercent()	Az adott időintervallumban elérhető 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, anélkül, hogy leállítja az automatikus skálázási kiértékelést.

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. A minták rögzítése és az automatikus skálázási képletek számára történő elérhetősége között általában késés tapasztalható. Emellett előfordulhat, hogy a minták nem rögzíthetők adott időközönként, például hálózati vagy egyéb infrastruktúra-problémák miatt.

Minta százalékos értéke

Amikor samplePercent átadásra kerül a GetSample() metódusban, vagy amikor a GetSamplePercent() metódust meghívják, a százalék a Batch szolgáltatás által rögzített minták teljes lehetséges száma és az automatikus skálázási képlethez elérhető minták száma közötti összehasonlítást jelenti.

Tekintsünk meg például egy 10 perces időtartamot. Mivel a minták rögzítése 30 másodpercenként történik a 10 perces időtartamon belül, a Batch által rögzített minták maximális száma 20 minta (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 érhető el az automatikus skálázási képlethez olvasáshoz. Így például ebben a 10 perces időszakban a rögzített minták számának csak 75 százaléka érhető el a képlethez.

GetSample() és mintatartományok

Az automatikus skálázási képletek a fürtök bővülését és zsugorodását irányítják csomópontok hozzáadásával vagy eltávolításával. Mivel a csomópontok pénzbe kerülnek, győződjön meg arról, hogy a képletek megfelelő adatokon alapuló intelligens elemzési módszert használnak. Javasoljuk, hogy trend típusú elemzést használjon a képletekben. Ez a típus az összegyűjtött minták alapján növeli és zsugorítja a medencéket.

Ehhez használja GetSample(interval look-back start, interval look-back end) a minták vektorának visszaadására:

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

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

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

Miután összegyűjtötte a minták vektorát, használhatja az olyan függvényeket, mint a min(), max() és avg(), hogy értelmes értékeket származtasson az összegyűjtött tartományból.

A fokozott óvatosság érdekében beállíthatja, hogy a képletek kiértékelése sikertelen legyen, ha egy adott időszakban a rendelkezésre álló minta kevesebb, mint egy meghatározott százalék. Amikor egy képlet kiértékelését sikertelenre kényszeríti, utasítja a Batchet, hogy szüntesse meg a képlet további kiértékelését, ha a minták megadott százalékos aránya nem érhető el. Ebben az esetben nincs változás a pool méretében. Ha meg szeretné adni a sikeres értékeléshez szükséges minták százalékos arányát, 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 meg kell adnia egy egy percnél régebbi visszatekintési kezdési időponttal rendelkező időtartományt. A minták a rendszeren keresztüli propagálása körülbelül egy percet vesz igénybe, így előfordulhat, hogy a tartományban (0 * TimeInterval_Second, 60 * TimeInterval_Second) lévő minták nem érhetők el. 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 nekem az utolsó mintát, függetlenül attól, hogy mennyi ideje kérték le." Mivel ez csak egy minta, és lehet, hogy egy régebbi minta, lehet, hogy nem reprezentatív a legutóbbi tevékenység vagy erőforrás állapotának nagyobb képére. Ha mégis használja GetSample(1), győződjön meg arról, hogy ez egy nagyobb utasítás része, és nem az egyetlen adatpont, amelyre a képlet támaszkodik.

Egy automatikus méretezé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épletbe egyesíti. Ebben a szakaszban egy automatikus skálázási példaképletet hoz létre, amely valós skálázási döntéseket hozhat, és módosításokat hajthat végre.

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

• Ha a processzorhasználat magas, növelje a halmaz dedikált számítástechnikai csomópontjainak célszámát.
• Csökkentse a dedikált számítási csomópontok célszámát egy készletben, 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 feladatokat futtató csomópontokat; ha szükséges, várjon, amíg a feladatok 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 processzorhasználat során. Olyan utasítást határoz meg, amely feltölt egy felhasználó által definiált változót ($totalDedicatedNodes) a dedikált csomópontok aktuális célszámának 110%-ával, de csak akkor, ha az elmúlt 10 percben a minimális átlagos processzorhasználat 70 százalék 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 az alacsony processzorhasználat során, a képlet következő utasítása ugyanazt $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 elmúlt 60 perc átlagos processzorhasználata 20 százalék alatt volt. Ellenkező esetben a fenti utasításban kitöltött aktuális értéket $totalDedicatedNodes használja.

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

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

$TargetDedicatedNodes = min(400, $totalDedicatedNodes);

Végül győződjön meg arról, hogy a csomópontok nincsenek eltávolítva addig, amíg a feladataik 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;

Feljegyzés

Ha ezt választja, 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 skálázá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 intervallum a következő készlettulajdonságok használatával konfigurálható:

• BatchPool.AutoScaleEvaluationInterval (Batch .NET)
• autoScaleEvaluationInterval (REST API)

A minimális időköz öt perc, a maximum 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.

Feljegyzé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 a készlet méretének fokozatos módosítására szolgál a számítási feladatok futtatása során.

Automatikus méretezé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 REST API Batch PowerShell-parancsmagjai é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 az automatikus skálázást engedélyező készletet szeretne létrehozni a .NET-ben, kövesse az alábbi lépéseket:

1. Hozza létre a készletet a BatchAccountPoolCollection.CreateOrUpdateAsync használatával.
2. Állítsa a BatchPool.EnableAutoScale tulajdonságának értékét true értékre.
3. Állítsa be a BatchPool.AutoScaleFormula tulajdonságot az automatikus skálázási képlettel.
4. (Nem kötelező) Állítsa be a BatchPool.AutoScaleEvaluationInterval tulajdonságot (alapértelmezés szerint 15 perc).
5. Hozza létre a készletcsoportot a BatchClient.CreatePool vagy a CreatePoolAsync használatával.

Az alábbi példa egy automatikusan skálázható 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 hétfőnként 5-re, a hét minden második napján pedig 1-re állítja. Az automatikus skálázási időköz 30 percre van állítva. Ebben és a cikk többi C#-kódrészletében a myBatchClient a BatchClient osztály megfelelően inicializált példánya.

BatchAccountPoolData poolData = new BatchAccountPoolData()
{
    VmSize = "standard_d1_v2",
    DeploymentConfiguration = new BatchDeploymentConfiguration()
    {
        VmConfiguration = new BatchVmConfiguration(
            imageReference: new BatchImageReference()
            {
                Publisher = "MicrosoftWindowsServer",
                Offer = "WindowsServer",
                Sku = "2019-datacenter-core",
                Version = "latest"
            },
            nodeAgentSkuId: "batch.node.windows amd64")
    },
    ScaleSettings = new BatchAccountPoolScaleSettings()
    {
        AutoScale = new BatchAccountAutoScaleSettings(
            formula: "$TargetDedicatedNodes = (time().weekday == 1 ? 5:1);")
        {
            EvaluationInterval = TimeSpan.FromMinutes(30)
        }
    }
};

await batchAccount.GetBatchAccountPools().CreateOrUpdateAsync(WaitUntil.Completed, "mypool", poolData);

Fontos

Automatikus skálázást engedélyező készlet létrehozásakor ne adja meg a targetDedicatedNodes vagy a targetLowPriorityNodes paramétert a CreatePool hívásakor. Ehelyett adja meg a AutoScaleEnabled és AutoScaleFormula tulajdonságait a készleten. 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ésre képes készletet (például BatchClient.ResizePoolAsync használatával), először le kell tiltania az automatikus méretezést a készleten, majd át kell méreteznie.

Tipp

A .NET SDK használatára további példákat a GitHub Batch .NET gyorsútmutató-adattárában talál.

Python

Automatikusan skálázható 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 medencét a szolgáltatási klienshez.
3. Engedélyezze az automatikus skálázást a fürdőn, 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 = models.BatchPoolCreateOptions(
    id="autoscale-enabled-pool",
    virtual_machine_configuration=models.VirtualMachineConfiguration(
        image_reference=models.BatchVmImageReference(
          publisher="Canonical",
          offer="UbuntuServer",
          sku="20.04-LTS",
          version="latest"
            ),
        node_agent_sku_id="batch.node.ubuntu 20.04"),
    vm_size="STANDARD_D1_v2",
    target_dedicated_nodes=0,
    target_low_priority_nodes=0
)
batch_client.create_pool(pool=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
enable_options = models.BatchPoolEnableAutoScaleOptions(
    auto_scale_formula=formula,
    auto_scale_evaluation_interval=datetime.timedelta(minutes=10),
)
batch_client.enable_pool_auto_scale(pool_id=pool_id, enable_auto_scale_options=enable_options)

Tipp

A Python SDK használatára további példákat a GitHubon található Batch Python gyorsútmutató-adattárban talál.

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élda:

• BatchClient.EnablePoolAutoScaleAsync (Batch .NET)
• Automatikus skálázás engedélyezése poolban (REST API)

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

• Ha az automatikus skálázás jelenleg le van tiltva a készleten, érvényes autoskálázási képletet kell megadnia a kérelem benyújtásakor. 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 egy csoportra, megadhat egy új képletet, egy új időközt, vagy mindkettőt. A 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 új ütemezés indul el. 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érelmet kiadták.
  • Ha kihagyja az automatikus skálázási képletet vagy intervallumot, a Batch szolgáltatás továbbra is a beállítás aktuális értékét használja.

Feljegyzés

Ha a metódus targetDedicatedNodes vagy targetLowPriorityNodes paraméterének CreatePool értékeit adta meg 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 méretezé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 batchClient.EnablePoolAutoScaleAsync(
    "myexistingpool",
    new BatchPoolEnableAutoScaleOptions() { AutoScaleFormula = myAutoScaleFormula });

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

Ha frissíteni szeretné a képletet egy meglévő automatikus skálázás-kompatibilis készleten, hívja meg a műveletet, hogy újra engedélyezze az automatikus skálázást az új képlettel. Ha például az automatikus skálázás már engedélyezve van myexistingpool-n a következő .NET-kód végrehajtásakor, akkor az automatikus skálázási képletet a myNewFormula tartalma váltja fel.

await batchClient.EnablePoolAutoScaleAsync(
    "myexistingpool",
    new BatchPoolEnableAutoScaleOptions() { AutoScaleFormula = myNewFormula });

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

Egy meglévő automatikus skálázás-kompatibilis 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 engedélyezze újra az automatikus skálázást az új időközzel. Például, ha egy készlet esetén, amely már automatikus skálázásra van beállítva .NET-ben, 60 perces automatikus skálázási kiértékelési időközt szeretne beállítani:

await batchClient.EnablePoolAutoScaleAsync(
    "myexistingpool",
    new BatchPoolEnableAutoScaleOptions()
    {
        AutoScaleEvaluationInterval = TimeSpan.FromMinutes(60)
    });

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

Kiértékelheti a képletet, mielőtt alkalmazza egy halmazra. Ez lehetővé teszi a képlet eredményeinek tesztelését, mielőtt éles környezetbe helyezné.

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

• BatchClient.EvaluatePoolAutoScale vagy EvaluateAutoScaleAsync

  Ezek a Batch .NET-metódusok megkövetelik egy meglévő készlet azonosítóját és az automatikus skálázási képletet tartalmazó sztringet az értékeléshez.

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

  Ebben a REST API-kérelemben adja meg a készlet azonosítóját az URI-ban, és az automatikus skálázási képletet a kérelem törzsének autoScaleFormula elemében. A művelet válasza tartalmaz minden olyan hibainformációt, amely a képlethez kapcsolódhat.

Az alábbi Batch .NET-példa egy automatikus skálázási képletet értékel ki. Amennyiben a pool még nem használ automatikus skálázást, először engedélyezze azt.

// First obtain a reference to an existing pool
BatchPool pool = await batchClient.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.EnableAutoScale != true)
{
    // You need a valid autoscale formula to enable autoscaling on the
    // pool. This formula is valid, but won't resize the pool:
    await batchClient.EnablePoolAutoScaleAsync(
        pool.Id,
        new BatchPoolEnableAutoScaleOptions()
        {
            AutoScaleFormula = "$TargetDedicatedNodes = $CurrentDedicatedNodes;",
            AutoScaleEvaluationInterval = TimeSpan.FromMinutes(5)
        });

    // Batch limits EnablePoolAutoScale calls to once every 30 seconds.
    await Task.Delay(TimeSpan.FromSeconds(31));

    // Refresh the properties of the pool so that we've got the
    // latest value for EnableAutoScale.
    pool = await batchClient.GetPoolAsync(pool.Id);
}

// You must ensure that autoscaling is enabled on the pool prior to
// evaluating a formula
if (pool.EnableAutoScale == 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.EvaluatePoolAutoScaleAsync(
        pool.Id,
        new BatchPoolEvaluateAutoScaleOptions(myFormula));

    if (eval.Error == null)
    {
        Console.WriteLine("AutoScaleRun.Results: " +
            eval.Results.Replace("$", "\n    $"));

        // Apply the formula to the pool since it evaluated successfully
        await batchClient.EnablePoolAutoScaleAsync(
            pool.Id,
            new BatchPoolEnableAutoScaleOptions() { AutoScaleFormula = myFormula });
    }
    else
    {
        Console.WriteLine("AutoScaleRun.Error.Message: " + eval.Error.Message);
    }
}

Az ebben a kódrészletben szereplő 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

Javasoljuk, hogy rendszeresen ellenőrizze a Batch szolgáltatás automatikus skálázási képletének kiértékelését. Ehhez szerezzen be vagy frissítsen egy hivatkozást a poolra, majd vizsgálja meg az utolsó autoskálázás tulajdonságait.

A Batch .NET BatchPool.AutoScaleRun tulajdonság számos tulajdonsággal rendelkezik, amelyek információt nyújtanak a készleten végrehajtott legújabb automatikus méretezési futtatásról:

• AutoScaleRun.Timestamp
• AutoScaleRun.Results
• AutoScaleRun.Error

A REST API-ban a készletre vonatkozó információk tartalmazzák az automatikus skálázási futtatás legújabb adatait az automatikusScaleRun tulajdonságban.

A következő 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ának adatait.

BatchPool pool = await batchClient.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:

Az automatikus skálázás futtatási előzményeinek lekérése a 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. A Batch ezt az eseményt az automatikus skálázási képletek kiértékelésének és végrehajtásának rögzítéséhez bocsátja ki, 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": []
    }
}

Automatikus skálázási mintaképletek

Tekintsünk meg néhány képletet, amelyek különböző módszereket mutatnak a készlet számítási erőforrásainak módosítására.

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

Tegyük fel, hogy a medence 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 ennek megfelelően a csoport csomópontjainak számát.

A képlet először beolvasja az aktuális időt. Ha hétköznap van (1-5) és munkaidőn belül van (reggel 8 és 18 óra között), a célkapacitás 20 csomópontra van beállítva. Máskülönben 10 csomópontra van á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 módosítható a helyi időzónának megfelelően azáltal, hogy a time() hozzáadódik a TimeZoneInterval_Hour és az ön UTC-eltolásának szorzataként. Például használja a $curTime = time() + (-6 * TimeInterval_Hour);-t a hegyi nyári idő (MDT) esetében. 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 ilyen.

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

Ebben a példában a pool mérete a várólistán lévő feladatok száma alapján igazodik. A képletsztringek mind a megjegyzéseket, mind a sortöréseket tartalmazzák.

// Get pending tasks for the past 15 minutes.
$samples = $PendingTasks.GetSamplePercent(TimeInterval_Minute * 15);
// If you have fewer than 70 percent data points, use the last sample point,
// otherwise 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 feladatok könyvelése

Ez a példa a feladatok száma alapján módosítja a pool méretét. Ez a képlet figyelembe veszi a készlethez beállított TaskSlotsPerNode értéket is. Az a módszer hasznos olyan helyzetekben, amikor a csomagban engedélyezve van a párhuzamos feladatvégrehajtás.

// 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őszakban. Ezt követően a futó és aktív tevékenységek száma alapján módosítja az erőforrás készlet méretét.

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

• Négy csomópontra állítja be a kezdeti készletméretet.
• Nem állítja be a medence méretét a medence életciklusának első 10 percében.
• 10 perc elteltével megkapjuk a futó és aktív tevékenységek számának maximális értékét az előző 60 percből.
  • Ha mindkét érték 0, ami azt jelzi, hogy az elmúlt 60 percben nem futottak vagy voltak aktív feladatok, a pool mérete 0-ra van állítva.
  • Ha bármelyik érték nagyobb nullánál, nem történik változá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

• Megtudhatja, hogyan hajthat végre egyszerre több feladatot a készlet számítási csomópontjain. Az automatikus skálázás mellett ez segíthet csökkenteni bizonyos számítási feladatok időtartamát, így pénzt takaríthat meg.
• Megtudhatja, hogyan kérdezheti le hatékonyan az Azure Batch szolgáltatást.