Criar dependências de tarefas para executar tarefas que dependem de outras tarefas

Com as dependências de tarefas em batch, pode criar tarefas que são agendadas para execução em nós de computação após a conclusão de uma ou mais tarefas parentais. Por exemplo, você pode criar um trabalho que renderiza cada quadro de um filme 3D com tarefas separadas e paralelas. A tarefa final mescla os quadros renderizados no filme completo somente depois que todos os quadros tiverem sido renderizados com êxito. Em outras palavras, a tarefa final depende das tarefas predecessoras anteriores.

Alguns cenários em que as dependências de tarefas são úteis incluem:

• Cargas de trabalho no estilo MapReduce na nuvem.
• Trabalhos cujas tarefas de processamento de dados podem ser expressas como um gráfico acíclico direcionado (DAG).
• Processos de pré e pós-renderização, onde cada tarefa deve ser concluída antes que a próxima tarefa possa começar.
• Qualquer outra tarefa em que as tarefas a jusante dependam do resultado das tarefas a montante.

Por defeito, as tarefas dependentes são agendadas para execução apenas depois de a tarefa-mãe ter sido concluída com êxito. Pode especificar, opcionalmente, uma ação de dependência para substituir o comportamento padrão e executar a tarefa dependente, mesmo que a tarefa principal falhe.

Neste artigo, discutimos como configurar dependências de tarefas usando a biblioteca Batch .NET. Primeiro, mostramos como habilitar a dependência de tarefas em seus trabalhos e, em seguida, demonstramos como configurar uma tarefa com dependências. Também descrevemos como especificar uma ação de dependência para executar tarefas dependentes se o pai falhar. Finalmente, discutimos os cenários de dependência suportados pelo Batch.

Habilitar dependências de tarefas

Para usar dependências de tarefas na sua aplicação Batch, deve primeiro configurar o trabalho de modo a usar dependências de tarefas. No Batch .NET, habilite-o em seu CloudJob definindo sua propriedade UsesTaskDependencies como true:

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

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

No trecho de código anterior, "batchClient" é uma instância da classe BatchClient .

Criar tarefas dependentes

Para criar uma tarefa que depende da conclusão de uma ou mais tarefas pai, você pode especificar que a tarefa "depende" das outras tarefas. No Batch .NET, configure a propriedade CloudTask.DependsOn com uma instância da classe 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 trecho de código cria uma tarefa dependente com a ID da tarefa "Flores". A tarefa "Flores" depende das tarefas "Chuva" e "Sol". A tarefa "Flores" será agendada para ser executada em um nó de computação somente depois que as tarefas "Chuva" e "Sol" forem concluídas com êxito.

Cenários de dependência

Existem três cenários básicos de dependência de tarefas que pode utilizar no Azure Batch: um-para-um, um-para-muitos e dependência de intervalo de ID de tarefa. Estes três cenários podem ser combinados para fornecer um quarto cenário: muitos-para-muitos.

Cenário	Exemplo	Ilustração
Um para um	taskB depende de taskA taskB não será agendada para execução até taskA tenha sido concluída com êxito
Um-para-muitos	taskC depende da taskA e taskB taskC não será agendada para execução até que a taskA e a taskB sejam concluídas com êxito
Intervalo de ID da tarefa	taskD depende de um intervalo de tarefas taskD não será agendado para execução até que as tarefas com IDs 1 a 10 sejam concluídas com êxito

Um para um

Em uma relação um-para-um, uma tarefa depende da conclusão bem-sucedida de uma tarefa principal. Para criar a dependência, forneça um único ID de tarefa para o método estático TaskDependencies.OnId ao preencher a propriedade 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")
},

Um para muitos

Numa relação de um-para-muitos, uma tarefa depende da conclusão de várias tarefas pai. Para criar a dependência, forneça uma coleção de IDs de tarefas específicas para o método estático TaskDependencies.OnIds ao preencher a propriedade 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 da tarefa

Num intervalo de dependência de tarefas principais, uma tarefa depende da conclusão de tarefas cujas IDs estão dentro de um intervalo que você especifica.

Para criar a dependência, forneça os IDs da tarefa inicial e da tarefa final no intervalo ao método estático TaskDependencies.OnIdRange ao preencher a propriedade 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)
},

Ações de dependência

Por padrão (por defeito), uma tarefa dependente ou um conjunto de tarefas executa-se somente depois que uma tarefa primária é concluída com sucesso. Em alguns cenários, poderás querer executar tarefas dependentes mesmo se a tarefa principal falhar. Você pode substituir o comportamento padrão especificando uma ação de dependência que indica se uma tarefa dependente está qualificada para execução.

Por exemplo, suponha que uma tarefa dependente esteja aguardando dados da conclusão da tarefa upstream. Se a tarefa upstream falhar, a tarefa dependente ainda poderá ser executada usando dados mais antigos. Nesse caso, uma ação de dependência pode especificar que a tarefa dependente está elegível para ser executada, apesar da falha da tarefa pai.

Uma ação de dependência é baseada numa condição de saída para a tarefa-mãe. Você pode especificar uma ação de dependência para qualquer uma das seguintes condições de saída:

• Sempre que ocorrer um erro de pré-processamento.
• Sempre que ocorrer um erro de carregamento de ficheiros. Se a tarefa sair com um código de saída especificado por meio de exitCodes ou exitCodeRanges e, em seguida, encontrar um erro de carregamento de arquivo, a ação especificada pelo código de saída terá precedência.
• Sempre que a tarefa é encerrada com um código de saída definido pela propriedade ExitCodes .
• Sempre que a tarefa é encerrada com um código de saída que está dentro de um intervalo especificado pela propriedade ExitCodeRanges .
• O caso padrão, se a tarefa sair com um código de saída não definido por ExitCodes ou ExitCodeRanges, ou se a tarefa sair com um erro de pré-processamento e a propriedade PreProcessingError não estiver definida, ou se a tarefa falhar com um erro de carregamento de arquivo e a propriedade FileUploadError não estiver definida.

Para .NET, essas condições são definidas como propriedades da classe ExitConditions .

Para especificar uma ação de dependência, defina a propriedade ExitOptions.DependencyAction para a condição de saída como uma das seguintes opções:

• Satisfazer: Indica que as tarefas dependentes estão qualificadas para execução se a tarefa pai for encerrada com um erro especificado.
• Bloquear: indica que as tarefas dependentes não estão qualificadas para execução.

A configuração padrão para a propriedade DependencyAction é Satisfazer para o código de saída 0 e Bloquear para todas as outras condições de saída.

O seguinte excerto de código define a propriedade DependencyAction para uma tarefa principal. Se a tarefa pai for encerrada com um erro de pré-processamento ou com os códigos de erro especificados, a tarefa dependente fica bloqueada. Se a tarefa pai for encerrada com qualquer outro erro diferente de zero, a tarefa dependente estará elegível para execução.

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

Exemplo de código

O projeto de exemplo TaskDependencies no GitHub demonstra:

• Como habilitar a dependência de tarefas em um trabalho.
• Como criar tarefas que dependem de outras tarefas.
• Como executar essas tarefas em um pool de nós de computação.

Próximos passos

• Saiba mais sobre a funcionalidade de pacotes de aplicações do Batch, que fornece uma maneira fácil de implantar e fazer o versionamento das aplicações que as suas tarefas executam em nós de processamento.
• Saiba mais sobre a verificação de erros para trabalhos e tarefas.