Creare relazioni tra attività per eseguire attività che dipendono da altre attivitàCreate task dependencies to run tasks that depend on other tasks

È possibile definire dipendenze delle attività per eseguire un'attività o un set di attività solo dopo il completamento di un'attività padre.You can define task dependencies to run a task or set of tasks only after a parent task has completed. Ecco alcuni degli scenari in cui le dipendenze delle attività sono utili:Some scenarios where task dependencies are useful include:

  • Carichi di lavoro di tipo MapReduce nel cloud.MapReduce-style workloads in the cloud.
  • Processi le cui attività di elaborazione dati può essere espressa come grafo aciclico diretto (DAG).Jobs whose data processing tasks can be expressed as a directed acyclic graph (DAG).
  • Processi di pre-rendering e post-rendering, in cui ogni attività deve essere completata prima di poter avviare quella successiva.Pre-rendering and post-rendering processes, where each task must complete before the next task can begin.
  • Qualsiasi altro processo in cui le attività downstream dipendono l'output delle attività upstream.Any other job in which downstream tasks depend on the output of upstream tasks.

Tramite le dipendenze delle attività di Batch è possibile creare attività di cui pianificare l'esecuzione nei nodi di calcolo dopo il completamento di una o più attività padre.With Batch task dependencies, you can create tasks that are scheduled for execution on compute nodes after the completion of one or more parent tasks. Ad esempio, è possibile creare un processo che esegue il rendering di ogni fotogramma di un film 3D con le attività parallele separate.For example, you can create a job that renders each frame of a 3D movie with separate, parallel tasks. L'attività finale, ovvero "attività di unione", unisce i fotogrammi sottoposti a rendering in un filmato completo solo dopo che è stato eseguito il rendering di tutti i fotogrammi.The final task--the "merge task"--merges the rendered frames into the complete movie only after all frames have been successfully rendered.

Per impostazione predefinita, l'esecuzione delle attività dipendenti è pianificata solo dopo il corretto completamento dell'attività padre.By default, dependent tasks are scheduled for execution only after the parent task has completed successfully. È possibile specificare un'azione di dipendenza per sostituire il comportamento predefinito ed eseguire attività quando l'attività padre non riesce.You can specify a dependency action to override the default behavior and run tasks when the parent task fails. Per informazioni dettagliate, vedere la sezione Azioni di dipendenza.See the Dependency actions section for details.

È possibile creare attività che dipendono da altre attività in una relazione uno-a-uno o uno-a-molti.You can create tasks that depend on other tasks in a one-to-one or one-to-many relationship. È anche possibile creare una dipendenza da un intervallo, in cui un'attività dipende dal completamento di un gruppo di attività all'interno di un intervallo di ID attività specifico.You can also create a range dependency where a task depends on the completion of a group of tasks within a specified range of task IDs. È possibile combinare questi tre scenari di base per creare relazioni molti-a-molti.You can combine these three basic scenarios to create many-to-many relationships.

Relazioni tra attività con Batch .NETTask dependencies with Batch .NET

Questo articolo illustra la configurazione di relazioni tra attività tramite la libreria Batch .NET.In this article, we discuss how to configure task dependencies by using the Batch .NET library. Viene illustrato prima come abilitare le dipendenze tra attività nei processi, quindi viene spiegato come configurare un'attività con dipendenze.We first show you how to enable task dependency on your jobs, and then demonstrate how to configure a task with dependencies. Viene inoltre descritto come specificare un'azione di dipendenza per l'esecuzione di attività dipendenti se l'attività padre non riesce.We also describe how to specify a dependency action to run dependent tasks if the parent fails. Vengono infine illustrati gli scenari delle relazione supportate da Batch.Finally, we discuss the dependency scenarios that Batch supports.

Abilitare le relazioni tra attivitàEnable task dependencies

Per usare le dipendenze delle attività nell'applicazione Batch, è innanzitutto necessario configurare il processo per l'uso delle dipendenze.To use task dependencies in your Batch application, you must first configure the job to use task dependencies. In Batch .NET abilitare la funzionalità in CloudJob impostando la rispettiva proprietà UsesTaskDependencies su true:In Batch .NET, enable it on your CloudJob by setting its UsesTaskDependencies property to true:

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

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

Nel frammento di codice precedente "batchClient" è un'istanza della classe BatchClient.In the preceding code snippet, "batchClient" is an instance of the BatchClient class.

