Erstellen von Taskabhängigkeiten zum Ausführen von Tasks, die von anderen Tasks abhängen

Mit Taskabhängigkeiten in Batch erstellen Sie Tasks, deren Ausführung auf Computeknoten erst nach dem Abschluss von mindestens einem weiteren übergeordneten Task geplant wird. Beispielsweise können Sie einen Auftrag erstellen, der jedes Einzelbild eines 3D-Films mit separaten, parallelen Tasks rendert. Der letzte Task fügt die gerenderten Einzelbilder erst dann zu einem vollständigen Film zusammen, wenn alle Einzelbilder erfolgreich gerendert wurden. Anders ausgedrückt: Der letzte Task ist von den vorherigen übergeordneten Aufgaben abhängig.

Einige Szenarios, in denen Taskabhängigkeiten nützlich sind:

• Workloads vom Typ MapReduce in der Cloud.
• Aufträge, deren Datenverarbeitungstasks als gerichteter azyklischer Graph (DAG) ausgedrückt werden können.
• Vor- und Nachrenderingprozesse, bei denen jede Aufgabe abgeschlossen werden muss, bevor die nächste Aufgabe beginnen kann.
• Alle anderen Aufträge, in denen nachgelagerte Tasks von der Ausgabe vorgelagerter Tasks abhängen.

Standardmäßig werden abhängige Tasks erst für die Ausführung eingeplant, nachdem der übergeordnete Task erfolgreich abgeschlossen wurde. Sie können optional eine Abhängigkeitsaktion bestimmen, um das Standardverhalten zu überschreiben und die abhängigen Tasks auch dann auszuführen, wenn im übergeordneten Task ein Fehler auftritt.

In diesem Artikel wird beschrieben, wie Sie Taskabhängigkeiten mit der Batch-Bibliothek für .NET konfigurieren. Zuerst zeigen wir Ihnen, wie Sie die Taskabhängigkeit in Ihren Aufträgen aktivieren, danach erläutern wir, wie Sie einen Task mit Abhängigkeiten konfigurieren. Es wird auch beschrieben, wie Sie eine Abhängigkeitsaktion bestimmen, um abhängige Tasks auszuführen, wenn im übergeordneten Task ein Fehler auftritt. Zuletzt geht es um die von Batch unterstützten Abhängigkeitsszenarien .

Aktivieren von Taskabhängigkeiten

Um Taskabhängigkeiten in der Batch-Anwendung verwenden zu können, müssen Sie zuerst den Auftrag für die Verwendung von Taskabhängigkeiten konfigurieren. Aktivieren Sie ihn in Batch .NET für Ihr CloudJob-Objekt, indem Sie die dazugehörige UsesTaskDependencies-Eigenschaft auf true festlegen:

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

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

Im vorstehenden Codeausschnitt ist „batchClient“ eine Instanz der Klasse BatchClient.

Erstellen von abhängigen Tasks

Zum Erstellen eines Tasks, der vom Abschluss eines oder mehrerer übergeordneter Tasks abhängig ist, können Sie angeben, dass der Task von anderen Tasks abhängig ist („depends on“). Konfigurieren Sie in Batch .NET die Eigenschaft CloudTask.DependsOn mit einer Instanz der TaskDependencies-Klasse:

// 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")
},

Dieser Codeausschnitt erstellt einen abhängigen Task mit der Task-ID „Flowers“. Der Task „Flowers“ ist von den Tasks „Rain“ und „Sun“ abhängig. Die Aufgabe „Blumen“ wird für die Ausführung auf einem Berechnungsknoten erst geplant, nachdem die Vorgänge „Regen“ und „Sonne“ erfolgreich abgeschlossen wurden.

Hinweis

Standardmäßig gilt eine Aufgabe als erfolgreich abgeschlossen, wenn sie sich im abgeschlossenen Zustand befindet und der Ausgangscode 0 lautet. In Batch .NET bedeutet dies, dass ein CloudTask.State-Eigenschaftswert Completed und der TaskExecutionInformation.ExitCode-Eigenschaftswert von CloudTask 0 lautet. Informationen zum Ändern dieses Verhaltens finden Sie im Abschnitt Abhängigkeitsaktionen.

Abhängigkeitsszenarien

