Skapa aktivitetsberoenden för att köra aktiviteter som är beroende av andra uppgifter

Med Batch-aktivitetsberoenden skapar du aktiviteter som är schemalagda för körning på beräkningsnoder när en eller flera överordnade aktiviteter har slutförts. Du kan till exempel skapa ett jobb som renderar varje bildruta i en 3D-film med separata, parallella uppgifter. Den sista uppgiften sammanfogar de renderade bildrutorna i den fullständiga filmen först när alla bildrutor har renderats. Den slutliga aktiviteten är med andra ord beroende av de tidigare överordnade aktiviteterna.

Några scenarier där aktivitetsberoenden är användbara är:

• MapReduce-arbetsbelastningar i molnet.
• Jobb vars databehandlingsuppgifter kan uttryckas som en riktad acyklisk graf (DAG).
• Förrenderings- och efterrenderingsprocesser, där varje uppgift måste slutföras innan nästa uppgift kan börja.
• Alla andra jobb där underordnade aktiviteter är beroende av utdata från överordnade aktiviteter.

Som standard schemaläggs beroende aktiviteter endast för körning när den överordnade aktiviteten har slutförts. Du kan också ange en beroendeåtgärd för att åsidosätta standardbeteendet och köra den beroende aktiviteten även om den överordnade aktiviteten misslyckas.

I den här artikeln diskuterar vi hur du konfigurerar aktivitetsberoenden med hjälp av Batch .NET-biblioteket . Vi visar först hur du aktiverar aktivitetsberoende för dina jobb och visar sedan hur du konfigurerar en uppgift med beroenden. Vi beskriver också hur du anger en beroendeåtgärd för att köra beroende uppgifter om den överordnade åtgärden misslyckas. Slutligen diskuterar vi de beroendescenarier som Batch stöder.

Aktivera aktivitetsberoenden

Om du vill använda aktivitetsberoenden i Batch-programmet måste du först konfigurera jobbet så att det använder aktivitetsberoenden. I Batch .NET aktiverar du det på ditt CloudJob genom att ange egenskapen UsesTaskDependencies till true:

CloudJob unboundJob = batchClient.JobOperations.CreateJob( "job001",
    new PoolInformation { PoolId = "pool001" });

// IMPORTANT: This is REQUIRED for using task dependencies.
unboundJob.UsesTaskDependencies = true;

I föregående kodfragment är "batchClient" en instans av klassen BatchClient .

Skapa beroende uppgifter

Om du vill skapa en aktivitet som är beroende av slutförandet av en eller flera överordnade aktiviteter kan du ange att aktiviteten "är beroende av" de andra aktiviteterna. I Batch .NET konfigurerar du egenskapen CloudTask.DependsOn med en instans av klassen TaskDependencies :

// Task 'Flowers' depends on completion of both 'Rain' and 'Sun'
// before it is run.
new CloudTask("Flowers", "cmd.exe /c echo Flowers")
{
    DependsOn = TaskDependencies.OnIds("Rain", "Sun")
},

Det här kodfragmentet skapar en beroende uppgift med aktivitets-ID:t "Blommor". Uppgiften "Blommor" beror på uppgifterna "Rain" och "Sun". Aktiviteten "Blommor" schemaläggs att köras på en beräkningsnod först efter att aktiviteterna "Rain" och "Sun" har slutförts.

Kommentar

Som standard anses en aktivitet vara slutförd när den är i slutfört tillstånd och dess slutkod är 0. I Batch .NET innebär det att egenskapsvärdet CloudTask.State är Completed och egenskapen TaskExecutionInformation.ExitCode för CloudTask är 0. Information om hur du ändrar detta finns i avsnittet Beroendeåtgärder .

Beroendescenarier

Det finns tre grundläggande scenarier för aktivitetsberoende som du kan använda i Azure Batch: ett-till-en, ett-till-många- och aktivitets-ID-intervallberoende. Dessa tre scenarier kan kombineras för att ge ett fjärde scenario: många-till-många.

Scenario	Exempel	Illustration
En-till-en	taskB är beroende av taskA taskB schemaläggs inte för körning förrän taskA har slutförts
En-till-många	taskC är beroende av att både taskA och taskB taskC inte schemaläggs för körning förrän både taskA och taskB har slutförts
Aktivitets-ID-intervall	taskD beror på att ett antal aktiviteter som uppgiftSD inte schemaläggs för körning förrän aktiviteterna med ID 1 till 10 har slutförts

