Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Fügen Sie Task-Chunking zu einer Job-Vorlage hinzu
<a name="build-job-bundle-chunking-add"></a>

Das folgende Verfahren konvertiert eine Auftragsvorlage, die einen Frame pro Aufgabe rendert, in eine Vorlage, die Frame-Blöcke rendert. Hintergrundinformationen zum Chunking und zur Auswahl einer Chunk-Größe finden Sie unter. [Aufgabenteilung für Jobvorlagen](build-job-bundle-chunking.md)

Bevor Sie beginnen, muss Folgendes sichergestellt sein:
+ Ein Auftragspaket mit einer Auftragsvorlage, die einen Frame-Task-Parameter definiert. Weitere Informationen finden Sie unter [Elemente der Jobvorlage für Jobpakete](build-job-bundle-template.md).
+ Eine Warteschlange, die einer Flotte zugeordnet ist, die Chunking unterstützt. Service-managed Auf Flotten läuft immer ein kompatibler Worker Agent. Customer-managed Flotten benötigen Worker Agent Version 0.28.21 oder höher für die Worker.

**Um einer Job-Vorlage Aufgaben-Chunking hinzuzufügen**

1. Fügen Sie die `TASK_CHUNKING` Erweiterung am Anfang Ihrer `template.yaml` Datei hinzu:

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

   Wenn Sie diesen Schritt überspringen, schlägt die Auftragserstellung mit dem folgenden Fehler fehl `The CHUNK[INT] task parameter requires the TASK_CHUNKING extension.`

1. Ändern Sie in den Schritten den Parametertyp der Frame-Aufgabe von `INT` auf `CHUNK[INT]` und fügen Sie die folgende `chunks` Eigenschaft hinzu: `parameterSpace`

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

   Alle verfügbaren Felder finden Sie unter[Referenz für den CHUNK [INT] -Aufgabenparameter](build-job-bundle-chunking-reference.md).

1. Aktualisieren Sie das Skript des Schritts so, dass es einen Frame-Bereich statt eines einzelnen Frames akzeptiert. Mit `rangeConstraint: CONTIGUOUS` wird die `{{Task.Param.Frame}}` Variable immer auf einen `start-end` Formatbereich erweitert, sodass das Script sie mit dem `cut` folgenden Befehl aufteilen kann:

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

   Mit `rangeConstraint: NONCONTIGUOUS` wird die Variable auf einen beliebigen Bereichsausdruck erweitert, wie `1-3,5,7-20:2` z. B. Transformieren Sie den Ausdruck in die Syntax, die Ihre Anwendung akzeptiert. Eine funktionierende Transformation finden Sie in den Beispielen [ für das ](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) Aufteilen von Aufgaben unter. GitHub

1. Reichen Sie das Job-Paket mit der Deadline Cloud-CLI ein:

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

1. Um zu überprüfen, ob das Chunking wirksam ist, öffnen Sie den Job im Deadline Cloud-Monitor und sehen Sie sich die Aufgabenliste des Schritts an. Jede Aufgabe stellt einen Block dar und zeigt beispielsweise `1-10` anstelle einer einzelnen Frame-Nummer einen Frame-Bereich an.

Die folgende vollständige Auftragsvorlage rendert eine Blender-Animation in Blender-Abschnitten von 10 Bildern:

```
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 diesem Beispiel unterteilt Deadline Cloud die 100 Frames in Blöcke wie `1-10` und`11-20`, und jede Aufgabe rendert ihren Chunk mit einem einzigen Blender-Aufruf.

Weitere Informationen finden Sie unter den folgenden Themen:
+ [Gruppieren Sie Frames in Chunks mit Aufgaben-Chunking in Deadline Cloud](examples-jb-task-chunking.md)— Aufteilen von Samples, Ready-to-submit einschließlich einer nicht zusammenhängenden Variante.
+ [So reichen Sie einen Job bei Deadline Cloud ein](submit-jobs-how.md)— Reichen Sie das Job-Paket in Ihre Warteschlange ein.