Es gibt drei grundlegende Szenarien für Abhängigkeiten von Tasks, die Sie in Azure Batch verwenden können: 1:1, 1:n und Task-ID-Bereich. Diese drei Szenarien können Sie kombinieren, um ein viertes Szenario zu schaffen, und zwar „m:n“.

Szenario	Beispiel	Abbildung
1:1	taskB hängt von taskA ab. taskB wird erst ausgeführt, wenn taskA erfolgreich abgeschlossen wurde
1:n	taskC hängt sowohl von taskA als auch von taskB ab taskC wird nicht zur Ausführung eingeplant, bis sowohl taskA als auch taskB erfolgreich abgeschlossen werden.
Task-ID-Bereich	taskD hängt von einem Aufgabenbereich ab, der nicht für die Ausführung geplant wird, bis die Vorgänge mit IDs 1 bis 10 erfolgreich abgeschlossen wurden.

Tipp

Sie können m:n-Beziehungen erstellen, zum Beispiel in Fällen, bei denen die Aufgaben C, D, E und F jeweils von den Aufgaben A und B abhängen. Dies ist hilfreich in parallelisierten Vorverarbeitungsszenarien, in denen Ihre nachgelagerten Aufgaben von den Ergebnissen mehrerer vorgelagerter Aufgaben abhängig sind.

In den Beispielen in diesem Abschnitt wird ein abhängiger Task erst ausgeführt, nachdem die übergeordneten Tasks erfolgreich abgeschlossen wurden. Dies ist das Standardverhalten für eine abhängige Aufgabe. Sie können einen abhängigen Task ausführen, wenn im übergeordneten Task ein Fehler auftritt, indem Sie eine Abhängigkeitsaktion angeben, um das Standardverhalten zu überschreiben.

1:1

In einer 1 : 1-Beziehung hängt ein Task vom erfolgreichen Abschluss eines übergeordneten Tasks ab. Um die Abhängigkeit zu erstellen, geben Sie eine einzelne Task-ID für die statische TaskDependencies.OnId-Methode an, wenn Sie die CloudTask.DependsOn-Eigenschaft ausfüllen.

// 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")
},

1:n

In einer 1 : n-Beziehung hängt ein Task vom Abschluss mehrerer übergeordneter Tasks ab. Um die Abhängigkeit zu erstellen, geben Sie mehrere spezifische Task-IDs für die statische TaskDependencies.OnIds-Methode an, wenn Sie die CloudTask.DependsOn-Eigenschaft ausfüllen.

// '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")
},

Wichtig

Die Erstellung abhängiger Aufgaben schlägt fehl, wenn die kombinierte Länge der übergeordneten Vorgangs-IDs größer als 64.000 Zeichen ist. Um eine große Anzahl von übergeordneten Tasks anzugeben, sollten Sie stattdessen einen Task-ID-Bereich verwenden.

Task-ID-Bereich

Bei einer Abhängigkeit von einem Bereich von übergeordneten Tasks hängt ein Task vom Abschluss von Tasks ab, deren IDs innerhalb eines von Ihnen angegebenen Bereichs liegen.

Um die Abhängigkeit zu erstellen, geben Sie die IDs des ersten und letzten Tasks im Bereich für die statische TaskDependencies.OnIdRange-Methode an, wenn Sie die CloudTask.DependsOn-Eigenschaft ausfüllen.

Wichtig

Wenn Sie Aufgaben-ID-Bereiche für Ihre Abhängigkeiten verwenden, werden nur Vorgänge mit IDs, die ganze Zahlen darstellen, vom Bereich ausgewählt. Beispielsweise wählt der Bereich 1..10 Vorgänge 3 und 7, aber nicht 5flamingoesaus.

Führende Nullen sind beim Auswerten von Bereichsabhängigkeiten nicht signifikant, sodass Aufgaben mit Zeichenfolgenbezeichnern 404, und 004sich innerhalb des Bereichs befinden, da sie alle als Aufgabe 4behandelt werden, erfüllt die erste, die abgeschlossen werden soll, die Abhängigkeit.

Damit der abhängige Task ausgeführt wird, muss jeder Task in dem Bereich die Abhängigkeit erfüllen. Dies kann durch erfolgreichen Abschluss geschehen oder durch Abschließen mit einem Fehler, der einer Abhängigkeitsaktion zugeordnet ist, die auf Erfüllen festgelegt ist.

// 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)
},

