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.
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é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 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 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 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 méretezési képlettel a készlet kezdetben egyetlen virtuális géppel jön létre. 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 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 feladatok elküldésekor a készlet automatikusan nő. 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 skálázza a dedikált csomópontokat, de módosítható a kihasználatlan csomópontok méretezésére is.
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;
Fontos
A Batch szolgáltatás jelenleg korlátozásokkal rendelkezik a függőben lévő tevékenységek megoldására. Amikor hozzáad egy feladatot a feladathoz, az is bekerül egy belső üzenetsorba, amelyet a Batch szolgáltatás használ ütemezéshez. Ha a tevékenység még az ütemezés előtt törlődik, előfordulhat, hogy a tevékenység az üzenetsoron belül marad, és így továbbra is beleszámít a programba $PendingTasks. Ez a törölt tevékenység végül törlődik az üzenetsorból, amikor a Batch lehetőséget kap arra, hogy lekérje a feladatokat az üzenetsorból a Batch-készlet üresjárati csomópontjaival való ütemezéshez.
Előre átszerkesztett csomópontok
Ez a példa létrehoz egy készletet, amely 25 kihasználatlan csomóponttal kezdődik. Minden alkalommal, amikor egy kihasználatlan csomópont elő van állítva, egy dedikált csomópont lesz lecserélve. 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 kihasználatlan virtuális gépek előnyeinek kihasználásához, ugyanakkor biztosítja, hogy a készlet élettartama során csak meghatározott számú előbeírá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 írásvédett, néhány pedig írásvédett.
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 írásvédett és írásvédett változókat mutatják be.
Í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. |
| $TargetLowPriorityNodes | A készlet kihasználatlan 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 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 akkor sem é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ópontokról további információt a Kihasználatlan virtuális gépek használata a Batch használatával című témakörben talál. |
| $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. - megszakítás: A tevékenységek azonnal befejeződnek, és eltávolítják őket a feladatsorból. - feladatkiegészítés: Megvárja, amíg az éppen 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 újbóli lekérdezését, valamint 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. |
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 tevékenységek jelenleg nem szerepelnek az olyan változókban, amelyek tevékenységszámokat biztosítanak, 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 nem érhetők el 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ével társított 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. |
| $WallClockSeconds | A felhasznált másodpercek száma. Nyugdíjba vonulás 2024. március 31. után. |
| $MemoryBytes | A használt megabájtok átlagos száma. Nyugdíjba vonulás 2024. március 31. után. |
| $DiskBytes | A helyi lemezeken használt gigabájtok átlagos száma. Nyugdíjba vonulás 2024. március 31. után. |
| $DiskReadBytes | Az olvasási bájtok száma. Nyugdíjba vonulás 2024. március 31. után. |
| $DiskWriteBytes | A megírt bájtok száma. Nyugdíjba vonulás 2024. március 31. után. |
| $DiskReadOps | Az elvégzett olvasási lemezműveletek száma. Nyugdíjba vonulás 2024. március 31. után. |
| $DiskWriteOps | Az elvégzett írási lemezműveletek száma. Nyugdíjba vonulás 2024. március 31. után. |
| $NetworkInBytes | A bejövő bájtok száma. Nyugdíjba vonulás 2024. március 31. után. |
| $NetworkOutBytes | A kimenő bájtok száma. Nyugdíjba vonulás 2024. március 31. után. |
| $SampleNodeCount | A számítási csomópontok száma. Nyugdíjba vonulás 2024. március 31. után. |
| $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, és amelyek 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 és a $ActiveTasks$RunningTasks. |
| $SucceededTasks | A sikeresen befejezett tevékenységek száma. |
| $FailedTasks | 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. |
| $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. |
| $UsableNodeCount | 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. |
Figyelmeztetés
A szolgáltatás által definiált változók kiválasztása 2024. március 31. után megszűnik a fenti táblázatban leírtak szerint. A kivonási dátum után ezek a szolgáltatás által definiált változók már nem lesznek feltöltve mintaadatokkal. Ezen változók használatát a dátum előtt hagyja abba.
Feljegyzés
Skálázáskor az adott időpontban futó tevékenységek száma alapján, valamint $ActiveTasks a futtatásra váró feladatok száma alapján történő skálázáskor használható$RunningTasks.
Típusok
Az automatikus skálázási képletek a következő típusokat támogatják:
- double
- doubleVec
- doubleVecList
- húr
- 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ő esetén 1)
- óra (24 órás számformátumban, például 13: 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 az előző szakaszban felsorolt típusok esetében engedélyezettek.
| Művelet | Támogatott operátorok | Eredmény típusa |
|---|---|---|
| dupla operátor dupla | +, -, *, / | double |
| dupla operátor időintervallája | * | 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 időintervallása | - | 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 kettőst egy ternáris operátorral (double ? statement1 : statement2) tesztel, az eredmény nem igaz, a nulla pedig 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) | double | A doubleVecList összes értékének átlagértékét adja vissza. |
| ceil(dupla) | double | A legkisebb egész számértéket adja vissza, amely nem kisebb a dupla értéknél. |
| ceil(doubleVecList) | doubleVec | A doubleVecList összetevőjét ceil adja vissza. |
| emelet(dupla) | double | A legnagyobb egész számot adja vissza, amely nem nagyobb a dupla értéknél. |
| floor(doubleVecList) | doubleVec | A doubleVecList összetevőjét floor adja vissza. |
| len(doubleVecList) | double | A doubleVecListből létrehozott vektor hosszát adja vissza. |
| lg(dupla) | double | A kettős napló alapjának 2-ét adja vissza. |
| lg(doubleVecList) | doubleVec | A doubleVecList összetevőjét lg adja vissza. |
| ln(dupla) | double | A dupla természetes naplóját adja vissza. |
| ln(doubleVecList) | doubleVec | A doubleVecList összetevőjét ln adja vissza. |
| log(double) | double | A kettős napló alapjának 10-ét adja vissza. |
| log(doubleVecList) | doubleVec | A doubleVecList összetevőjét log adja vissza. |
| 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 vektor v percentilis elemét adja vissza. |
| rand() | double | Véletlenszerű értéket ad vissza 0,0 és 1,0 között. |
| range(doubleVecList) | double | A doubleVecList minimális és maximális értékei közötti különbséget adja vissza. |
| kerek(dupla) | double | A legközelebbi egész számot a dupla értékre (lebegőpontos formátumban) adja vissza, a nullától távol eső esetek felfelé kerekítésével. |
| round(doubleVecList) | doubleVec | A doubleVecList összetevőjét round adja vissza. |
| std(doubleVecList) | double | A doubleVecList értékeinek szórásá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 | 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 tagolt lista a dupla és a duplavec bármilyen kombinációja. 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. Ha például a v = [1,2,3]hívás egyenértékű a hívással avg(v)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 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: - $TargetDedicatedNodes - $TargetLowPriorityNodes - $CurrentDedicatedNodes - $CurrentLowPriorityNodes - $PreemptedNodeCount - $UsableNodeCount 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 - $WallClockSeconds - $MemoryBytes - $DiskBytes - $DiskReadBytes - $DiskWriteBytes - $DiskReadOps - $DiskWriteOps - $NetworkInBytes - $NetworkOutBytes |
| Task | 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 - $PendingTasks - $SucceededTasks - $FailedTasks |
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 az előzmények 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. |
| GetSamplePeriod() | 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. |
| HistoryBeginTime() | 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. |
Mintá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 olvasása (és olvasása) között azonban á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 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 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 csomópontok hozzáadásával vagy eltávolításával növekednek és zsugorodnak a készletek. 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 több összegyűjtött minta alapján növeli és zsugorítja a készleteket.
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 min()a , max()és avg() az összegyűjtött tartományból származó értelmes értékek származtathatók.
A fokozott óvatosság érdekében kényszerítheti a képletek kiértékelését, ha egy adott időszakban kevesebb mint egy bizonyos mintaszázada érhető el. 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 készlet 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.
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 készlet dedikált számítási 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 csak a feladataik befejezéséig lesznek eltávolítva.
$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ó:
- CloudPool.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 (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 APIBatch 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:
- Hozza létre a készletet a BatchClient.PoolOperations.CreatePool használatával.
- Állítsa a CloudPool.AutoScaleEnabled tulajdonság értékét igaz értékre.
- Állítsa be a CloudPool.AutoScaleFormula tulajdonságot az automatikus skálázási képlettel.
- (Nem kötelező) Állítsa be a CloudPool.AutoScaleEvaluationInterval tulajdonságot (alapértelmezés szerint 15 perc).
- Véglegesítse a készletet a CloudPool.Commit vagy a CommitAsync 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 cikkben myBatchClient szereplő többi C#-kódrészlet a BatchClient osztály megfelelő 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 híváshoz CreatePool. Ehelyett adja meg a AutoScaleEnabled készlet tulajdonságait és AutoScaleFormula tulajdonságait. 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.PoolOperations.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:
- Hozzon létre egy készletet, és adja meg annak konfigurációját.
- Adja hozzá a készletet a szolgáltatásügyfélhöz.
- 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="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_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 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.PoolOperations.EnableAutoScaleAsync (Batch .NET)
- Automatikus skálázás engedélyezése készleten (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 automatikus skálázási képletet kell megadnia a kérés kiadá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 a készleten, 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 myBatchClient.PoolOperations.EnableAutoScaleAsync(
"myexistingpool",
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 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 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. Ha például 60 percre szeretné beállítani az automatikus skálázási kiértékelési időközt 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:
BatchClient.PoolOperations.EvaluateAutoScale 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. Ha a készlet még nem használja az automatikus skálázást, először engedélyezze azt.
// 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)
{
// You 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 you want to apply our new autoscale formula below if it
// evaluates successfully, and you *just* enabled autoscaling on
// this pool, pause here to ensure you 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();
}
// You 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 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 szerezze be (vagy frissítse) a készletre mutató hivatkozást, majd vizsgálja meg az utolsó automatikus skálázási futtatás tulajdonságait.
A Batch .NET-ben a CloudPool.AutoScaleRun tulajdonság számos 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érelem adatainak lekérése a készletre vonatkozó információkat adja vissza, amely tartalmazza az automatikus skálázási futtatás legújabb információit 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.
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ényekkel
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 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észlet csomópontjainak számát ennek megfelelően.
A képlet először beolvasja az aktuális időt. Ha hétköznap (1-5) és munkaidőn belül (reggel 8 és 18 óra között) van, a célkészlet mérete 20 csomópontra van állítva. Ellenkező esetben 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;
$curTimea helyi időzónának megfelelően módosítható a termékhez TimeZoneInterval_Hour való hozzáadással time() és az UTC-eltolással. Például a hegyi nyári idő (MDT) esetében.$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 ilyen.
2. példa: Tevékenységalapú kiigazítás
Ebben a C#-példában a készlet mérete az üzenetsorban lévő tevékenységek száma alapján van módosítva. 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 C#-példa a tevékenységek száma alapján módosítja a készlet méretét. Ez a képlet figyelembe veszi a készlethez beállított TaskSlotsPerNode értéket is. Ez a módszer olyan helyzetekben hasznos, amikor a párhuzamos feladatvégrehajtás engedélyezve van 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őszakban. 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észletméretet 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 lekérjük 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 futottak vagy aktívak a tevékenységek, a készlet mérete 0.
- 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.