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.

# Ajouter un découpage des tâches à un modèle de tâche
<a name="build-job-bundle-chunking-add"></a>

La procédure suivante convertit un modèle de tâche qui affiche une image par tâche en un modèle qui affiche des blocs d'images. Pour plus d'informations sur le découpage et sur la manière de choisir une taille de morceau, voir. [Découpage des tâches pour les modèles de tâches](build-job-bundle-chunking.md)

Avant de commencer, vous avez besoin de ce qui suit :
+ Un ensemble de tâches avec un modèle de tâche qui définit un paramètre de tâche cadre. Pour de plus amples informations, veuillez consulter [Éléments de modèle de poste pour les offres d'emploi](build-job-bundle-template.md).
+ Une file d'attente associée à une flotte qui prend en charge le découpage. Service-managed les flottes font toujours appel à un agent de travail compatible. Customer-managed les flottes nécessitent la version 0.28.21 ou ultérieure de l'agent de travail pour les travailleurs.

**Pour ajouter le découpage des tâches à un modèle de tâche**

1. Ajoutez l'`TASK_CHUNKING`extension en haut de votre `template.yaml` fichier :

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

   Si vous ignorez cette étape, la création d'une tâche échoue avec le message d'erreur `The CHUNK[INT] task parameter requires the TASK_CHUNKING extension.`

1. Au cours des étapes`parameterSpace`, modifiez le type de paramètre de tâche du cadre de `INT` à `CHUNK[INT]` et ajoutez la `chunks` propriété :

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

   Pour tous les champs disponibles, consultez[Référence des paramètres de tâche CHUNK [INT]](build-job-bundle-chunking-reference.md).

1. Mettez à jour le script de l'étape pour accepter une plage d'images au lieu d'une seule image. Avec`rangeConstraint: CONTIGUOUS`, la `{{Task.Param.Frame}}` variable s'étend toujours jusqu'à une plage de `start-end` format, de sorte que le script peut la scinder à l'aide de la `cut` commande suivante :

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

   Avec`rangeConstraint: NONCONTIGUOUS`, la variable s'étend à une expression de plage arbitraire telle que`1-3,5,7-20:2`. Transformez l'expression selon la syntaxe acceptée par votre application. Pour une transformation fonctionnelle, consultez les exemples de découpage des [ tâches ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) sur GitHub.

1. Soumettez le job bundle à l'aide de l'interface de ligne de commande Deadline Cloud :

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

1. Pour vérifier que le découpage est effectif, ouvrez la tâche dans le moniteur Deadline Cloud et consultez la liste des tâches de l'étape. Chaque tâche représente un segment et affiche une plage d'images, par exemple, au `1-10` lieu d'un numéro de trame unique.

Le modèle de tâche complet suivant affiche une animation Blender en morceaux de 10 images :

```
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 blocs tels que `1-10` et`11-20`, et chaque tâche affiche son segment avec une seule invocation de Blender.

Pour plus d’informations, consultez les rubriques suivantes :
+ [Regroupez les cadres en morceaux grâce à la segmentation des tâches sur Deadline Cloud](examples-jb-task-chunking.md)— des échantillons Ready-to-submit découpés, y compris une variante non contiguë.
+ [Comment soumettre une offre d'emploi à Deadline Cloud](submit-jobs-how.md)— Soumettez le lot de tâches à votre file d'attente.