Een automatische formule maken voor het schalen van rekenknooppunten in een Batch-pool

Azure Batch kunt pools automatisch schalen op basis van parameters die u definieert, waardoor u tijd en geld bespaart. Met automatisch schalen voegt Batch dynamisch knooppunten toe aan een pool naarmate de vraag naar taken toeneemt en worden rekenknooppunten verwijderd naarmate de vraag naar taken afneemt.

Als u automatisch schalen wilt inschakelen voor een pool met rekenknooppunten, koppelt u de pool aan een formule voor automatisch schalen die u definieert. De Batch-service gebruikt de formule voor automatisch schalen om te bepalen hoeveel knooppunten er nodig zijn om uw workload uit te voeren. Deze knooppunten kunnen toegewezen knooppunten of knooppunten met lage prioriteit zijn. Batch controleert vervolgens periodiek de metrische gegevens van de service en gebruikt deze om het aantal knooppunten in de pool aan te passen op basis van uw formule en met een interval dat u definieert.

U kunt automatisch schalen inschakelen wanneer u een pool maakt of deze toepassen op een bestaande pool. Met Batch kunt u uw formules evalueren voordat u ze toewijst aan pools en kunt u de status van automatische schalings runs controleren. Zodra u een pool met automatisch schalen hebt geconfigureerd, kunt u later wijzigingen aanbrengen in de formule.

Formules automatisch schalen

Een formule voor automatisch schalen is een tekenreekswaarde die u definieert en die een of meer instructies bevat. De formule voor automatisch schalen wordt toegewezen aan het element autoScaleFormula van een pool (Batch REST) of de eigenschap CloudPool.AutoScaleFormula (Batch .NET). De Batch-service gebruikt uw formule om het doelaantal rekenknooppunten in de pool te bepalen voor het volgende verwerkingsinterval. De formulereeks mag niet groter zijn dan 8 kB, kan maximaal 100 instructies bevatten die worden gescheiden door puntkomma's en kan regelafbreaks en opmerkingen bevatten.

U kunt formules voor automatisch schalen zien als een 'taal' voor automatisch schalen in Batch. Formule-instructies zijn vrije expressies die zowel door de service gedefinieerde variabelen (gedefinieerd door de Batch-service) als door de gebruiker gedefinieerde variabelen kunnen bevatten. Formules kunnen verschillende bewerkingen op deze waarden uitvoeren met behulp van ingebouwde typen, operators en functies. Een instructie kan bijvoorbeeld de volgende vorm hebben:

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

Formules bevatten over het algemeen meerdere instructies die bewerkingen uitvoeren op waarden die zijn verkregen in eerdere instructies. We verkrijgen bijvoorbeeld eerst een waarde voor en geven deze variable1 vervolgens door aan een functie om te variable2 vullen:

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

Neem deze instructies op in uw formule voor automatisch schalen om een doelaantal rekenknooppunten te bereiken. Toegewezen knooppunten en knooppunten met lage prioriteit hebben elk hun eigen doelinstellingen. Een formule voor automatisch schalen kan een doelwaarde voor toegewezen knooppunten, een doelwaarde voor knooppunten met lage prioriteit of beide bevatten.

Het doelaantal knooppunten kan hoger, lager of gelijk zijn aan het huidige aantal knooppunten van dat type in de pool. Batch evalueert de formule voor automatisch schalen van een pool met een specifiek automatisch schalingsinterval. Batch past het doelaantal van elk type knooppunt in de pool aan aan het getal dat uw formule voor automatisch schalen op het moment van de evaluatie aangeeft.

Voorbeelden van formules voor automatisch schalen

Hieronder vindt u voorbeelden van twee formules voor automatisch schalen, die voor de meeste scenario's kunnen worden aangepast. De variabelen startingNumberOfVMs en in de maxNumberofVMs voorbeeldformules kunnen worden aangepast aan uw behoeften.

Taken in behandeling

Met deze formule voor automatisch schalen wordt de pool in eerste instantie gemaakt met één VM. De $PendingTasks metriek definieert het aantal taken dat wordt uitgevoerd of in de wachtrij wordt geplaatst. De formule zoekt het gemiddelde aantal taken in behandeling in de afgelopen 180 seconden en stelt de $TargetDedicatedNodes variabele dienovereenkomstig in. De formule zorgt ervoor dat het doelaantal toegewezen knooppunten nooit groter is dan 25 VM's. Wanneer nieuwe taken worden verzonden, wordt de pool automatisch groter. Als de taken zijn voltooid, worden VM's gratis en wordt de pool verkleind met de formule voor automatisch schalen.