Creare attività dipendentiCreate dependent tasks

Per creare un'attività che dipende dal completamento di una o più attività padre, è possibile specificare che l'attività "dipende" dalle altre attività.To create a task that depends on the completion of one or more parent tasks, you can specify that the task "depends on" the other tasks. In Batch .NET configurare la proprietà CloudTask.DependsOn con un'istanza della classe TaskDependencies:In Batch .NET, configure the CloudTask.DependsOn property with an instance of the TaskDependencies class:

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

Questo frammento di codice crea un'attività dipendente con ID attività "Flowers".This code snippet creates a dependent task with task ID "Flowers". L'attività "Flowers" dipende dalle attività "Rain" e "Sun".The "Flowers" task depends on tasks "Rain" and "Sun". L'esecuzione dell'attività "Flowers" in un nodo di calcolo verrà pianificata solo dopo il corretto completamento delle attività "Rain" e "Sun".Task "Flowers" will be scheduled to run on a compute node only after tasks "Rain" and "Sun" have completed successfully.

Nota

Un'attività viene considerata correttamente completata quando l'attività è in stato completato e il codice di uscita è 0.A task is considered to be completed successfully when it is in the completed state and its exit code is 0. In Batch .NET ciò corrisponde a un valore della proprietà CloudTask.State pari a Completed e il valore della proprietà TaskExecutionInformation.ExitCode è 0.In Batch .NET, this means a CloudTask.State property value of Completed and the CloudTask's TaskExecutionInformation.ExitCode property value is 0.

scenari delle relazioneDependency scenarios

In Azure Batch è possibile usare tre scenari di relazioni tra attività di base, ovvero uno-a-uno, uno-a-molti e la relazione tra intervalli di ID.There are three basic task dependency scenarios that you can use in Azure Batch: one-to-one, one-to-many, and task ID range dependency. Questi scenari possono essere combinati per ottenere un quarto scenario, ovvero molti-a-molti.These can be combined to provide a fourth scenario, many-to-many.

Scenario       Scenario        EsempioExample
Uno-a-unoOne-to-one L'attivitàB dipende dall'attivitàAtaskB depends on taskA

L'attivitàB sarà pianificata per l'esecuzione solo dopo il completamento corretto dell'attivitàAtaskB will not be scheduled for execution until taskA has completed successfully

Diagramma: relazione uno-a-uno tra attivitàDiagram: one-to-one task dependency
Uno-a-moltiOne-to-many L'attivitàC dipende sia dall'attivitàA che dall'attivitàB.taskC depends on both taskA and taskB

L'attivitàC sarà pianificata per l'esecuzione solo dopo il completamento corretto dell'attivitàA e dell'attivitàBtaskC will not be scheduled for execution until both taskA and taskB have completed successfully

Diagramma: relazione uno-a-molti tra attivitàDiagram: one-to-many task dependency
Intervallo di ID attivitàTask ID range L'attivitàD dipende da un intervallo di attivitàtaskD depends on a range of tasks

L'attivitàD sarà pianificata per l'esecuzione solo dopo il completamento corretto delle attività con ID compresi tra 1 e 10taskD will not be scheduled for execution until the tasks with IDs 1 through 10 have completed successfully

Diagramma: relazione tra intervalli di ID attivitàDiagram: Task id range dependency

Suggerimento

È possibile creare relazioni molti-a-molti, ad esempio relazioni in cui le attività C, D, E e F dipendono dalle attività A e B. Questo tipo di relazione risulta utile, ad esempio, negli scenari di pre-elaborazione parallelizzata, in cui le attività downstream dipendono dall'output di più attività upstream.You can create many-to-many relationships, such as where tasks C, D, E, and F each depend on tasks A and B. This is useful, for example, in parallelized preprocessing scenarios where your downstream tasks depend on the output of multiple upstream tasks.

Negli esempi di questa sezione un'attività dipendente viene eseguita solo dopo che le attività padre vengono completate correttamente.In the examples in this section, a dependent task runs only after the parent tasks complete successfully. Questo comportamento è quello predefinito per un'attività dipendente.This behavior is the default behavior for a dependent task. È possibile eseguire un'attività dipendente dopo che un'attività padre non riesce specificando un'azione di dipendenza per sostituire il comportamento predefinito.You can run a dependent task after a parent task fails by specifying a dependency action to override the default behavior. Per informazioni dettagliate, vedere la sezione Azioni di dipendenza.See the Dependency actions section for details.

