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á.

# Adicionar fragmentação de tarefas a um modelo de trabalho
<a name="build-job-bundle-chunking-add"></a>

O procedimento a seguir converte um modelo de trabalho que renderiza um quadro por tarefa em um que renderiza blocos de quadros. Para obter informações sobre fragmentação e como escolher um tamanho de fragmentação, consulte. [Divisão de tarefas para modelos de trabalho](build-job-bundle-chunking.md)

Antes de começar, você precisará fazer o seguinte:
+ Um pacote de trabalhos com um modelo de trabalho que define um parâmetro de tarefa de quadro. Para obter mais informações, consulte [Elementos de modelo de trabalho para pacotes de tarefas](build-job-bundle-template.md).
+ Uma fila associada a uma frota que suporta fragmentação. Service-managed as frotas sempre operam um agente de trabalho compatível. Customer-managed frotas exigem agente de trabalhadores versão 0.28.21 ou posterior para os trabalhadores.

**Para adicionar fragmentação de tarefas a um modelo de trabalho**

1. Adicione a `TASK_CHUNKING` extensão na parte superior do seu `template.yaml` arquivo:

   ```
   specificationVersion: 'jobtemplate-2023-09'
   extensions:
     - TASK_CHUNKING
   ```

   Se você pular essa etapa, a criação do trabalho falhará com o erro `The CHUNK[INT] task parameter requires the TASK_CHUNKING extension.`

1. Nas etapas`parameterSpace`, altere o tipo de parâmetro da tarefa do quadro de `INT` para `CHUNK[INT]` e adicione a `chunks` propriedade:

   ```
   taskParameterDefinitions:
     - name: Frame
       type: CHUNK[INT]
       range: "{{Param.Frames}}"
       chunks:
         defaultTaskCount: 10
         rangeConstraint: CONTIGUOUS
   ```

   Para ver todos os campos disponíveis, consulte[Referência do parâmetro de tarefa CHUNK [INT]](build-job-bundle-chunking-reference.md).

1. Atualize o script da etapa para aceitar um intervalo de quadros em vez de um único quadro. Com`rangeConstraint: CONTIGUOUS`, a `{{Task.Param.Frame}}` variável sempre se expande para um intervalo no `start-end` formato, para que o script possa dividi-la com o `cut` comando:

   ```
   START_FRAME="$(echo '{{Task.Param.Frame}}' | cut -d- -f1)"
   END_FRAME="$(echo '{{Task.Param.Frame}}' | cut -d- -f2)"
   ```

   Com`rangeConstraint: NONCONTIGUOUS`, a variável se expande para uma expressão de intervalo arbitrário, como. `1-3,5,7-20:2` Transforme a expressão na sintaxe que seu aplicativo aceita. Para uma transformação funcional, consulte a [ tarefa agrupando amostras ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) em. GitHub

1. Envie o pacote de trabalho com a CLI do Deadline Cloud:

   ```
   deadline bundle submit {{my-job-bundle}}
   ```

1. Para verificar se a fragmentação está em vigor, abra a tarefa no monitor do Deadline Cloud e veja a lista de tarefas da etapa. Cada tarefa representa um fragmento e mostra um intervalo de quadros, por exemplo, `1-10` em vez de um único número de quadro.

O seguinte modelo de trabalho completo renderiza uma animação do Blender em blocos de 10 quadros:

```
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` e`11-20`, e cada tarefa renderiza sua parte com uma única invocação do Blender.

Para saber mais, consulte os seguintes tópicos:
+ [Agrupe quadros em partes com a divisão de tarefas no Deadline Cloud](examples-jb-task-chunking.md)— Ready-to-submit fragmentação de amostras, incluindo uma variante não contígua.
+ [Como enviar um trabalho para o Deadline Cloud](submit-jobs-how.md)— Envie o pacote de trabalho para sua fila.