Met deze formule worden toegewezen knooppunten geschaald, maar deze kunnen ook worden aangepast om knooppunten met lage prioriteit te schalen.

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;

Verwijderde knooppunten

In dit voorbeeld wordt een pool gemaakt die begint met 25 knooppunten met lage prioriteit. Telkens als een knooppunt met lage prioriteit wordt vereend, wordt het vervangen door een toegewezen knooppunt. Net als in het eerste voorbeeld voorkomt maxNumberofVMs de variabele dat de pool 25 VM's overschrijdt. Dit voorbeeld is handig om gebruik te maken van VM's met lage prioriteit en om ervoor te zorgen dat er slechts een vast aantal toe-eigeningen optreedt voor de levensduur van de pool.

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

Verder in dit onderwerp leert u meer over het maken van formules voor automatisch schalen en ziet u aanvullende voorbeeldformules voor automatisch schalen.

Variabelen

U kunt zowel door de service gedefinieerde als door de gebruiker gedefinieerde variabelen gebruiken in uw formules voor automatisch schalen.

De door de service gedefinieerde variabelen zijn ingebouwd in de Batch-service. Sommige door de service gedefinieerde variabelen zijn lezen/schrijven en sommige variabelen zijn alleen-lezen.

Door de gebruiker gedefinieerde variabelen zijn variabelen die u definieert. In de bovenstaande voorbeeldformule zijn $TargetDedicatedNodes en door de service $PendingTasks gedefinieerde variabelen, terwijl startingNumberOfVMs en door de gebruiker maxNumberofVMs gedefinieerde variabelen zijn.

De volgende tabellen tonen de variabelen read-write en read-only die zijn gedefinieerd door de Batch-service.

Door de lees-schrijfservice gedefinieerde variabelen

U kunt de waarden van deze door de service gedefinieerde variabelen op halen en instellen om het aantal rekenknooppunten in een pool te beheren.

Alleen-lezen service-gedefinieerde variabelen

U kunt de waarde van deze door de service gedefinieerde variabelen krijgen om aanpassingen aan te brengen die zijn gebaseerd op metrische gegevens van de Batch-service.

Typen

Formules voor automatisch schalen ondersteunen de volgende typen:

• double
• doubleVec
• doubleVecList
• tekenreeks
• timestamp: een samengestelde structuur die de volgende leden bevat:
  • jaar
  • maand (1-12)
  • dag (1-31)
  • weekdag (in de notatie van getal; bijvoorbeeld 1 voor maandag)
  • uur (in getalnotatie van 24 uur; 13 betekent bijvoorbeeld 1 PM)
  • minuut (00-59)
  • seconde (00-59)
• timeinterval
  • TimeInterval_Zero
  • TimeInterval_100ns
  • TimeInterval_Microsecond
  • TimeInterval_Millisecond
  • TimeInterval_Second
  • TimeInterval_Minute
  • TimeInterval_Hour
  • TimeInterval_Day
  • TimeInterval_Week
  • TimeInterval_Year

Operations

Deze bewerkingen zijn toegestaan voor de typen die in de vorige sectie worden vermeld.

Wanneer u een dubbel test met een ternaire operator ( double ? statement1 : statement2 ), is nonzero true en nul onwaar.

Functions

U kunt deze vooraf gedefinieerde functies gebruiken bij het definiëren van een formule voor automatisch schalen.

Sommige van de functies die in de vorige tabel worden beschreven, kunnen een lijst als argument accepteren. De door komma's gescheiden lijst is een combinatie van double en doubleVec. Bijvoorbeeld:

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

De waarde doubleVecList wordt vóór de evaluatie geconverteerd naar één doubleVec. Als u bijvoorbeeld v = [1,2,3] aanroept, is aanroepen avg(v) gelijk aan het aanroepen avg(1,2,3) van . avg(v, 7)Aanroepen is gelijk aan het aanroepen van avg(1,2,3,7) .

Metrische gegevens

U kunt zowel metrische gegevens voor resources als taken gebruiken bij het definiëren van een formule. U past het doelaantal toegewezen knooppunten in de pool aan op basis van de metrische gegevens die u verkrijgt en evalueert. Zie de sectie Variabelen hierboven voor meer informatie over elk metrisch gegeven.

Voorbeeldgegevens verkrijgen