Uno-a-unoOne-to-one

In una relazione uno-a-uno un'attività dipende dal corretto completamento di una sola attività padre.In a one-to-one relationship, a task depends on the successful completion of one parent task. Per creare la dipendenza, specificare un solo ID attività nel metodo statico TaskDependencies.OnId quando si popola la proprietà DependsOn di CloudTask.To create the dependency, provide a single task ID to the TaskDependencies.OnId static method when you populate the DependsOn property of CloudTask.

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

Uno-a-moltiOne-to-many

In una relazione uno-a-molti un'attività dipende dal completamento di più attività padre.In a one-to-many relationship, a task depends on the completion of multiple parent tasks. Per creare la dipendenza, specificare una raccolta di ID attività nel metodo statico TaskDependencies.OnId quando si popola la proprietà DependsOn di CloudTask.To create the dependency, provide a collection of task IDs to the TaskDependencies.OnIds static method when you populate the DependsOn property of CloudTask.

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

Intervallo di ID attivitàTask ID range

In una dipendenza da un intervallo di attività padre un'attività dipende dal completamento delle attività il cui ID è compreso all'interno di un intervallo.In a dependency on a range of parent tasks, a task depends on the the completion of tasks whose IDs lie within a range. Per creare la dipendenza, specificare il primo e l'ultimo ID attività dell'intervallo nel metodo statico TaskDependencies.OnIdRange quando si popola la proprietà DependsOn di CloudTask.To create the dependency, provide the first and last task IDs in the range to the TaskDependencies.OnIdRange static method when you populate the DependsOn property of CloudTask.

Importante

Quando si usano intervalli di ID attività per le relazioni, gli ID attività inclusi nell'intervallo devono essere rappresentazioni di stringa di valori interi.When you use task ID ranges for your dependencies, the task IDs in the range must be string representations of integer values.

Ogni attività compresa nell'intervallo deve soddisfare la dipendenza attraverso il corretto completamento o il completamento con un errore associato a un'azione di dipendenza impostata su Satisfy.Every task in the range must satisfy the dependency, either by completing successfully or by completing with a failure that’s mapped to a dependency action set to Satisfy. Per informazioni dettagliate, vedere la sezione Azioni di dipendenza.See the Dependency actions section for details.

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

Azioni di dipendenzaDependency actions

Per impostazione predefinita, un'attività o un set di attività dipendenti vengono eseguite solo dopo il corretto completamento di un'attività padre.By default, a dependent task or set of tasks runs only after a parent task has completed successfully. In alcuni scenari potrebbe essere necessario eseguire attività dipendenti anche se l'attività padre non riesce.In some scenarios, you may want to run dependent tasks even if the parent task fails. È possibile sostituire il comportamento predefinito specificando un'azione di dipendenza.You can override the default behavior by specifying a dependency action. Un'azione di dipendenza specifica se un'attività dipendente è idonea per l'esecuzione in base alla riuscita o meno dell'attività padre.A dependency action specifies whether a dependent task is eligible to run, based on the success or failure of the parent task.

Si supponga, ad esempio, un'attività dipendente in attesa di dati dal completamento dell'attività upstream.For example, suppose that a dependent task is awaiting data from the completion of the upstream task. Se l'attività upstream non riesce, l'attività dipendente potrebbe comunque essere eseguita usando dati meno recenti.If the upstream task fails, the dependent task may still be able to run using older data. In questo caso, un'azione di dipendenza può specificare che l'attività dipendente è idonea per l'esecuzione nonostante l'errore dell'attività padre.In this case, a dependency action can specify that the dependent task is eligible to run despite the failure of the parent task.