Dricks

Du kan skapa många-till-många-relationer , till exempel var uppgifter C, D, E och F var och en är beroende av uppgifter A och B. Detta är användbart, till exempel i parallelliserade förbearbetningsscenarier där dina underordnade uppgifter är beroende av utdata från flera överordnade aktiviteter.

I exemplen i det här avsnittet körs en beroende aktivitet först när de överordnade aktiviteterna har slutförts. Det här beteendet är standardbeteendet för en beroende uppgift. Du kan köra en beroende aktivitet när en överordnad aktivitet misslyckas genom att ange en beroendeåtgärd för att åsidosätta standardbeteendet.

En-till-en

I en en-till-en-relation beror en aktivitet på att en överordnad aktivitet har slutförts. Om du vill skapa beroendet anger du ett enda aktivitets-ID till den statiska metoden TaskDependencies.OnId när du fyller i egenskapen CloudTask.DependsOn .

// Task 'taskA' doesn't depend on any other tasks
new CloudTask("taskA", "cmd.exe /c echo taskA"),

// Task 'taskB' depends on completion of task 'taskA'
new CloudTask("taskB", "cmd.exe /c echo taskB")
{
    DependsOn = TaskDependencies.OnId("taskA")
},

En till flera

I en en-till-många-relation beror en aktivitet på slutförandet av flera överordnade aktiviteter. Skapa beroendet genom att ange en samling specifika aktivitets-ID:t till den statiska metoden TaskDependencies.OnIds när du fyller i egenskapen CloudTask.DependsOn .

// 'Rain' and 'Sun' don't depend on any other tasks
new CloudTask("Rain", "cmd.exe /c echo Rain"),
new CloudTask("Sun", "cmd.exe /c echo Sun"),

// Task 'Flowers' depends on completion of both 'Rain' and 'Sun'
// before it is run.
new CloudTask("Flowers", "cmd.exe /c echo Flowers")
{
    DependsOn = TaskDependencies.OnIds("Rain", "Sun")
},

Viktigt!

Det går inte att skapa beroende aktivitet om den kombinerade längden på överordnade aktivitets-ID:er är större än 64 000 tecken. Om du vill ange ett stort antal överordnade aktiviteter bör du överväga att använda ett aktivitets-ID-intervall i stället.

Aktivitets-ID-intervall

I ett beroende av ett intervall med överordnade aktiviteter beror en aktivitet på slutförandet av uppgifter vars ID ligger inom ett intervall som du anger.

Om du vill skapa beroendet anger du det första och sista aktivitets-ID:t i intervallet till den statiska metoden TaskDependencies.OnIdRange när du fyller i egenskapen CloudTask.DependsOn .

Viktigt!

När du använder aktivitets-ID-intervall för dina beroenden väljs endast uppgifter med ID:t som representerar heltalsvärden av intervallet. Till exempel väljer intervallet 1..10 uppgifter 3 och 7, men inte 5flamingoes.

Inledande nollor är inte signifikanta när du utvärderar intervallberoenden, så aktiviteter med strängidentifierare 4, 04 och 004 kommer alla att ligga inom intervallet, eftersom de alla kommer att behandlas som uppgift 4, kommer den första som ska slutföras att uppfylla beroendet.

För att den beroende aktiviteten ska kunna köras måste varje aktivitet i intervallet uppfylla beroendet, antingen genom att slutföras eller genom att slutföras med ett fel som mappas till en beroendeåtgärd inställd på Tillfredsställ.

// Tasks 1, 2, and 3 don't depend on any other tasks. Because
// we will be using them for a task range dependency, we must
// specify string representations of integers as their ids.
new CloudTask("1", "cmd.exe /c echo 1"),
new CloudTask("2", "cmd.exe /c echo 2"),
new CloudTask("3", "cmd.exe /c echo 3"),

// Task 4 depends on a range of tasks, 1 through 3
new CloudTask("4", "cmd.exe /c echo 4")
{
    // To use a range of tasks, their ids must be integer values.
    // Note that we pass integers as parameters to TaskIdRange,
    // but their ids (above) are string representations of the ids.
    DependsOn = TaskDependencies.OnIdRange(1, 3)
},

Beroendeåtgärder

