Taken gelijktijdig uitvoeren om het gebruik van Batch-rekenknooppunten te maximaliseren

  • Artikel

U kunt het resourcegebruik op een kleiner aantal rekenknooppunten in uw pool maximaliseren door meer dan één taak tegelijk op elk knooppunt uit te voeren.

Hoewel sommige scenario's het beste werken met alle resources van een knooppunt die zijn toegewezen aan één taak, kunnen bepaalde workloads kortere taaktijden en lagere kosten met zich meebrengen wanneer meerdere taken deze resources delen. Denk eens na over de volgende scenario's:

  • Gegevensoverdracht minimaliseren voor taken die gegevens kunnen delen. U kunt de kosten voor gegevensoverdracht aanzienlijk verlagen door gedeelde gegevens te kopiëren naar een kleiner aantal knooppunten en vervolgens taken parallel uit te voeren op elk knooppunt. Deze strategie is met name van toepassing als de gegevens die naar elk knooppunt moeten worden gekopieerd, moeten worden overgedragen tussen geografische regio's.
  • Maximaliseer het geheugengebruik voor taken die een grote hoeveelheid geheugen vereisen, maar alleen tijdens korte perioden en op variabele tijdstippen tijdens de uitvoering. U kunt minder, maar grotere rekenknooppunten met meer geheugen gebruiken om dergelijke pieken efficiënt te verwerken. Deze knooppunten hebben meerdere taken die parallel op elk knooppunt worden uitgevoerd, maar elke taak kan op verschillende tijdstippen gebruikmaken van het overvloedige geheugen van de knooppunten.
  • Limieten voor knooppuntnummers beperken wanneer communicatie tussen knooppunten binnen een pool is vereist. Momenteel zijn pools die zijn geconfigureerd voor communicatie tussen knooppunten beperkt tot 50 rekenknooppunten. Als elk knooppunt in een dergelijke pool taken parallel kan uitvoeren, kan een groter aantal taken tegelijkertijd worden uitgevoerd.
  • Repliceer een on-premises rekencluster, bijvoorbeeld wanneer u voor het eerst een rekenomgeving naar Azure verplaatst. Als uw huidige on-premises oplossing meerdere taken per rekenknooppunt uitvoert, kunt u het maximum aantal knooppunttaken verhogen om die configuratie beter te weerspiegelen.

Voorbeeldscenario

Stel bijvoorbeeld een taaktoepassing met CPU- en geheugenvereisten, zodat Standard_D1 knooppunten voldoende zijn. Als u de taak echter binnen de vereiste tijd wilt voltooien, zijn er 1000 van deze knooppunten nodig.

In plaats van Standard_D1 knooppunten met één CPU-kern te gebruiken, kunt u Standard_D14 knooppunten met elk 16 kernen gebruiken en parallelle taakuitvoering inschakelen. U kunt mogelijk 16 keer minder knooppunten gebruiken in plaats van 1.000 knooppunten, er zijn er slechts 63 vereist. Als voor elk knooppunt grote toepassingsbestanden of referentiegegevens nodig zijn, worden de duur en efficiëntie van de taak verbeterd, omdat de gegevens naar slechts 63 knooppunten worden gekopieerd.

Parallelle taakuitvoering inschakelen

U configureert rekenknooppunten voor parallelle taakuitvoering op groepsniveau. Stel met de Batch .NET-bibliotheek de eigenschap CloudPool.TaskSlotsPerNode in wanneer u een pool maakt. Als u de Batch REST API gebruikt, stelt u het element taskSlotsPerNode in de aanvraagbody in tijdens het maken van de pool.

Notitie

U kunt het element en de taskSlotsPerNode eigenschap TaskSlotsPerNode alleen instellen tijdens het maken van de pool. Ze kunnen niet worden gewijzigd nadat er al een pool is gemaakt.

met Azure Batch kunt u taaksleuven per knooppunt instellen tot (4x) het aantal knooppuntkernen. Als de pool bijvoorbeeld is geconfigureerd met knooppunten met de grootte 'Groot' (vier kernen), taskSlotsPerNode kan worden ingesteld op 16. U kunt echter niet meer dan 256 taaksleuven per knooppunt hebben, ongeacht hoeveel kernen het knooppunt heeft. Zie Grootten voor Cloud Services (klassiek) voor meer informatie over het aantal kernen voor elk van de knooppuntgrootten. Zie Batch-servicequota en -limieten voor meer informatie over servicelimieten.

Tip

Zorg ervoor dat u rekening houdt met de taskSlotsPerNode waarde wanneer u een formule voor automatische schaalaanpassing voor uw pool maakt. Een formule die bijvoorbeeld wordt geëvalueerd $RunningTasks , kan aanzienlijk worden beïnvloed door een toename van taken per knooppunt. Zie Een automatische formule maken voor het schalen van rekenknooppunten in een Batch-pool voor meer informatie.

Taakdistributie opgeven

Wanneer u gelijktijdige taken inschakelt, is het belangrijk om op te geven hoe de taken moeten worden verdeeld over de knooppunten in de pool.