Un'azione di dipendenza è basata su una condizione di uscita per l'attività padre.A dependency action is based on an exit condition for the parent task. È possibile specificare un'azione di dipendenza per una qualsiasi delle condizioni di uscita seguenti. Per .NET, vedere la classe ExitConditions per altre informazioni.You can specify a dependency action for any of the following exit conditions; for .NET, see the ExitConditions class for details:

  • Quando si verifica un errore di pre-elaborazione.When a pre-processing error occurs.
  • Quando si verifica un errore di caricamento dei file.When a file upload error occurs. Se l'attività si chiude con un codice di uscita specificato tramite exitCodes o exitCodeRanges e quindi si verifica un errore di caricamento dei file, l'azione specificata dal codice di uscita ha la precedenza.If the task exits with an exit code that was specified via exitCodes or exitCodeRanges, and then encounters a file upload error, the action specified by the exit code takes precedence.
  • Quando l'attività termina con un codice di uscita definito dalla proprietà ExitCodes.When the task exits with an exit code defined by the ExitCodes property.
  • Quando l'attività termina con un codice di uscita compreso in un intervallo specificato dalla proprietà ExitCodeRanges.When the task exits with an exit code that falls within a range specified by the ExitCodeRanges property.
  • Il caso predefinito, ovvero se l'attività si chiude con un codice di uscita non definito da ExitCodes o ExitCodeRanges oppure se l'attività si chiude con un errore di pre-elaborazione e la proprietà PreProcessingError non è stata configurata o se l'attività ha esito negativo con un errore di caricamento dei file e la proprietà FileUploadError non è stata configurata.The default case, if the task exits with an exit code not defined by ExitCodes or ExitCodeRanges, or if the task exits with a pre-processing error and the PreProcessingError property is not set, or if the task fails with a file upload error and the FileUploadError property is not set.

Per specificare un'azione di dipendenza in .NET, impostare la proprietà ExitOptions.DependencyAction per la condizione di uscita.To specify a dependency action in .NET, set the ExitOptions.DependencyAction property for the exit condition. La proprietà DependencyAction accetta uno di questi due valori:The DependencyAction property takes one of two values:

  • L'impostazione della proprietà DependencyAction su Satisfy indica che le attività dipendenti sono idonee per l'esecuzione se l'attività padre termina con un errore specificato.Setting the DependencyAction property to Satisfy indicates that dependent tasks are eligible to run if the parent task exits with a specified error.
  • L'impostazione della proprietà DependencyAction su Block indica che le attività dipendenti non sono idonee per l'esecuzione.Setting the DependencyAction property to Block indicates that dependent tasks are not eligible to run.

L'impostazione predefinita per la proprietà DependencyAction è Satisfy per il codice di uscita 0 e Block per tutte le altre condizioni di uscita.The default setting for the DependencyAction property is Satisfy for exit code 0, and Block for all other exit conditions.

Il frammento di codice seguente imposta la proprietà DependencyAction per un'attività padre.The following code snippet sets the DependencyAction property for a parent task. Se l'attività padre termina con un errore di pre-elaborazione o con i codici di errore specificati, l'attività dipendente viene bloccata.If the parent task exits with a pre-processing error, or with the specified error codes, the dependent task is blocked. Se l'attività padre termina con qualsiasi altro errore diverso da zero, l'attività dipendente è idonea per l'esecuzione.If the parent task exits with any other non-zero error, the dependent task is eligible to run.

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

Esempio di codiceCode sample

Il progetto di esempio TaskDependencies è uno degli esempi di codice di Azure Batch disponibili in GitHub.The TaskDependencies sample project is one of the Azure Batch code samples on GitHub. Questa soluzione di Visual Studio mostra:This Visual Studio solution demonstrates:

  • Come abilitare la dipendenza delle attività in un processoHow to enable task dependency on a job
  • Come creare attività che dipendono da altre attivitàHow to create tasks that depend on other tasks
  • Come eseguire queste attività in un pool di nodi di calcolo.How to execute those tasks on a pool of compute nodes.

Passaggi successiviNext steps

Distribuzione dell'applicazioneApplication deployment

La funzionalità Pacchetti dell'applicazione di Batch offre un modo semplice per distribuire e controllare le versioni delle applicazioni eseguite dalle attività nei nodi di calcolo.The application packages feature of Batch provides an easy way to both deploy and version the applications that your tasks execute on compute nodes.

Installazione delle applicazioni e staging dei datiInstalling applications and staging data

Per una panoramica dei metodi di preparazione dei nodi per l'esecuzione di attività, vedere Installing applications and staging data on Batch compute nodes (Installazione di applicazioni e staging dei dati nei nodi di calcolo di Batch) nel forum di Azure Batch.See Installing applications and staging data on Batch compute nodes in the Azure Batch forum for an overview of methods for preparing your nodes to run tasks. Scritto da uno dei membri del team di Azure Batch, questo post è una panoramica utile dei diversi modi disponibili per copiare applicazioni, dati di input di attività e altri file nei nodi di calcolo.Written by one of the Azure Batch team members, this post is a good primer on the different ways to copy applications, task input data, and other files to your compute nodes.