De kernbewerking van een formule voor automatisch schalen is het verkrijgen van metrische gegevens van taken en resources (voorbeelden) en vervolgens de poolgrootte aanpassen op basis van die gegevens. Daarom is het belangrijk om een duidelijk inzicht te hebben in de manier waarop formules voor automatisch schalen communiceren met voorbeelden.

Methoden

Formules voor automatisch schalen worden gebruikt voor voorbeelden van metrische gegevens die worden geleverd door de Batch-service. Met een formule wordt de poolgrootte groter of kleiner op basis van de waarden die worden ontvangen. Door de service gedefinieerde variabelen zijn objecten die methoden bieden voor toegang tot gegevens die aan dat object zijn gekoppeld. De volgende expressie toont bijvoorbeeld een aanvraag om de laatste vijf minuten cpu-gebruik op te halen:

$CPUPercent.GetSample(TimeInterval_Minute * 5)

De volgende methoden kunnen worden gebruikt voor het verkrijgen van voorbeeldgegevens over door de service gedefinieerde variabelen.

Voorbeelden

De Batch-service neemt regelmatig voorbeelden van metrische gegevens voor taken en resources en maakt deze beschikbaar voor uw formules voor automatisch schalen. Deze voorbeelden worden elke 30 seconden vastgelegd door de Batch-service. Er is echter meestal een vertraging tussen het moment waarop deze voorbeelden zijn vastgelegd en wanneer ze beschikbaar worden gesteld voor (en kunnen worden gelezen door) uw formules voor automatisch schalen. Bovendien kunnen voorbeelden niet worden vastgelegd voor een bepaald interval vanwege factoren zoals netwerk- of andere infrastructuurproblemen.

Voorbeeldpercentage

Wanneer wordt doorgegeven aan de methode of de methode wordt aangeroepen, verwijst percentage naar een vergelijking tussen het totale aantal voorbeelden dat door de Batch-service wordt vastgelegd en het aantal voorbeelden dat beschikbaar is voor uw formule voor automatisch samplePercent GetSample() GetSamplePercent() schalen.

Laten we eens kijken naar een periode van 10 minuten als voorbeeld. Omdat voorbeelden elke 30 seconden binnen die periode van 10 minuten worden vastgelegd, zou het maximum aantal steekproeven dat door Batch wordt vastgelegd, 20 steekproeven (2 per minuut) zijn. Vanwege de inherente latentie van het rapportagemechanisme en andere problemen binnen Azure zijn er echter mogelijk slechts 15 voorbeelden beschikbaar voor uw formule voor automatisch schalen om te lezen. Voor die periode van 10 minuten is bijvoorbeeld slechts 75% van het totale aantal vastgelegde steekproeven beschikbaar voor uw formule.

GetSample() en voorbeeldbereiken

Uw formules voor automatisch schalen worden groter en kleiner door knooppunten toe te voegen of te verwijderen. Omdat knooppunten u geld kosten, moet u ervoor zorgen dat uw formules een intelligente analysemethode gebruiken die is gebaseerd op voldoende gegevens. U wordt aangeraden een trending-type-analyse in uw formules te gebruiken. Dit type groeit en verkleint uw pools op basis van een reeks verzamelde voorbeelden.

Gebruik om dit te doen om GetSample(interval look-back start, interval look-back end) een vector van steekproeven te retourneren:

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

Wanneer de bovenstaande regel wordt geëvalueerd door Batch, retourneert deze een reeks voorbeelden als een vector van waarden. Bijvoorbeeld:

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

Zodra u de vector van voorbeelden hebt verzameld, kunt u functies zoals , en gebruiken om zinvolle waarden af te leiden min() max() uit het verzamelde avg() bereik.

Voor extra beveiliging kunt u forceer dat een formule-evaluatie mislukt als er minder dan een bepaald voorbeeldpercentage beschikbaar is voor een bepaalde periode. Wanneer u een formule-evaluatie forceren mislukt, instrueert u Batch om de verdere evaluatie van de formule te stoppen als het opgegeven percentage van de voorbeelden niet beschikbaar is. In dit geval wordt er geen wijziging aangebracht in de poolgrootte. Als u een vereist percentage voorbeelden wilt opgeven om de evaluatie te laten slagen, geeft u dit op als de derde parameter voor GetSample() . Hier wordt een vereiste van 75 procent van de voorbeelden opgegeven:

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