Met behulp van de eigenschap CloudPool.TaskSchedulingPolicy kunt u opgeven dat taken gelijkmatig moeten worden toegewezen over alle knooppunten in de pool ('spreiden'). U kunt ook opgeven dat er zoveel mogelijk taken aan elk knooppunt moeten worden toegewezen voordat taken worden toegewezen aan een ander knooppunt in de pool ('packing').

Neem bijvoorbeeld de pool van Standard_D14-knooppunten (in het vorige voorbeeld) die is geconfigureerd met de waarde 16 voor CloudPool.TaskSlotsPerNode . Als CloudPool.TaskSchedulingPolicy is geconfigureerd met een ComputeNodeFillType van Pack, wordt het gebruik van alle 16 kernen van elk knooppunt gemaximaliseerd en kan een pool voor automatisch schalen ongebruikte knooppunten (knooppunten zonder toegewezen taken) uit de pool verwijderen. Automatisch schalen minimaliseert het resourcegebruik en kan geld besparen.

Variabele sleuven per taak definiëren

Een taak kan worden gedefinieerd met de eigenschap CloudTask.RequiredSlots , waarmee wordt opgegeven hoeveel sleuven er nodig zijn om op een rekenknooppunt te worden uitgevoerd. De standaardwaarde is 1. U kunt variabele taaksites instellen als uw taken verschillende gewichten hebben die zijn gekoppeld aan hun resourcegebruik op het rekenknooppunt. Met variabele taaksleuven kan elk rekenknooppunt een redelijk aantal gelijktijdige taken uitvoeren zonder systeemresources zoals CPU of geheugen te overweldigen.

Voor een pool met eigenschap taskSlotsPerNode = 8kunt u bijvoorbeeld multi-core vereiste CPU-intensieve taken verzenden met requiredSlots = 8, terwijl andere taken kunnen worden ingesteld op requiredSlots = 1. Wanneer deze gemengde workload wordt gepland, worden de CPU-intensieve taken uitsluitend uitgevoerd op hun rekenknooppunten, terwijl andere taken gelijktijdig (maximaal acht taken tegelijk) op andere knooppunten kunnen worden uitgevoerd. De gemengde workload helpt u bij het verdelen van uw workload over rekenknooppunten en het verbeteren van de efficiëntie van het resourcegebruik.

Zorg ervoor dat u niet opgeeft dat een taak requiredSlots groter moet zijn dan die van taskSlotsPerNodede pool, anders wordt de taak nooit uitgevoerd. De Batch-service valideert dit conflict momenteel niet wanneer u taken verzendt. Het conflict wordt niet gevalideerd, omdat een taak mogelijk geen pool gebonden heeft op het moment van indienen, of omdat de taak kan worden gewijzigd in een andere groep door uit te schakelen/opnieuw in te schakelen.

Tip

Wanneer u variabele taaksleuven gebruikt, is het mogelijk dat grote taken met meer vereiste sleuven tijdelijk niet kunnen worden gepland omdat er onvoldoende sleuven beschikbaar zijn op een rekenknooppunt, zelfs als er nog niet-actieve sleuven op sommige knooppunten zijn. U kunt de taakprioriteit voor deze taken verhogen om hun kans te vergroten om te concurreren om beschikbare sites op knooppunten.

De Batch-service verzendt de TaskScheduleFailEvent wanneer het niet lukt om een taak uit te voeren en blijft de planning opnieuw uitvoeren totdat de vereiste sites beschikbaar zijn. U kunt naar die gebeurtenis luisteren om mogelijke problemen met taakplanning te detecteren en dienovereenkomstig te verhelpen.

Batch .NET-voorbeeld

De volgende Batch .NET API-codefragmenten laten zien hoe u een pool maakt met meerdere taaksleuven per knooppunt en hoe u een taak met de vereiste sleuven verzendt.

Een pool met meerdere taaksleuven per knooppunt maken

Dit codefragment toont een aanvraag voor het maken van een pool die vier knooppunten bevat, met vier taaksites die per knooppunt zijn toegestaan. Hiermee wordt een taakplanningsbeleid opgegeven dat elk knooppunt vult met taken voordat taken worden toegewezen aan een ander knooppunt in de pool.

Zie BatchClient.PoolOperations.CreatePool voor meer informatie over het toevoegen van pools met behulp van de Batch .NET API.

