As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Divisão de tarefas para modelos de trabalho
<a name="build-job-bundle-chunking"></a>

O agrupamento de tarefas permite agrupar várias tarefas em uma única unidade de trabalho chamada fragmento. Em um trabalho de renderização, por exemplo, isso significa que o Deadline Cloud pode enviar vários quadros juntos em vez de um quadro por invocação de comando. Isso reduz a sobrecarga de iniciar aplicativos para cada tarefa e reduz o tempo de execução total do trabalho. Para obter detalhes, consulte [Executando vários quadros ao mesmo tempo](https://github.com/OpenJobDescription/openjd-specifications/wiki/Job-Intro-03-Creating-a-Job-Template#42-running-multiple-frames-at-a-time) no wiki do OpenJD.

O OpenJD suporta extensões que adicionam recursos opcionais aos modelos de trabalho. A fragmentação de tarefas é ativada com a adição da `TASK_CHUNKING` extensão. Para usar o agrupamento, adicione a extensão ao seu modelo de trabalho e use o tipo de parâmetro da `CHUNK[INT]` tarefa. Envie trabalhos fragmentados usando o mesmo `deadline bundle submit` comando. Por exemplo, o modelo de trabalho a seguir renderiza quadros em blocos de 10:

```
specificationVersion: 'jobtemplate-2023-09'
extensions:
  - TASK_CHUNKING
name: Blender Render with Contiguous Chunking
parameterDefinitions:
  - name: BlenderSceneFile
    type: PATH
    objectType: FILE
    dataFlow: IN
  - name: Frames
    type: STRING
    default: "1-100"
  - name: OutputDir
    type: PATH
    objectType: DIRECTORY
    dataFlow: OUT
    default: "./output"
steps:
  - name: RenderBlender
    parameterSpace:
      taskParameterDefinitions:
        - name: Frame
          type: CHUNK[INT]
          range: "{{Param.Frames}}"
          chunks:
            defaultTaskCount: 10
            rangeConstraint: CONTIGUOUS
    script:
      actions:
        onRun:
          command: bash
          args: ["{{Task.File.Run}}"]
      embeddedFiles:
        - name: Run
          type: TEXT
          data: |
            set -xeuo pipefail
            
            mkdir -p '{{Param.OutputDir}}'
            
            # Parse the chunk range (e.g., "1-10") into start and end frames
            START_FRAME="$(echo '{{Task.Param.Frame}}' | cut -d- -f1)"
            END_FRAME="$(echo '{{Task.Param.Frame}}' | cut -d- -f2)"
            
            blender --background '{{Param.BlenderSceneFile}}' \
                    --render-output '{{Param.OutputDir}}/output_####' \
                    --render-format PNG \
                    --use-extension 1 \
                    -s "$START_FRAME" \
                    -e "$END_FRAME" \
                    --render-anim
```

Neste exemplo, o Deadline Cloud divide os 100 quadros em partes como `1-10``11-20`, e assim por diante. A `{{Task.Param.Frame}}` variável se expande para uma expressão de intervalo como`1-10`. Como `rangeConstraint` está definido como`CONTIGUOUS`, o intervalo está sempre no `start-end` formato. O script analisa esse intervalo e passa os quadros inicial e final para o Blender usando as `-e` opções `-s` e com. `--render-anim`

A `chunks` propriedade suporta os seguintes campos:
+ `defaultTaskCount`— (Obrigatório) Quantas tarefas combinar em um único bloco. O valor máximo é 150.
+ `rangeConstraint`— (Obrigatório) Se`CONTIGUOUS`, um pedaço é sempre um intervalo contíguo, como. `1-10` Se`NONCONTIGUOUS`, um pedaço pode ser um conjunto arbitrário, como. `1,3,7-10`
+ `targetRuntimeSeconds`— (Opcional) O tempo de execução desejado em segundos para cada bloco. O Deadline Cloud pode ajustar dinamicamente o tamanho do bloco para se aproximar dessa meta depois que alguns trechos forem concluídos.

[Para mais exemplos de fragmentação de tarefas, incluindo exemplos básicos e do Blender com partes contíguas e não contíguas, consulte os exemplos de fragmentação de tarefas no repositório de amostras do Deadline Cloud em.](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) GitHub

**Requisitos de frota gerenciados pelo cliente**  
A fragmentação de tarefas requer uma versão compatível do agente de trabalho. Se você usa frotas gerenciadas pelo cliente, certifique-se de que seus agentes de trabalho estejam atualizados antes de enviar trabalhos com fragmentação. As frotas gerenciadas por serviços sempre usam uma versão de agente de trabalho compatível.

**Baixando a saída para trabalhos fragmentados**  
Quando você baixa a saída de uma única tarefa em um trabalho fragmentado, o Deadline Cloud baixa a saída de todo o fragmento. Por exemplo, se os quadros de 1 a 10 foram processados juntos, o download da saída do quadro 3 incluirá todos os quadros de 1 a 10. Esse recurso requer a `deadline-cloud` versão 0.53.3 ou posterior.