Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Buat lowongan kerja untuk dikirimkan ke Deadline Cloud
<a name="building-jobs"></a>

Anda mengirimkan pekerjaan ke Deadline Cloud menggunakan paket pekerjaan. Paket pekerjaan adalah kumpulan file, termasuk template [pekerjaan Open Job Description (OpenJD)](https://github.com/OpenJobDescription/openjd-specifications) dan file aset apa pun yang diperlukan untuk merender pekerjaan.

 Template pekerjaan menjelaskan bagaimana pekerja memproses dan mengakses aset, dan menyediakan skrip yang dijalankan pekerja. Paket Job memungkinkan artis, direktur teknis, dan pengembang pipeline untuk dengan mudah mengirimkan pekerjaan kompleks ke Deadline Cloud dari workstation lokal atau farm render lokal mereka. Paket Job sangat berguna bagi tim yang mengerjakan efek visual skala besar, animasi, atau proyek rendering media lainnya yang membutuhkan sumber daya komputasi sesuai permintaan yang dapat diskalakan.

Anda dapat membuat bundel pekerjaan menggunakan sistem file lokal untuk menyimpan file dan editor teks untuk membuat template pekerjaan. Setelah membuat bundel, kirimkan pekerjaan ke Deadline Cloud menggunakan Deadline Cloud CLI atau alat seperti pengirim Deadline Cloud

Anda dapat menyimpan aset Anda dalam sistem file yang dibagikan di antara pekerja Anda, atau Anda dapat menggunakan lampiran pekerjaan Deadline Cloud untuk mengotomatiskan pemindahan aset ke bucket S3 tempat pekerja Anda dapat mengaksesnya. Lampiran Job juga membantu memindahkan output dari pekerjaan Anda kembali ke workstation Anda.

 Bagian berikut memberikan petunjuk terperinci tentang membuat dan mengirimkan paket pekerjaan ke Deadline Cloud. 

**Topics**
+ [Templat Open Job Description (OpenJD) untuk Deadline Cloud](build-job-bundle.md)
+ [Menggunakan file dalam pekerjaan Anda](using-files-in-your-jobs.md)
+ [Gunakan lampiran pekerjaan untuk berbagi file](build-job-attachments.md)
+ [Buat batas sumber daya untuk pekerjaan](build-job-limits.md)
+ [Cara mengirimkan pekerjaan ke Deadline Cloud](submit-jobs-how.md)
+ [Jadwalkan pekerjaan di Deadline Cloud](build-jobs-scheduling.md)
+ [Ubah pekerjaan di Deadline Cloud](build-jobs-modifying.md)

# Templat Open Job Description (OpenJD) untuk Deadline Cloud
<a name="build-job-bundle"></a>

*Paket pekerjaan* adalah salah satu alat yang Anda gunakan untuk menentukan pekerjaan untuk AWS Deadline Cloud. Mereka mengelompokkan template [Open Job Description (OpenJD)](https://github.com/OpenJobDescription/openjd-specifications) dengan informasi tambahan seperti file dan direktori yang digunakan pekerjaan Anda dengan lampiran pekerjaan. Anda menggunakan antarmuka baris perintah Deadline Cloud (CLI) untuk menggunakan bundel pekerjaan untuk mengirimkan pekerjaan agar antrian dapat dijalankan.

Bundel pekerjaan adalah struktur direktori yang berisi template pekerjaan OpenJD, file lain yang menentukan pekerjaan, dan file khusus pekerjaan yang diperlukan sebagai input untuk pekerjaan Anda. Anda dapat menentukan file yang menentukan pekerjaan Anda sebagai file YAMAL atau JSON.

Satu-satunya file yang diperlukan adalah salah satu `template.yaml` atau`template.json`. Anda juga dapat menyertakan file-file berikut:

```
/template.yaml (or template.json)
/asset_references.yaml (or asset_references.json)
/parameter_values.yaml (or parameter_values.json)
/other job-specific files and directories
```

Gunakan bundel pekerjaan untuk pengiriman pekerjaan khusus dengan Deadline Cloud CLI dan lampiran pekerjaan, atau Anda dapat menggunakan antarmuka pengiriman grafis. Misalnya, berikut ini adalah sampel Blender dari GitHub. Untuk menjalankan sampel menggunakan perintah berikut di [direktori sampel Blender](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles):

```
deadline bundle gui-submit blender_render
```

![\[Contoh antarmuka pengiriman pekerjaan khusus untuk Blender.\]](http://docs.aws.amazon.com/id_id/deadline-cloud/latest/developerguide/images/blender_submit_shared_settings.png)


Panel pengaturan khusus pekerjaan dihasilkan dari `userInterface` properti parameter pekerjaan yang ditentukan dalam templat pekerjaan.

Untuk mengirimkan pekerjaan menggunakan baris perintah, Anda dapat menggunakan perintah yang mirip dengan berikut ini

```
deadline bundle submit \
    --yes \
    --name Demo \
     -p BlenderSceneFile=location of scene file \
     -p OutputDir=file pathe for job output \
      blender_render/
```

Atau Anda dapat menggunakan `deadline.client.api.create_job_from_job_bundle` fungsi dalam paket `deadline` Python.

Semua plugin pengirim pekerjaan yang disediakan dengan Deadline Cloud, seperti plugin Autodesk Maya, menghasilkan bundel pekerjaan untuk kiriman Anda dan kemudian gunakan paket Deadline Cloud Python untuk mengirimkan pekerjaan Anda ke Deadline Cloud. Anda dapat melihat bundel pekerjaan yang dikirimkan di direktori riwayat pekerjaan stasiun kerja Anda atau dengan menggunakan pengirim. Anda dapat menemukan direktori riwayat pekerjaan Anda dengan perintah berikut:

```
deadline config get settings.job_history_dir
```

Ketika pekerjaan Anda berjalan pada pekerja Deadline Cloud, ia memiliki akses ke variabel lingkungan yang memberikan informasi tentang pekerjaan tersebut. Variabel lingkungan adalah:


| Nama variabel | Available | 
| --- | --- | 
| DEADLINE\$1FARM\$1ID | Semua tindakan | 
| DEADLINE\$1FLEET\$1ID | Semua tindakan | 
| DEADLINE\$1WORKER\$1ID | Semua tindakan | 
| DEADLINE\$1QUEUE\$1ID | Semua tindakan | 
| DEADLINE\$1JOB\$1ID | Semua tindakan | 
| DEADLINE\$1STEP\$1ID | Tindakan tugas | 
| DEADLINE\$1SESSION\$1ID | Semua tindakan | 
| DEADLINE\$1TASK\$1ID | Tindakan tugas | 
| DEADLINE\$1SESSIONACTION\$1ID | Semua tindakan | 

**Topics**
+ [Elemen template Job untuk bundel pekerjaan](build-job-bundle-template.md)
+ [Pembagian tugas untuk templat pekerjaan](build-job-bundle-chunking.md)
+ [Nilai parameter elemen untuk bundel pekerjaan](build-job-bundle-parameters.md)
+ [Elemen referensi aset untuk bundel pekerjaan](build-job-bundle-assets.md)

# Elemen template Job untuk bundel pekerjaan
<a name="build-job-bundle-template"></a>

Template pekerjaan mendefinisikan lingkungan runtime dan proses yang berjalan sebagai bagian dari pekerjaan Deadline Cloud. Anda dapat membuat parameter dalam template sehingga dapat digunakan untuk membuat pekerjaan yang hanya berbeda dalam nilai input, seperti fungsi dalam bahasa pemrograman.

Saat Anda mengirimkan pekerjaan ke Deadline Cloud, itu berjalan di lingkungan antrian apa pun yang diterapkan ke antrian. Lingkungan antrian dibangun menggunakan spesifikasi lingkungan eksternal Open Job Description (OpenJD). Untuk detailnya, lihat [template Lingkungan di repositori](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#12-environment-template) OpenJD GitHub .

Untuk pengenalan yang membuat pekerjaan dengan template pekerjaan OpenJD, lihat [Pengantar untuk membuat pekerjaan di repositori](https://github.com/OpenJobDescription/openjd-specifications/wiki/Introduction-to-Creating-a-Job) GitHub OpenJD. Informasi tambahan dapat ditemukan di [Bagaimana pekerjaan dijalankan](https://github.com/OpenJobDescription/openjd-specifications/wiki/How-Jobs-Are-Run). Ada contoh template pekerjaan di dalam direktori GitHub repositori OpenJD. `samples`

Anda dapat menentukan template pekerjaan dalam format YAMAL (`template.yaml`) atau format JSON (`template.json`). Contoh di bagian ini ditampilkan dalam format YAMAL.

Misalnya, template pekerjaan untuk `blender_render` sampel mendefinisikan parameter input `BlenderSceneFile` sebagai jalur file:

```
- name: BlenderSceneFile
  type: PATH
  objectType: FILE
  dataFlow: IN
  userInterface:
    control: CHOOSE_INPUT_FILE
    label: Blender Scene File
    groupLabel: Render Parameters
    fileFilters:
    - label: Blender Scene Files
      patterns: ["*.blend"]
    - label: All Files
      patterns: ["*"]
  description: >
    Choose the Blender scene file to render. Use the 'Job Attachments' tab
    to add textures and other files that the job needs.
```

`userInterface`Properti mendefinisikan perilaku antarmuka pengguna yang dihasilkan secara otomatis untuk kedua baris perintah menggunakan `deadline bundle gui-submit` perintah dan dalam plugin pengiriman pekerjaan untuk aplikasi seperti Autodesk Maya.

Dalam contoh ini, widget UI untuk memasukkan nilai untuk `BlenderSceneFile` parameter adalah dialog pemilihan file yang hanya menampilkan file. `.blend`

![\[Widget antarmuka pengguna untuk memasukkan parameter file adegan untuk template pekerjaan OpenJD.\]](http://docs.aws.amazon.com/id_id/deadline-cloud/latest/developerguide/images/blender_submit_scene_file_widget.png)


Untuk lebih banyak contoh penggunaan `userInteface` elemen, lihat contoh [gui\$1control\$1showcase](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/gui_control_showcase) di repositori pada. [deadline-cloud-samples](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline) GitHub

`dataFlow`Properti `objectType` dan mengontrol perilaku lampiran pekerjaan saat Anda mengirimkan pekerjaan dari bundel pekerjaan. Dalam hal ini, `objectType: FILE` dan `dataFlow:IN` berarti bahwa nilai `BlenderSceneFile` adalah file input untuk lampiran pekerjaan.

Sebaliknya, definisi `OutputDir` parameter memiliki `objectType: DIRECTORY` dan`dataFlow: OUT`:

```
- name: OutputDir
  type: PATH
  objectType: DIRECTORY
  dataFlow: OUT
  userInterface:
    control: CHOOSE_DIRECTORY
    label: Output Directory
    groupLabel: Render Parameters
  default: "./output"
  description: Choose the render output directory.
```

Nilai `OutputDir` parameter digunakan oleh lampiran pekerjaan sebagai direktori tempat pekerjaan menulis file output.

Untuk informasi selengkapnya tentang `dataFlow` properti `objectType` dan properti, lihat [JobPathParameterDefinition](https://github.com/OpenJobDescription/openjd-specifications/wiki/2023-09-Template-Schemas#22-jobpathparameterdefinition)[spesifikasi Open Job Description](https://github.com/OpenJobDescription/openjd-specifications)

Contoh template `blender_render` pekerjaan lainnya mendefinisikan alur kerja pekerjaan sebagai langkah tunggal dengan setiap frame dalam animasi yang dirender sebagai tugas terpisah:

```
steps:
- name: RenderBlender
  parameterSpace:
    taskParameterDefinitions:
    - name: Frame
      type: INT
      range: "{{Param.Frames}}"
  script:
    actions:
      onRun:
        command: bash
        # Note: {{Task.File.Run}} is a variable that expands to the filename on the worker host's
        # disk where the contents of the 'Run' embedded file, below, is written.
        args: ['{{Task.File.Run}}']
    embeddedFiles:
      - name: Run
        type: TEXT
        data: |
          # Configure the task to fail if any individual command fails.
          set -xeuo pipefail

          mkdir -p '{{Param.OutputDir}}'

          blender --background '{{Param.BlenderSceneFile}}' \
                  --render-output '{{Param.OutputDir}}/{{Param.OutputPattern}}' \
                  --render-format {{Param.Format}} \
                  --use-extension 1 \
                  --render-frame {{Task.Param.Frame}}
```

Misalnya, jika nilai `Frames` parameternya`1-10`, ia mendefinisikan 10 tugas. Masing-masing memiliki tugas memiliki nilai yang berbeda untuk `Frame` parameter. Untuk menjalankan tugas:

1. Semua referensi variabel dalam `data` properti file tertanam diperluas, misalnya`--render-frame 1`.

1. Isi `data` properti ditulis ke file di direktori kerja sesi pada disk.

1. `onRun`Perintah tugas menyelesaikan `bash location of embedded file` dan kemudian berjalan.

Untuk informasi selengkapnya tentang file yang disematkan, sesi, dan lokasi yang dipetakan jalur, lihat [Bagaimana pekerjaan dijalankan](https://github.com/OpenJobDescription/openjd-specifications/wiki/How-Jobs-Are-Run) dalam spesifikasi Open [Job Description](https://github.com/OpenJobDescription/openjd-specifications/wiki/How-Jobs-Are-Run).

Ada lebih banyak contoh template pekerjaan di repositori [deadline-cloud-samples/job\$1bundles](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles), serta sampel [template yang disediakan](https://github.com/OpenJobDescription/openjd-specifications/tree/mainline/samples) dengan spesifikasi Open Job Descriptions.

# Pembagian tugas untuk templat pekerjaan
<a name="build-job-bundle-chunking"></a>

Task chunking memungkinkan Anda mengelompokkan beberapa tugas ke dalam satu unit kerja yang disebut chunk. Dalam pekerjaan render, misalnya, ini berarti Deadline Cloud dapat mengirimkan beberapa frame bersama-sama, bukan satu frame per permintaan perintah. Ini mengurangi overhead aplikasi awal untuk setiap tugas dan mempersingkat total runtime pekerjaan. Untuk detailnya, lihat [Menjalankan beberapa frame sekaligus](https://github.com/OpenJobDescription/openjd-specifications/wiki/Job-Intro-03-Creating-a-Job-Template#42-running-multiple-frames-at-a-time) di wiki OpenJD.

OpenJD mendukung ekstensi yang menambahkan fitur opsional ke template pekerjaan. Chunking tugas diaktifkan dengan menambahkan ekstensi. `TASK_CHUNKING` Untuk menggunakan chunking, tambahkan ekstensi ke template pekerjaan Anda dan gunakan tipe parameter `CHUNK[INT]` tugas. Kirim pekerjaan yang terpotong menggunakan perintah yang sama`deadline bundle submit`. Misalnya, template pekerjaan berikut merender frame dalam potongan 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
```

Dalam contoh ini, Deadline Cloud membagi 100 frame menjadi potongan-potongan seperti`1-10`,`11-20`, dan seterusnya. `{{Task.Param.Frame}}`Variabel meluas ke ekspresi rentang seperti`1-10`. Karena `rangeConstraint` diatur ke`CONTIGUOUS`, rentang selalu dalam `start-end` format. Skrip mem-parsing rentang ini dan meneruskan frame awal dan akhir ke Blender menggunakan `-e` opsi `-s` dan dengan`--render-anim`.

`chunks`Properti mendukung bidang-bidang berikut:
+ `defaultTaskCount`— (Wajib) Berapa banyak tugas untuk digabungkan menjadi satu bagian. Nilai maksimumnya adalah 150.
+ `rangeConstraint`— (Wajib) Jika`CONTIGUOUS`, potongan selalu merupakan rentang yang berdekatan seperti. `1-10` Jika`NONCONTIGUOUS`, potongan bisa menjadi set sewenang-wenang seperti. `1,3,7-10`
+ `targetRuntimeSeconds`— (Opsional) Target runtime dalam hitungan detik untuk setiap potongan. Deadline Cloud dapat secara dinamis menyesuaikan ukuran potongan untuk mendekati target ini setelah beberapa potongan selesai.

[Untuk contoh potongan tugas lainnya, termasuk contoh dasar dan Blender dengan potongan yang berdekatan dan tidak bersebelahan, lihat tugas memotong sampel di repositori sampel Deadline Cloud pada.](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/task_chunking) GitHub

**Persyaratan armada yang dikelola pelanggan**  
Task chunking memerlukan versi agen pekerja yang kompatibel. Jika Anda menggunakan armada yang dikelola pelanggan, pastikan agen pekerja Anda diperbarui sebelum mengirimkan pekerjaan dengan chunking. Armada yang dikelola layanan selalu menggunakan versi agen pekerja yang kompatibel.

**Mengunduh output untuk pekerjaan yang terpotong**  
Saat Anda mengunduh output untuk satu tugas dalam pekerjaan yang dipotong, Deadline Cloud mengunduh output untuk seluruh potongan. Misalnya, jika frame 1-10 diproses bersama, mengunduh output untuk frame 3 mencakup semua frame 1-10. Fitur ini membutuhkan `deadline-cloud` versi 0.53.3 atau yang lebih baru.

# Nilai parameter elemen untuk bundel pekerjaan
<a name="build-job-bundle-parameters"></a>

Anda dapat menggunakan file parameter untuk mengatur nilai beberapa parameter pekerjaan di template pekerjaan atau argumen permintaan [CreateJob](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html)operasi dalam bundel pekerjaan sehingga Anda tidak perlu menetapkan nilai saat mengirimkan pekerjaan. UI untuk pengiriman pekerjaan memungkinkan Anda untuk mengubah nilai-nilai ini.

Anda dapat menentukan template pekerjaan dalam format YAMAL (`parameter_values.yaml`) atau format JSON (`parameter_values.json`). Contoh di bagian ini ditampilkan dalam format YAMAL.

Di YAMAL, format file adalah:

```
parameterValues:
- name: <string>
  value: <integer>, <float>, or <string>
- name: <string>
  value: <integer>, <float>, or <string>ab
... repeating as necessary
```

Setiap elemen `parameterValues` daftar harus salah satu dari yang berikut:
+ Parameter pekerjaan didefinisikan dalam template pekerjaan.
+ Parameter pekerjaan yang ditentukan dalam lingkungan antrian untuk antrian yang Anda kirimkan pekerjaan ke..
+ Parameter khusus diteruskan ke `CreateJob` operasi saat membuat pekerjaan.
  + `deadline:priority`— Nilai harus berupa bilangan bulat. Itu diteruskan ke `CreateJob` operasi sebagai parameter [prioritas](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html#deadlinecloud-CreateJob-request-priority).
  + `deadline:targetTaskRunStatus`— Nilai harus berupa string. Itu diteruskan ke `CreateJob` operasi sebagai parameter [targetTaskRunStatus](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html#deadlinecloud-CreateJob-request-targetTaskRunStatus).
  + `deadline:maxFailedTasksCount`— Nilai harus berupa bilangan bulat. Itu diteruskan ke `CreateJob` operasi sebagai parameter [maxFailedTasksCount](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html#deadlinecloud-CreateJob-request-maxFailedTasksCount).
  + `deadline:maxRetriesPerTask`— Nilai harus berupa bilangan bulat. Itu diteruskan ke `CreateJob` operasi sebagai parameter [maxRetriesPerTugas](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html#deadlinecloud-CreateJob-request-maxRetriesPerTask).
  + `deadline:maxWorkercount`— Nilai harus berupa bilangan bulat. Itu diteruskan ke `CreateJob` operasi sebagai [maxWorkerCount](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html#deadlinecloud-CreateJob-request-maxRetriesPerTask)parameter.

Template pekerjaan selalu merupakan template daripada pekerjaan tertentu untuk dijalankan. File nilai parameter memungkinkan bundel pekerjaan untuk bertindak sebagai templat jika beberapa parameter tidak memiliki nilai yang ditentukan dalam file ini, atau sebagai pengiriman pekerjaan tertentu jika semua parameter memiliki nilai.

Misalnya, [sampel blender\$1render](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/blender_render) tidak memiliki file parameter dan template pekerjaannya mendefinisikan parameter tanpa nilai default. Template ini harus digunakan sebagai template untuk membuat pekerjaan. Setelah Anda membuat pekerjaan menggunakan bundel pekerjaan ini, Deadline Cloud menulis bundel pekerjaan baru ke direktori riwayat pekerjaan. 

Misalnya, ketika Anda mengirimkan pekerjaan dengan perintah berikut:

```
deadline bundle gui-submit blender_render/
```

Bundel pekerjaan baru berisi `parameter_values.yaml` file yang berisi parameter yang ditentukan:

```
% cat ~/.deadline/job_history/\(default\)/2024-06/2024-06-20-01-JobBundle-Demo/parameter_values.yaml
parameterValues:
- name: deadline:targetTaskRunStatus
  value: READY
- name: deadline:maxFailedTasksCount
  value: 10
- name: deadline:maxRetriesPerTask
  value: 5
- name: deadline:priority
  value: 75
- name: BlenderSceneFile
  value: /private/tmp/bundle_demo/bmw27_cpu.blend
- name: Frames
  value: 1-10
- name: OutputDir
  value: /private/tmp/bundle_demo/output
- name: OutputPattern
  value: output_####
- name: Format
  value: PNG
- name: CondaPackages
  value: blender
- name: RezPackages
  value: blender
```

Anda dapat membuat pekerjaan yang sama dengan perintah berikut:

```
deadline bundle submit ~/.deadline/job_history/\(default\)/2024-06/2024-06-20-01-JobBundle-Demo/
```

**catatan**  
Paket pekerjaan yang Anda kirimkan disimpan ke direktori riwayat pekerjaan Anda. Anda dapat menemukan lokasi direktori tersebut dengan perintah berikut:  

```
deadline config get settings.job_history_dir
```

# Elemen referensi aset untuk bundel pekerjaan
<a name="build-job-bundle-assets"></a>

Anda dapat menggunakan [lampiran pekerjaan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-job-attachments.html) Deadline Cloud untuk mentransfer file bolak-balik antara workstation dan Deadline Cloud. File referensi aset mencantumkan file input dan direktori, serta direktori keluaran untuk lampiran Anda. Jika Anda tidak mencantumkan semua file dan direktori dalam file ini, Anda dapat memilihnya saat Anda mengirimkan pekerjaan dengan `deadline bundle gui-submit` perintah.

File ini tidak berpengaruh jika Anda tidak menggunakan lampiran pekerjaan.

Anda dapat menentukan template pekerjaan dalam format YAMAL (`asset_references.yaml`) atau format JSON (`asset_references.json`). Contoh di bagian ini ditampilkan dalam format YAMAL.

Di YAMAL, format file adalah:

```
assetReferences:
    inputs:
        # Filenames on the submitting workstation whose file contents are needed as 
        # inputs to run the job.
        filenames:
        - list of file paths
        # Directories on the submitting workstation whose contents are needed as inputs
        # to run the job.
        directories:
        - list of directory paths

    outputs:
        # Directories on the submitting workstation where the job writes output files
        # if running locally.
        directories:
        - list of directory paths

    # Paths referenced by the job, but not necessarily input or output.
    # Use this if your job uses the name of a path in some way, but does not explicitly need
    # the contents of that path.
    referencedPaths:
    - list of directory paths
```

Saat memilih file input atau output untuk diunggah ke Amazon S3, Deadline Cloud membandingkan jalur file dengan jalur yang tercantum dalam profil penyimpanan Anda. Setiap lokasi sistem file `SHARED` -type dalam profil penyimpanan mengabstraksi berbagi file jaringan yang dipasang di workstation dan host pekerja Anda. Deadline Cloud hanya mengunggah file yang tidak ada di salah satu pembagian file ini.

Untuk informasi selengkapnya tentang membuat dan menggunakan profil penyimpanan, lihat [Penyimpanan bersama di Deadline Cloud](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-shared.html) di *Panduan Pengguna Cloud AWS Deadline*.

**Example - File referensi aset yang dibuat oleh Deadline Cloud GUI**  
Gunakan perintah berikut untuk mengirimkan pekerjaan menggunakan sampel [blender\$1render](https://github.com/aws-deadline/deadline-cloud-samples/tree/mainline/job_bundles/blender_render).  

```
deadline bundle gui-submit blender_render/
```
Tambahkan beberapa file tambahan ke pekerjaan di tab **Lampiran Job**:  

![\[Panel lampiran pekerjaan dari GUI pengiriman pekerjaan Deadline Cloud. Tambahkan file input/private/tmp/bundle_demo/a_texture.png and the input directory /private/tmp/bundle_demo/assets.\]](http://docs.aws.amazon.com/id_id/deadline-cloud/latest/developerguide/images/blender_submit_add_job_attachments.png)

Setelah mengirimkan pekerjaan, Anda dapat melihat `asset_references.yaml` file dalam bundel pekerjaan di direktori riwayat pekerjaan untuk melihat aset dalam file YAMAL:  

```
% cat ~/.deadline/job_history/\(default\)/2024-06/2024-06-20-01-JobBundle-Demo/asset_references.yaml 
assetReferences:
  inputs:
    filenames:
    - /private/tmp/bundle_demo/a_texture.png
    directories:
    - /private/tmp/bundle_demo/assets
  outputs:
    directories: []
  referencedPaths: []
```

# Menggunakan file dalam pekerjaan Anda
<a name="using-files-in-your-jobs"></a>

 Banyak pekerjaan yang Anda kirimkan ke AWS Deadline Cloud memiliki file input dan output. File input dan direktori output Anda mungkin terletak pada kombinasi sistem file bersama dan drive lokal. Pekerjaan perlu menemukan konten di lokasi tersebut. Deadline Cloud menyediakan dua fitur, [lampiran pekerjaan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-job-attachments.html) dan [profil penyimpanan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-shared.html) yang bekerja sama untuk membantu pekerjaan Anda menemukan file yang mereka butuhkan. 

Lampiran Job menawarkan beberapa manfaat
+ Memindahkan file antar host menggunakan Amazon S3
+ Transfer file dari stasiun kerja Anda ke host pekerja dan sebaliknya
+ Tersedia untuk pekerjaan dalam antrian tempat Anda mengaktifkan fitur
+ Terutama digunakan dengan armada yang dikelola layanan, tetapi juga kompatibel dengan armada yang dikelola pelanggan.

 Gunakan profil penyimpanan untuk memetakan tata letak lokasi sistem file bersama di workstation dan host pekerja Anda. Pemetaan ini membantu pekerjaan Anda menemukan file dan direktori bersama ketika lokasinya berbeda antara workstation dan host pekerja Anda, seperti pengaturan lintas platform dengan workstation berbasis dan host pekerja Windows berbasis. Linux Peta profil penyimpanan konfigurasi sistem file Anda juga digunakan oleh lampiran pekerjaan untuk mengidentifikasi file yang diperlukan untuk berpindah antar host melalui Amazon S3. 

 Jika Anda tidak menggunakan lampiran pekerjaan, dan Anda tidak perlu memetakan ulang lokasi file dan direktori antara workstation dan host pekerja maka Anda tidak perlu memodelkan fileshares Anda dengan profil penyimpanan. 

**Topics**
+ [Contoh infrastruktur proyek](sample-project-infrastructure.md)
+ [Profil penyimpanan dan pemetaan jalur](storage-profiles-and-path-mapping.md)

# Contoh infrastruktur proyek
<a name="sample-project-infrastructure"></a>

Untuk mendemonstrasikan penggunaan lampiran pekerjaan dan profil penyimpanan, siapkan lingkungan pengujian dengan dua proyek terpisah. Anda dapat menggunakan konsol Deadline Cloud untuk membuat sumber daya pengujian.

1. Jika Anda belum melakukannya, buat peternakan uji. Untuk membuat peternakan, ikuti prosedur di [Buat peternakan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/farms.html). 

1. Buat dua antrian untuk pekerjaan di masing-masing dari dua proyek. Untuk membuat antrian, ikuti prosedur di [Buat](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-queue.html) antrian.

   1. Buat antrian pertama yang disebut**Q1**. Gunakan konfigurasi berikut, gunakan default untuk semua item lainnya.
      + Untuk lampiran pekerjaan, pilih **Buat bucket Amazon S3 baru**.
      + Pilih **Aktifkan asosiasi dengan armada yang dikelola pelanggan**.
      + Untuk menjalankan sebagai pengguna, masukkan **jobuser** untuk pengguna dan grup POSIX.
      + Untuk peran layanan antrian, buat peran baru bernama **AssetDemoFarm-Q1-Role**
      + Kosongkan kotak centang lingkungan antrian conda default.

   1. Buat antrian kedua yang disebut**Q2**. Gunakan konfigurasi berikut, gunakan default untuk semua item lainnya.
      + Untuk lampiran pekerjaan, pilih **Buat bucket Amazon S3 baru**.
      + Pilih **Aktifkan asosiasi dengan armada yang dikelola pelanggan**.
      + Untuk menjalankan sebagai pengguna, masukkan **jobuser** untuk pengguna dan grup POSIX.
      + Untuk peran layanan antrian, buat peran baru bernama **AssetDemoFarm-Q2-Role**
      + Kosongkan kotak centang lingkungan antrian conda default.

1. Buat satu armada yang dikelola pelanggan yang menjalankan pekerjaan dari kedua antrian. Untuk membuat armada, ikuti prosedur di [Buat armada yang dikelola pelanggan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/create-a-cmf.html). Gunakan konfigurasi berikut:
   + Untuk **Nama**, gunakan**DemoFleet**.
   + Untuk **jenis Armada** pilih **Customer managed**
   + Untuk **peran layanan Armada, buat peran** baru bernama **AssetDemoFarm-Fleet-Role**.
   + Jangan mengaitkan armada dengan antrian apa pun.

Lingkungan pengujian mengasumsikan bahwa ada tiga sistem file yang dibagi antara host menggunakan berbagi file jaringan. Dalam contoh ini, lokasi memiliki nama-nama berikut:
+ `FSCommon`- berisi aset pekerjaan masukan yang umum untuk kedua proyek.
+ `FS1`- berisi input dan output aset pekerjaan untuk proyek 1.
+ `FS2`- berisi input dan output aset pekerjaan untuk proyek 2.

Lingkungan pengujian juga mengasumsikan bahwa ada tiga workstation, sebagai berikut:
+ `WSAll`- Workstation Linux berbasis yang digunakan oleh pengembang untuk semua proyek. Lokasi sistem file bersama adalah:
  + `FSCommon`: `/shared/common`
  + `FS1`: `/shared/projects/project1`
  + `FS2`: `/shared/projects/project2`
+ `WS1`- Sebuah workstation Windows berbasis yang digunakan untuk proyek 1. Lokasi sistem file bersama adalah:
  + `FSCommon`: `S:\`
  + `FS1`: `Z:\`
  + `FS2`: Tidak tersedia
+ `WS1`- Workstation macOS berbasis yang digunakan untuk proyek 2. Lokasi sistem file bersama adalah:
  + `FSCommon`: `/Volumes/common`
  + `FS1`: Tidak tersedia
  + `FS2`: `/Volumes/projects/project2`

Terakhir, tentukan lokasi sistem file bersama untuk pekerja di armada Anda. Contoh-contoh berikut mengacu pada konfigurasi ini sebagai`WorkerConfig`. Lokasi bersama adalah: 
+ `FSCommon`: `/mnt/common`
+ `FS1`: `/mnt/projects/project1`
+ `FS2`: `/mnt/projects/project2`

 Anda tidak perlu menyiapkan sistem file bersama, workstation, atau pekerja yang cocok dengan konfigurasi ini. Lokasi bersama tidak perlu ada untuk demonstrasi. 

# Profil penyimpanan dan pemetaan jalur
<a name="storage-profiles-and-path-mapping"></a>

Gunakan profil penyimpanan untuk memodelkan sistem file di workstation dan host pekerja Anda. Setiap profil penyimpanan menjelaskan sistem operasi dan tata letak sistem file dari salah satu konfigurasi sistem Anda. Topik ini menjelaskan cara menggunakan profil penyimpanan untuk memodelkan konfigurasi sistem file host Anda sehingga Deadline Cloud dapat menghasilkan aturan pemetaan jalur untuk pekerjaan Anda, dan bagaimana aturan pemetaan jalur tersebut dihasilkan dari profil penyimpanan Anda.

Saat mengirimkan pekerjaan ke Deadline Cloud, Anda dapat memberikan ID profil penyimpanan opsional untuk pekerjaan tersebut. Profil penyimpanan ini menjelaskan sistem file workstation pengiriman. Ini menjelaskan konfigurasi sistem file asli yang digunakan jalur file dalam template pekerjaan.

Anda juga dapat mengaitkan profil penyimpanan dengan armada. Profil penyimpanan menjelaskan konfigurasi sistem file dari semua host pekerja di armada. Jika Anda memiliki pekerja dengan konfigurasi sistem file yang berbeda, pekerja tersebut harus ditugaskan ke armada yang berbeda di peternakan Anda.

 Aturan pemetaan jalur menjelaskan bagaimana jalur harus dipetakan ulang dari cara mereka ditentukan dalam pekerjaan ke lokasi aktual jalur pada host pekerja. Deadline Cloud membandingkan konfigurasi sistem file yang dijelaskan dalam profil penyimpanan pekerjaan dengan profil penyimpanan armada yang menjalankan pekerjaan untuk mendapatkan aturan pemetaan jalur ini. 

**Topics**
+ [Model lokasi sistem file bersama dengan profil penyimpanan](modeling-your-shared-filesystem-locations-with-storage-profiles.md)
+ [Konfigurasikan profil penyimpanan untuk armada](configuring-storage-profiles-for-fleets.md)
+ [Konfigurasikan profil penyimpanan untuk antrian](storage-profiles-for-queues.md)
+ [Turunkan aturan pemetaan jalur dari profil penyimpanan](deriving-path-mapping-rules-from-storage-profiles.md)

# Model lokasi sistem file bersama dengan profil penyimpanan
<a name="modeling-your-shared-filesystem-locations-with-storage-profiles"></a>

 Profil penyimpanan memodelkan konfigurasi sistem file dari salah satu konfigurasi host Anda. Ada empat konfigurasi host yang berbeda dalam [infrastruktur proyek sampel](). Dalam contoh ini Anda membuat profil penyimpanan terpisah untuk masing-masing. Anda dapat membuat profil penyimpanan menggunakan salah satu dari berikut ini:
+ [CreateStorageProfile API](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateStorageProfile.html)
+ [AWS::Deadline::StorageProfile](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-deadline-storageprofile.html) CloudFormation sumber daya
+ [AWS konsol](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/storage-shared.html#storage-profile)

 Profil penyimpanan terdiri dari daftar lokasi sistem file yang masing-masing memberi tahu Deadline Cloud lokasi dan jenis lokasi sistem file yang relevan untuk pekerjaan yang dikirim dari atau dijalankan pada host. Profil penyimpanan seharusnya hanya memodelkan lokasi yang relevan untuk pekerjaan. Misalnya, `FSCommon` lokasi bersama terletak di workstation `WS1` di`S:\`, jadi lokasi sistem file yang sesuai adalah: 

```
{
    "name": "FSCommon",
    "path": "S:\\",
    "type": "SHARED"
}
```

 Gunakan perintah berikut untuk membuat profil penyimpanan untuk konfigurasi workstation `WS1``WS2`, `WS3` dan konfigurasi pekerja `WorkerConfig` menggunakan in [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html): [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html) 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff

aws deadline create-storage-profile --farm-id $FARM_ID \
  --display-name WSAll \
  --os-family LINUX \
  --file-system-locations \
  '[
      {"name": "FSCommon", "type":"SHARED", "path":"/shared/common"},
      {"name": "FS1", "type":"SHARED", "path":"/shared/projects/project1"},
      {"name": "FS2", "type":"SHARED", "path":"/shared/projects/project2"}
  ]'

aws deadline create-storage-profile --farm-id $FARM_ID \
  --display-name WS1 \
  --os-family WINDOWS \
  --file-system-locations \
  '[
      {"name": "FSCommon", "type":"SHARED", "path":"S:\\"},
      {"name": "FS1", "type":"SHARED", "path":"Z:\\"}
   ]'

aws deadline create-storage-profile --farm-id $FARM_ID \
  --display-name WS2 \
  --os-family MACOS \
  --file-system-locations \
  '[
      {"name": "FSCommon", "type":"SHARED", "path":"/Volumes/common"},
      {"name": "FS2", "type":"SHARED", "path":"/Volumes/projects/project2"}
  ]'

aws deadline create-storage-profile --farm-id $FARM_ID \
  --display-name WorkerCfg \
  --os-family LINUX \
  --file-system-locations \
  '[
      {"name": "FSCommon", "type":"SHARED", "path":"/mnt/common"},
      {"name": "FS1", "type":"SHARED", "path":"/mnt/projects/project1"},
      {"name": "FS2", "type":"SHARED", "path":"/mnt/projects/project2"}
  ]'
```

**catatan**  
Anda harus merujuk ke lokasi sistem file di profil penyimpanan Anda menggunakan nilai yang sama untuk `name` properti di semua profil penyimpanan di pertanian Anda. Deadline Cloud membandingkan nama untuk menentukan bahwa lokasi sistem file dari profil penyimpanan yang berbeda merujuk ke lokasi yang sama saat membuat aturan pemetaan jalur. 

# Konfigurasikan profil penyimpanan untuk armada
<a name="configuring-storage-profiles-for-fleets"></a>

Anda dapat mengonfigurasi armada untuk menyertakan profil penyimpanan yang memodelkan lokasi sistem file pada semua pekerja di armada. Konfigurasi sistem file host dari semua pekerja dalam armada harus sesuai dengan profil penyimpanan armada mereka. Pekerja dengan konfigurasi sistem file yang berbeda harus berada dalam armada terpisah. 

Untuk mengatur konfigurasi armada Anda agar menggunakan profil `WorkerConfig` penyimpanan, gunakan fitur [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html)in [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html): 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of FLEET_ID to your fleet's identifier
FLEET_ID=fleet-00112233445566778899aabbccddeeff
# Change the value of WORKER_CFG_ID to your storage profile named WorkerConfig
WORKER_CFG_ID=sp-00112233445566778899aabbccddeeff

FLEET_WORKER_MODE=$( \
  aws deadline get-fleet --farm-id $FARM_ID --fleet-id $FLEET_ID \
   --query '.configuration.customerManaged.mode' \
)
FLEET_WORKER_CAPABILITIES=$( \
  aws deadline get-fleet --farm-id $FARM_ID --fleet-id $FLEET_ID \
   --query '.configuration.customerManaged.workerCapabilities' \
)

aws deadline update-fleet --farm-id $FARM_ID --fleet-id $FLEET_ID \
  --configuration \
  "{
    \"customerManaged\": {
      \"storageProfileId\": \"$WORKER_CFG_ID\",
      \"mode\": $FLEET_WORKER_MODE,
      \"workerCapabilities\": $FLEET_WORKER_CAPABILITIES
    }
  }"
```

# Konfigurasikan profil penyimpanan untuk antrian
<a name="storage-profiles-for-queues"></a>

 Konfigurasi antrian mencakup daftar nama peka huruf besar/kecil dari lokasi sistem file bersama yang pekerjaan yang dikirimkan ke antrian memerlukan akses ke. misalnya, pekerjaan yang dikirimkan ke antrian `Q1` memerlukan lokasi sistem file dan. `FSCommon` `FS1` Pekerjaan yang dikirimkan ke antrian `Q2` memerlukan lokasi sistem file `FSCommon` dan`FS2`. 

Untuk mengatur konfigurasi antrian agar memerlukan lokasi sistem file ini, gunakan skrip berikut: 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of QUEUE2_ID to queue Q2's identifier
QUEUE2_ID=queue-00112233445566778899aabbccddeeff

aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
  --required-file-system-location-names-to-add FSComm FS1

aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE2_ID \
  --required-file-system-location-names-to-add FSComm FS2
```

 Konfigurasi antrian juga mencakup daftar profil penyimpanan yang diizinkan yang berlaku untuk pekerjaan yang dikirimkan dan armada yang terkait dengan antrian tersebut. Hanya profil penyimpanan yang menentukan lokasi sistem file untuk semua lokasi sistem file yang diperlukan untuk antrian yang diizinkan dalam daftar antrian profil penyimpanan yang diizinkan. 

Pekerjaan gagal jika Anda mengirimkannya dengan profil penyimpanan yang tidak ada dalam daftar profil penyimpanan yang diizinkan untuk antrian. Anda selalu dapat mengirimkan pekerjaan tanpa profil penyimpanan ke antrian. Konfigurasi workstation berlabel `WSAll` dan `WS1` keduanya memiliki lokasi sistem file yang diperlukan (`FSCommon`dan`FS1`) untuk antrian. `Q1` Mereka harus diizinkan untuk mengirimkan pekerjaan ke antrian. Demikian pula, konfigurasi workstation `WSAll` dan `WS2` memenuhi persyaratan untuk antrian. `Q2` Mereka harus diizinkan untuk mengirimkan pekerjaan ke antrian itu. Perbarui kedua konfigurasi antrian untuk memungkinkan pekerjaan dikirimkan dengan profil penyimpanan ini menggunakan skrip berikut: 

```
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff
# Change the value of WS1 to the identifier of the WS1 storage profile
WS1_ID=sp-00112233445566778899aabbccddeeff
# Change the value of WS2 to the identifier of the WS2 storage profile
WS2_ID=sp-00112233445566778899aabbccddeeff

aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
  --allowed-storage-profile-ids-to-add $WSALL_ID $WS1_ID

aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE2_ID \
  --allowed-storage-profile-ids-to-add $WSALL_ID $WS2_ID
```

 Jika Anda menambahkan profil `WS2` penyimpanan ke daftar profil penyimpanan yang diizinkan untuk antrian, `Q1` itu gagal: 

```
$ aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
  --allowed-storage-profile-ids-to-add $WS2_ID

An error occurred (ValidationException) when calling the UpdateQueue operation: Storage profile id: sp-00112233445566778899aabbccddeeff does not have required file system location: FS1
```

 Ini karena profil `WS2` penyimpanan tidak berisi definisi untuk lokasi sistem file bernama antrian `FS1` yang `Q1` diperlukan. 

 Mengaitkan armada yang dikonfigurasi dengan profil penyimpanan yang tidak ada dalam daftar antrian profil penyimpanan yang diizinkan juga gagal. Contoh: 

```
$ aws deadline create-queue-fleet-association --farm-id $FARM_ID \
   --fleet-id $FLEET_ID \
   --queue-id $QUEUE1_ID

An error occurred (ValidationException) when calling the CreateQueueFleetAssociation operation: Mismatch between storage profile ids.
```

Untuk memperbaiki kesalahan, tambahkan profil penyimpanan yang diberi nama `WorkerConfig` ke daftar profil penyimpanan yang diizinkan untuk antrian `Q1` dan antrian. `Q2` Kemudian, kaitkan armada dengan antrian ini sehingga pekerja di armada dapat menjalankan pekerjaan dari kedua antrian. 

```
# Change the value of FLEET_ID to your fleet's identifier
FLEET_ID=fleet-00112233445566778899aabbccddeeff
# Change the value of WORKER_CFG_ID to your storage profile named WorkerCfg
WORKER_CFG_ID=sp-00112233445566778899aabbccddeeff

aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
  --allowed-storage-profile-ids-to-add $WORKER_CFG_ID

aws deadline update-queue --farm-id $FARM_ID --queue-id $QUEUE2_ID \
  --allowed-storage-profile-ids-to-add $WORKER_CFG_ID

aws deadline create-queue-fleet-association --farm-id $FARM_ID \
  --fleet-id $FLEET_ID \
  --queue-id $QUEUE1_ID

aws deadline create-queue-fleet-association --farm-id $FARM_ID \
  --fleet-id $FLEET_ID \
  --queue-id $QUEUE2_ID
```

# Turunkan aturan pemetaan jalur dari profil penyimpanan
<a name="deriving-path-mapping-rules-from-storage-profiles"></a>

 Aturan pemetaan jalur menjelaskan bagaimana jalur harus dipetakan ulang dari pekerjaan ke lokasi sebenarnya jalur pada host pekerja. Saat tugas dijalankan pada pekerja, profil penyimpanan dari pekerjaan tersebut dibandingkan dengan profil penyimpanan armada pekerja untuk mendapatkan aturan pemetaan jalur untuk tugas tersebut. 

 Deadline Cloud membuat aturan pemetaan untuk setiap lokasi sistem file yang diperlukan dalam konfigurasi antrian. Misalnya, pekerjaan yang dikirimkan dengan profil `WSAll` penyimpanan ke antrian `Q1` memiliki aturan pemetaan jalur: 
+  `FSComm`: `/shared/common -> /mnt/common` 
+  `FS1`: `/shared/projects/project1 -> /mnt/projects/project1` 

 Deadline Cloud membuat aturan untuk lokasi `FSComm` dan sistem `FS1` file, tetapi bukan lokasi sistem `FS2` file meskipun profil `WSAll` dan `WorkerConfig` penyimpanan ditentukan`FS2`. Ini karena daftar antrian `Q1` lokasi sistem file yang diperlukan adalah`["FSComm", "FS1"]`. 

 Anda dapat mengonfirmasi aturan pemetaan jalur yang tersedia untuk pekerjaan yang dikirimkan dengan profil penyimpanan tertentu dengan mengirimkan pekerjaan yang mencetak [file aturan pemetaan jalur Open Job Description](https://github.com/OpenJobDescription/openjd-specifications/wiki/How-Jobs-Are-Run#path-mapping), lalu membaca log sesi setelah pekerjaan selesai: 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSALL storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

aws deadline create-job --farm-id $FARM_ID --queue-id $QUEUE1_ID \
  --priority 50 \
  --storage-profile-id $WSALL_ID \
  --template-type JSON --template \
  '{
    "specificationVersion": "jobtemplate-2023-09",
    "name": "DemoPathMapping",
    "steps": [
      {
        "name": "ShowPathMappingRules",
        "script": {
          "actions": {
            "onRun": {
              "command": "/bin/cat",
              "args": [ "{{Session.PathMappingRulesFile}}" ]
            }
          }
        }
      }
    ]
  }'
```

 Jika Anda menggunakan [Deadline Cloud CLI](https://pypi.org/project/deadline/) untuk mengirimkan pekerjaan, pengaturan `settings.storage_profile_id` konfigurasinya menetapkan profil penyimpanan yang akan dimiliki oleh pekerjaan yang dikirimkan dengan CLI. Untuk mengirimkan pekerjaan dengan profil `WSAll` penyimpanan, atur: 

```
deadline config set settings.storage_profile_id $WSALL_ID
```

 Untuk menjalankan pekerja yang dikelola pelanggan seolah-olah sedang berjalan di infrastruktur sampel, ikuti prosedur di [Jalankan agen pekerja di](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/run-worker.html) *Panduan Pengguna Cloud Tenggat* Waktu untuk menjalankan pekerja. AWS CloudShell Jika Anda mengikuti instruksi tersebut sebelumnya, hapus `~/demoenv-persist` direktori `~/demoenv-logs` dan direktori terlebih dahulu. Juga, tetapkan nilai-nilai variabel `DEV_FARM_ID` dan `DEV_CMF_ID` lingkungan yang referensi arah sebagai berikut sebelum melakukannya: 

```
DEV_FARM_ID=$FARM_ID
DEV_CMF_ID=$FLEET_ID
```

 Setelah pekerjaan berjalan, Anda dapat melihat aturan pemetaan jalur di file log pekerjaan: 

```
cat demoenv-logs/${QUEUE1_ID}/*.log
...
JJSON log results (see below)
...
```

Log berisi pemetaan untuk sistem `FSComm` file `FS1` dan file. Diformat ulang agar mudah dibaca, entri log terlihat seperti ini:

```
{
    "version": "pathmapping-1.0",
    "path_mapping_rules": [
        {
            "source_path_format": "POSIX",
            "source_path": "/shared/projects/project1",
            "destination_path": "/mnt/projects/project1"
        },
        {
            "source_path_format": "POSIX",
            "source_path": "/shared/common",
            "destination_path": "/mnt/common"
        }
    ]
```

 Anda dapat mengirimkan pekerjaan dengan profil penyimpanan yang berbeda untuk melihat bagaimana aturan pemetaan jalur berubah. 

# Gunakan lampiran pekerjaan untuk berbagi file
<a name="build-job-attachments"></a>

Gunakan *lampiran pekerjaan* untuk membuat file yang tidak ada di direktori bersama tersedia untuk pekerjaan Anda, dan untuk menangkap file output jika tidak ditulis ke direktori bersama. Lampiran Job menggunakan Amazon S3 untuk mengirim file antar host. File disimpan dalam bucket S3, dan Anda tidak perlu mengunggah file jika kontennya tidak berubah.

Anda harus menggunakan lampiran pekerjaan saat menjalankan pekerjaan pada [armada yang dikelola layanan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/smf-manage.html) karena host tidak berbagi lokasi sistem file. Lampiran Job juga berguna dengan [armada yang dikelola pelanggan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/manage-cmf.html) ketika file input atau output pekerjaan disimpan pada sistem file jaringan bersama, seperti ketika [bundel pekerjaan](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/submit-job-bundle.html) Anda berisi skrip shell atau Python. 

 Saat Anda mengirimkan paket pekerjaan dengan [Deadline Cloud CLI](https://pypi.org/project/deadline/) atau pengirim Deadline Cloud, lampiran pekerjaan menggunakan profil penyimpanan pekerjaan dan lokasi sistem file yang diperlukan antrian untuk mengidentifikasi file input yang tidak ada di host pekerja dan harus diunggah ke Amazon S3 sebagai bagian dari pengiriman pekerjaan. Profil penyimpanan ini juga membantu Deadline Cloud mengidentifikasi file keluaran di lokasi host pekerja yang harus diunggah ke Amazon S3 sehingga tersedia untuk stasiun kerja Anda. 

 Contoh lampiran pekerjaan menggunakan konfigurasi profil pertanian, armada, antrian, dan penyimpanan dari dan. [Contoh infrastruktur proyek](sample-project-infrastructure.md) [Profil penyimpanan dan pemetaan jalur](storage-profiles-and-path-mapping.md) Anda harus melalui bagian-bagian itu sebelum yang satu ini. 

Dalam contoh berikut, Anda menggunakan bundel pekerjaan sampel sebagai titik awal, lalu memodifikasinya untuk mengeksplorasi fungsionalitas lampiran pekerjaan. Paket Job adalah cara terbaik bagi pekerjaan Anda untuk menggunakan lampiran pekerjaan. Mereka menggabungkan template [pekerjaan Open Job Description](https://github.com/OpenJobDescription/openjd-specifications/wiki) dalam direktori dengan file tambahan yang mencantumkan file dan direktori yang dibutuhkan oleh pekerjaan menggunakan bundel pekerjaan. Untuk informasi selengkapnya tentang paket pekerjaan, lihat[Templat Open Job Description (OpenJD) untuk Deadline Cloud](build-job-bundle.md).

# Mengirimkan file dengan pekerjaan
<a name="submitting-files-with-a-job"></a>

Dengan Deadline Cloud, Anda dapat mengaktifkan alur kerja pekerjaan untuk mengakses file input yang tidak tersedia di lokasi sistem file bersama di host pekerja. Lampiran Job memungkinkan rendering pekerjaan untuk mengakses file yang hanya berada di drive workstation lokal atau lingkungan armada yang dikelola layanan. Saat mengirimkan bundel pekerjaan, Anda dapat menyertakan daftar file input dan direktori yang diperlukan oleh pekerjaan. Deadline Cloud mengidentifikasi file yang tidak dibagikan ini, mengunggahnya dari mesin lokal ke Amazon S3, dan mengunduhnya ke host pekerja. Ini merampingkan proses mentransfer aset input ke render node, memastikan semua file yang diperlukan dapat diakses untuk eksekusi pekerjaan terdistribusi.

Anda dapat menentukan file untuk pekerjaan secara langsung di bundel pekerjaan, menggunakan parameter dalam template pekerjaan yang Anda berikan menggunakan variabel lingkungan atau skrip, dan menggunakan `assets_references` file pekerjaan. Anda dapat menggunakan salah satu metode ini atau kombinasi ketiganya. Anda dapat menentukan profil penyimpanan untuk bundel untuk pekerjaan sehingga hanya mengunggah file yang telah berubah di workstation lokal.

Bagian ini menggunakan contoh bundel pekerjaan GitHub untuk menunjukkan bagaimana Deadline Cloud mengidentifikasi file dalam pekerjaan Anda untuk diunggah, bagaimana file tersebut diatur di Amazon S3, dan bagaimana file tersebut tersedia untuk host pekerja yang memproses pekerjaan Anda. 

**Topics**
+ [Bagaimana Deadline Cloud mengunggah file ke Amazon S3](what-job-attachments-uploads-to-amazon-s3.md)
+ [Bagaimana Deadline Cloud memilih file yang akan diunggah](how-job-attachments-decides-what-to-upload-to-amazon-s3.md)
+ [Bagaimana pekerjaan menemukan file input lampiran pekerjaan](how-jobs-find-job-attachments-input-files.md)

# Bagaimana Deadline Cloud mengunggah file ke Amazon S3
<a name="what-job-attachments-uploads-to-amazon-s3"></a>

Contoh ini menunjukkan bagaimana Deadline Cloud mengunggah file dari workstation atau host pekerja Anda ke Amazon S3 sehingga file tersebut dapat dibagikan. Ini menggunakan bundel pekerjaan sampel dari GitHub dan Deadline Cloud CLI untuk mengirimkan pekerjaan.

 Mulailah dengan mengkloning [ GitHubrepositori sampel Deadline Cloud](https://github.com/aws-deadline/deadline-cloud-samples) ke [AWS CloudShell](https://docs.aws.amazon.com/cloudshell/latest/userguide/welcome.html)lingkungan Anda, lalu salin bundel `job_attachments_devguide` pekerjaan ke direktori home Anda: 

```
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
cp -r deadline-cloud-samples/job_bundles/job_attachments_devguide ~/
```

 Instal [Deadline Cloud CLI](https://pypi.org/project/deadline/) untuk mengirimkan bundel pekerjaan: 

```
pip install deadline --upgrade
```

 Bundel `job_attachments_devguide` pekerjaan memiliki satu langkah dengan tugas yang menjalankan skrip bash shell yang lokasi sistem filenya diteruskan sebagai parameter pekerjaan. Definisi parameter pekerjaan adalah: 

```
...
- name: ScriptFile
  type: PATH
  default: script.sh
  dataFlow: IN
  objectType: FILE
...
```

 `IN`Nilai `dataFlow` properti memberi tahu lampiran pekerjaan bahwa nilai `ScriptFile` parameter adalah masukan ke pekerjaan. Nilai `default` properti adalah lokasi relatif ke direktori bundel pekerjaan, tetapi juga bisa menjadi jalur absolut. Definisi parameter ini mendeklarasikan `script.sh` file dalam direktori bundel pekerjaan sebagai file input yang diperlukan agar pekerjaan dapat dijalankan. 

 Selanjutnya, pastikan bahwa Deadline Cloud CLI tidak memiliki profil penyimpanan yang dikonfigurasi kemudian kirimkan pekerjaan ke antrian: `Q1` 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id ''

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/
```

 Output dari Deadline Cloud CLI setelah perintah ini dijalankan terlihat seperti: 

```
Submitting to Queue: Q1
...
Hashing Attachments  [####################################]  100%
Hashing Summary:
    Processed 1 file totaling 39.0 B.
    Skipped re-processing 0 files totaling 0.0 B.
    Total processing time of 0.0327 seconds at 1.19 KB/s.

Uploading Attachments  [####################################]  100%
Upload Summary:
    Processed 1 file totaling 39.0 B.
    Skipped re-processing 0 files totaling 0.0 B.
    Total processing time of 0.25639 seconds at 152.0 B/s.

Waiting for Job to be created...
Submitted job bundle:
   job_attachments_devguide/
Job creation completed successfully
job-74148c13342e4514b63c7a7518657005
```

Saat Anda mengirimkan pekerjaan, Deadline Cloud pertama-tama melakukan hash `script.sh` file dan kemudian mengunggahnya ke Amazon S3. 

Deadline Cloud memperlakukan bucket S3 sebagai penyimpanan yang dapat dialamatkan konten. File diunggah ke objek S3. Nama objek berasal dari hash dari isi file. Jika dua file memiliki konten yang identik, mereka memiliki nilai hash yang sama terlepas dari di mana file tersebut berada atau apa namanya. Penyimpanan yang dapat dialamatkan konten ini memungkinkan Deadline Cloud untuk menghindari mengunggah file jika sudah tersedia.

 Anda dapat menggunakan [AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-welcome.html) untuk melihat objek yang diunggah ke Amazon S3: 

```
# The name of queue `Q1`'s job attachments S3 bucket
Q1_S3_BUCKET=$(
  aws deadline get-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
    --query 'jobAttachmentSettings.s3BucketName' | tr -d '"'
)

aws s3 ls s3://$Q1_S3_BUCKET --recursive
```

 Dua objek diunggah ke S3: 
+  `DeadlineCloud/Data/87cb19095dd5d78fcaf56384ef0e6241.xxh128`— Isi dari`script.sh`. [Nilai `87cb19095dd5d78fcaf56384ef0e6241` dalam kunci objek adalah hash dari isi file, dan ekstensi `xxh128` menunjukkan bahwa nilai hash dihitung sebagai 128 bit xxhash.](https://xxhash.com/) 
+  `DeadlineCloud/Manifests/<farm-id>/<queue-id>/Inputs/<guid>/a1d221c7fd97b08175b3872a37428e8c_input`— Objek manifes untuk pengajuan pekerjaan. Nilai`<farm-id>`,`<queue-id>`, dan `<guid>` merupakan pengidentifikasi pertanian Anda, pengidentifikasi antrian, dan nilai heksidesimal acak. Nilai `a1d221c7fd97b08175b3872a37428e8c` dalam contoh ini adalah nilai hash yang dihitung dari string`/home/cloudshell-user/job_attachments_devguide`, direktori tempat `script.sh` berada. 

 Objek manifes berisi informasi untuk file input pada jalur root tertentu yang diunggah ke S3 sebagai bagian dari pengiriman pekerjaan. Unduh file manifes ini (`aws s3 cp s3://$Q1_S3_BUCKET/<objectname>`). Isinya mirip dengan: 

```
{
    "hashAlg": "xxh128",
    "manifestVersion": "2023-03-03",
    "paths": [
        {
            "hash": "87cb19095dd5d78fcaf56384ef0e6241",
            "mtime": 1721147454416085,
            "path": "script.sh",
            "size": 39
        }
    ],
    "totalSize": 39
}
```

Ini menunjukkan bahwa file `script.sh` telah diunggah, dan hash dari konten file itu. `87cb19095dd5d78fcaf56384ef0e6241` Nilai hash ini cocok dengan nilai dalam nama `DeadlineCloud/Data/87cb19095dd5d78fcaf56384ef0e6241.xxh128` objek. Ini digunakan oleh Deadline Cloud untuk mengetahui objek mana yang akan diunduh untuk konten file ini.

 Skema lengkap untuk file ini [tersedia di GitHub](https://github.com/aws-deadline/deadline-cloud/blob/mainline/src/deadline/job_attachments/asset_manifests/v2023_03_03/validate.py). 

Bila Anda menggunakan [CreateJob operasi](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateJob.html), Anda dapat mengatur lokasi objek manifes. Anda dapat menggunakan [GetJoboperasi](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_GetJob.html) untuk melihat lokasi: 

```
{
    "attachments": {
        "file system": "COPIED",
        "manifests": [
            {
                "inputManifestHash": "5b0db3d311805ea8de7787b64cbbe8b3",
                "inputManifestPath": "<farm-id>/<queue-id>/Inputs/<guid>/a1d221c7fd97b08175b3872a37428e8c_input",
                "rootPath": "/home/cloudshell-user/job_attachments_devguide",
                "rootPathFormat": "posix"
            }
        ]
    },
    ...
}
```

# Bagaimana Deadline Cloud memilih file yang akan diunggah
<a name="how-job-attachments-decides-what-to-upload-to-amazon-s3"></a>

 File dan direktori yang dipertimbangkan oleh lampiran pekerjaan untuk diunggah ke Amazon S3 sebagai input ke pekerjaan Anda adalah: 
+  Nilai-nilai dari semua parameter pekerjaan `PATH` -type didefinisikan dalam template pekerjaan bundel pekerjaan dengan `dataFlow` nilai `IN` atau`INOUT`.
+  File dan direktori terdaftar sebagai input dalam file referensi aset bundel pekerjaan. 

 Jika Anda mengirimkan pekerjaan tanpa profil penyimpanan, semua file yang dipertimbangkan untuk diunggah akan diunggah. Jika Anda mengirimkan pekerjaan dengan profil penyimpanan, file tidak akan diunggah ke Amazon S3 jika mereka berada di lokasi sistem file tipe penyimpanan profil `SHARED` penyimpanan yang juga diperlukan lokasi sistem file untuk antrian. Lokasi ini diharapkan tersedia di host pekerja yang menjalankan pekerjaan, jadi tidak perlu mengunggahnya ke S3. 

 Dalam contoh ini, Anda membuat lokasi sistem `SHARED` file `WSAll` di CloudShell lingkungan AWS Anda dan kemudian menambahkan file ke lokasi sistem file tersebut. Gunakan perintah berikut ini. 

```
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

sudo mkdir -p /shared/common /shared/projects/project1 /shared/projects/project2
sudo chown -R cloudshell-user:cloudshell-user /shared

for d in /shared/common /shared/projects/project1 /shared/projects/project2; do
  echo "File contents for $d" > ${d}/file.txt
done
```

 Selanjutnya, tambahkan file referensi aset ke bundel pekerjaan yang menyertakan semua file yang Anda buat sebagai input untuk pekerjaan tersebut. Gunakan perintah berikut ini. 

```
cat > ${HOME}/job_attachments_devguide/asset_references.yaml << EOF
assetReferences:
  inputs:
    filenames:
    - /shared/common/file.txt
    directories:
    - /shared/projects/project1
    - /shared/projects/project2
EOF
```

 Selanjutnya, konfigurasikan Deadline Cloud CLI untuk mengirimkan pekerjaan dengan `WSAll` profil penyimpanan, lalu kirimkan bundel pekerjaan: 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/
```

Deadline Cloud mengunggah dua file ke Amazon S3 saat Anda mengirimkan pekerjaan. Anda dapat mengunduh objek manifes untuk pekerjaan dari S3 untuk melihat file yang diunggah: 

```
for manifest in $( \
  aws deadline get-job --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID \
    --query 'attachments.manifests[].inputManifestPath' \
    | jq -r '.[]'
); do
  echo "Manifest object: $manifest"
  aws s3 cp --quiet s3://$Q1_S3_BUCKET/DeadlineCloud/Manifests/$manifest /dev/stdout | jq .
done
```

 Dalam contoh ini, ada satu file manifes dengan konten berikut: 

```
{
    "hashAlg": "xxh128",
    "manifestVersion": "2023-03-03",
    "paths": [
        {
            "hash": "87cb19095dd5d78fcaf56384ef0e6241",
            "mtime": 1721147454416085,
            "path": "home/cloudshell-user/job_attachments_devguide/script.sh",
            "size": 39
        },
        {
            "hash": "af5a605a3a4e86ce7be7ac5237b51b79",
            "mtime": 1721163773582362,
            "path": "shared/projects/project2/file.txt",
            "size": 44
        }
    ],
    "totalSize": 83
}
```

 Gunakan [GetJob operasi](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_GetJob.html) untuk manifes untuk melihat bahwa `rootPath` adalah “/”. 

```
aws deadline get-job --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID --query 'attachments.manifests[*]'
```

 Jalur root untuk kumpulan file input selalu merupakan subpath umum terpanjang dari file-file tersebut. Jika pekerjaan Anda dikirim dari Windows sebagai gantinya dan ada file input tanpa subpath umum karena mereka berada di drive yang berbeda, Anda melihat jalur root terpisah pada setiap drive. Jalur dalam manifes selalu relatif terhadap jalur root manifes, sehingga file input yang diunggah adalah: 
+  `/home/cloudshell-user/job_attachments_devguide/script.sh`— File skrip dalam bundel pekerjaan. 
+  `/shared/projects/project2/file.txt`— File di lokasi sistem `SHARED` file di profil `WSAll` penyimpanan yang **tidak** ada dalam daftar lokasi sistem file yang diperlukan untuk antrian`Q1`. 

File di lokasi sistem file `FSCommon` (`/shared/common/file.txt`) dan `FS1` (`/shared/projects/project1/file.txt`) tidak ada dalam daftar. Ini karena lokasi sistem file tersebut berada `SHARED` di profil `WSAll` penyimpanan dan keduanya berada dalam daftar lokasi sistem file yang diperlukan dalam antrian`Q1`. 

Anda dapat melihat lokasi sistem file yang dipertimbangkan `SHARED` untuk pekerjaan yang dikirimkan dengan profil penyimpanan tertentu dengan [GetStorageProfileForQueue operasi](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_GetStorageProfileForQueue.html). Untuk kueri profil penyimpanan `WSAll` untuk antrian `Q1` gunakan perintah berikut: 

```
aws deadline get-storage-profile --farm-id $FARM_ID --storage-profile-id $WSALL_ID

aws deadline get-storage-profile-for-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID --storage-profile-id $WSALL_ID
```

# Bagaimana pekerjaan menemukan file input lampiran pekerjaan
<a name="how-jobs-find-job-attachments-input-files"></a>

 Agar pekerjaan dapat menggunakan file yang diunggah Deadline Cloud ke Amazon S3 menggunakan lampiran pekerjaan, pekerjaan Anda memerlukan file-file tersebut yang tersedia melalui sistem file di host pekerja. Saat [sesi](https://github.com/OpenJobDescription/openjd-specifications/wiki/How-Jobs-Are-Run#sessions) untuk pekerjaan Anda berjalan di host pekerja, Deadline Cloud mengunduh file input untuk pekerjaan tersebut ke direktori sementara di drive lokal host pekerja dan menambahkan aturan pemetaan jalur untuk setiap jalur root pekerjaan ke lokasi sistem filenya di drive lokal. 

 Untuk contoh ini, mulai agen pekerja Deadline Cloud di CloudShell tab AWS. Biarkan pekerjaan yang dikirimkan sebelumnya selesai berjalan, lalu hapus log pekerjaan dari direktori log: 

```
rm -rf ~/devdemo-logs/queue-*
```

 Skrip berikut memodifikasi bundel pekerjaan untuk menampilkan semua file di direktori kerja sementara sesi dan isi file aturan pemetaan jalur, dan kemudian mengirimkan pekerjaan dengan bundel yang dimodifikasi: 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

cat > ~/job_attachments_devguide/script.sh << EOF
#!/bin/bash

echo "Session working directory is: \$(pwd)"
echo
echo "Contents:"
find . -type f
echo
echo "Path mapping rules file: \$1"
jq . \$1
EOF

cat > ~/job_attachments_devguide/template.yaml << EOF
specificationVersion: jobtemplate-2023-09
name: "Job Attachments Explorer"
parameterDefinitions:
- name: ScriptFile
  type: PATH
  default: script.sh
  dataFlow: IN
  objectType: FILE
steps:
- name: Step
  script:
    actions:
      onRun:
        command: /bin/bash
        args:
        - "{{Param.ScriptFile}}"
        - "{{Session.PathMappingRulesFile}}"
EOF

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/
```

 Anda dapat melihat log pekerjaan yang dijalankan setelah dijalankan oleh pekerja di AWS CloudShell lingkungan Anda: 

```
cat demoenv-logs/queue-*/session*.log
```

Log menunjukkan bahwa hal pertama yang terjadi dalam sesi adalah dua file input untuk pekerjaan yang diunduh ke pekerja: 

```
2024-07-17 01:26:37,824 INFO ==============================================
2024-07-17 01:26:37,825 INFO --------- Job Attachments Download for Job
2024-07-17 01:26:37,825 INFO ==============================================
2024-07-17 01:26:37,825 INFO Syncing inputs using Job Attachments
2024-07-17 01:26:38,116 INFO Downloaded 142.0 B / 186.0 B of 2 files (Transfer rate: 0.0 B/s)
2024-07-17 01:26:38,174 INFO Downloaded 186.0 B / 186.0 B of 2 files (Transfer rate: 733.0 B/s)
2024-07-17 01:26:38,176 INFO Summary Statistics for file downloads:
Processed 2 files totaling 186.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.09752 seconds at 1.91 KB/s.
```

 Berikutnya adalah output dari `script.sh` run by the job: 
+  File masukan yang diunggah saat pekerjaan dikirimkan terletak di bawah direktori yang namanya dimulai dengan “assetroot” di direktori sementara sesi. 
+  Jalur file input telah dipindahkan relatif ke direktori “assetroot” alih-alih relatif terhadap jalur root untuk manifes input pekerjaan (). `"/"`
+  File aturan pemetaan jalur berisi aturan tambahan yang memetakan ulang `"/"` ke jalur absolut direktori “assetroot”. 

 Contoh: 

```
2024-07-17 01:26:38,264 INFO Output:
2024-07-17 01:26:38,267 INFO Session working directory is: /sessions/session-5b33f
2024-07-17 01:26:38,267 INFO 
2024-07-17 01:26:38,267 INFO Contents:
2024-07-17 01:26:38,269 INFO ./tmp_xdhbsdo.sh
2024-07-17 01:26:38,269 INFO ./tmpdi00052b.json
2024-07-17 01:26:38,269 INFO ./assetroot-assetroot-3751a/shared/projects/project2/file.txt
2024-07-17 01:26:38,269 INFO ./assetroot-assetroot-3751a/home/cloudshell-user/job_attachments_devguide/script.sh
2024-07-17 01:26:38,269 INFO 
2024-07-17 01:26:38,270 INFO Path mapping rules file: /sessions/session-5b33f/tmpdi00052b.json
2024-07-17 01:26:38,282 INFO {
2024-07-17 01:26:38,282 INFO   "version": "pathmapping-1.0",
2024-07-17 01:26:38,282 INFO   "path_mapping_rules": [
2024-07-17 01:26:38,282 INFO     {
2024-07-17 01:26:38,282 INFO       "source_path_format": "POSIX",
2024-07-17 01:26:38,282 INFO       "source_path": "/shared/projects/project1",
2024-07-17 01:26:38,283 INFO       "destination_path": "/mnt/projects/project1"
2024-07-17 01:26:38,283 INFO     },
2024-07-17 01:26:38,283 INFO     {
2024-07-17 01:26:38,283 INFO       "source_path_format": "POSIX",
2024-07-17 01:26:38,283 INFO       "source_path": "/shared/common",
2024-07-17 01:26:38,283 INFO       "destination_path": "/mnt/common"
2024-07-17 01:26:38,283 INFO     },
2024-07-17 01:26:38,283 INFO     {
2024-07-17 01:26:38,283 INFO       "source_path_format": "POSIX",
2024-07-17 01:26:38,283 INFO       "source_path": "/",
2024-07-17 01:26:38,283 INFO       "destination_path": "/sessions/session-5b33f/assetroot-assetroot-3751a"
2024-07-17 01:26:38,283 INFO     }
2024-07-17 01:26:38,283 INFO   ]
2024-07-17 01:26:38,283 INFO }
```

**catatan**  
 Jika pekerjaan yang Anda kirimkan memiliki beberapa manifes dengan jalur root yang berbeda, ada direktori bernama “assetroot” yang berbeda untuk setiap jalur root. 

 Jika Anda perlu mereferensikan lokasi sistem file yang dipindahkan dari salah satu file input, direktori, atau lokasi sistem file Anda, Anda dapat memproses file aturan pemetaan jalur dalam pekerjaan Anda dan melakukan pemetaan ulang sendiri, atau menambahkan parameter `PATH` jenis pekerjaan ke template pekerjaan di bundel pekerjaan Anda dan meneruskan nilai yang Anda perlukan untuk memetakan ulang sebagai nilai parameter itu. Misalnya, contoh berikut memodifikasi bundel pekerjaan untuk memiliki salah satu parameter pekerjaan ini dan kemudian mengirimkan pekerjaan dengan lokasi sistem file `/shared/projects/project2` sebagai nilainya: 

```
cat > ~/job_attachments_devguide/template.yaml << EOF
specificationVersion: jobtemplate-2023-09
name: "Job Attachments Explorer"
parameterDefinitions:
- name: LocationToRemap
  type: PATH
steps:
- name: Step
  script:
    actions:
      onRun:
        command: /bin/echo
        args:
        - "The location of {{RawParam.LocationToRemap}} in the session is {{Param.LocationToRemap}}"
EOF

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID job_attachments_devguide/ \
  -p LocationToRemap=/shared/projects/project2
```

 File log untuk menjalankan pekerjaan ini berisi outputnya: 

```
2024-07-17 01:40:35,283 INFO Output:
2024-07-17 01:40:35,284 INFO The location of /shared/projects/project2 in the session is /sessions/session-5b33f/assetroot-assetroot-3751a
```

# Mendapatkan file output dari pekerjaan
<a name="getting-output-files-from-a-job"></a>

Contoh ini menunjukkan bagaimana Deadline Cloud mengidentifikasi file output yang dihasilkan oleh pekerjaan Anda, memutuskan apakah akan mengunggah file tersebut ke Amazon S3, dan bagaimana Anda bisa mendapatkan file output tersebut di workstation Anda. 

 Gunakan bundel `job_attachments_devguide_output` pekerjaan alih-alih bundel `job_attachments_devguide` pekerjaan untuk contoh ini. Mulailah dengan membuat salinan bundel di AWS CloudShell lingkungan Anda dari tiruan repositori sampel GitHub Deadline Cloud: 

```
cp -r deadline-cloud-samples/job_bundles/job_attachments_devguide_output ~/
```

 Perbedaan penting antara bundel pekerjaan ini dan bundel `job_attachments_devguide` pekerjaan adalah penambahan parameter pekerjaan baru di templat pekerjaan: 

```
...
parameterDefinitions:
...
- name: OutputDir
  type: PATH
  objectType: DIRECTORY
  dataFlow: OUT
  default: ./output_dir
  description: This directory contains the output for all steps.
...
```

 `dataFlow`Properti parameter memiliki nilai`OUT`. Deadline Cloud menggunakan nilai parameter `dataFlow` pekerjaan dengan nilai `OUT` atau `INOUT` sebagai output dari pekerjaan Anda. Jika lokasi sistem file diteruskan sebagai nilai ke jenis parameter pekerjaan ini dipetakan ulang ke lokasi sistem file lokal pada pekerja yang menjalankan pekerjaan, maka Deadline Cloud akan mencari file baru di lokasi dan mengunggahnya ke Amazon S3 sebagai output pekerjaan. 

 Untuk melihat cara kerjanya, pertama-tama mulai agen pekerja Deadline Cloud di AWS CloudShell tab. Biarkan pekerjaan yang dikirimkan sebelumnya selesai berjalan. Kemudian hapus log pekerjaan dari direktori log: 

```
rm -rf ~/devdemo-logs/queue-*
```

 Selanjutnya, kirimkan pekerjaan dengan bundel pekerjaan ini. Setelah pekerja berjalan dalam CloudShell proses Anda, lihat log: 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID ./job_attachments_devguide_output
```

 Log menunjukkan bahwa file terdeteksi sebagai output dan diunggah ke Amazon S3: 

```
2024-07-17 02:13:10,873 INFO ----------------------------------------------
2024-07-17 02:13:10,873 INFO Uploading output files to Job Attachments
2024-07-17 02:13:10,873 INFO ----------------------------------------------
2024-07-17 02:13:10,873 INFO Started syncing outputs using Job Attachments
2024-07-17 02:13:10,955 INFO Found 1 file totaling 117.0 B in output directory: /sessions/session-7efa/assetroot-assetroot-3751a/output_dir
2024-07-17 02:13:10,956 INFO Uploading output manifest to DeadlineCloud/Manifests/farm-0011/queue-2233/job-4455/step-6677/task-6677-0/2024-07-17T02:13:10.835545Z_sessionaction-8899-1/c6808439dfc59f86763aff5b07b9a76c_output
2024-07-17 02:13:10,988 INFO Uploading 1 output file to S3: s3BucketName/DeadlineCloud/Data
2024-07-17 02:13:11,011 INFO Uploaded 117.0 B / 117.0 B of 1 file (Transfer rate: 0.0 B/s)
2024-07-17 02:13:11,011 INFO Summary Statistics for file uploads:
Processed 1 file totaling 117.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.02281 seconds at 5.13 KB/s.
```

 Log juga menunjukkan bahwa Deadline Cloud membuat objek manifes baru di bucket Amazon S3 yang dikonfigurasi untuk digunakan oleh lampiran pekerjaan pada antrian. `Q1` Nama objek manifes berasal dari pertanian, antrian, pekerjaan, langkah, tugas, stempel waktu, dan `sessionaction` pengidentifikasi tugas yang menghasilkan output. Unduh file manifes ini untuk melihat di mana Deadline Cloud menempatkan file output untuk tugas ini: 

```
# The name of queue `Q1`'s job attachments S3 bucket
Q1_S3_BUCKET=$(
  aws deadline get-queue --farm-id $FARM_ID --queue-id $QUEUE1_ID \
    --query 'jobAttachmentSettings.s3BucketName' | tr -d '"'
)

# Fill this in with the object name from your log
OBJECT_KEY="DeadlineCloud/Manifests/..."

aws s3 cp --quiet s3://$Q1_S3_BUCKET/$OBJECT_KEY /dev/stdout | jq .
```

 Manifes terlihat seperti: 

```
{
  "hashAlg": "xxh128",
  "manifestVersion": "2023-03-03",
  "paths": [
    {
      "hash": "34178940e1ef9956db8ea7f7c97ed842",
      "mtime": 1721182390859777,
      "path": "output_dir/output.txt",
      "size": 117
    }
  ],
  "totalSize": 117
}
```

 Ini menunjukkan bahwa konten file output disimpan ke Amazon S3 dengan cara yang sama seperti file input pekerjaan disimpan. Mirip dengan file input, file output disimpan dalam S3 dengan nama objek yang berisi hash file dan awalan. `DeadlineCloud/Data` 

```
$ aws s3 ls --recursive s3://$Q1_S3_BUCKET | grep 34178940e1ef9956db8ea7f7c97ed842
2024-07-17 02:13:11        117 DeadlineCloud/Data/34178940e1ef9956db8ea7f7c97ed842.xxh128
```

 Anda dapat mengunduh output pekerjaan ke workstation Anda menggunakan monitor Deadline Cloud atau Deadline Cloud CLI: 

```
deadline job download-output --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID
```

 Nilai parameter `OutputDir` pekerjaan dalam pekerjaan yang dikirimkan adalah`./output_dir`, sehingga output diunduh ke direktori yang disebut `output_dir` dalam direktori bundel pekerjaan. Jika Anda menentukan jalur absolut atau lokasi relatif yang berbeda sebagai nilainya`OutputDir`, maka file output akan diunduh ke lokasi itu sebagai gantinya. 

```
$ deadline job download-output --farm-id $FARM_ID --queue-id $QUEUE1_ID --job-id $JOB_ID
Downloading output from Job 'Job Attachments Explorer: Output'

Summary of files to download:
    /home/cloudshell-user/job_attachments_devguide_output/output_dir/output.txt (1 file)

You are about to download files which may come from multiple root directories. Here are a list of the current root directories:
[0] /home/cloudshell-user/job_attachments_devguide_output
> Please enter the index of root directory to edit, y to proceed without changes, or n to cancel the download (0, y, n) [y]: 

Downloading Outputs  [####################################]  100%
Download Summary:
    Downloaded 1 files totaling 117.0 B.
    Total download time of 0.14189 seconds at 824.0 B/s.
    Download locations (total file counts):
        /home/cloudshell-user/job_attachments_devguide_output (1 file)
```

# Menggunakan file dari langkah dalam langkah dependen
<a name="using-files-output-from-a-step-in-a-dependent-step"></a>

Contoh ini menunjukkan bagaimana satu langkah dalam pekerjaan dapat mengakses output dari langkah yang bergantung pada pekerjaan yang sama. 

 Untuk membuat output dari satu langkah tersedia untuk yang lain, Deadline Cloud menambahkan tindakan tambahan ke sesi untuk mengunduh output tersebut sebelum menjalankan tugas dalam sesi. Anda memberi tahu langkah mana untuk mengunduh output dengan mendeklarasikan langkah-langkah tersebut sebagai dependensi dari langkah yang perlu menggunakan output. 

Gunakan bundel `job_attachments_devguide_output` pekerjaan untuk contoh ini. Mulailah dengan membuat salinan di AWS CloudShell lingkungan Anda dari klon repositori sampel GitHub Deadline Cloud. Ubah untuk menambahkan langkah dependen yang hanya berjalan setelah langkah yang ada dan menggunakan output langkah itu: 

```
cp -r deadline-cloud-samples/job_bundles/job_attachments_devguide_output ~/

cat >> job_attachments_devguide_output/template.yaml << EOF
- name: DependentStep
  dependencies:
  - dependsOn: Step
  script:
    actions:
      onRun:
        command: /bin/cat
        args:
        - "{{Param.OutputDir}}/output.txt"
EOF
```

 Pekerjaan yang dibuat dengan bundel pekerjaan yang dimodifikasi ini berjalan sebagai dua sesi terpisah, satu untuk tugas di langkah “Langkah” dan kemudian yang kedua untuk tugas di langkah "DependentStep”. 

Pertama mulai agen pekerja Deadline Cloud di CloudShell tab. Biarkan pekerjaan yang dikirimkan sebelumnya selesai berjalan, lalu hapus log pekerjaan dari direktori log: 

```
rm -rf ~/devdemo-logs/queue-*
```

 Selanjutnya, kirimkan pekerjaan menggunakan bundel `job_attachments_devguide_output` pekerjaan yang dimodifikasi. Tunggu sampai selesai berjalan pada pekerja di CloudShell lingkungan Anda. Lihatlah log untuk dua sesi: 

```
# Change the value of FARM_ID to your farm's identifier
FARM_ID=farm-00112233445566778899aabbccddeeff
# Change the value of QUEUE1_ID to queue Q1's identifier
QUEUE1_ID=queue-00112233445566778899aabbccddeeff
# Change the value of WSALL_ID to the identifier of the WSAll storage profile
WSALL_ID=sp-00112233445566778899aabbccddeeff

deadline config set settings.storage_profile_id $WSALL_ID

deadline bundle submit --farm-id $FARM_ID --queue-id $QUEUE1_ID ./job_attachments_devguide_output

# Wait for the job to finish running, and then:

cat demoenv-logs/queue-*/session-*
```

 Dalam log sesi untuk tugas di langkah bernama`DependentStep`, ada dua tindakan unduhan terpisah yang dijalankan: 

```
2024-07-17 02:52:05,666 INFO ==============================================
2024-07-17 02:52:05,666 INFO --------- Job Attachments Download for Job
2024-07-17 02:52:05,667 INFO ==============================================
2024-07-17 02:52:05,667 INFO Syncing inputs using Job Attachments
2024-07-17 02:52:05,928 INFO Downloaded 207.0 B / 207.0 B of 1 file (Transfer rate: 0.0 B/s)
2024-07-17 02:52:05,929 INFO Summary Statistics for file downloads:
Processed 1 file totaling 207.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.03954 seconds at 5.23 KB/s.

2024-07-17 02:52:05,979 INFO 
2024-07-17 02:52:05,979 INFO ==============================================
2024-07-17 02:52:05,979 INFO --------- Job Attachments Download for Step
2024-07-17 02:52:05,979 INFO ==============================================
2024-07-17 02:52:05,980 INFO Syncing inputs using Job Attachments
2024-07-17 02:52:06,133 INFO Downloaded 117.0 B / 117.0 B of 1 file (Transfer rate: 0.0 B/s)
2024-07-17 02:52:06,134 INFO Summary Statistics for file downloads:
Processed 1 file totaling 117.0 B.
Skipped re-processing 0 files totaling 0.0 B.
Total processing time of 0.03227 seconds at 3.62 KB/s.
```

 Tindakan pertama mengunduh `script.sh` file yang digunakan oleh langkah bernama “Langkah.” Tindakan kedua mengunduh output dari langkah itu. Deadline Cloud menentukan file mana yang akan diunduh dengan menggunakan manifes keluaran yang dihasilkan oleh langkah tersebut sebagai manifes masukan. 

 Di akhir log yang sama, Anda dapat melihat output dari langkah bernama "DependentStep“: 

```
2024-07-17 02:52:06,213 INFO Output:
2024-07-17 02:52:06,216 INFO Script location: /sessions/session-5b33f/assetroot-assetroot-3751a/script.sh
```

# Buat batas sumber daya untuk pekerjaan
<a name="build-job-limits"></a>

Pekerjaan yang dikirimkan ke Deadline Cloud mungkin bergantung pada sumber daya yang dibagi di antara beberapa pekerjaan. Misalnya, sebuah peternakan mungkin memiliki lebih banyak pekerja daripada lisensi mengambang untuk sumber daya tertentu. Atau server file bersama mungkin hanya dapat melayani data ke sejumlah pekerja terbatas pada saat yang bersamaan. Dalam beberapa kasus, satu atau lebih pekerjaan dapat mengklaim semua sumber daya ini, menyebabkan kesalahan karena sumber daya yang tidak tersedia ketika pekerja baru mulai. 

Untuk membantu mengatasi hal ini, Anda dapat menggunakan *batas* untuk sumber daya terbatas ini. Deadline Cloud memperhitungkan ketersediaan sumber daya terbatas dan menggunakan informasi tersebut untuk memastikan bahwa sumber daya tersedia saat pekerja baru memulai sehingga pekerjaan memiliki kemungkinan gagal yang lebih rendah karena sumber daya yang tidak tersedia.

Batas dibuat untuk seluruh peternakan. Pekerjaan yang dikirimkan ke antrian hanya dapat memperoleh batas yang terkait dengan antrian. Jika Anda menentukan batas untuk pekerjaan yang tidak terkait dengan antrian, pekerjaan tersebut tidak kompatibel dan tidak akan berjalan.

Untuk menggunakan batas, Anda 
+ [Buat batas](job-limit-create.md)
+ [Kaitkan batas dan antrian](job-limit-associate.md)
+ [Kirim pekerjaan yang membutuhkan batasan](job-limit-job.md)

**catatan**  
Jika Anda menjalankan pekerjaan yang memiliki sumber daya terbatas dalam antrian yang tidak terkait dengan batas, pekerjaan itu dapat menghabiskan semua sumber daya. Jika Anda memiliki sumber daya terbatas, pastikan bahwa semua langkah dalam pekerjaan dalam antrian yang menggunakan sumber daya dikaitkan dengan batas.

Untuk batas yang ditentukan di peternakan, terkait dengan antrian, dan ditentukan dalam pekerjaan, salah satu dari empat hal dapat terjadi:
+ Jika Anda membuat batas, kaitkan dengan antrian, dan tentukan batas dalam templat pekerjaan, pekerjaan akan berjalan dan hanya menggunakan sumber daya yang ditentukan dalam batas.
+ Jika Anda membuat batas, tentukan dalam templat pekerjaan, tetapi jangan mengaitkan batas dengan antrian, pekerjaan ditandai tidak kompatibel dan tidak akan berjalan.
+ Jika Anda membuat batas, jangan kaitkan dengan antrian, dan jangan tentukan batas dalam templat pekerjaan, pekerjaan berjalan tetapi tidak menggunakan batas.
+ Jika Anda tidak menggunakan batas sama sekali, pekerjaan berjalan.

Jika Anda mengaitkan batas ke beberapa antrian, antrian berbagi sumber daya yang dibatasi oleh batas. Misalnya, jika Anda membuat batas 100, dan satu antrian menggunakan 60 sumber daya, antrian lain hanya dapat menggunakan 40 sumber daya. Ketika sumber daya dirilis, itu dapat diambil oleh tugas dari antrian apa pun.

Deadline Cloud menyediakan dua AWS CloudFormation metrik untuk membantu Anda memantau sumber daya yang disediakan oleh batas. Anda dapat memantau jumlah sumber daya saat ini yang digunakan dan jumlah maksimum sumber daya yang tersedia dalam batas. Untuk informasi selengkapnya, lihat [Metrik batas sumber daya](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/cloudwatch-metrics.html#cloudwatch-metrics-limits) di Panduan *Pengembang Cloud Batas* Waktu.

Anda menerapkan batas untuk langkah pekerjaan dalam template pekerjaan. Saat Anda menentukan nama persyaratan jumlah batas di `amounts` bagian langkah dan batas yang sama `amountRequirementName` dikaitkan dengan antrian pekerjaan, tugas yang dijadwalkan untuk langkah ini dibatasi oleh batas sumber daya. `hostRequirements`

Jika sebuah langkah membutuhkan sumber daya yang dibatasi oleh batas yang tercapai, tugas dalam langkah itu tidak akan diambil oleh pekerja tambahan.

Anda dapat menerapkan lebih dari satu batas untuk langkah pekerjaan. Misalnya, jika langkah menggunakan dua lisensi perangkat lunak yang berbeda, Anda dapat menerapkan batas terpisah untuk setiap lisensi. Jika sebuah langkah membutuhkan dua batasan dan batas untuk salah satu sumber daya tercapai, tugas dalam langkah itu tidak akan diambil oleh pekerja tambahan sampai sumber daya tersedia.

## Menghentikan dan menghapus batas
<a name="job-limit-stop-delete"></a>

Saat Anda menghentikan atau menghapus asosiasi antara antrian dan batas, pekerjaan yang menggunakan batas menghentikan penjadwalan tugas dari langkah-langkah yang memerlukan batas ini dan memblokir pembuatan sesi baru untuk satu langkah.

Tugas yang berada dalam status READY tetap siap, dan tugas secara otomatis dilanjutkan dengan asosiasi antara antrian dan batas menjadi aktif kembali. Anda tidak perlu meminta pekerjaan apa pun.

Ketika Anda menghentikan atau menghapus asosiasi antara antrian dan batas, Anda memiliki dua pilihan tentang cara menghentikan menjalankan tugas:
+ Hentikan dan batalkan tugas — Pekerja dengan sesi yang memperoleh batas membatalkan semua tugas.
+ Berhenti dan selesaikan tugas yang sedang berjalan — Pekerja dengan sesi yang memperoleh batas menyelesaikan tugas mereka.

Ketika Anda menghapus batas menggunakan konsol, pekerja pertama-tama berhenti menjalankan tugas segera atau akhirnya ketika mereka selesai. Ketika asosiasi dihapus, hal berikut terjadi: 
+ Langkah-langkah yang membutuhkan batas ditandai tidak kompatibel.
+ Seluruh pekerjaan yang berisi langkah-langkah tersebut dibatalkan, termasuk langkah-langkah yang tidak memerlukan batas.
+ Pekerjaan ditandai tidak kompatibel.

Jika antrian yang terkait dengan batas memiliki armada terkait dengan kemampuan armada yang sesuai dengan jumlah persyaratan nama batas, armada tersebut akan terus memproses pekerjaan dengan batas yang ditentukan.

# Buat batas
<a name="job-limit-create"></a>

Anda membuat batas menggunakan konsol Deadline Cloud atau [CreateLimit operasi di Deadline Cloud API](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateLimit.html). Batas didefinisikan untuk pertanian, tetapi terkait dengan antrian. Setelah Anda membuat batas, Anda dapat mengaitkannya dengan satu atau lebih antrian.

**Untuk membuat batas**

1. Dari dasbor Deadline Cloud console ([Deadline Cloud console](https://console.aws.amazon.com/deadlinecloud/home)), pilih farm yang ingin Anda buat antrean.

1. Pilih peternakan untuk menambahkan batas, pilih tab **Batas**, lalu pilih **Buat batas**.

1. Berikan detail untuk batasnya. **Nama persyaratan Jumlah** adalah nama yang digunakan dalam template pekerjaan untuk mengidentifikasi batas. Itu harus dimulai dengan awalan **amount.** diikuti dengan nama jumlah. Nama persyaratan jumlah harus unik dalam antrian yang terkait dengan batas.

1. Jika Anda memilih **Tetapkan jumlah maksimum**, itu adalah jumlah total sumber daya yang diizinkan oleh batas ini. Jika Anda memilih **Tidak ada jumlah maksimum**, penggunaan sumber daya tidak terbatas. Bahkan ketika penggunaan sumber daya tidak terbatas, CloudWatch metrik `CurrentCount` Amazon dipancarkan sehingga Anda dapat melacak penggunaan. Untuk informasi selengkapnya, lihat [CloudWatchmetrik](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/cloudwatch-metrics.html) di Panduan *Pengembang Cloud Deadline*.

1. Jika Anda sudah tahu antrian yang harus menggunakan batas, Anda dapat memilihnya sekarang. Anda tidak perlu mengaitkan antrian untuk membuat batas.

1. Pilih **Buat batas**.

# Kaitkan batas dan antrian
<a name="job-limit-associate"></a>

Setelah Anda membuat batas, Anda dapat mengaitkan satu atau lebih antrian dengan batas. Hanya antrian yang terkait dengan batas yang menggunakan nilai yang ditentukan dalam batas.

Anda membuat asosiasi dengan antrian menggunakan konsol Deadline Cloud atau [CreateQueueLimitAssociation operasi di Deadline](https://docs.aws.amazon.com/deadline-cloud/latest/APIReference/API_CreateQueueLimitAssociation.html) Cloud API.

**Untuk mengaitkan antrian dengan batas**

1. Dari dasbor Deadline Cloud console ([Deadline Cloud console](https://console.aws.amazon.com/deadlinecloud/home)), pilih farm tempat Anda ingin mengaitkan batas dengan antrian.

1. Pilih tab **Limits**, pilih limit untuk mengaitkan antrian dengan, lalu pilih **Edit limit**.

1. Di bagian **antrian Associate**, pilih antrian yang akan dikaitkan dengan batas.

1. Pilih **Simpan perubahan**.

# Kirim pekerjaan yang membutuhkan batasan
<a name="job-limit-job"></a>

Anda menerapkan batas dengan menentukannya sebagai persyaratan tuan rumah untuk pekerjaan atau langkah pekerjaan. Jika Anda tidak menentukan batas dalam satu langkah dan langkah itu menggunakan sumber daya terkait, penggunaan langkah tidak dihitung terhadap batas saat pekerjaan dijadwalkan..

Beberapa submitter Deadline Cloud memungkinkan Anda untuk menetapkan persyaratan host. Anda dapat menentukan nama persyaratan jumlah batas di pengirim untuk menerapkan batas.

Jika pengirim Anda tidak mendukung penambahan persyaratan host, Anda juga dapat menerapkan batasan dengan mengedit templat pekerjaan untuk pekerjaan itu.

**Untuk menerapkan batas pada langkah pekerjaan dalam bundel pekerjaan**

1. Buka template pekerjaan untuk pekerjaan menggunakan editor teks. Template pekerjaan terletak di direktori bundel pekerjaan untuk pekerjaan itu. Untuk informasi selengkapnya, lihat [Paket Job](https://docs.aws.amazon.com/deadline-cloud/latest/developerguide/build-job-bundle.html) di Panduan *Pengembang Cloud Deadline*.

1. Temukan definisi langkah untuk langkah yang menerapkan batas.

1. Tambahkan yang berikut ini ke definisi langkah. Ganti *amount.name* dengan nama persyaratan jumlah batas Anda. Untuk penggunaan umum, Anda harus menetapkan `min` nilai ke 1.

------
#### [ YAML ]

   ```
     hostRequirements:
       amounts:
       - name: amount.name
         min: 1
   ```

------
#### [ JSON ]

   ```
   "hostRequirements": {
       "amounts": [
           {
               "name": "amount.name",
               "min": "1"
           }
       }
   }
   ```

------

   Anda dapat menambahkan beberapa batasan ke langkah pekerjaan sebagai berikut. Ganti *amount.name\$11* dan *amount.name\$12* dengan nama persyaratan jumlah batas Anda.

------
#### [ YAML ]

   ```
     hostRequirements:
       amounts:
       - name: amount.name_1
         min: 1
       - name: amount.name_2
         min: 1
   ```

------
#### [ JSON ]

   ```
   "hostRequirements": {
       "amounts": [
           {
               "name": "amount.name_1",
               "min": "1"
           },
           {
               "name": "amount.name_2",
               "min": "1"
           }
       }
   }
   ```

------

1. Simpan perubahan pada template pekerjaan.

# Cara mengirimkan pekerjaan ke Deadline Cloud
<a name="submit-jobs-how"></a>

Ada banyak cara berbeda untuk mengirimkan pekerjaan ke AWS Deadline Cloud. Bagian ini menjelaskan beberapa cara Anda dapat mengirimkan pekerjaan menggunakan alat yang disediakan oleh Deadline Cloud atau dengan membuat alat kustom Anda sendiri untuk beban kerja Anda. 
+ Dari terminal — untuk saat Anda pertama kali mengembangkan paket pekerjaan, atau saat pengguna mengirimkan pekerjaan merasa nyaman menggunakan baris perintah
+ Dari skrip - untuk menyesuaikan dan mengotomatiskan beban kerja
+ Dari aplikasi — untuk saat pekerjaan pengguna berada dalam aplikasi, atau ketika konteks aplikasi penting.

 Contoh berikut menggunakan pustaka `deadline` Python dan alat baris `deadline` perintah. Keduanya tersedia dari [PyPi](https://pypi.org/project/deadline/)dan [di-host GitHub](https://github.com/aws-deadline/deadline-cloud). 

**Topics**
+ [Kirim pekerjaan ke Deadline Cloud dari terminal](from-a-terminal.md)
+ [Kirim pekerjaan ke Deadline Cloud menggunakan skrip](from-a-script.md)
+ [Kirim pekerjaan dalam aplikasi](from-within-applications.md)

# Kirim pekerjaan ke Deadline Cloud dari terminal
<a name="from-a-terminal"></a>

Dengan hanya menggunakan bundel pekerjaan dan Deadline Cloud CLI, Anda atau pengguna Anda yang lebih teknis dapat dengan cepat mengulangi penulisan bundel pekerjaan untuk menguji pengiriman pekerjaan. Gunakan perintah berikut untuk mengirimkan bundel pekerjaan: 

```
deadline bundle submit <path-to-job-bundle>
```

 Jika Anda mengirimkan bundel pekerjaan dengan parameter yang tidak memiliki default dalam bundel, Anda dapat menentukannya dengan opsi/. `-p` `--parameter` 

```
deadline bundle submit <path-to-job-bundle> -p <parameter-name>=<parameter-value> -p ...
```

 Untuk daftar lengkap opsi yang tersedia, jalankan perintah bantuan: 

```
deadline bundle submit --help
```

## Kirim pekerjaan ke Deadline Cloud menggunakan GUI
<a name="with-a-submission-window"></a>

 Deadline Cloud CLI juga dilengkapi dengan antarmuka pengguna grafis yang memungkinkan pengguna untuk melihat parameter yang harus mereka berikan sebelum mengirimkan pekerjaan. Jika pengguna Anda memilih untuk tidak berinteraksi dengan baris perintah, Anda dapat menulis pintasan desktop yang membuka dialog untuk mengirimkan bundel pekerjaan tertentu: 

```
deadline bundle gui-submit <path-to-job-bundle>
```

 Gunakan `--browse` opsi ini sehingga pengguna dapat memilih bundel pekerjaan: 

```
deadline bundle gui-submit --browse
```

 Untuk daftar lengkap opsi yang tersedia, jalankan perintah bantuan: 

```
deadline bundle gui-submit --help
```

# Kirim pekerjaan ke Deadline Cloud menggunakan skrip
<a name="from-a-script"></a>

 Untuk mengotomatiskan pengiriman pekerjaan ke Deadline Cloud, Anda dapat membuat skrip menggunakan alat seperti bash, Powershell, dan file batch. 

Anda dapat menambahkan fungsionalitas seperti mengisi parameter pekerjaan dari variabel lingkungan atau aplikasi lain. Anda juga dapat mengirimkan beberapa pekerjaan berturut-turut, atau membuat skrip pembuatan bundel pekerjaan untuk dikirimkan. 

## Kirim pekerjaan menggunakan Python
<a name="with-python"></a>

Deadline Cloud juga memiliki pustaka Python open-source untuk berinteraksi dengan layanan. [Kode sumber tersedia di GitHub](https://github.com/aws-deadline/deadline-cloud). 

Pustaka tersedia di pypi melalui pip ()`pip install deadline`. Ini adalah perpustakaan yang sama yang digunakan oleh alat Deadline Cloud CLI: 

```
from deadline.client import api

job_bundle_path = "/path/to/job/bundle"
job_parameters = [
    {
        "name": "parameter_name",
        "value": "parameter_value"
    },
]

job_id = api.create_job_from_job_bundle(
    job_bundle_path,
    job_parameters
)
print(job_id)
```

 Untuk membuat dialog seperti `deadline bundle gui-submit` perintah, Anda dapat menggunakan `show_job_bundle_submitter` fungsi dari [`deadline.client.ui.job_bundle_submitter`.](https://github.com/aws-deadline/deadline-cloud/blob/mainline/src/deadline/client/ui/job_bundle_submitter.py) 

 Contoh berikut memulai aplikasi Qt dan menunjukkan pengirim bundel pekerjaan: 

```
# The GUI components must be installed with pip install "deadline[gui]"
import sys
from qtpy.QtWidgets import QApplication
from deadline.client.ui.job_bundle_submitter import show_job_bundle_submitter

app = QApplication(sys.argv)
submitter = show_job_bundle_submitter(browse=True)
submitter.show()
app.exec()
print(submitter.create_job_response)
```

Untuk membuat dialog Anda sendiri, Anda dapat menggunakan `SubmitJobToDeadlineDialog` kelas di [https://github.com/aws-deadline/deadline-cloud/blob/mainline/src/deadline/client/ui/dialogs/submit_job_to_deadline_dialog.py](https://github.com/aws-deadline/deadline-cloud/blob/mainline/src/deadline/client/ui/dialogs/submit_job_to_deadline_dialog.py). Anda dapat meneruskan nilai, menyematkan tab spesifik pekerjaan Anda sendiri, dan menentukan bagaimana bundel pekerjaan dibuat (atau diteruskan). 

# Kirim pekerjaan dalam aplikasi
<a name="from-within-applications"></a>

 Untuk memudahkan pengguna mengirimkan pekerjaan, Anda dapat menggunakan runtime scripting atau sistem plugin yang disediakan oleh aplikasi. Pengguna memiliki antarmuka yang akrab dan Anda dapat membuat alat canggih yang membantu pengguna saat mengirimkan beban kerja. 

## Sematkan bundel pekerjaan dalam aplikasi
<a name="simple-embedding"></a>

Contoh ini menunjukkan pengiriman bundel pekerjaan yang Anda sediakan dalam aplikasi.

 Untuk memberi pengguna akses ke bundel pekerjaan ini, buat skrip yang disematkan dalam item menu yang meluncurkan CLI Deadline Cloud. 

 Skrip berikut memungkinkan pengguna untuk memilih bundel pekerjaan: 

```
deadline bundle gui-submit --install-gui
```

 Untuk menggunakan bundel pekerjaan tertentu dalam item menu sebagai gantinya, gunakan yang berikut ini: 

```
deadline bundle gui-submit </path/to/job/bundle> --install-gui
```

 Ini membuka dialog di mana pengguna dapat memodifikasi parameter pekerjaan, input, dan output, dan kemudian mengirimkan pekerjaan. Anda dapat memiliki item menu yang berbeda untuk bundel pekerjaan yang berbeda bagi pengguna untuk mengirimkan dalam aplikasi. 

Jika job yang Anda kirimkan dengan bundel pekerjaan berisi parameter dan referensi aset yang serupa di seluruh kiriman, Anda dapat mengisi nilai default di bundel pekerjaan yang mendasarinya. 

## Dapatkan informasi dari aplikasi
<a name="deep-integration"></a>

Untuk menarik informasi dari aplikasi sehingga pengguna tidak perlu menambahkannya secara manual ke kiriman, Anda dapat mengintegrasikan Deadline Cloud dengan aplikasi sehingga pengguna Anda dapat mengirimkan pekerjaan menggunakan antarmuka yang sudah dikenal tanpa perlu keluar dari aplikasi atau menggunakan alat baris perintah.

[Jika aplikasi Anda memiliki runtime scripting yang mendukung Python dan pyside/pyqt, Anda dapat menggunakan komponen GUI dari pustaka klien Deadline Cloud untuk membuat UI.](https://github.com/aws-deadline/deadline-cloud) Sebagai contoh, lihat [Deadline Cloud untuk integrasi Maya](https://github.com/aws-deadline/deadline-cloud-for-maya) pada GitHub. 

Pustaka klien Deadline Cloud menyediakan operasi yang melakukan hal berikut untuk membantu Anda memberikan pengalaman pengguna terintegrasi yang kuat:
+ Tarik parameter lingkungan antrian, parameter pekerjaan, dan referensi aset membentuk variabel lingkungan dan dengan memanggil SDK aplikasi.
+ Atur parameter dalam bundel pekerjaan. Untuk menghindari memodifikasi bundel asli, Anda harus membuat salinan bundel dan mengirimkan salinannya.

Jika Anda menggunakan `deadline bundle gui-submit` perintah untuk mengirimkan bundel pekerjaan, Anda harus secara terprogram `asset_references.yaml` file `parameter_values.yaml` dan untuk meneruskan informasi dari aplikasi. Untuk informasi selengkapnya tentang file-file ini, lihat[Templat Open Job Description (OpenJD) untuk Deadline Cloud](build-job-bundle.md).

Jika Anda memerlukan kontrol yang lebih kompleks daripada yang ditawarkan oleh OpenJD, perlu mengabstraksi pekerjaan dari pengguna, atau ingin membuat integrasi cocok dengan gaya visual aplikasi, Anda dapat menulis dialog Anda sendiri yang memanggil pustaka klien Deadline Cloud untuk mengirimkan pekerjaan.

# Jadwalkan pekerjaan di Deadline Cloud
<a name="build-jobs-scheduling"></a>

Setelah pekerjaan dibuat, AWS Deadline Cloud menjadwalkannya untuk diproses pada satu atau lebih armada yang terkait dengan antrian. Armada yang memproses tugas tertentu dipilih berdasarkan kemampuan yang dikonfigurasi untuk armada dan persyaratan tuan rumah dari langkah tertentu.

Pekerjaan dalam antrian dijadwalkan dalam urutan prioritas upaya terbaik, tertinggi ke terendah. Ketika dua pekerjaan memiliki prioritas yang sama, pekerjaan tertua dijadwalkan terlebih dahulu.

Bagian berikut memberikan rincian proses penjadwalan pekerjaan.

## Tentukan kompatibilitas armada
<a name="jobs-scheduling-compatibility"></a>

Setelah pekerjaan dibuat, Deadline Cloud memeriksa persyaratan host untuk setiap langkah dalam pekerjaan terhadap kemampuan armada yang terkait dengan antrian pekerjaan yang diajukan. Jika armada memenuhi persyaratan tuan rumah, pekerjaan itu dimasukkan ke `READY` negara bagian.

Jika ada langkah dalam pekerjaan yang memiliki persyaratan yang tidak dapat dipenuhi oleh armada yang terkait dengan antrian, status langkah diatur ke`NOT_COMPATIBLE`. Selain itu, sisa langkah dalam pekerjaan dibatalkan.

Kemampuan untuk armada ditetapkan pada tingkat armada. Bahkan jika seorang pekerja dalam armada memenuhi persyaratan pekerjaan, itu tidak akan diberikan tugas dari pekerjaan jika armadanya tidak memenuhi persyaratan pekerjaan.

Template pekerjaan berikut memiliki langkah yang menentukan persyaratan host untuk langkah tersebut:

```
name: Sample Job With Host Requirements
specificationVersion: jobtemplate-2023-09
steps:
- name: Step 1
  script:
    actions:
      onRun:
        args:
        - '1'
        command: /usr/bin/sleep
  hostRequirements:
    amounts:
    # Capabilities starting with "amount." are amount capabilities. If they start with "amount.worker.",
    # they are defined by the OpenJD specification. Other names are free for custom usage.
    - name: amount.worker.vcpu
      min: 4
      max: 8
    attributes:
    - name: attr.worker.os.family
      anyOf:
      - linux
```

Pekerjaan ini dapat dijadwalkan ke armada dengan kemampuan sebagai berikut:

```
{
    "vCpuCount": {"min": 4, "max": 8},
    "memoryMiB": {"min": 1024},
    "osFamily": "linux",
    "cpuArchitectureType": "x86_64"
}
```

Pekerjaan ini tidak dapat dijadwalkan ke armada dengan salah satu kemampuan berikut:

```
{
    "vCpuCount": {"min": 4},
    "memoryMiB": {"min": 1024},
    "osFamily": "linux",
    "cpuArchitectureType": "x86_64"
}
    The vCpuCount has no maximum, so it exceeds the maximum vCPU host requirement.
    
{
    "vCpuCount": {"max": 8},
    "memoryMiB": {"min": 1024},
    "osFamily": "linux",
    "cpuArchitectureType": "x86_64"
}
    The vCpuCount has no minimum, so it doesn't satisfy the minimum vCPU host requirement.

{
    "vCpuCount": {"min": 4, "max": 8},
    "memoryMiB": {"min": 1024},
    "osFamily": "windows",
    "cpuArchitectureType": "x86_64"
}    
    The osFamily doesn't match.
```

## Penskalaan armada
<a name="jobs-scheduling-scaling"></a>

Ketika pekerjaan ditugaskan ke armada yang dikelola layanan yang kompatibel, armada diskalakan secara otomatis. Jumlah pekerja di armada berubah berdasarkan jumlah tugas yang tersedia untuk dijalankan armada.

Ketika pekerjaan ditugaskan ke armada yang dikelola pelanggan, pekerja mungkin sudah ada atau dapat dibuat menggunakan penskalaan otomatis berbasis peristiwa. Untuk informasi selengkapnya, lihat [Menggunakan EventBridge untuk menangani peristiwa penskalaan otomatis](https://docs.aws.amazon.com/autoscaling/ec2/userguide/automating-ec2-auto-scaling-with-eventbridge.html) di Panduan Pengguna *Amazon EC2 Auto* Scaling.

## Sesi
<a name="jobs-scheduling-sessions"></a>

Tugas dalam suatu pekerjaan dibagi menjadi satu atau lebih sesi. Pekerja menjalankan sesi untuk mengatur lingkungan, menjalankan tugas, dan kemudian meruntuhkan lingkungan. Setiap sesi terdiri dari satu atau lebih tindakan yang harus dilakukan seorang pekerja.

Saat pekerja menyelesaikan tindakan bagian, tindakan sesi tambahan dapat dikirim ke pekerja. Pekerja menggunakan kembali lingkungan yang ada dan lampiran pekerjaan dalam sesi untuk menyelesaikan tugas dengan lebih efisien.

Pada pekerja armada yang dikelola layanan, direktori sesi dihapus setelah sesi berakhir, tetapi direktori lain dipertahankan di antara sesi. Perilaku ini memungkinkan Anda menerapkan strategi caching untuk data yang dapat digunakan kembali di beberapa sesi. Untuk menyimpan data antar sesi, simpan di bawah direktori home pengguna yang menjalankan pekerjaan. Misalnya, paket conda di-cache di bawah direktori home pengguna pekerjaan `C:\Users\job-user\.conda-pkgs` di Windows pekerja dan `/home/job-user/.conda-pkgs` pekerja. Linux Data ini tetap tersedia sampai pekerja dimatikan.

Lampiran Job dibuat oleh pengirim yang Anda gunakan sebagai bagian dari paket pekerjaan Deadline Cloud CLI Anda. Anda juga dapat membuat lampiran pekerjaan menggunakan `--attachments` opsi untuk `create-job` AWS CLI perintah. Lingkungan didefinisikan di dua tempat: lingkungan antrian yang dilampirkan ke antrian tertentu, dan lingkungan pekerjaan dan langkah yang ditentukan dalam templat pekerjaan.

Ada empat jenis tindakan sesi:
+ `syncInputJobAttachments`— Mengunduh lampiran pekerjaan input ke pekerja.
+ `envEnter`— Melakukan `onEnter` tindakan untuk suatu lingkungan.
+ `taskRun`— Melakukan `onRun` tindakan untuk suatu tugas.
+ `envExit`— Melakukan `onExit` tindakan untuk suatu lingkungan.

Template pekerjaan berikut memiliki lingkungan langkah. Ini memiliki `onEnter` definisi untuk mengatur lingkungan langkah, `onRun` definisi yang mendefinisikan tugas yang akan dijalankan, dan `onExit` definisi untuk meruntuhkan lingkungan langkah. Sesi yang dibuat untuk pekerjaan ini akan mencakup `envEnter` tindakan, satu atau lebih `taskRun` tindakan, dan kemudian `envExit` tindakan.

```
name: Sample Job with Maya Environment
specificationVersion: jobtemplate-2023-09
steps:
- name: Maya Step
  stepEnvironments:
  - name: Maya
    description: Runs Maya in the background.
    script:
      embeddedFiles:
      - name: initData
        filename: init-data.yaml
        type: TEXT
        data: |
          scene_file: MyAwesomeSceneFile
          renderer: arnold
          camera: persp
      actions:
        onEnter:
          command: MayaAdaptor
          args:
          - daemon
          - start
          - --init-data
          - file://{{Env.File.initData}}
        onExit:
          command: MayaAdaptor
          args:
          - daemon
          - stop
  parameterSpace:
    taskParameterDefinitions:
    - name: Frame
      range: 1-5
      type: INT
  script:
    embeddedFiles:
    - name: runData
      filename: run-data.yaml
      type: TEXT
      data: |
        frame: {{Task.Param.Frame}}
    actions:
      onRun:
        command: MayaAdaptor
        args:
        - daemon
        - run
        - --run-data
        - file://{{ Task.File.runData }}
```

### Tindakan sesi pipelining
<a name="jobs-session-pipelining"></a>

Tindakan sesi pipelining memungkinkan penjadwal pra-menetapkan beberapa tindakan sesi ke pekerja. Pekerja kemudian dapat menjalankan tindakan ini secara berurutan, mengurangi atau menghilangkan waktu idle antar tugas.

Untuk membuat tugas awal, penjadwal membuat sesi dengan satu tugas, pekerja menyelesaikan tugas, dan kemudian penjadwal menganalisis durasi tugas untuk menentukan tugas masa depan.

Agar penjadwal efektif, ada aturan durasi tugas. Untuk tugas di bawah satu menit, penjadwal menggunakan pola pertumbuhan power-of-2. Misalnya, untuk tugas 1 detik, penjadwal memberikan 2 tugas baru, lalu 4, lalu 8. Untuk tugas lebih dari satu menit, penjadwal hanya menetapkan satu tugas baru dan pipelining tetap dinonaktifkan.

Untuk menghitung ukuran pipa, penjadwal melakukan hal berikut:
+ Menggunakan durasi tugas rata-rata dari tugas yang diselesaikan
+ Bertujuan untuk membuat pekerja sibuk selama satu menit
+ Mempertimbangkan hanya tugas dalam sesi yang sama
+ Tidak berbagi data durasi di seluruh pekerja

Dengan piplelining tindakan sesi, pekerja segera memulai tugas baru dan tidak ada waktu tunggu di antara permintaan penjadwal. Ini juga memberikan peningkatan efisiensi pekerja dan distribusi tugas yang lebih baik untuk proses yang berjalan lama.

Selain itu, jika ada pekerjaan prioritas baru yang lebih tinggi yang tersedia, pekerja akan menyelesaikan semua pekerjaan yang ditugaskan sebelumnya sebelum sesi saat ini berakhir dan sesi baru dari pekerjaan prioritas yang lebih tinggi ditugaskan.

## Ketergantungan langkah
<a name="jobs-scheduling-dependencies"></a>

Deadline Cloud mendukung mendefinisikan dependensi antar langkah sehingga satu langkah menunggu hingga langkah lain selesai sebelum memulai. Anda dapat menentukan lebih dari satu ketergantungan untuk satu langkah. Langkah dengan ketergantungan tidak dijadwalkan sampai semua dependensinya selesai.

Jika template pekerjaan mendefinisikan ketergantungan melingkar, pekerjaan ditolak dan status pekerjaan disetel ke. `CREATE_FAILED`

Template pekerjaan berikut membuat pekerjaan dengan dua langkah. `StepB`tergantung pada`StepA`. `StepB`hanya berjalan setelah `StepA` selesai dengan sukses. 

Setelah pekerjaan dibuat, `StepA` berada di `READY` negara bagian dan `StepB` berada di `PENDING` negara bagian. Setelah `StepA` selesai, `StepB` pindah ke `READY` negara bagian. Jika `StepA` gagal, atau `StepA` jika dibatalkan, `StepB` pindah ke `CANCELED` negara bagian.

Anda dapat mengatur ketergantungan pada beberapa langkah. Misalnya, jika `StepC` tergantung pada keduanya `StepA` dan`StepB`, `StepC` tidak akan dimulai sampai dua langkah lainnya selesai.

Dependensi langkah memiliki batasan berikut:
+ **Dependensi per langkah** — Sebuah langkah dapat bergantung pada maksimum 128 langkah lainnya.
+ **Konsumen per langkah** — Maksimal 32 langkah lain dapat bergantung pada satu langkah.

```
name: Step-Step Dependency Test
specificationVersion: 'jobtemplate-2023-09'
steps:
- name: A
  script:
    actions:
      onRun:
        command: bash
        args: ['{{ Task.File.run }}']
    embeddedFiles:
      - name: run
        type: TEXT
        data: |
          #!/bin/env bash

          set -euo pipefail

          sleep 1
          echo Task A Done!
- name: B
  dependencies:
  - dependsOn: A # This means Step B depends on Step A
  script:
    actions:
      onRun:
        command: bash
        args: ['{{ Task.File.run }}']
    embeddedFiles:
      - name: run
        type: TEXT
        data: |
          #!/bin/env bash

          set -euo pipefail

          sleep 1
          echo Task B Done!
```

# Ubah pekerjaan di Deadline Cloud
<a name="build-jobs-modifying"></a>

Anda dapat menggunakan `update` perintah AWS Command Line Interface (AWS CLI) berikut untuk mengubah konfigurasi pekerjaan, atau untuk menetapkan status target pekerjaan, langkah, atau tugas: ``
+ `aws deadline update-job`
+ `aws deadline update-step`
+ `aws deadline update-task`

Dalam contoh `update` perintah berikut, ganti masing-masing *`user input placeholder`* dengan informasi Anda sendiri.

**Example — Meminta pekerjaan**  
Semua tugas dalam pekerjaan beralih ke `READY` status, kecuali ada dependensi langkah. Langkah-langkah dengan dependensi beralih ke salah satu `READY` atau `PENDING` saat dipulihkan.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--target-task-run-status PENDING
```

**Example — Batalkan pekerjaan**  
Semua tugas dalam pekerjaan yang tidak memiliki status `SUCCEEDED` atau `FAILED` ditandai`CANCELED`.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--target-task-run-status CANCELED
```

**Example — Tandai pekerjaan gagal**  
Semua tugas dalam pekerjaan yang memiliki status `SUCCEEDED` dibiarkan tidak berubah. Semua tugas lainnya ditandai`FAILED`.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--target-task-run-status FAILED
```

**Example — Tandai pekerjaan yang sukses**  
Semua tugas dalam pekerjaan pindah ke `SUCCEEDED` negara bagian.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--target-task-run-status SUCCEEDED
```

**Example — Menangguhkan pekerjaan**  
Tugas dalam pekerjaan di`SUCCEEDED`,`CANCELED`, atau `FAILED` negara bagian tidak berubah. Semua tugas lainnya ditandai`SUSPENDED`.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--target-task-run-status SUSPENDED
```

**Example — Mengubah prioritas pekerjaan**  
Memperbarui prioritas pekerjaan dalam antrian untuk mengubah urutan yang dijadwalkan. Pekerjaan prioritas yang lebih tinggi umumnya dijadwalkan terlebih dahulu.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--priority 100
```

**Example — Ubah jumlah tugas gagal yang diizinkan**  
Memperbarui jumlah maksimum tugas yang gagal yang dapat dimiliki pekerjaan sebelum tugas yang tersisa dibatalkan.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--max-failed-tasks-count 200
```

**Example — Ubah jumlah percobaan ulang tugas yang diizinkan**  
Memperbarui jumlah maksimum percobaan ulang untuk tugas sebelum tugas gagal. Tugas yang telah mencapai jumlah percobaan ulang maksimum tidak dapat diulang sampai nilai ini meningkat.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--max-retries-per-task 10
```

**Example — Arsipkan pekerjaan**  
Memperbarui status siklus hidup pekerjaan ke. `ARCHIVED` Pekerjaan yang diarsipkan tidak dapat dijadwalkan atau diubah. Anda hanya dapat mengarsipkan pekerjaan yang ada di`FAILED`, `CANCELED``SUCCEEDED`, atau `SUSPENDED` negara bagian.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--lifecycle-status ARCHIVED
```

**Example — Mengubah nama pekerjaan**  
Memperbarui nama tampilan pekerjaan. Panjang nama pekerjaan bisa mencapai 128 karakter.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--name "New Job Name"
```

**Example — Mengubah deskripsi pekerjaan**  
Memperbarui deskripsi pekerjaan. Deskripsi dapat mencapai 2048 karakter. Untuk menghapus deskripsi yang ada, berikan string kosong.  

```
aws deadline update-job \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--description "New Job Description"
```

**Example — Meminta satu langkah**  
Semua tugas di langkah beralih ke `READY` status, kecuali ada dependensi langkah. Tugas dalam langkah-langkah dengan dependensi beralih ke salah satu `READY` atau`PENDING`, dan tugas dipulihkan.  

```
aws deadline update-step \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--step-id stepID \
--target-task-run-status PENDING
```

**Example — Batalkan langkah**  
Semua tugas dalam langkah yang tidak memiliki status `SUCCEEDED` atau `FAILED` ditandai`CANCELED`.  

```
aws deadline update-step \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--step-id stepID \
--target-task-run-status CANCELED
```

**Example — Tandai langkah gagal**  
Semua tugas dalam langkah yang memiliki status `SUCCEEDED` dibiarkan tidak berubah. Semua tugas lainnya ditandai`FAILED`.  

```
aws deadline update-step \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--step-id stepID \
--target-task-run-status FAILED
```

**Example — Tandai langkah sukses**  
Semua tugas dalam langkah ditandai`SUCCEEDED`.  

```
aws deadline update-step \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--step-id stepID \
--target-task-run-status SUCCEEDED
```

**Example — Tangguhkan satu langkah**  
Tugas dalam langkah di`SUCCEEDED`,`CANCELED`, atau `FAILED` status tidak berubah. Semua tugas lainnya ditandai`SUSPENDED`.  

```
aws deadline update-step \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--step-id stepID \
--target-task-run-status SUSPENDED
```

**Example — Mengubah status tugas**  
Saat Anda menggunakan perintah `update-task` Deadline Cloud CLI, tugas beralih ke status yang ditentukan.  

```
aws deadline update-task \
--farm-id farmID \
--queue-id queueID \
--job-id jobID \
--step-id stepID \
--task-id taskID \
--target-task-run-status SUCCEEDED | SUSPENDED | CANCELED | FAILED | PENDING
```