Creación de dependencias de tareas para ejecutar las tareas que dependan de otras tareas

Con dependencias de la tarea de Batch, puede crear tareas que estén programadas para su ejecución en los nodos de proceso después de la finalización de una o varias tareas principales. Por ejemplo, puede crear un trabajo que represente cada fotograma de una película 3D con una tarea independiente y paralela. La última tarea combina los fotogramas representados en la película completa solo después de que todos se hayan representado correctamente. Es decir, la tarea final depende de las tareas primarias anteriores.

A continuación se indican algunos escenarios donde las dependencias de tareas son útiles:

• Cargas de trabajo del estilo MapReduce en la nube.
• Trabajos cuyas tareas de procesamiento de datos se pueden expresar como un gráfico acíclico dirigido (DAG).
• Procesos de representación previa y posterior, donde cada tarea debe completarse antes de que pueda comenzar la siguiente tarea.
• Cualquier otro trabajo en el que las tareas que siguen en la cadena dependen de las tareas que preceden en la cadena.

De forma predeterminada, las tareas dependientes están programadas para ejecutarse solo después de que la tarea principal se haya completado correctamente. Opcionalmente puede especificar una acción de dependencia para invalidar el comportamiento predeterminado y ejecutar la tarea dependiente incluso si se produce un error en la tarea principal.

En este artículo se describe cómo configurar las dependencias de tareas mediante la biblioteca de .NET de Batch. Primero le mostraremos cómo habilitar la dependencia de tareas en sus trabajos y, después, le demostraremos cómo configurar una tarea con dependencias. También se describe cómo especificar una acción de dependencia para ejecutar tareas dependientes, si se produce un error en la principal. Por último, se tratarán los escenarios de dependencia compatibles con Batch.

Habilitación de dependencias de tareas

Para utilizar la dependencia de tareas en la aplicación Batch, antes es preciso configurar el trabajo para usar dependencias de tareas. En Batch para .NET, habilítelo en CloudJob estableciendo su propiedad UsesTaskDependencies en true:

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

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

En el fragmento de código anterior, "batchClient" es una instancia de la clase BatchClient.

Creación de tareas dependientes

Para crear una tarea que dependa de la finalización de una o varias tareas, puede especificar que la tarea "dependa" de las otras tareas. En .NET para Batch, configure la propiedad CloudTask.DependsOn con una instancia de la clase 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")
},

Este fragmento de código crea una tarea dependiente con el identificador de tarea "Flowers". La tarea "Flowers" depende de las tareas "Rain" y "Sun". La tarea "Flores" se programará para ejecutarse en un nodo de proceso solo después de que las tareas "Rain" y "Sun" se completen correctamente.

escenarios de dependencia

Hay tres escenarios de dependencia de tareas básicos que puede usar en Azure Batch: uno a uno, uno a varios y la dependencia de intervalo de identificadores de tarea. Estos tres escenarios se pueden combinar para proporcionar un cuarto escenario: varios a varios.

Escenario	Ejemplo	Ilustración
Uno a uno	taskB depende de taskA taskB no se programa para que se ejecute hasta que taskA se haya completado correctamente
Uno a varios	taskC depende de taskA y taskB taskC no se programará para su ejecución hasta que tanto taskA como taskB se completen correctamente.
Intervalo de id. de tarea	taskD depende de un intervalo de tareas taskD no se programará para su ejecución hasta que las tareas con identificadores 1 a 10 se completen correctamente.

Uno a uno

En una relación uno a uno, una tarea depende de la finalización correcta de una tarea principal. Para crear la dependencia, proporcione un identificador de tarea único al método estático TaskDependencies.OnId cuando rellene la propiedad 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")
},

Uno a varios

En una relación uno a muchos, una tarea depende de la finalización correcta de varias tareas principales. Para crear la dependencia, proporcione una colección de identificadores de tarea concretos al método estático TaskDependencies.OnIds cuando rellene la propiedad 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")
},

Intervalo de id. de tarea

En un dependencia de un intervalo de tareas principales, una tarea depende de la finalización de las tareas cuyos identificadores se encuentran dentro de un intervalo especificado.

Para crear la dependencia, proporcione el primer y el último identificador de tarea del intervalo al método estático TaskDependencies.OnIdRange cuando rellene la propiedad CloudTask.DependsOn.

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

Acciones de dependencia

De forma predeterminada, una tarea dependiente o un conjunto de tareas se ejecuta solo después de que una tarea primaria se complete correctamente. En algunos escenarios, puede que desee ejecutar tareas dependientes incluso si se produce un error en la tarea principal. Puede invalidar el comportamiento predeterminado si especifica una acción de dependencia que indique si una tarea dependiente es apta para ejecutarse.

Por ejemplo, suponga que una tarea dependiente está esperando los datos de la finalización de la tarea de nivel superior. Si se produce un error en la tarea de nivel superior, la tarea dependiente aún puede ejecutarse con datos más antiguos. En este caso, una acción de dependencia puede especificar que la tarea dependiente es apta para ejecutarse a pesar del error de la tarea principal.

Una acción de dependencia se basa en una condición de salida para la tarea principal. Puede especificar una acción de dependencia para cualquiera de las siguientes condiciones de salida:

• Cada vez que se produce un error de preprocesamiento.
• Cada vez que se produce un error de carga de archivos. Si la tarea finaliza con un código de salida que se especificó mediante exitCodes o exitCodeRanges y, a continuación, encuentra un error de carga de archivo, la acción especificada por el código de salida tiene prioridad.
• Siempre que la tarea salga con un código de salida definido por la propiedad ExitCodes .
• Siempre que la tarea salga con un código de salida que se encuentre dentro de un intervalo especificado por la propiedad ExitCodeRanges .
• El caso predeterminado, si la tarea sale con un código de salida no definido por ExitCodes o ExitCodeRanges, o si la tarea se cierra con un error de preprocesamiento y la propiedad PreProcessingError no está establecida, o si la tarea produce un error de carga de archivos y la propiedad FileUploadError no está establecida.

Para .NET, estas condiciones se definen como propiedades de la clase ExitConditions.

Para especificar una acción de dependencia, establezca la propiedad ExitOptions.DependencyAction para la condición de salida en una de las siguientes opciones:

• Satisfy: indica que las tareas dependientes son aptas para ejecutarse si la tarea principal se cierra con un error especificado.
• Bloquear: indica que las tareas dependientes no son aptas para ejecutarse.

La configuración predeterminada para la propiedad DependencyAction es Satisfacer para el código de salida 0, y Bloquear para todas las demás condiciones de salida.

El fragmento de código siguiente establece la propiedad DependencyAction para una tarea principal. Si la tarea primaria sale con un error de preprocesamiento o con los códigos de error especificados, se bloquea la tarea dependiente. Si la tarea primaria se cierra con cualquier otro error distinto de cero, la tarea dependiente es apta para ejecutarse.

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

Código de ejemplo

En el proyecto de ejemplo TaskDependencies de GitHub se muestra lo siguiente:

• Cómo habilitar la dependencia de tareas en un trabajo.
• Cómo crear tareas que dependen de otras tareas.
• Cómo ejecutar las tareas en un grupo de nodos de proceso.

Pasos siguientes

• Obtenga información sobre la característica paquetes de aplicación de Batch, que proporciona una manera sencilla de implementar y de cambiar la versión de las aplicaciones que las tareas ejecutan en los nodos de proceso.
• Obtenga información sobre la comprobación de errores de trabajos y tareas.