Som standard körs en beroende aktivitet eller uppsättning aktiviteter först när en överordnad aktivitet har slutförts. I vissa scenarier kanske du vill köra beroende aktiviteter även om den överordnade aktiviteten misslyckas. Du kan åsidosätta standardbeteendet genom att ange en beroendeåtgärd som anger om en beroende aktivitet är berättigad att köras.

Anta till exempel att en beroende aktivitet väntar på data från slutförandet av den överordnade aktiviteten. Om den överordnade aktiviteten misslyckas kan den beroende aktiviteten fortfarande köras med äldre data. I det här fallet kan en beroendeåtgärd ange att den beroende aktiviteten är berättigad att köras trots att den överordnade aktiviteten har misslyckats.

En beroendeåtgärd baseras på ett avslutningsvillkor för den överordnade aktiviteten. Du kan ange en beroendeåtgärd för något av följande avslutsvillkor:

• När ett förbearbetningsfel inträffar.
• När ett filuppladdningsfel inträffar. Om uppgiften avslutas med en slutkod som har angetts via exitCodes eller exitCodeRanges och sedan stöter på ett filuppladdningsfel har åtgärden som anges av slutkoden företräde.
• När aktiviteten avslutas med en slutkod som definierats av egenskapen ExitCodes .
• När aktiviteten avslutas med en slutkod som ligger inom ett intervall som anges av egenskapen ExitCodeRanges .
• Standardfallet, om aktiviteten avslutas med en slutkod som inte definierats av ExitCodes eller ExitCodeRanges, eller om aktiviteten avslutas med ett förbearbetningsfel och egenskapen PreProcessingError inte har angetts, eller om aktiviteten misslyckas med ett filuppladdningsfel och egenskapen FileUploadError inte har angetts.

För .NET definieras dessa villkor som egenskaper för klassen ExitConditions .

Om du vill ange en beroendeåtgärd anger du egenskapen ExitOptions.DependencyAction för avslutningsvillkoret till något av följande:

• Uppfyller: Anger att beroende aktiviteter är berättigade att köras om den överordnade aktiviteten avslutas med ett angivet fel.
• Blockera: Anger att beroende aktiviteter inte är berättigade att köras.

Standardinställningen för egenskapen DependencyAction är Tillfredsställ för slutkod 0 och Blockera för alla andra avslutningsvillkor.

Följande kodfragment anger egenskapen DependencyAction för en överordnad uppgift. Om den överordnade aktiviteten avslutas med ett förbearbetningsfel eller med de angivna felkoderna blockeras den beroende aktiviteten. Om den överordnade aktiviteten avslutas med något annat fel som inte är noll är den beroende aktiviteten berättigad att köras.

// Task A is the parent task.
new CloudTask("A", "cmd.exe /c echo A")
{
    // Specify exit conditions for task A and their dependency actions.
    ExitConditions = new ExitConditions
    {
        // If task A exits with a pre-processing error, block any downstream tasks (in this example, task B).
        PreProcessingError = new ExitOptions
        {
            DependencyAction = DependencyAction.Block
        },
        // If task A exits with the specified error codes, block any downstream tasks (in this example, task B).
        ExitCodes = new List<ExitCodeMapping>
        {
            new ExitCodeMapping(10, new ExitOptions() { DependencyAction = DependencyAction.Block }),
            new ExitCodeMapping(20, new ExitOptions() { DependencyAction = DependencyAction.Block })
        },
        // If task A succeeds or fails with any other error, any downstream tasks become eligible to run 
        // (in this example, task B).
        Default = new ExitOptions
        {
            DependencyAction = DependencyAction.Satisfy
        }
    }
},
// Task B depends on task A. Whether it becomes eligible to run depends on how task A exits.
new CloudTask("B", "cmd.exe /c echo B")
{
    DependsOn = TaskDependencies.OnId("A")
},

Kodexempel

Exempelprojektet TaskDependencies på GitHub visar:

• Så här aktiverar du aktivitetsberoende för ett jobb.
• Så här skapar du uppgifter som är beroende av andra uppgifter.
• Så här kör du dessa uppgifter i en pool med beräkningsnoder.

Nästa steg

• Lär dig mer om programpaketfunktionen i Batch, som ger ett enkelt sätt att distribuera och version de program som dina uppgifter kör på beräkningsnoder.
• Läs mer om felkontroll för jobb och uppgifter.