Abhängigkeitsaktionen

Standardmäßig wird eine abhängige Aufgabe oder eine Gruppe von Aufgaben erst ausgeführt, nachdem eine übergeordnete Aufgabe erfolgreich abgeschlossen wurde. In einigen Szenarios möchten Sie abhängige Tasks eventuell auch ausführen, wenn im übergeordneten Task ein Fehler auftritt. Sie können das Standardverhalten überschreiben, indem Sie eine Abhängigkeitsaktion angeben, die angibt, ob ein abhängiger Task ausgeführt werden kann.

Nehmen wir beispielsweise an, dass ein abhängiger Task auf Daten vom Abschluss des Upstreamtasks wartet. Wenn der Upstreamtask fehlschlägt, kann der abhängige Task möglicherweise mit älteren Daten ausgeführt werden. In diesem Fall kann eine Abhängigkeitsaktion angeben, dass der abhängige Task berechtigt ist, trotz des Fehlers im übergeordneten Task ausgeführt zu werden.

Eine Abhängigkeitsaktion basiert auf einer Beendigungsbedingung für den übergeordneten Task. Sie können eine Abhängigkeitsaktion für jede der folgenden Beendigungsbedingungen angeben:

• Immer wenn ein Vorverarbeitungsfehler auftritt.
• Immer wenn ein Dateiuploadfehler auftritt. Wenn der Task mit einem Exitcode beendet wird, der über ExitCodes oder ExitCodeRanges angegeben wurde und dann ein Fehler beim Dateiupload auftritt, hat die durch den Exitcode angegebene Aktion Vorrang.
• Wenn die Aufgabe mit einem durch die ExitCodes-Eigenschaft definierten ExitCode beendet wird.
• Wenn die Aufgabe mit einem Exitcode beendet wird, der in einen durch die ExitCodeRanges-Eigenschaft angegebenen Bereich fällt.
• Der Standardfall, wenn die Aufgabe mit einem Exitcode beendet wird, der nicht durch ExitCodes oder ExitCodeRanges definiert ist, oder wenn die Aufgabe mit einem Vorverarbeitungsfehler beendet wird und die PreProcessingError-Eigenschaft nicht festgelegt ist oder wenn die Aufgabe mit einem Dateiuploadfehler fehlschlägt und die FileUploadError-Eigenschaft nicht festgelegt ist.

Für .NET werden diese Bedingungen als Eigenschaften der ExitConditions-Klasse definiert.

Um eine Abhängigkeitsaktion anzugeben, legen Sie die ExitOptions.DependencyAction-Eigenschaft für die Beendigungsbedingung auf eine der folgenden Optionen fest:

• Erfüllen: gibt an, dass abhängige Aufgaben zur Ausführung berechtigt sind, wenn die übergeordnete Aufgabe mit einem angegebenen Fehler beendet wird.
• Block: Gibt an, dass abhängige Aufgaben nicht zur Ausführung berechtigt sind.

Die Standardeinstellung für die DependencyAction-Eigenschaft ist Satisfy (Erfüllen) für den Exitcode 0 und Block (Blockieren) für alle anderen Beendigungsbedingungen.

Der folgende Codeausschnitt legt die DependencyAction-Eigenschaft für einen übergeordneten Task fest. Wenn der übergeordnete Vorgang mit einem Vorverarbeitungsfehler oder mit den angegebenen Fehlercodes beendet wird, wird der abhängige Vorgang blockiert. Wenn die übergeordnete Aufgabe mit einem anderen Nicht-null-Fehler beendet wird, kann die abhängige Aufgabe ausgeführt werden.

// 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")
},

Codebeispiel

Das TaskDependencies-Beispielprojekt auf GitHub veranschaulicht Folgendes:

• Wie Sie Taskabhängigkeit für einen Auftrag aktivieren.
• Wie Sie Tasks erstellen, die von anderen Tasks abhängen.
• So führen Sie diese Tasks in einem Pool von Computeknoten aus

Nächste Schritte

• Erfahren Sie mehr über das Batch-Feature Anwendungspakete, das eine einfache Möglichkeit zum Bereitstellen und Versionieren der Anwendungen bietet, die von Ihren Tasks auf Computeknoten ausgeführt werden.
• Erfahren Sie mehr über die Überprüfung auf Auftrags- und Taskfehler.