CloudPool pool =
    batchClient.PoolOperations.CreatePool(
        poolId: "mypool",
        targetDedicatedComputeNodes: 4
        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.TaskSlotsPerNode = 4;
pool.TaskSchedulingPolicy = new TaskSchedulingPolicy(ComputeNodeFillType.Pack);
pool.Commit();

Een taak met de vereiste sleuven maken

Met dit codefragment maakt u een taak met niet-standaard requiredSlots. Deze taak wordt uitgevoerd wanneer er voldoende vrije sleuven beschikbaar zijn op een rekenknooppunt.

CloudTask task = new CloudTask(taskId, taskCommandLine)
{
    RequiredSlots = 2
};

Rekenknooppunten weergeven met aantallen voor het uitvoeren van taken en sleuven

Met dit codefragment worden alle rekenknooppunten in de pool weergegeven en worden de aantallen voor het uitvoeren van taken en taaksleuven per knooppunt afgedrukt.

ODATADetailLevel nodeDetail = new ODATADetailLevel(selectClause: "id,runningTasksCount,runningTaskSlotsCount");
IPagedEnumerable<ComputeNode> nodes = batchClient.PoolOperations.ListComputeNodes(poolId, nodeDetail);

await nodes.ForEachAsync(node =>
{
    Console.WriteLine(node.Id + " :");
    Console.WriteLine($"RunningTasks = {node.RunningTasksCount}, RunningTaskSlots = {node.RunningTaskSlotsCount}");

}).ConfigureAwait(continueOnCapturedContext: false);

Taakaantallen voor de taak weergeven

Met dit codefragment worden taaktellingen voor de taak ophaalt, waaronder zowel taken als het aantal takenleuven per taakstatus.

TaskCountsResult result = await batchClient.JobOperations.GetJobTaskCountsAsync(jobId);

Console.WriteLine("\t\tActive\tRunning\tCompleted");
Console.WriteLine($"TaskCounts:\t{result.TaskCounts.Active}\t{result.TaskCounts.Running}\t{result.TaskCounts.Completed}");
Console.WriteLine($"TaskSlotCounts:\t{result.TaskSlotCounts.Active}\t{result.TaskSlotCounts.Running}\t{result.TaskSlotCounts.Completed}");

Batch REST-voorbeeld

De volgende Batch REST API-codefragmenten laten zien hoe u een pool maakt met meerdere taaksites per knooppunt en hoe u een taak met de vereiste sleuven verzendt.

Een pool met meerdere taaksleuven per knooppunt maken

Dit fragment toont een aanvraag voor het maken van een pool met twee grote knooppunten met een maximum van vier taken per knooppunt.

Zie Een groep toevoegen aan een account voor meer informatie over het toevoegen van pools met behulp van de REST API.

{
  "odata.metadata":"https://myaccount.myregion.batch.azure.com/$metadata#pools/@Element",
  "id":"mypool",
  "vmSize":"large",
  "virtualMachineConfiguration": {
    "imageReference": {
      "publisher": "canonical",
      "offer": "ubuntuserver",
      "sku": "20.04-lts"
    },
    "nodeAgentSKUId": "batch.node.ubuntu 20.04"
  },
  "targetDedicatedComputeNodes":2,
  "taskSlotsPerNode":4,
  "enableInterNodeCommunication":true,
}

Een taak met de vereiste sleuven maken

Dit fragment toont een aanvraag voor het toevoegen van een taak met niet-standaard .requiredSlots Deze taak wordt alleen uitgevoerd wanneer er voldoende vrije sleuven beschikbaar zijn op het rekenknooppunt.

{
  "id": "taskId",
  "commandLine": "bash -c 'echo hello'",
  "userIdentity": {
    "autoUser": {
      "scope": "task",
      "elevationLevel": "nonadmin"
    }
  },
  "requiredSLots": 2
}

Codevoorbeeld op GitHub

Het project ParallelTasks op GitHub illustreert het gebruik van de eigenschap CloudPool.TaskSlotsPerNode .

Deze C#-consoletoepassing maakt gebruik van de Batch .NET-bibliotheek om een pool te maken met een of meer rekenknooppunten. Er wordt een configureerbaar aantal taken op deze knooppunten uitgevoerd om een variabele belasting te simuleren. Uitvoer van de toepassing laat zien welke knooppunten elke taak hebben uitgevoerd. De toepassing biedt ook een samenvatting van de taakparameters en duur.

In het volgende voorbeeld ziet u het samenvattingsgedeelte van de uitvoer van twee verschillende uitvoeringen van de Voorbeeldtoepassing ParallelTasks. De taakduur die hier wordt weergegeven, omvat geen aanmaaktijd van de pool, omdat elke taak is verzonden naar een eerder gemaakte pool waarvan de rekenknooppunten op het moment van indiening de status Inactief hadden.

De eerste uitvoering van de voorbeeldtoepassing laat zien dat met één knooppunt in de pool en de standaardinstelling van één taak per knooppunt, de duur van de taak meer dan 30 minuten is.

Nodes: 1
Node size: large
Task slots per node: 1
Max slots per task: 1
Tasks: 32
Duration: 00:30:01.4638023

In de tweede uitvoering van het voorbeeld ziet u een aanzienlijke afname van de duur van de taak. Deze vermindering komt doordat de pool is geconfigureerd met vier taken per knooppunt, waardoor parallelle taakuitvoering de taak in bijna een kwart van de tijd kan voltooien.

Nodes: 1
Node size: large
Task slots per node: 4
Max slots per task: 1
Tasks: 32
Duration: 00:08:48.2423500

Volgende stappen