Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Aggiungere la suddivisione in parti delle attività a un modello di lavoro
<a name="build-job-bundle-chunking-add"></a>

La procedura seguente converte un modello di lavoro che esegue il rendering di un frame per attività in uno che esegue il rendering di blocchi di frame. Per informazioni sulla suddivisione in blocchi e su come scegliere la dimensione dei blocchi, consulta. [Suddivisione delle attività per i modelli di lavoro](build-job-bundle-chunking.md)

Prima di iniziare, avrai bisogno di:
+ Un pacchetto di lavoro con un modello di lavoro che definisce un parametro frame task. Per ulteriori informazioni, consulta [Elementi del modello di lavoro per i pacchetti di lavoro](build-job-bundle-template.md).
+ Una coda associata a una flotta che supporta la suddivisione in blocchi. Service-managed le flotte gestiscono sempre un worker agent compatibile. Customer-managed le flotte richiedono la versione 0.28.21 o successiva del worker agent per i lavoratori.

**Per aggiungere la suddivisione delle attività a un modello di lavoro**

1. Aggiungi l'`TASK_CHUNKING`estensione all'inizio del file`template.yaml`:

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

   Se salti questo passaggio, la creazione del lavoro non riesce e viene visualizzato l'errore `The CHUNK[INT] task parameter requires the TASK_CHUNKING extension.`

1. Nei passaggi`parameterSpace`, modificate il tipo di parametro del frame task da `INT` a `CHUNK[INT]` e aggiungete la `chunks` proprietà:

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

   Per tutti i campi disponibili, consulta[Riferimento al parametro del task CHUNK [INT]](build-job-bundle-chunking-reference.md).

1. Aggiornate lo script del passo in modo che accetti un intervallo di frame anziché un singolo frame. Con`rangeConstraint: CONTIGUOUS`, la `{{Task.Param.Frame}}` variabile si espande sempre in un intervallo di `start-end` formato, quindi lo script può dividerla con il `cut` comando:

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

   Con`rangeConstraint: NONCONTIGUOUS`, la variabile si espande in un'espressione di intervallo arbitraria come. `1-3,5,7-20:2` Trasforma l'espressione nella sintassi accettata dall'applicazione. Per una trasformazione funzionante, consulta il [ task Chunking Sample on. ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) GitHub

1. Invia il pacchetto di lavoro con la CLI di Deadline Cloud:

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

1. Per verificare che la suddivisione in blocchi sia effettiva, apri il lavoro nel monitor Deadline Cloud e visualizza l'elenco delle attività della fase. Ogni attività rappresenta un blocco e mostra un intervallo di frame, ad esempio `1-10` invece di un singolo numero di frame.

Il seguente modello di lavoro completo rende un'animazione di Blender in blocchi di 10 fotogrammi:

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

In questo esempio, Deadline Cloud divide i 100 fotogrammi in blocchi come `1-10` e`11-20`, e ogni attività esegue il rendering della propria parte con una singola chiamata a Blender.

Per ulteriori informazioni, consulta i seguenti argomenti:
+ [Raggruppa i frame in blocchi con la suddivisione delle attività su Deadline Cloud](examples-jb-task-chunking.md)— Ready-to-submit suddivisione in blocchi dei campioni, inclusa una variante non contigua.
+ [Come inviare un lavoro a Deadline Cloud](submit-jobs-how.md)— Invia il job bundle alla tua coda.