Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Découpage des tâches pour les modèles de tâches
<a name="build-job-bundle-chunking"></a>

Le découpage des tâches vous permet de regrouper plusieurs tâches en une seule unité de travail appelée partie. Dans une tâche de rendu, par exemple, cela signifie que Deadline Cloud peut distribuer plusieurs images ensemble au lieu d'une image par appel de commande. Cela réduit la charge de travail liée au démarrage des applications pour chaque tâche et réduit le temps d'exécution total des tâches. Pour plus de détails, voir [Exécuter plusieurs images à la fois](https://github.com/OpenJobDescription/openjd-specifications/wiki/Job-Intro-03-Creating-a-Job-Template#42-running-multiple-frames-at-a-time) dans le wiki OpenJD.

OpenJD prend en charge les extensions qui ajoutent des fonctionnalités facultatives aux modèles de tâches. Le découpage des tâches est activé en ajoutant l'`TASK_CHUNKING`extension. Pour utiliser le découpage, ajoutez l'extension à votre modèle de tâche et utilisez le type de paramètre de `CHUNK[INT]` tâche. Soumettez des tâches segmentées à l'aide de la même `deadline bundle submit` commande. Par exemple, le modèle de tâche suivant affiche les cadres par blocs 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
```

Dans cet exemple, Deadline Cloud divise les 100 images en morceaux tels que `1-10``11-20`,, etc. La `{{Task.Param.Frame}}` variable s'étend jusqu'à une expression de plage telle que`1-10`. Comme elle `rangeConstraint` est définie sur`CONTIGUOUS`, la plage est toujours au `start-end` format. Le script analyse cette plage et transmet les images de début et de fin à Blender en utilisant les `-e` options `-s` et avec`--render-anim`.

La `chunks` propriété prend en charge les champs suivants :
+ `defaultTaskCount`— (Obligatoire) Combien de tâches combiner en un seul morceau. La valeur maximale est de 150.
+ `rangeConstraint`— (Obligatoire) Si`CONTIGUOUS`, un fragment est toujours une plage contiguë, par exemple. `1-10` Si`NONCONTIGUOUS`, un morceau peut être un ensemble arbitraire, comme`1,3,7-10`.
+ `targetRuntimeSeconds`— (Facultatif) Le temps d'exécution cible en secondes pour chaque segment. Deadline Cloud peut ajuster dynamiquement la taille des fragments pour s'approcher de cette cible une fois que certains fragments sont terminés.

Pour d'autres exemples de découpage de tâches, y compris des exemples de base et des exemples de Blender avec des segments contigus et non contigus, consultez les exemples de découpage de [tâches dans le référentiel d'exemples de Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) sur. GitHub

**Exigences relatives à la gestion du parc par le client**  
Le découpage des tâches nécessite une version d'agent de travail compatible. Si vous utilisez des flottes gérées par le client, assurez-vous que vos agents de travail sont à jour avant de soumettre des tâches par segmentation. Les flottes gérées par des services utilisent toujours une version d'agent de travail compatible.

**Téléchargement du résultat pour les tâches segmentées**  
Lorsque vous téléchargez le résultat d'une tâche unique dans une tâche fragmentée, Deadline Cloud télécharge le résultat pour l'ensemble du fragment. Par exemple, si les images 1 à 10 ont été traitées ensemble, le téléchargement de la sortie pour l'image 3 inclut toutes les images 1 à 10. Cette fonctionnalité nécessite `deadline-cloud` la version 0.53.3 ou ultérieure.