Omdat er een vertraging in de beschikbaarheid van het voorbeeld kan zijn, moet u altijd een tijdsbereik opgeven met een begintijd voor terugkijken die ouder is dan één minuut. Het duurt ongeveer één minuut voor voorbeelden zijn doorgegeven via het systeem, zodat voorbeelden in het bereik (0 * TimeInterval_Second, 60 * TimeInterval_Second) mogelijk niet beschikbaar zijn. Ook hier kunt u de parameter percentage van gebruiken om GetSample() een bepaald vereiste steekproefpercentage af te dwingen.

Een formule voor automatisch schalen schrijven

U bouwt een formule voor automatisch schalen door instructies te maken die gebruikmaken van de bovenstaande onderdelen en deze instructies vervolgens combineren tot een volledige formule. In deze sectie maken we een voorbeeldformule voor automatische schaalaanpassing die beslissingen voor schaalaanpassing in de echte wereld kan uitvoeren en aanpassingen kan aanbrengen.

Eerst gaan we de vereisten voor onze nieuwe formule voor automatisch schalen definiëren. De formule moet:

• Verhoog het doelaantal toegewezen rekenknooppunten in een pool als het CPU-gebruik hoog is.
• Verminder het doelaantal toegewezen rekenknooppunten in een pool wanneer het CPU-gebruik laag is.
• Beperk altijd het maximum aantal toegewezen knooppunten tot 400.
• Wanneer u het aantal knooppunten vermindert, verwijdert u geen knooppunten waarop taken worden uitgevoerd; Wacht zo nodig totdat taken zijn voltooid voordat u knooppunten verwijdert.

De eerste instructie in onze formule verhoogt het aantal knooppunten tijdens hoog CPU-gebruik. We definiëren een instructie die een door de gebruiker gedefinieerde variabele ( ) vult met een waarde die 110 procent is van het huidige doelaantal toegewezen knooppunten, maar alleen als het minimale gemiddelde CPU-gebruik in de afgelopen 10 minuten hoger is dan $totalDedicatedNodes 70 procent. Anders wordt de waarde gebruikt voor het huidige aantal toegewezen knooppunten.

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

Om het aantal toegewezen knooppunten te verlagen tijdens een laag CPU-gebruik, stelt de volgende instructie in onze formule dezelfde variabele in op 90 procent van het huidige doelaantal toegewezen knooppunten, als het gemiddelde CPU-gebruik in de afgelopen 60 minuten lager is dan $totalDedicatedNodes 20 procent. Anders wordt de huidige waarde van gebruikt $totalDedicatedNodes die we in de bovenstaande instructie hebben ingevuld.

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

Nu beperken we het doelaantal toegewezen rekenknooppunten tot maximaal 400.

$TargetDedicatedNodes = min(400, $totalDedicatedNodes)

Ten slotte zorgen we ervoor dat knooppunten pas worden verwijderd als hun taken zijn voltooid.

$NodeDeallocationOption = taskcompletion;

Dit is de volledige formule:

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

Interval voor automatisch schalen

De Batch-service past standaard elke 15 minuten de grootte van een pool aan op basis van de formule voor automatisch schalen. Dit interval kan worden geconfigureerd met behulp van de volgende pooleigenschappen:

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

Het minimale interval is vijf minuten en het maximum is 168 uur. Als een interval buiten dit bereik is opgegeven, retourneert de Batch-service de fout Bad Request (400).

Een pool voor automatisch schalen maken met Batch-SDK's

Automatisch schalen van pool kan worden geconfigureerd met behulp van een van de Batch SDK's,de Batch REST API Batch PowerShell-cmdletsen de Batch CLI. In deze sectie ziet u voorbeelden voor zowel .NET als Python.

.NET

Als u een pool wilt maken met automatisch schalen ingeschakeld in .NET, volgt u deze stappen:

1. Maak de pool met BatchClient.PoolOperations.CreatePool.
2. Stel de eigenschap CloudPool.AutoScaleEnabled in op true .
3. Stel de eigenschap CloudPool.AutoScaleFormula in met uw formule voor automatisch schalen.
4. (Optioneel) Stel de eigenschap CloudPool.AutoScaleEvaluationInterval in (de standaardwaarde is 15 minuten).
5. Commit the pool with CloudPool.Commit or CommitAsync.

In het volgende voorbeeld wordt een pool met automatisch schalen gemaakt in .NET. De formule voor automatisch schalen van de pool stelt het doelaantal toegewezen knooppunten op maandagen in op 5 en op 1 op elke andere dag van de week. Het interval voor automatisch schalen is ingesteld op 30 minuten. In dit en de andere C#-codefragmenten in dit artikel is een correct initialiseerde instantie myBatchClient van de BatchClient-klasse.

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();

