Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memulai dengan sumber daya Deadline Cloud
Untuk mulai membuat solusi khusus untuk AWS Deadline Cloud, Anda harus menyiapkan sumber daya Anda. Ini termasuk pertanian, setidaknya satu antrian untuk pertanian, dan setidaknya satu armada pekerja untuk melayani antrian. Anda dapat membuat sumber daya menggunakan konsol Deadline Cloud, atau Anda dapat menggunakan. AWS Command Line Interface
Dalam tutorial ini, Anda akan menggunakan AWS CloudShell untuk membuat peternakan pengembang sederhana dan menjalankan agen pekerja. Anda kemudian dapat mengirimkan dan menjalankan pekerjaan sederhana dengan parameter dan lampiran, menambahkan armada yang dikelola layanan, dan membersihkan sumber daya pertanian Anda setelah selesai.
Bagian berikut memperkenalkan Anda ke berbagai fitur Deadline Cloud, dan bagaimana mereka berfungsi dan bekerja sama. Mengikuti langkah-langkah ini berguna untuk mengembangkan dan menguji beban kerja dan penyesuaian baru.
Untuk petunjuk cara menyiapkan farm menggunakan konsol, lihat [Memulai](https://docs.aws.amazon.com/deadline-cloud/latest/userguide/getting-started.html) di *Panduan Pengguna Cloud Tenggat* Waktu.
**Topics**
+ [Buat pertanian Cloud Deadline](create-a-farm.md)
+ [Jalankan agen pekerja Deadline Cloud](run-worker.md)
+ [Kirim dengan Deadline Cloud](submit-a-job.md)
+ [Kirim pekerjaan dengan lampiran pekerjaan di Deadline Cloud](run-jobs-job-attachments.md)
+ [Menambahkan armada yang dikelola layanan ke farm pengembang Anda di Deadline Cloud](service-managed-fleet.md)
+ [Bersihkan sumber daya pertanian Anda di Deadline Cloud](cleaning-up.md)
# Buat pertanian Cloud Deadline
Untuk membuat resource farm dan antrean developer di AWS Deadline Cloud, gunakan AWS Command Line Interface (AWS CLI), seperti yang ditunjukkan pada prosedur berikut. Anda juga akan membuat peran AWS Identity and Access Management (IAM) dan armada yang dikelola pelanggan (CMF) dan mengaitkan armada dengan antrian Anda. Kemudian Anda dapat mengonfigurasi AWS CLI dan mengonfirmasi bahwa peternakan Anda sudah diatur dan berfungsi seperti yang ditentukan.
Anda dapat menggunakan peternakan ini untuk menjelajahi fitur Deadline Cloud, kemudian mengembangkan dan menguji beban kerja, penyesuaian, dan integrasi pipeline baru.
**Untuk membuat peternakan**
1. [Buka AWS CloudShell sesi](https://console.aws.amazon.com/cloudshell/home?region=us-west-2). Anda akan menggunakan CloudShell jendela untuk memasukkan AWS Command Line Interface (AWS CLI) perintah untuk menjalankan contoh dalam tutorial ini. Biarkan CloudShell jendela tetap terbuka saat Anda melanjutkan.
1. Buat nama untuk peternakan Anda, dan tambahkan nama pertanian itu ke`~/.bashrc`. Ini akan membuatnya tersedia untuk sesi terminal lainnya.
```
echo "DEV_FARM_NAME=DeveloperFarm" >> ~/.bashrc
source ~/.bashrc
```
1. Buat sumber daya pertanian, dan tambahkan ID pertaniannya ke`~/.bashrc`.
```
aws deadline create-farm \
--display-name "$DEV_FARM_NAME"
echo "DEV_FARM_ID=\$(aws deadline list-farms \
--query \"farms[?displayName=='\$DEV_FARM_NAME'].farmId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Buat sumber daya antrian, dan tambahkan ID antreannya `~/.bashrc.`
```
aws deadline create-queue \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME Queue" \
--job-run-as-user '{"posix": {"user": "job-user", "group": "job-group"}, "runAs":"QUEUE_CONFIGURED_USER"}'
echo "DEV_QUEUE_ID=\$(aws deadline list-queues \
--farm-id \$DEV_FARM_ID \
--query \"queues[?displayName=='\$DEV_FARM_NAME Queue'].queueId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Buat peran IAM untuk armada. Peran ini memberi host pekerja di armada Anda kredensi keamanan yang diperlukan untuk menjalankan pekerjaan dari antrian Anda.
```
aws iam create-role \
--role-name "${DEV_FARM_NAME}FleetRole" \
--assume-role-policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.deadline.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
aws iam put-role-policy \
--role-name "${DEV_FARM_NAME}FleetRole" \
--policy-name WorkerPermissions \
--policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"deadline:AssumeFleetRoleForWorker",
"deadline:UpdateWorker",
"deadline:DeleteWorker",
"deadline:UpdateWorkerSchedule",
"deadline:BatchGetJobEntity",
"deadline:AssumeQueueRoleForWorker"
],
"Resource": "*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:CreateLogStream"
],
"Resource": "arn:aws:logs:*:*:*:/aws/deadline/*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
},
{
"Effect": "Allow",
"Action": [
"logs:PutLogEvents",
"logs:GetLogEvents"
],
"Resource": "arn:aws:logs:*:*:*:/aws/deadline/*",
"Condition": {
"StringEquals": {
"aws:PrincipalAccount": "${aws:ResourceAccount}"
}
}
}
]
}'
```
1. Buat armada yang dikelola pelanggan (CMF), dan tambahkan ID armadanya ke. `~/.bashrc`
```
FLEET_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}FleetRole"
aws deadline create-fleet \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME CMF" \
--role-arn $FLEET_ROLE_ARN \
--max-worker-count 5 \
--configuration \
'{
"customerManaged": {
"mode": "NO_SCALING",
"workerCapabilities": {
"vCpuCount": {"min": 1},
"memoryMiB": {"min": 512},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
}
}
}'
echo "DEV_CMF_ID=\$(aws deadline list-fleets \
--farm-id \$DEV_FARM_ID \
--query \"fleets[?displayName=='\$DEV_FARM_NAME CMF'].fleetId \
| [0]\" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Kaitkan CMF dengan antrian Anda.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_CMF_ID
```
1. Instal antarmuka baris perintah Deadline Cloud.
```
pip install deadline
```
1. Untuk menyetel farm default ke ID farm dan antrean ke ID antrian yang Anda buat sebelumnya, gunakan perintah berikut.
```
deadline config set defaults.farm_id $DEV_FARM_ID
deadline config set defaults.queue_id $DEV_QUEUE_ID
```
1. (Opsional) Untuk mengonfirmasi bahwa peternakan Anda diatur sesuai dengan spesifikasi Anda, gunakan perintah berikut:
+ Daftar semua peternakan — **deadline farm list**
+ Buat daftar semua antrian di pertanian default — **deadline queue list**
+ Daftar semua armada di peternakan default — **deadline fleet list**
+ Dapatkan peternakan default — **deadline farm get**
+ Dapatkan antrian default — **deadline queue get**
+ Dapatkan semua armada yang terkait dengan antrian default — **deadline fleet get**
## Langkah berikutnya
Setelah membuat peternakan, Anda dapat menjalankan agen pekerja Deadline Cloud di host di armada Anda untuk memproses pekerjaan. Lihat [Jalankan agen pekerja Deadline Cloud](run-worker.md).
# Jalankan agen pekerja Deadline Cloud
Sebelum Anda dapat menjalankan pekerjaan yang Anda kirimkan ke antrian di peternakan pengembang Anda, Anda harus menjalankan agen pekerja AWS Deadline Cloud dalam mode pengembang pada host pekerja.
Sepanjang sisa tutorial ini, Anda akan melakukan AWS CLI operasi di peternakan pengembang Anda menggunakan dua AWS CloudShell tab. Di tab pertama, Anda dapat mengirimkan pekerjaan. Di tab kedua, Anda dapat menjalankan agen pekerja.
**catatan**
Jika Anda membiarkan CloudShell sesi Anda menganggur selama lebih dari 20 menit, itu akan batas waktu dan menghentikan agen pekerja. Untuk memulai kembali agen pekerja, ikuti instruksi dalam prosedur berikut.
Sebelum Anda dapat memulai agen pekerja, Anda harus menyiapkan pertanian Deadline Cloud, antrian, dan armada. Lihat [Buat pertanian Cloud Deadline](create-a-farm.md).
**Untuk menjalankan agen pekerja dalam mode pengembang**
1. Dengan pertanian Anda masih terbuka di CloudShell tab pertama, buka CloudShell tab kedua, lalu buat `demoenv-persist` direktori `demoenv-logs` dan.
```
mkdir ~/demoenv-logs
mkdir ~/demoenv-persist
```
1. Unduh dan instal paket agen pekerja Deadline Cloud dari PyPI:
**catatan**
Pada Windows, diperlukan bahwa file agen diinstal ke direktori paket situs global Python. Lingkungan virtual Python saat ini tidak didukung.
```
python -m pip install deadline-cloud-worker-agent
```
1. Untuk memungkinkan agen pekerja membuat direktori sementara untuk menjalankan pekerjaan, buat direktori:
```
sudo mkdir /sessions
sudo chmod 750 /sessions
sudo chown cloudshell-user /sessions
```
1. Jalankan agen pekerja Deadline Cloud dalam mode pengembang dengan variabel `DEV_FARM_ID` dan `DEV_CMF_ID` yang Anda tambahkan ke`~/.bashrc`.
```
deadline-worker-agent \
--farm-id $DEV_FARM_ID \
--fleet-id $DEV_CMF_ID \
--run-jobs-as-agent-user \
--logs-dir ~/demoenv-logs \
--persistence-dir ~/demoenv-persist
```
Saat agen pekerja menginisialisasi dan kemudian melakukan polling pada operasi `UpdateWorkerSchedule` API, output berikut ditampilkan:
```
INFO Worker Agent starting
[2024-03-27 15:51:01,292][INFO ] 👋 Worker Agent starting
[2024-03-27 15:51:01,292][INFO ] AgentInfo
Python Interpreter: /usr/bin/python3
Python Version: 3.9.16 (main, Sep 8 2023, 00:00:00) - [GCC 11.4.1 20230605 (Red Hat 11.4.1-2)]
Platform: linux
...
[2024-03-27 15:51:02,528][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params={'assignedSessions': {}, 'cancelSessionActions': {}, 'updateIntervalSeconds': 15} ...
[2024-03-27 15:51:17,635][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params=(Duplicate removed, see previous response) ...
[2024-03-27 15:51:32,756][INFO ] 📥 API.Resp 📥 [deadline:UpdateWorkerSchedule](200) params=(Duplicate removed, see previous response) ...
...
```
1. Pilih CloudShell tab pertama Anda, lalu daftarkan pekerja di armada.
```
deadline worker list --fleet-id $DEV_CMF_ID
```
Output seperti berikut ini ditampilkan:
```
Displaying 1 of 1 workers starting at 0
- workerId: worker-8c9af877c8734e89914047111f
status: STARTED
createdAt: 2023-12-13 20:43:06+00:00
```
Dalam konfigurasi produksi, agen pekerja Deadline Cloud memerlukan pengaturan beberapa pengguna dan direktori konfigurasi sebagai pengguna administratif di mesin host. Anda dapat mengganti pengaturan ini karena Anda menjalankan pekerjaan di peternakan pengembangan Anda sendiri, yang hanya dapat Anda akses.
## Langkah selanjutnya
Sekarang agen pekerja berjalan di host pekerja Anda, Anda dapat mengirim pekerjaan ke pekerja Anda. Anda dapat:
+ [Kirim dengan Deadline Cloud](submit-a-job.md)menggunakan bundel pekerjaan OpenJD sederhana.
+ [Kirim pekerjaan dengan lampiran pekerjaan di Deadline Cloud](run-jobs-job-attachments.md)yang berbagi file antar workstation menggunakan sistem operasi yang berbeda.
# Kirim dengan Deadline Cloud
Untuk menjalankan pekerjaan Deadline Cloud di host pekerja Anda, Anda membuat dan menggunakan paket pekerjaan Open Job Description (OpenJD) untuk mengonfigurasi pekerjaan. Bundel mengkonfigurasi pekerjaan, misalnya dengan menentukan file input untuk pekerjaan dan di mana untuk menulis output pekerjaan. Topik ini mencakup contoh cara Anda dapat mengonfigurasi bundel pekerjaan.
Sebelum Anda dapat mengikuti prosedur di bagian ini, Anda harus menyelesaikan yang berikut:
+ [Buat pertanian Cloud Deadline](create-a-farm.md)
+ [Jalankan agen pekerja Deadline Cloud](run-worker.md)
Untuk menggunakan AWS Deadline Cloud untuk menjalankan pekerjaan, gunakan prosedur berikut. Gunakan AWS CloudShell tab pertama untuk mengirimkan pekerjaan ke peternakan pengembang Anda. Gunakan CloudShell tab kedua untuk melihat output agen pekerja.
**Topics**
+ [Kirim simple\$1job sampelnya](#submit-a-simplejob-sample)
+ [Kirim simple\$1job dengan parameter](#submit-with-parameter)
+ [Buat bundel pekerjaan simple\$1file\$1job dengan file I/O](#create-job-bundle-with-file-io)
+ [Langkah selanjutnya](#submit-a-job-next)
## Kirim simple\$1job sampelnya
Setelah membuat peternakan dan menjalankan agen pekerja, Anda dapat mengirimkan simple\$1job sampel ke Deadline Cloud.
**Untuk mengirimkan simple\$1job sampel ke Deadline Cloud**
1. Pilih CloudShell tab pertama Anda.
1. Unduh sampel dari GitHub.
```
cd ~
git clone https://github.com/aws-deadline/deadline-cloud-samples.git
```
1. Arahkan ke direktori sampel bundel pekerjaan.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Kirim simple\$1job sampel.
```
deadline bundle submit simple_job
```
1. Pilih CloudShell tab kedua Anda untuk melihat output logging tentang panggilan`BatchGetJobEntities`, mendapatkan sesi, dan menjalankan tindakan sesi.
```
...
[2024-03-27 16:00:21,846][INFO ] 🔷 Session.Starting 🔷 [session-053d77cef82648fe2] Starting new Session. [queue-3ba4ff683ff54db09b851a2ed8327d7b/job-d34cc98a6e234b6f82577940ab4f76c6]
[2024-03-27 16:00:21,853][INFO ] 📤 API.Req 📤 [deadline:BatchGetJobEntity] resource={'farm-id': 'farm-3e24cfc9bbcd423e9c1b6754bc1', 'fleet-id': 'fleet-246ee60f46d44559b6cce010d05', 'worker-id': 'worker-75e0fce9c3c344a69bff57fcd83'} params={'identifiers': [{'jobDetails': {'jobId': 'job-d34cc98a6e234b6f82577940ab4'}}]} request_url=https://scheduling.deadline.us-west-2.amazonaws.com/2023-10-12/farms/farm-3e24cfc9bbcd423e /fleets/fleet-246ee60f46d44559b1 /workers/worker- 75e0fce9c3c344a69b /batchGetJobEntity
[2024-03-27 16:00:22,013][INFO ] 📥 API.Resp 📥 [deadline:BatchGetJobEntity](200) params={'entities': [{'jobDetails': {'jobId': 'job-d34cc98a6e234b6f82577940ab6', 'jobRunAsUser': {'posix': {'user': 'job-user', 'group': 'job-group'}, 'runAs': 'QUEUE_CONFIGURED_USER'}, 'logGroupName': '/aws/deadline/farm-3e24cfc9bbcd423e9c1b6754bc1/queue-3ba4ff683ff54db09b851a2ed83', 'parameters': '*REDACTED*', 'schemaVersion': 'jobtemplate-2023-09'}}], 'errors': []} request_id=a3f55914-6470-439e-89e5-313f0c6
[2024-03-27 16:00:22,013][INFO ] 🔷 Session.Add 🔷 [session-053d77cef82648fea9c69827182] Appended new SessionActions. (ActionIds: ['sessionaction-053d77cef82648fea9c69827182-0']) [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ab6]
[2024-03-27 16:00:22,014][WARNING ] 🔷 Session.User 🔷 [session-053d77cef82648fea9c69827182] Running as the Worker Agent's user. (User: cloudshell-user) [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ac6]
[2024-03-27 16:00:22,015][WARNING ] 🔷 Session.AWSCreds 🔷 [session-053d77cef82648fea9c69827182] AWS Credentials are not available: Queue has no IAM Role. [queue-3ba4ff683ff54db09b851a2ed8b/job-d34cc98a6e234b6f82577940ab6]
[2024-03-27 16:00:22,026][INFO ] 🔷 Session.Logs 🔷 [session-053d77cef82648fea9c69827182] Logs streamed to: AWS CloudWatch Logs. (LogDestination: /aws/deadline/farm-3e24cfc9bbcd423e9c1b6754bc1/queue-3ba4ff683ff54db09b851a2ed83/session-053d77cef82648fea9c69827181) [queue-3ba4ff683ff54db09b851a2ed83/job-d34cc98a6e234b6f82577940ab4]
[2024-03-27 16:00:22,026][INFO ] 🔷 Session.Logs 🔷 [session-053d77cef82648fea9c69827182] Logs streamed to: local file. (LogDestination: /home/cloudshell-user/demoenv-logs/queue-3ba4ff683ff54db09b851a2ed8b/session-053d77cef82648fea9c69827182.log) [queue-3ba4ff683ff54db09b851a2ed83/job-d34cc98a6e234b6f82577940ab4]
...
```
**catatan**
Hanya output logging dari agen pekerja yang ditampilkan. Ada log terpisah untuk sesi yang menjalankan pekerjaan.
1. Pilih tab pertama Anda, lalu periksa file log yang ditulis agen pekerja.
1. Arahkan ke direktori log agen pekerja dan lihat isinya.
```
cd ~/demoenv-logs
ls
```
1. Cetak file log pertama yang dibuat oleh agen pekerja.
```
cat worker-agent-bootstrap.log
```
File ini berisi output agen pekerja tentang bagaimana itu disebut Deadline Cloud API untuk membuat sumber daya pekerja di armada Anda, dan kemudian mengambil peran armada.
1. Cetak output file log saat agen pekerja bergabung dengan armada.
```
cat worker-agent.log
```
Log ini berisi output tentang semua tindakan yang diambil agen pekerja, tetapi tidak berisi output tentang antrian tempat ia menjalankan pekerjaan, kecuali untuk sumber daya tersebut IDs .
1. Cetak file log untuk setiap sesi dalam direktori yang diberi nama sama dengan id sumber daya antrian.
```
cat $DEV_QUEUE_ID/session-*.log
```
Jika pekerjaan berhasil, output file log akan mirip dengan yang berikut ini:
```
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
2024-03-27 16:00:22,026 WARNING Session running with no AWS Credentials.
2024-03-27 16:00:22,404 INFO
2024-03-27 16:00:22,405 INFO ==============================================
2024-03-27 16:00:22,405 INFO --------- Running Task
2024-03-27 16:00:22,405 INFO ==============================================
2024-03-27 16:00:22,406 INFO ----------------------------------------------
2024-03-27 16:00:22,406 INFO Phase: Setup
2024-03-27 16:00:22,406 INFO ----------------------------------------------
2024-03-27 16:00:22,406 INFO Writing embedded files for Task to disk.
2024-03-27 16:00:22,406 INFO Mapping: Task.File.runScript -> /sessions/session-053d77cef82648fea9c698271812a/embedded_fileswa_gj55_/tmp2u9yqtsz
2024-03-27 16:00:22,406 INFO Wrote: runScript -> /sessions/session-053d77cef82648fea9c698271812a/embedded_fileswa_gj55_/tmp2u9yqtsz
2024-03-27 16:00:22,407 INFO ----------------------------------------------
2024-03-27 16:00:22,407 INFO Phase: Running action
2024-03-27 16:00:22,407 INFO ----------------------------------------------
2024-03-27 16:00:22,407 INFO Running command /sessions/session-053d77cef82648fea9c698271812a/tmpzuzxpslm.sh
2024-03-27 16:00:22,414 INFO Command started as pid: 471
2024-03-27 16:00:22,415 INFO Output:
2024-03-27 16:00:22,420 INFO Welcome to AWS Deadline Cloud!
2024-03-27 16:00:22,571 INFO
2024-03-27 16:00:22,572 INFO ==============================================
2024-03-27 16:00:22,572 INFO --------- Session Cleanup
2024-03-27 16:00:22,572 INFO ==============================================
2024-03-27 16:00:22,572 INFO Deleting working directory: /sessions/session-053d77cef82648fea9c698271812a
```
1. Cetak informasi tentang pekerjaan itu.
```
deadline job get
```
Saat Anda mengirimkan pekerjaan, sistem menyimpannya sebagai default sehingga Anda tidak perlu memasukkan ID pekerjaan.
## Kirim simple\$1job dengan parameter
Anda dapat mengirimkan pekerjaan dengan parameter. Dalam prosedur berikut, Anda mengedit simple\$1job template untuk menyertakan pesan khusus, mengirimkansimple\$1job, lalu mencetak file log sesi untuk melihat pesan.
**Untuk mengirimkan simple\$1job sampel dengan parameter**
1. Pilih CloudShell tab pertama Anda, lalu arahkan ke direktori sampel bundel pekerjaan.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Cetak isi simple\$1job template.
```
cat simple_job/template.yaml
```
`parameterDefinitions`Bagian dengan `Message` parameter akan terlihat seperti berikut:
```
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
```
1. Kirim simple\$1job sampel dengan nilai parameter, lalu tunggu pekerjaan selesai berjalan.
```
deadline bundle submit simple_job \
-p "Message=Greetings from the developer getting started guide."
```
1. Untuk melihat pesan kustom, lihat file log sesi terbaru.
```
cd ~/demoenv-logs
cat $DEV_QUEUE_ID/$(ls -t $DEV_QUEUE_ID | head -1)
```
## Buat bundel pekerjaan simple\$1file\$1job dengan file I/O
Pekerjaan render perlu membaca definisi adegan, merender gambar darinya, dan kemudian menyimpan gambar itu ke file output. Anda dapat mensimulasikan tindakan ini dengan membuat pekerjaan menghitung hash input alih-alih merender gambar.
**Untuk membuat bundel pekerjaan simple\$1file\$1job dengan file I/O**
1. Pilih CloudShell tab pertama Anda, lalu arahkan ke direktori sampel bundel pekerjaan.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Buat salinan `simple_job` dengan nama baru`simple_file_job`.
```
cp -r simple_job simple_file_job
```
1. Edit template pekerjaan sebagai berikut:
**catatan**
Kami menyarankan Anda menggunakan nano langkah-langkah ini. Jika Anda lebih suka menggunakanVim, Anda harus mengatur mode tempel menggunakan`:set paste`.
1. Buka template di editor teks.
```
nano simple_file_job/template.yaml
```
1. Tambahkan yang berikut ini`type`,`objectType`, dan `dataFlow``parameterDefinitions`.
```
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
```
1. Tambahkan perintah `bash` script berikut ke akhir file yang membaca dari file input dan menulis ke file output.
```
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
Yang diperbarui `template.yaml` harus sama persis dengan yang berikut:
```
specificationVersion: 'jobtemplate-2023-09'
name: Simple File Job Bundle Example
parameterDefinitions:
- name: Message
type: STRING
default: Welcome to AWS Deadline Cloud!
- name: InFile
type: PATH
objectType: FILE
dataFlow: IN
- name: OutFile
type: PATH
objectType: FILE
dataFlow: OUT
steps:
- name: WelcomeToDeadlineCloud
script:
actions:
onRun:
command: '{{Task.File.Run}}'
embeddedFiles:
- name: Run
type: TEXT
runnable: true
data: |
#!/usr/bin/env bash
echo "{{Param.Message}}"
# hash the input file, and write that to the output
sha256sum "{{Param.InFile}}" > "{{Param.OutFile}}"
```
**catatan**
Jika Anda ingin menyesuaikan spasi di`template.yaml`, pastikan Anda menggunakan spasi alih-alih lekukan.
1. Simpan file, dan keluar dari editor teks.
1. Berikan nilai parameter untuk file input dan output untuk mengirimkan simple\$1file\$1job.
```
deadline bundle submit simple_file_job \
-p "InFile=simple_job/template.yaml" \
-p "OutFile=hash.txt"
```
1. Cetak informasi tentang pekerjaan itu.
```
deadline job get
```
+ Anda akan melihat output seperti berikut ini:
```
parameters:
Message:
string: Welcome to AWS Deadline Cloud!
InFile:
path: /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
OutFile:
path: /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/hash.txt
```
+ Meskipun Anda hanya menyediakan jalur relatif, parameter memiliki jalur lengkap yang disetel. AWS CLI Menggabungkan direktori kerja saat ini ke jalur apa pun yang disediakan sebagai parameter saat jalur memiliki tipe`PATH`.
+ Agen pekerja yang berjalan di jendela terminal lain mengambil dan menjalankan pekerjaan. Tindakan ini membuat `hash.txt` file, yang dapat Anda lihat dengan perintah berikut.
```
cat hash.txt
```
Perintah ini akan mencetak output yang mirip dengan berikut ini.
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /local/home/cloudshell-user/BundleFiles/JobBundle-Examples/simple_job/template.yaml
```
## Langkah selanjutnya
Setelah mempelajari cara mengirimkan pekerjaan sederhana menggunakan Deadline Cloud CLI, Anda dapat menjelajahi:
+ [Kirim pekerjaan dengan lampiran pekerjaan di Deadline Cloud](run-jobs-job-attachments.md)untuk mempelajari cara menjalankan pekerjaan pada host yang menjalankan sistem operasi yang berbeda.
+ [Menambahkan armada yang dikelola layanan ke farm pengembang Anda di Deadline Cloud](service-managed-fleet.md)untuk menjalankan pekerjaan Anda di host yang dikelola oleh Deadline Cloud.
+ [Bersihkan sumber daya pertanian Anda di Deadline Cloud](cleaning-up.md)untuk mematikan sumber daya yang Anda gunakan untuk tutorial ini.
# Kirim pekerjaan dengan lampiran pekerjaan di Deadline Cloud
Banyak peternakan menggunakan sistem file bersama untuk berbagi file antara host yang mengirimkan pekerjaan dan yang menjalankan pekerjaan. Misalnya, pada `simple_file_job` contoh sebelumnya, sistem file lokal dibagi antara jendela AWS CloudShell terminal, yang berjalan di tab satu tempat Anda mengirimkan pekerjaan, dan tab dua tempat Anda menjalankan agen pekerja.
Sistem file bersama menguntungkan ketika workstation submitter dan host pekerja berada di jaringan area lokal yang sama. Jika Anda menyimpan data Anda di lokasi dekat workstation yang mengaksesnya, maka menggunakan farm berbasis cloud berarti Anda harus membagikan sistem file Anda melalui VPN latensi tinggi atau menyinkronkan sistem file Anda di cloud. Tak satu pun dari opsi ini mudah diatur atau dioperasikan.
AWS Deadline Cloud menawarkan solusi sederhana dengan *lampiran pekerjaan*, yang mirip dengan lampiran email. Dengan lampiran pekerjaan, Anda melampirkan data ke pekerjaan Anda. Kemudian, Deadline Cloud menangani detail transfer dan penyimpanan data pekerjaan Anda di bucket Amazon Simple Storage Service (Amazon S3).
Alur kerja pembuatan konten sering berulang, artinya pengguna mengirimkan pekerjaan dengan subset kecil file yang dimodifikasi. Karena bucket Amazon S3 menyimpan lampiran pekerjaan dalam penyimpanan yang dapat dialamatkan konten, nama setiap objek didasarkan pada hash data objek dan konten pohon direktori disimpan dalam format file manifes yang dilampirkan ke pekerjaan.
Sebelum Anda dapat mengikuti prosedur di bagian ini, Anda harus menyelesaikan yang berikut:
+ [Buat pertanian Cloud Deadline](create-a-farm.md)
+ [Jalankan agen pekerja Deadline Cloud](run-worker.md)
Untuk menjalankan pekerjaan dengan lampiran pekerjaan, selesaikan langkah-langkah berikut.
**Topics**
+ [Tambahkan konfigurasi lampiran pekerjaan ke antrian Anda](#job-attachments-config)
+ [Kirim simple\$1file\$1job dengan lampiran pekerjaan](#submit-job-attachments)
+ [Memahami bagaimana lampiran pekerjaan disimpan di Amazon S3](#job-attachments-in-depth)
+ [Langkah selanjutnya](#run-jobs-job-attachments-next)
## Tambahkan konfigurasi lampiran pekerjaan ke antrian Anda
Untuk mengaktifkan lampiran pekerjaan dalam antrian Anda, tambahkan konfigurasi lampiran pekerjaan ke sumber daya antrian di akun Anda.
**Untuk menambahkan konfigurasi lampiran pekerjaan ke antrian**
1. Pilih CloudShell tab pertama Anda, lalu masukkan salah satu perintah berikut untuk menggunakan bucket Amazon S3 untuk lampiran pekerjaan.
+ Jika Anda tidak memiliki bucket Amazon S3 pribadi yang sudah ada, Anda dapat membuat dan menggunakan bucket S3 baru.
```
DEV_FARM_BUCKET=$(echo $DEV_FARM_NAME \
| tr '[:upper:]' '[:lower:]')-$(xxd -l 16 -p /dev/urandom)
if [ "$AWS_REGION" == "us-east-1" ]; then LOCATION_CONSTRAINT=
else LOCATION_CONSTRAINT="--create-bucket-configuration \
LocationConstraint=${AWS_REGION}"
fi
aws s3api create-bucket \
$LOCATION_CONSTRAINT \
--acl private \
--bucket ${DEV_FARM_BUCKET}
```
+ Jika Anda sudah memiliki bucket Amazon S3 pribadi, Anda dapat menggunakannya *`MY_BUCKET_NAME`* dengan menggantinya dengan nama bucket Anda.
```
DEV_FARM_BUCKET=MY_BUCKET_NAME
```
1. Setelah membuat atau memilih bucket Amazon S3, tambahkan nama bucket agar bucket tersedia `~/.bashrc` untuk sesi terminal lainnya.
```
echo "DEV_FARM_BUCKET=$DEV_FARM_BUCKET" >> ~/.bashrc
source ~/.bashrc
```
1. Buat peran AWS Identity and Access Management (IAM) untuk antrian.
```
aws iam create-role --role-name "${DEV_FARM_NAME}QueueRole" \
--assume-role-policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "credentials.deadline.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}'
aws iam put-role-policy \
--role-name "${DEV_FARM_NAME}QueueRole" \
--policy-name S3BucketsAccess \
--policy-document \
'{
"Version": "2012-10-17",
"Statement": [
{
"Action": [
"s3:GetObject*",
"s3:GetBucket*",
"s3:List*",
"s3:DeleteObject*",
"s3:PutObject",
"s3:PutObjectLegalHold",
"s3:PutObjectRetention",
"s3:PutObjectTagging",
"s3:PutObjectVersionTagging",
"s3:Abort*"
],
"Resource": [
"arn:aws:s3:::'$DEV_FARM_BUCKET'",
"arn:aws:s3:::'$DEV_FARM_BUCKET'/*"
],
"Effect": "Allow"
}
]
}'
```
1. Perbarui antrian Anda untuk menyertakan pengaturan lampiran pekerjaan dan peran IAM.
```
QUEUE_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}QueueRole"
aws deadline update-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--role-arn $QUEUE_ROLE_ARN \
--job-attachment-settings \
'{
"s3BucketName": "'$DEV_FARM_BUCKET'",
"rootPrefix": "JobAttachments"
}'
```
1. Konfirmasikan bahwa Anda memperbarui antrian Anda.
```
deadline queue get
```
Output seperti berikut ini ditampilkan:
```
...
jobAttachmentSettings:
s3BucketName: DEV_FARM_BUCKET
rootPrefix: JobAttachments
roleArn: arn:aws:iam::ACCOUNT_NUMBER:role/DeveloperFarmQueueRole
...
```
## Kirim simple\$1file\$1job dengan lampiran pekerjaan
Saat Anda menggunakan lampiran pekerjaan, paket pekerjaan harus memberi Deadline Cloud informasi yang cukup untuk menentukan aliran data pekerjaan, seperti menggunakan parameter. `PATH` Dalam kasussimple\$1file\$1job, Anda mengedit `template.yaml` file untuk memberi tahu Deadline Cloud bahwa aliran data ada di file input dan file output.
Setelah menambahkan konfigurasi lampiran pekerjaan ke antrian, Anda dapat mengirimkan sampel simple\$1file\$1job dengan lampiran pekerjaan. Setelah Anda melakukan ini, Anda dapat melihat logging dan output pekerjaan untuk mengonfirmasi bahwa lampiran pekerjaan simple\$1file\$1job dengan berfungsi.
**Untuk mengirimkan bundel pekerjaan simple\$1file\$1job dengan lampiran pekerjaan**
1. Pilih CloudShell tab pertama Anda, lalu buka `JobBundle-Samples` direktori.
1.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Kirim simple\$1file\$1job ke antrian. Saat diminta untuk mengonfirmasi unggahan, masukkan**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Untuk melihat output log sesi transfer data lampiran pekerjaan, jalankan perintah berikut.
```
JOB_ID=$(deadline config get defaults.job_id)
SESSION_ID=$(aws deadline list-sessions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "sessions[0].sessionId" \
--output text)
cat ~/demoenv-logs/$DEV_QUEUE_ID/$SESSION_ID.log
```
1. Buat daftar tindakan sesi yang dijalankan dalam sesi.
```
aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID
```
Output seperti berikut ini ditampilkan:
```
{
"sessionactions": [
{
"sessionActionId": "sessionaction-123-0",
"status": "SUCCEEDED",
"startedAt": "",
"endedAt": "",
"progressPercent": 100.0,
"definition": {
"syncInputJobAttachments": {}
}
},
{
"sessionActionId": "sessionaction-123-1",
"status": "SUCCEEDED",
"startedAt": "",
"endedAt": "",
"progressPercent": 100.0,
"definition": {
"taskRun": {
"taskId": "task-abc-0",
"stepId": "step-def"
}
}
}
]
}
```
Tindakan sesi pertama mengunduh lampiran pekerjaan input, sedangkan tindakan kedua menjalankan tugas seperti pada langkah sebelumnya dan kemudian mengunggah lampiran pekerjaan keluaran.
1. Daftar direktori output.
```
ls *.txt
```
Output seperti `hash.txt` ada di direktori, tetapi `hash-jobattachments.txt` tidak ada karena file output dari pekerjaan belum diunduh.
1. Unduh output dari pekerjaan terbaru.
```
deadline job download-output
```
1. Lihat output dari file yang diunduh.
```
cat hash-jobattachments.txt
```
Output seperti berikut ini ditampilkan:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Memahami bagaimana lampiran pekerjaan disimpan di Amazon S3
Anda dapat menggunakan AWS Command Line Interface (AWS CLI) untuk mengunggah atau mengunduh data untuk lampiran pekerjaan, yang disimpan di bucket Amazon S3. Memahami bagaimana Deadline Cloud menyimpan lampiran pekerjaan di Amazon S3 akan membantu saat Anda mengembangkan beban kerja dan integrasi pipeline.
**Untuk memeriksa bagaimana lampiran pekerjaan Deadline Cloud disimpan di Amazon S3**
1. Pilih CloudShell tab pertama Anda, lalu buka direktori sampel bundel pekerjaan.
```
cd ~/deadline-cloud-samples/job_bundles/
```
1. Periksa properti pekerjaan.
```
deadline job get
```
Output seperti berikut ini ditampilkan:
```
parameters:
Message:
string: Welcome to AWS Deadline Cloud!
InFile:
path: /home/cloudshell-user/deadline-cloud-samples/job_bundles/simple_job/template.yaml
OutFile:
path: /home/cloudshell-user/deadline-cloud-samples/job_bundles/hash-jobattachments.txt
attachments:
manifests:
- rootPath: /home/cloudshell-user/deadline-cloud-samples/job_bundles/
rootPathFormat: posix
outputRelativeDirectories:
- .
inputManifestPath: farm-3040c59a5b9943d58052c29d907a645d/queue-cde9977c9f4d4018a1d85f3e6c1a4e6e/Inputs/f46af01ca8904cd8b514586671c79303/0d69cd94523ba617c731f29c019d16e8_input.xxh128
inputManifestHash: f95ef91b5dab1fc1341b75637fe987ee
fileSystem: COPIED
```
Bidang lampiran berisi daftar struktur manifes yang menjelaskan jalur data input dan output yang digunakan pekerjaan saat dijalankan. Lihatlah `rootPath` untuk melihat jalur direktori lokal pada mesin yang mengirimkan pekerjaan. Untuk melihat akhiran objek Amazon S3 yang berisi file manifes, tinjau. `inputManifestFile` File manifes berisi metadata untuk snapshot pohon direktori dari data input pekerjaan.
1. Cetak objek manifes Amazon S3 dengan cantik untuk melihat struktur direktori input untuk pekerjaan tersebut.
```
MANIFEST_SUFFIX=$(aws deadline get-job \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "attachments.manifests[0].inputManifestPath" \
--output text)
aws s3 cp s3://$DEV_FARM_BUCKET/JobAttachments/Manifests/$MANIFEST_SUFFIX - | jq .
```
Output seperti berikut ini ditampilkan:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "2ec297b04c59c4741ed97ac8fb83080c",
"mtime": 1698186190000000,
"path": "simple_job/template.yaml",
"size": 445
}
],
"totalSize": 445
}
```
1. Buat awalan Amazon S3 yang menyimpan manifes untuk lampiran pekerjaan keluaran dan daftarkan objek di bawahnya.
```
SESSION_ACTION=$(aws deadline list-session-actions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--session-id $SESSION_ID \
--query "sessionActions[?definition.taskRun != null] | [0]")
STEP_ID=$(echo $SESSION_ACTION | jq -r .definition.taskRun.stepId)
TASK_ID=$(echo $SESSION_ACTION | jq -r .definition.taskRun.taskId)
TASK_OUTPUT_PREFIX=JobAttachments/Manifests/$DEV_FARM_ID/$DEV_QUEUE_ID/$JOB_ID/$STEP_ID/$TASK_ID/
aws s3api list-objects-v2 --bucket $DEV_FARM_BUCKET --prefix $TASK_OUTPUT_PREFIX
```
Lampiran pekerjaan keluaran tidak direferensikan secara langsung dari sumber daya pekerjaan tetapi ditempatkan di bucket Amazon S3 berdasarkan sumber daya pertanian. IDs
1. Dapatkan kunci objek manifes terbaru untuk id tindakan sesi tertentu, lalu cetak objek manifes dengan cantik.
```
SESSION_ACTION_ID=$(echo $SESSION_ACTION | jq -r .sessionActionId)
MANIFEST_KEY=$(aws s3api list-objects-v2 \
--bucket $DEV_FARM_BUCKET \
--prefix $TASK_OUTPUT_PREFIX \
--query "Contents[*].Key" --output text \
| grep $SESSION_ACTION_ID \
| sort | tail -1)
MANIFEST_OBJECT=$(aws s3 cp s3://$DEV_FARM_BUCKET/$MANIFEST_KEY -)
echo $MANIFEST_OBJECT | jq .
```
Anda akan melihat properti file `hash-jobattachments.txt` dalam output seperti berikut ini:
```
{
"hashAlg": "xxh128",
"manifestVersion": "2023-03-03",
"paths": [
{
"hash": "f60b8e7d0fabf7214ba0b6822e82e08b",
"mtime": 1698785252554950,
"path": "hash-jobattachments.txt",
"size": 182
}
],
"totalSize": 182
}
```
Pekerjaan Anda hanya akan memiliki satu objek manifes per tugas yang dijalankan, tetapi secara umum dimungkinkan untuk memiliki lebih banyak objek per tugas yang dijalankan.
1. Lihat output penyimpanan Amazon S3 yang dapat dialamatkan konten di bawah awalan. `Data`
```
FILE_HASH=$(echo $MANIFEST_OBJECT | jq -r .paths[0].hash)
FILE_PATH=$(echo $MANIFEST_OBJECT | jq -r .paths[0].path)
aws s3 cp s3://$DEV_FARM_BUCKET/JobAttachments/Data/$FILE_HASH -
```
Output seperti berikut ini ditampilkan:
```
eaa2df5d34b54be5ac34c56a24a8c237b8487231a607eaf530a04d76b89c9cd3 /tmp/openjd/session-123/assetroot-abc/simple_job/template.yaml
```
## Langkah selanjutnya
Setelah mempelajari cara mengirimkan pekerjaan dengan lampiran menggunakan Deadline Cloud CLI, Anda dapat menjelajahi:
+ [Kirim dengan Deadline Cloud](submit-a-job.md)untuk mempelajari cara menjalankan pekerjaan menggunakan bundel OpenJD di host pekerja Anda.
+ [Menambahkan armada yang dikelola layanan ke farm pengembang Anda di Deadline Cloud](service-managed-fleet.md)untuk menjalankan pekerjaan Anda di host yang dikelola oleh Deadline Cloud.
+ [Bersihkan sumber daya pertanian Anda di Deadline Cloud](cleaning-up.md)untuk mematikan sumber daya yang Anda gunakan untuk tutorial ini.
# Menambahkan armada yang dikelola layanan ke farm pengembang Anda di Deadline Cloud
AWS CloudShell tidak menyediakan kapasitas komputasi yang cukup untuk menguji beban kerja yang lebih besar. Ini juga tidak dikonfigurasi untuk bekerja dengan pekerjaan yang mendistribusikan tugas di beberapa host pekerja.
Alih-alih menggunakan CloudShell, Anda dapat menambahkan armada terkelola layanan Auto Scaling (SMF) ke peternakan pengembang Anda. SMF menyediakan kapasitas komputasi yang cukup untuk beban kerja yang lebih besar dan dapat menangani pekerjaan yang perlu mendistribusikan tugas pekerjaan di beberapa host pekerja.
Sebelum menambahkan SMF, Anda harus menyiapkan pertanian, antrian, dan armada Deadline Cloud. Lihat [Buat pertanian Cloud Deadline](create-a-farm.md).
**Untuk menambahkan armada yang dikelola layanan ke peternakan pengembang Anda**
1. Pilih AWS CloudShell tab pertama Anda, lalu buat armada yang dikelola layanan dan tambahkan ID armadanya. `.bashrc` Tindakan ini membuatnya tersedia untuk sesi terminal lainnya.
```
FLEET_ROLE_ARN="arn:aws:iam::$(aws sts get-caller-identity \
--query "Account" --output text):role/${DEV_FARM_NAME}FleetRole"
aws deadline create-fleet \
--farm-id $DEV_FARM_ID \
--display-name "$DEV_FARM_NAME SMF" \
--role-arn $FLEET_ROLE_ARN \
--max-worker-count 5 \
--configuration \
'{
"serviceManagedEc2": {
"instanceCapabilities": {
"vCpuCount": {
"min": 2,
"max": 4
},
"memoryMiB": {
"min": 512
},
"osFamily": "linux",
"cpuArchitectureType": "x86_64"
},
"instanceMarketOptions": {
"type": "spot"
}
}
}'
echo "DEV_SMF_ID=$(aws deadline list-fleets \
--farm-id $DEV_FARM_ID \
--query "fleets[?displayName=='$DEV_FARM_NAME SMF'].fleetId \
| [0]" --output text)" >> ~/.bashrc
source ~/.bashrc
```
1. Kaitkan SMF dengan antrian Anda.
```
aws deadline create-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $DEV_SMF_ID
```
1. Kirim simple\$1file\$1job ke antrian. Saat diminta untuk mengonfirmasi unggahan, masukkan**y**.
```
deadline bundle submit simple_file_job \
-p InFile=simple_job/template.yaml \
-p OutFile=hash-jobattachments.txt
```
1. Konfirmasikan SMF berfungsi dengan benar.
```
deadline fleet get
```
+ Pekerja mungkin membutuhkan waktu beberapa menit untuk memulai. Ulangi `deadline fleet get` perintah sampai Anda dapat melihat bahwa armada sedang berjalan.
+ Armada yang dikelola `queueFleetAssociationsStatus` untuk layanan akan. `ACTIVE`
+ SMF `autoScalingStatus` akan berubah dari `GROWING` ke`STEADY`.
Status Anda akan terlihat mirip dengan yang berikut ini:
```
fleetId: fleet-2cc78e0dd3f04d1db427e7dc1d51ea44
farmId: farm-63ee8d77cdab4a578b685be8c5561c4a
displayName: DeveloperFarm SMF
description: ''
status: ACTIVE
autoScalingStatus: STEADY
targetWorkerCount: 0
workerCount: 0
minWorkerCount: 0
maxWorkerCount: 5
```
1. Lihat log untuk pekerjaan yang Anda kirimkan. Log ini disimpan dalam log di Amazon CloudWatch Logs, bukan sistem CloudShell file.
```
JOB_ID=$(deadline config get defaults.job_id)
SESSION_ID=$(aws deadline list-sessions \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--job-id $JOB_ID \
--query "sessions[0].sessionId" \
--output text)
aws logs tail /aws/deadline/$DEV_FARM_ID/$DEV_QUEUE_ID \
--log-stream-names $SESSION_ID
```
## Langkah selanjutnya
Setelah membuat dan menguji armada yang dikelola layanan, Anda harus menghapus sumber daya yang Anda buat untuk menghindari biaya yang tidak perlu.
+ [Bersihkan sumber daya pertanian Anda di Deadline Cloud](cleaning-up.md)untuk mematikan sumber daya yang Anda gunakan untuk tutorial ini.
# Bersihkan sumber daya pertanian Anda di Deadline Cloud
Untuk mengembangkan dan menguji beban kerja baru dan integrasi pipeline, Anda dapat terus menggunakan Deadline Cloud developer farm yang Anda buat untuk tutorial ini. Jika Anda tidak lagi membutuhkan peternakan pengembang, Anda dapat menghapus sumber dayanya termasuk peran pertanian, armada, antrian, AWS Identity and Access Management (IAM), dan log di Amazon CloudWatch Logs. Setelah Anda menghapus sumber daya ini, Anda harus memulai tutorial lagi untuk menggunakan sumber daya. Untuk informasi selengkapnya, lihat [Memulai dengan sumber daya Deadline Cloud](getting-started.md).
**Untuk membersihkan sumber daya pertanian pengembang**
1. Pilih CloudShell tab pertama Anda, lalu hentikan semua asosiasi antrian-armada untuk antrian Anda.
```
FLEETS=$(aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--query "queueFleetAssociations[].fleetId" \
--output text)
for FLEET_ID in $FLEETS; do
aws deadline update-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $FLEET_ID \
--status STOP_SCHEDULING_AND_CANCEL_TASKS
done
```
1. Buat daftar asosiasi armada antrian.
```
aws deadline list-queue-fleet-associations \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
Anda mungkin perlu menjalankan kembali perintah sampai laporan output`"status": "STOPPED"`, maka Anda dapat melanjutkan ke langkah berikutnya. Proses ini bisa memakan waktu beberapa menit untuk menyelesaikannya.
```
{
"queueFleetAssociations": [
{
"queueId": "queue-abcdefgh01234567890123456789012id",
"fleetId": "fleet-abcdefgh01234567890123456789012id",
"status": "STOPPED",
"createdAt": "2023-11-21T20:49:19+00:00",
"createdBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName",
"updatedAt": "2023-11-21T20:49:38+00:00",
"updatedBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName"
},
{
"queueId": "queue-abcdefgh01234567890123456789012id",
"fleetId": "fleet-abcdefgh01234567890123456789012id",
"status": "STOPPED",
"createdAt": "2023-11-21T20:32:06+00:00",
"createdBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName",
"updatedAt": "2023-11-21T20:49:39+00:00",
"updatedBy": "arn:aws:sts::123456789012:assumed-role/RoleToBeAssumed/MySessionName"
}
]
}
```
1. Hapus semua asosiasi antrian-armada untuk antrian Anda.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-queue-fleet-association \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID \
--fleet-id $FLEET_ID
done
```
1. Hapus semua armada yang terkait dengan antrian Anda.
```
for FLEET_ID in $FLEETS; do
aws deadline delete-fleet \
--farm-id $DEV_FARM_ID \
--fleet-id $FLEET_ID
done
```
1. Hapus antrian.
```
aws deadline delete-queue \
--farm-id $DEV_FARM_ID \
--queue-id $DEV_QUEUE_ID
```
1. Hapus peternakan.
```
aws deadline delete-farm \
--farm-id $DEV_FARM_ID
```
1. Hapus AWS sumber daya lain untuk peternakan Anda.
1. Hapus peran armada AWS Identity and Access Management (IAM).
```
aws iam delete-role-policy \
--role-name "${DEV_FARM_NAME}FleetRole" \
--policy-name WorkerPermissions
aws iam delete-role \
--role-name "${DEV_FARM_NAME}FleetRole"
```
1. Hapus peran IAM antrian.
```
aws iam delete-role-policy \
--role-name "${DEV_FARM_NAME}QueueRole" \
--policy-name S3BucketsAccess
aws iam delete-role \
--role-name "${DEV_FARM_NAME}QueueRole"
```
1. Hapus grup CloudWatch log Amazon Logs. Setiap antrian dan armada memiliki grup log mereka sendiri.
```
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_QUEUE_ID"
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_CMF_ID"
aws logs delete-log-group \
--log-group-name "/aws/deadline/$DEV_FARM_ID/$DEV_SMF_ID"
```