Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Agregue la fragmentación de tareas a una plantilla de trabajo
<a name="build-job-bundle-chunking-add"></a>

El procedimiento siguiente convierte una plantilla de trabajo que representa un fotograma por tarea en una que renderiza fragmentos de fotogramas. Para obtener más información sobre la fragmentación y cómo elegir un tamaño de fragmento, consulte. [Fragmentación de tareas para plantillas de trabajo](build-job-bundle-chunking.md)

Antes de comenzar, necesitará lo siguiente:
+ Un paquete de tareas con una plantilla de tareas que define un parámetro de tarea de marco. Para obtener más información, consulte [Elementos de plantilla de trabajo para paquetes de trabajos](build-job-bundle-template.md).
+ Una cola asociada a una flota que admite la fragmentación. Service-managed las flotas siempre utilizan un agente de trabajo compatible. Customer-managed las flotas requieren la versión 0.28.21 del agente de trabajo o una versión posterior para los trabajadores.

**Para agregar la fragmentación de tareas a una plantilla de trabajo**

1. Añade la `TASK_CHUNKING` extensión al principio del `template.yaml` archivo:

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

   Si omite este paso, se producirá un error al crear el trabajo `The CHUNK[INT] task parameter requires the TASK_CHUNKING extension.`

1. En los pasos`parameterSpace`, cambie el tipo de parámetro de la tarea del marco de `INT` a `CHUNK[INT]` y añada la `chunks` propiedad:

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

   Para ver todos los campos disponibles, consulte[Referencia del parámetro de tarea CHUNK [INT]](build-job-bundle-chunking-reference.md).

1. Actualice el guion del paso para que acepte un rango de fotogramas en lugar de un único fotograma. Con`rangeConstraint: CONTIGUOUS`, la `{{Task.Param.Frame}}` variable siempre se expande a un rango de `start-end` formato, por lo que el script puede dividirla con el `cut` comando:

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

   Con`rangeConstraint: NONCONTIGUOUS`, la variable se expande hasta convertirse en una expresión de rango arbitraria, como`1-3,5,7-20:2`. Transforma la expresión en la sintaxis que acepta tu aplicación. Para ver una transformación que funcione, consulte los ejemplos [ de fragmentación de ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) tareas. GitHub

1. Envíe el paquete de trabajos con la CLI de Deadline Cloud:

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

1. Para comprobar que la fragmentación está en vigor, abra el trabajo en el monitor de Deadline Cloud y consulte la lista de tareas del paso. Cada tarea representa un fragmento y muestra un rango de fotogramas, por ejemplo, `1-10` en lugar de un único número de fotogramas.

La siguiente plantilla de trabajo completa renderiza una animación de Blender en fragmentos de 10 fotogramas:

```
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
```

En este ejemplo, Deadline Cloud divide los 100 fotogramas en fragmentos, como `1-10` y`11-20`, y cada tarea renderiza su fragmento con una sola invocación de Blender.

Para obtener más información, consulte los temas siguientes:
+ [Agrupe los fotogramas en fragmentos con la fragmentación de tareas en Deadline Cloud](examples-jb-task-chunking.md)— Ready-to-submit fragmentar muestras, incluida una variante no contigua.
+ [Cómo enviar un trabajo a Deadline Cloud](submit-jobs-how.md)— Envía el paquete de trabajos a tu lista de espera.