Python

Voor automatisch schalen ingeschakelde pool maken met de Python-SDK:

1. Maak een pool en geef de configuratie op.
2. Voeg de pool toe aan de serviceclient.
3. Schakel automatisch schalen in voor de pool met een formule die u schrijft.

In het volgende voorbeeld worden deze stappen geïllustreerd.

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

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

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

Automatisch schalen inschakelen voor een bestaande pool

Elke Batch-SDK biedt een manier om automatisch schalen mogelijk te maken. Bijvoorbeeld:

• BatchClient.PoolOperations.EnableAutoScaleAsync (Batch .NET)
• Automatisch schalen inschakelen voor een pool (REST API)

Wanneer u automatisch schalen in een bestaande pool inschakelen, moet u rekening houden met het volgende:

• Als automatisch schalen momenteel is uitgeschakeld voor de groep, moet u een geldige formule voor automatisch schalen opgeven wanneer u de aanvraag indient. U kunt eventueel een automatisch schaalinterval opgeven. Als u geen interval opgeeft, wordt de standaardwaarde 15 minuten gebruikt.
• Als automatische schalen momenteel is ingeschakeld voor de pool, kunt u een nieuwe formule, een nieuw interval of beide opgeven. U moet ten minste één van deze eigenschappen opgeven.
  • Als u een nieuw automatisch schaalinterval opgeeft, wordt de bestaande planning gestopt en wordt een nieuwe planning gestart. De begintijd van het nieuwe schema is het tijdstip waarop de aanvraag voor het inschakelen van automatisch schalen is uitgegeven.
  • Als u de formule of het interval voor automatisch schalen weglaten, blijft de Batch-service de huidige waarde van die instelling gebruiken.

In dit C#-voorbeeld wordt de Batch .NET-bibliotheek gebruikt om automatisch schalen in te stellen voor een bestaande pool.

// 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);

Een formule voor automatisch schalen bijwerken

Als u de formule voor een bestaande pool met automatische schaalbewerking wilt bijwerken, roept u de bewerking aan om automatisch schalen opnieuw in te stellen met de nieuwe formule. Als automatisch schalen bijvoorbeeld al is ingeschakeld wanneer de volgende .NET-code wordt uitgevoerd, wordt de formule voor automatisch schalen vervangen door de myexistingpool inhoud van myNewFormula .

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

Het interval voor automatisch schalen bijwerken

Als u het evaluatie-interval voor automatisch schalen van een bestaande pool met automatische schaalbewerking wilt bijwerken, roept u de bewerking aan om automatisch schalen opnieuw in te stellen met het nieuwe interval. Als u bijvoorbeeld het evaluatie-interval voor automatisch schalen wilt instellen op 60 minuten voor een pool die al automatisch wordt geschaald in .NET:

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

Een formule voor automatisch schalen evalueren

U kunt een formule evalueren voordat u deze op een pool gaat toepassen. Hiermee kunt u de resultaten van de formule testen voordat u deze in productie gaat nemen.

Voordat u een formule voor automatisch schalen kunt evalueren, moet u automatisch schalen inschakelen voor de pool met een geldige formule, zoals de formule van één $TargetDedicatedNodes = 0 regel. Gebruik vervolgens een van de volgende opties om de formule te evalueren die u wilt testen:

• BatchClient.PoolOperations.EvaluateAutoScale of EvaluateAutoScaleAsync

  Voor deze Batch .NET-methoden is de id van een bestaande pool en een tekenreeks met de formule voor automatisch schalen vereist om te evalueren.

• Een formule voor automatisch schalen evalueren

  Geef in REST API aanvraag de pool-id op in de URI en de formule voor automatisch schalen in het element autoScaleFormula van de aanvraag body. Het antwoord van de bewerking bevat foutinformatie die mogelijk betrekking heeft op de formule.

In dit Batch .NET-voorbeeld wordt een formule voor automatisch schalen geëvalueerd. Als de pool nog geen gebruik maakt van automatisch schalen, moet u deze eerst inschakelen.

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

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

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

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

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

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

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

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

Een geslaagde evaluatie van de formule die in dit codefragment wordt weergegeven, levert resultaten op die vergelijkbaar zijn met:

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

Informatie over automatisch schalen

Om ervoor te zorgen dat uw formule werkt zoals verwacht, raden we u aan om regelmatig de resultaten te controleren van de automatisch schalen die Batch voor uw pool uitvoert. U doet dit door een verwijzing naar de pool op te halen (of te vernieuwen) en vervolgens de eigenschappen van de laatste keer automatisch schalen te bekijken.

In Batch .NET heeft de eigenschap CloudPool.AutoScaleRun verschillende eigenschappen die informatie bieden over de meest recente automatische schaalrun die op de pool wordt uitgevoerd:

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

In de REST API retourneert de aanvraag Voor informatie over een pool informatie over de pool, waaronder de meest recente gegevens over de automatische schalingsuitslag in de eigenschap autoScaleRun.

In het volgende C#-voorbeeld wordt de Batch .NET-bibliotheek gebruikt om informatie af te drukken over de laatste automatische schalen die in de pool myPool is uitgevoerd.

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);

Voorbeelduitvoer uit het voorgaande voorbeeld:

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:

Geschiedenis van automatisch schalen op basis van gebeurtenissen voor automatisch schalen van pool

U kunt ook de geschiedenis van automatisch schalen controleren door een query uit te voeren op PoolAutoScaleEvent. Deze gebeurtenis wordt door Batch Service uitgevoerd om vast te maken of er formules automatisch worden geëvalueerd en uitgevoerd. Dit kan handig zijn om potentiële problemen op te lossen.

Voorbeeldgebeurtenis voor PoolAutoScaleEvent:

{
    "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": []
    }
}

Voorbeeldformules voor automatisch schalen

Laten we eens kijken naar een aantal formules die verschillende manieren laten zien om de hoeveelheid rekenbronnen in een pool aan te passen.

Voorbeeld 1: Aanpassing op basis van tijd

Stel dat u de poolgrootte wilt aanpassen op basis van de dag van de week en het tijdstip van de dag. In dit voorbeeld ziet u hoe u het aantal knooppunten in de pool dienovereenkomstig verhoogt of verlaagt.

De formule verkrijgt eerst de huidige tijd. Als het een doordeweekse dag (1-5) en binnen werkuren (8:00 tot 18:00 uur) is, wordt de grootte van de doelgroep ingesteld op 20 knooppunten. Anders wordt deze ingesteld op 10 knooppunten.

$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 kan worden aangepast aan uw lokale tijdzone door toe te time() voegen aan het product van en uw TimeZoneInterval_Hour UTC-offset. Gebruik bijvoorbeeld voor $curTime = time() + (-6 * TimeInterval_Hour); Mountain Daylight Time (MDT). Houd er rekening mee dat de offset moet worden aangepast aan het begin en einde van de zomertijd (indien van toepassing).

Voorbeeld 2: Aanpassing op basis van taken

In dit C#-voorbeeld wordt de poolgrootte aangepast op basis van het aantal taken in de wachtrij. We hebben zowel opmerkingen als regelbreaks opgenomen in de formulereeksen.

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

Voorbeeld 3: Accounting voor parallelle taken

In dit C#-voorbeeld wordt de poolgrootte aangepast op basis van het aantal taken. Deze formule houdt ook rekening met de waarde TaskSlotsPerNode die is ingesteld voor de pool. Deze aanpak is handig in situaties waarin parallelle taakuitvoering is ingeschakeld in uw pool.

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

Voorbeeld 4: Een initiële poolgrootte instellen

In dit voorbeeld ziet u een C#-voorbeeld met een formule voor automatisch schalen die de poolgrootte in een eerste periode in stelt op een opgegeven aantal knooppunten. Daarna wordt de poolgrootte aangepast op basis van het aantal actieve en actieve taken.

Deze formule doet met name het volgende:

• Hiermee stelt u de grootte van de initiële pool in op vier knooppunten.
• De grootte van de pool wordt niet binnen de eerste tien minuten van de levenscyclus van de pool aangepast.
• Na 10 minuten verkrijgt de maximale waarde van het aantal actieve en actieve taken binnen de afgelopen 60 minuten.
  • Als beide waarden 0 zijn (wat aangeeft dat er in de afgelopen 60 minuten geen taken werden uitgevoerd of actief waren), wordt de poolgrootte ingesteld op 0.
  • Als een van beide waarden groter is dan nul, wordt er geen wijziging aangebracht.

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);

Volgende stappen

• Meer informatie over het gelijktijdig uitvoeren van meerdere taken op de rekenknooppunten in uw pool. Naast automatische schalen kan dit helpen om de duur van de taak voor sommige workloads te verlagen, waardoor u geld bespaart.
• Meer informatie over het efficiënt uitvoeren Azure Batch de service voor verdere efficiëntie.