Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Lowongan
Pekerjaan adalah unit kerja yang dimulai oleh AWS Batch. Pekerjaan dapat dipanggil sebagai aplikasi kontainer yang berjalan di instans penampung Amazon ECS di cluster ECS.
Tugas dalam kontainer dapat mereferensikan citra kontainer, perintah, dan parameter. Untuk informasi selengkapnya, lihat [JobDefinition](https://docs.aws.amazon.com/batch/latest/APIReference/API_JobDefinition.html).
Anda dapat mengirimkan sejumlah besar tugas independen dan sederhana.
**Topics**
+ [Tutorial: kirimkan pekerjaan](submit_job.md)
+ [Lowongan kerja Service di AWS Batch](service-jobs.md)
+ [Status Job](job_states.md)
+ [AWS Batch variabel lingkungan kerja](job_env_vars.md)
+ [Percobaan kembali tugas secara otomatis](job_retries.md)
+ [Dependensi Job](job_dependencies.md)
+ [Batas waktu Job](job_timeouts.md)
+ [Lowongan kerja Amazon EKS](eks-jobs.md)
+ [Tugas paralel multisimpul](multi-node-parallel-jobs.md)
+ [Pekerjaan paralel multi-node di Amazon EKS](mnp-eks-jobs.md)
+ [Tugas array](array_jobs.md)
+ [Jalankan lowongan kerja GPU](gpu-jobs.md)
+ [Lihat AWS Batch pekerjaan dalam antrian pekerjaan](view-jobs.md)
+ [AWS Batch Cari pekerjaan dalam antrian pekerjaan](searching-filtering-jobs.md)
+ [Mode jaringan untuk AWS Batch pekerjaan](networking-modes-jobs.md)
+ [Lihat log AWS Batch pekerjaan di CloudWatch Log](review-job-logs.md)
+ [Tinjau informasi AWS Batch pekerjaan](review-job-info.md)
# Tutorial: kirimkan pekerjaan
Setelah Anda mendaftarkan definisi pekerjaan, Anda dapat mengirimkannya sebagai pekerjaan ke antrian AWS Batch pekerjaan. Anda dapat mengganti banyak parameter yang ditentukan dalam definisi pekerjaan saat runtime.
**Untuk mengirim tugas**
1. Buka AWS Batch konsol di [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).
1. Dari bilah navigasi, pilih yang Wilayah AWS akan digunakan.
1. Di panel navigasi, pilih **Tugas**.
1. Pilih **Kirim pekerjaan baru**.
1. Untuk **Name** (Name), masukkan nama yang unik untuk ketentuan tugas Anda. Nama dapat memiliki panjang hingga 128 karakter. Nama dapat memuat huruf besar dan huruf kecil, angka, tanda hubung (-), dan garis bawah (\$1).
1. Untuk **definisi Job**, pilih definisi pekerjaan yang ada untuk pekerjaan Anda. Untuk informasi selengkapnya, lihat [Buat definisi pekerjaan simpul tunggal](create-job-definition.md).
1. Untuk **antrean Job, pilih antrean** pekerjaan yang ada. Untuk informasi selengkapnya, lihat [Membuat antrean tugas](create-job-queue.md).
1. Untuk **dependensi Job, pilih Add** **Job** dependencies.
1. Untuk **id Job**, masukkan ID pekerjaan untuk dependensi apa pun. Kemudian pilih **Tambahkan dependensi pekerjaan**. Sebuah pekerjaan dapat memiliki hingga 20 dependensi. Untuk informasi selengkapnya, lihat [Dependensi Job](job_dependencies.md).
1. (Khusus tugas array) Untuk **Array size** (Ukuran array), tentukan ukuran array antara 2 hingga 10.000.
1. (Opsional) Perluas **Tag** dan kemudian pilih **Tambahkan tag** untuk menambahkan tag ke sumber daya. Masukkan kunci dan nilai opsional, lalu pilih **Tambah tag**.
1. Pilih **Halaman berikutnya**.
1. Di bagian **Job overrides**:
1.
(Opsional) Untuk **prioritas Penjadwalan**, masukkan nilai prioritas penjadwalan antara 0 dan 100. Nilai yang lebih tinggi diberikan prioritas yang lebih tinggi.
1. (Opsional) Untuk **upaya Job**, masukkan jumlah maksimum kali yang AWS Batch mencoba memindahkan pekerjaan ke `RUNNABLE` status. Anda dapat memasukkan angka antara 1 dan 10. Untuk informasi selengkapnya, lihat [Percobaan kembali tugas secara otomatis](job_retries.md).
1. (Opsional) Untuk **batas waktu Eksekusi**, masukkan nilai batas waktu (dalam detik). Batas waktu eksekusi adalah lamanya waktu sebelum pekerjaan yang belum selesai dihentikan. Jika upaya melebihi durasi batas waktu, itu dihentikan dan dipindahkan ke `FAILED` status. Untuk informasi selengkapnya, lihat [Batas waktu Job](job_timeouts.md). Nilai minimum adalah 60 detik.
**penting**
Jangan mengandalkan pekerjaan yang berjalan pada sumber daya Fargate untuk berjalan selama lebih dari 14 hari. Setelah 14 hari, sumber daya Fargate mungkin tidak lagi tersedia dengan pekerjaan yang kemungkinan diberhentikan.
1. (Opsional) Aktifkan **Propagate tag** untuk menyebarkan tag dari definisi pekerjaan dan pekerjaan ke tugas Amazon ECS.
1. Perluas **Additional configuration** (Konfigurasi tambahan).
1. (Opsional) Untuk **kondisi strategi Coba lagi**, pilih **Tambahkan evaluasi saat keluar**. Masukkan setidaknya satu nilai parameter dan kemudian pilih **Action**. Untuk setiap rangkaian kondisi, **Tindakan** harus diatur ke **Coba Ulang** atau **Keluar**. Tindakan ini berarti sebagai berikut:
+ **Coba lagi — AWS Batch coba** lagi sampai jumlah upaya pekerjaan yang Anda tentukan tercapai.
+ **Keluar** — AWS Batch berhenti mencoba kembali pekerjaan.
**penting**
Jika Anda memilih **Tambahkan evaluasi saat keluar**, konfigurasikan setidaknya satu parameter dan pilih salah satu **Tindakan** atau pilih **Hapus evaluasi saat keluar**.
1. Untuk **Parameter**, pilih **Tambahkan parameter** untuk menambahkan placeholder substitusi parameter. Kemudian, masukkan **Kunci** dan **Nilai** opsional.
1. Di bagian **Container overrides**:
1. Untuk **Command**, masukkan perintah ke dalam bidang sebagai setara dengan array string **JSON** mereka.
Parameter ini sesuai dengan `Cmd` di bagian [Buat kontainer](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) di [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) dan parameter `COMMAND` untuk [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/). Untuk informasi selengkapnya tentang `CMD` parameter Docker, lihat [https://docs.docker.com/engine/reference/builder/](https://docs.docker.com/engine/reference/builder/#cmd) \$1cmd.
**catatan**
Parameter ini tidak dapat berisi string kosong.
1. Untuk **v CPUs**, masukkan jumlah v CPUs untuk cadangan wadah. Parameter ini sesuai dengan `CpuShares` di bagian [Buat kontainer](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) di [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) dan opsi `--cpu-shares` untuk [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/). Setiap vCPU setara dengan 1.024 bagian CPU. Anda harus menentukan setidaknya satu vCPU.
1. Untuk **Memori**, masukkan batas memori yang tersedia untuk wadah. Jika kontainer Anda mencoba untuk melebihi memori yang ditentukan di sini, kontainer akan dihentikan. Parameter ini sesuai dengan `Memory` di bagian [Buat kontainer](https://docs.docker.com/engine/api/v1.38/#operation/ContainerCreate) di [Docker Remote API](https://docs.docker.com/engine/api/v1.38/) dan opsi `--memory` untuk [https://docs.docker.com/engine/reference/commandline/run/](https://docs.docker.com/engine/reference/commandline/run/). Anda harus menentukan sedikitnya 4 MiB memori untuk sebuah tugas.
**catatan**
Untuk memaksimalkan pemanfaatan sumber daya Anda, prioritaskan memori untuk pekerjaan dari jenis instans tertentu. Untuk informasi selengkapnya, lihat [Menghitung manajemen memori sumber daya](memory-management.md).
1. (Opsional) Untuk **Jumlah GPUs**, pilih jumlah yang GPUs akan dicadangkan untuk wadah.
1. (Opsional) Untuk **variabel Lingkungan**, pilih **Tambahkan variabel lingkungan** untuk menambahkan variabel lingkungan sebagai pasangan nama-nilai. Variabel-variabel ini diteruskan ke wadah.
1. Pilih **Halaman berikutnya**.
1. Untuk **tinjauan Job**, tinjau langkah-langkah konfigurasi. Jika Anda perlu melakukan perubahan, pilih **Edit**. Setelah selesai, pilih **Buat definisi pekerjaan**.
# Lowongan kerja Service di AWS Batch
AWS Batch pekerjaan layanan memungkinkan Anda untuk mengirimkan permintaan ke AWS layanan melalui antrian AWS Batch pekerjaan. Saat ini, AWS Batch mendukung pekerjaan SageMaker Pelatihan sebagai pekerjaan layanan. Tidak seperti pekerjaan kontainer di mana AWS Batch mengelola eksekusi kontainer yang mendasarinya, pekerjaan layanan memungkinkan AWS Batch untuk menyediakan penjadwalan pekerjaan dan kemampuan antrian sementara AWS layanan target (seperti SageMaker AI) menangani eksekusi pekerjaan yang sebenarnya.
AWS Batch untuk pekerjaan SageMaker Pelatihan memungkinkan ilmuwan data untuk mengirimkan pekerjaan pelatihan dengan prioritas ke antrian yang dapat dikonfigurasi, memastikan beban kerja berjalan tanpa intervensi segera setelah sumber daya tersedia. Kemampuan ini mengatasi tantangan umum seperti koordinasi sumber daya, mencegah pengeluaran berlebihan yang tidak disengaja, memenuhi kendala anggaran, mengoptimalkan biaya dengan instans cadangan, dan menghilangkan kebutuhan untuk koordinasi manual antara anggota tim.
Pekerjaan layanan berbeda dari pekerjaan kontainer dalam beberapa cara utama:
+ **Pengajuan Job**: Pekerjaan layanan harus dikirimkan menggunakan [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API. Pekerjaan layanan tidak dapat dikirimkan melalui AWS Batch konsol.
+ **Job execution**: AWS Batch menjadwalkan dan mengantri pekerjaan layanan, tetapi AWS layanan target menjalankan beban kerja pekerjaan yang sebenarnya.
+ **Pengidentifikasi sumber daya**: Penggunaan pekerjaan layanan ARNs yang berisi “pekerjaan layanan” alih-alih “pekerjaan” untuk membedakannya dari pekerjaan dalam peti kemas.
Untuk memulai pekerjaan AWS Batch layanan untuk SageMaker Pelatihan, lihat[SageMaker Memulai AWS Batch dengan AI](getting-started-sagemaker.md).
**Topics**
+ [Muatan pekerjaan layanan di AWS Batch](service-job-payload.md)
+ [Kirim pekerjaan layanan di AWS Batch](service-job-submit.md)
+ [Memetakan status pekerjaan AWS Batch layanan ke status SageMaker AI](service-job-status.md)
+ [Strategi coba lagi pekerjaan layanan di AWS Batch](service-job-retries.md)
+ [Pantau pekerjaan layanan dalam AWS Batch antrian](monitor-sagemaker-job-queue.md)
+ [Hentikan pekerjaan layanan](terminate-service-jobs.md)
# Muatan pekerjaan layanan di AWS Batch
Ketika Anda mengirimkan pekerjaan layanan menggunakan [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html), Anda memberikan dua parameter utama yang menentukan pekerjaan:`serviceJobType`, dan`serviceRequestPayload`.
+ `serviceJobType`Menentukan AWS layanan mana yang akan melaksanakan pekerjaan. Untuk pekerjaan SageMaker Pelatihan, nilai ini adalah`SAGEMAKER_TRAINING`.
+ `serviceRequestPayload`Ini adalah string yang dikodekan JSON yang berisi permintaan lengkap yang biasanya akan dikirim langsung ke layanan target. Untuk pekerjaan SageMaker Pelatihan, payload ini berisi parameter yang sama yang akan Anda gunakan dengan SageMaker AI [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API.
Untuk daftar lengkap semua parameter yang tersedia dan deskripsinya, lihat referensi SageMaker AI [CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API. Semua parameter yang didukung oleh `CreateTrainingJob` dapat dimasukkan dalam payload pekerjaan layanan Anda.
Untuk contoh konfigurasi pekerjaan pelatihan lainnya, lihat, [CLIAPIs, SDKs](https://docs.aws.amazon.com/sagemaker/latest/dg/api-and-sdk-reference-overview.html) dan di Panduan [SageMaker Pengembang AI](https://docs.aws.amazon.com/sagemaker/latest/dg/gs.html).
Sebaiknya gunakan pySDK untuk pembuatan pekerjaan layanan karena pySDK memiliki kelas dan utilitas pembantu. Untuk contoh penggunaan pySDK, lihat [contoh SageMaker AI](https://github.com/aws/amazon-sagemaker-examples) di. GitHub
## Contoh payload pekerjaan layanan
Contoh berikut menunjukkan payload pekerjaan layanan sederhana untuk pekerjaan SageMaker Pelatihan yang menjalankan skrip pelatihan “hello world”:
Payload ini akan diteruskan sebagai string JSON ke `serviceRequestPayload` parameter saat memanggil. `SubmitServiceJob`
```
{
"TrainingJobName": "my-simple-training-job",
"RoleArn": "arn:aws:iam::123456789012:role/SageMakerExecutionRole",
"AlgorithmSpecification": {
"TrainingInputMode": "File",
"TrainingImage": "763104351884.dkr.ecr.us-west-2.amazonaws.com/pytorch-training:2.0.0-cpu-py310",
"ContainerEntrypoint": [
"echo",
"hello world"
]
},
"ResourceConfig": {
"InstanceType": "ml.c5.xlarge",
"InstanceCount": 1,
"VolumeSizeInGB": 1
},
"OutputDataConfig": {
"S3OutputPath": "s3://your-output-bucket/output"
},
"StoppingCondition": {
"MaxRuntimeInSeconds": 30
}
}
```
# Kirim pekerjaan layanan di AWS Batch
Untuk mengirimkan pekerjaan layanan AWS Batch, Anda menggunakan [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)API. Anda dapat mengirimkan pekerjaan menggunakan AWS CLI atau SDK.
Jika Anda belum memiliki peran eksekusi maka Anda harus membuatnya sebelum Anda dapat mengirimkan pekerjaan layanan Anda. Untuk membuat peran eksekusi SageMaker AI, lihat [Cara menggunakan peran eksekusi SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) dalam *[panduan Pengembang SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html)*.
## Alur kerja penyerahan pekerjaan layanan
Saat Anda mengirimkan pekerjaan layanan, AWS Batch ikuti alur kerja ini:
1. AWS Batch menerima `[SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html)` permintaan Anda dan memvalidasi parameter AWS Batch-spesifik. `serviceRequestPayload`Itu dilewatkan tanpa validasi.
1. Pekerjaan memasuki `SUBMITTED` negara bagian dan ditempatkan dalam antrian pekerjaan yang ditentukan
1. AWS Batch mengevaluasi apakah ada kapasitas yang tersedia di lingkungan layanan untuk `RUNNABLE` pekerjaan di depan antrian
1. Jika kapasitas tersedia, pekerjaan pindah ke `SCHEDULED` dan pekerjaan telah diteruskan ke SageMaker AI
1. Ketika kapasitas telah diperoleh dan SageMaker AI telah mengunduh data pekerjaan layanan, pekerjaan layanan akan memulai inisialisasi dan pekerjaan diubah menjadi`STARTING`.
1. Ketika SageMaker AI mulai menjalankan pekerjaan, statusnya diubah menjadi`RUNNING`.
1. Sementara SageMaker AI menjalankan pekerjaan, AWS Batch memantau kemajuannya dan memetakan status layanan ke status AWS Batch pekerjaan. Untuk detail tentang bagaimana status pekerjaan layanan dipetakan, lihat [Memetakan status pekerjaan AWS Batch layanan ke status SageMaker AI](service-job-status.md)
1. Ketika pekerjaan layanan selesai, ia pindah ke `SUCCEEDED` dan output apa pun siap untuk diunduh.
## Prasyarat
Sebelum mengirimkan pekerjaan layanan, pastikan Anda memiliki:
+ **Lingkungan layanan** — Lingkungan layanan yang mendefinisikan batas kapasitas. Untuk informasi selengkapnya, lihat [Menciptakan lingkungan layanan di AWS Batch](create-service-environments.md).
+ **SageMaker antrian pekerjaan — Antrian** SageMaker pekerjaan untuk menyediakan penjadwalan pekerjaan. Untuk informasi selengkapnya, lihat [Buat antrian pekerjaan SageMaker Pelatihan di AWS Batch](create-sagemaker-job-queue.md).
+ **Izin IAM** — Izin untuk membuat dan mengelola antrian AWS Batch pekerjaan dan lingkungan layanan. Untuk informasi selengkapnya, lihat [AWS Batch Kebijakan, peran, dan izin IAM](IAM_policies.md).
## Kirim pekerjaan layanan dengan AWS CLI
Berikut ini menunjukkan cara mengirimkan pekerjaan layanan menggunakan AWS CLI:
```
aws batch submit-service-job \
--job-name "my-sagemaker-training-job" \
--job-queue "my-sagemaker-job-queue" \
--service-job-type "SAGEMAKER_TRAINING" \
--service-request-payload '{\"TrainingJobName\": \"sagemaker-training-job-example\", \"AlgorithmSpecification\": {\"TrainingImage\": \"123456789012.dkr.ecr.us-east-1.amazonaws.com/pytorch-inference:1.8.0-cpu-py3\", \"TrainingInputMode\": \"File\", \"ContainerEntrypoint\": [\"sleep\", \"1\"]}, \"RoleArn\":\"arn:aws:iam::123456789012:role/SageMakerExecutionRole\", \"OutputDataConfig\": {\"S3OutputPath\": \"s3://example-bucket/model-output/\"}, \"ResourceConfig\": {\"InstanceType\": \"ml.m5.large\", \"InstanceCount\": 1, \"VolumeSizeInGB\": 1}}'
--client-token "unique-token-12345"
```
Untuk informasi selengkapnya tentang `serviceRequestPayload` parameter, lihat[Muatan pekerjaan layanan di AWS Batch](service-job-payload.md).
# Memetakan status pekerjaan AWS Batch layanan ke status SageMaker AI
Saat Anda mengirimkan pekerjaan ke antrian SageMaker pekerjaan menggunakan [SubmitServiceJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitServiceJob.html), AWS Batch mengelola siklus hidup pekerjaan dan memetakan status pekerjaan ke [status AWS Batch pekerjaan](job_states.md) SageMaker Pelatihan yang setara. Pekerjaan layanan, seperti pekerjaan SageMaker Pelatihan, mengikuti siklus hidup negara bagian yang berbeda dari pekerjaan kontainer tradisional. Sementara pekerjaan layanan berbagi sebagian besar negara bagian dengan pekerjaan kontainer, mereka memperkenalkan `SCHEDULED` negara bagian dan menunjukkan perilaku coba lagi yang berbeda, terutama untuk menangani kesalahan kapasitas yang tidak mencukupi dari layanan target.
Tabel berikut menunjukkan status AWS Batch pekerjaan dan Status yang SageMaker sesuai/SecondaryStatus:
| Status Batch | SageMaker Status Utama AI | SageMaker Status Sekunder AI | Deskripsi |
| --- | --- | --- | --- |
| SUBMITTED | N/A | N/A | Job diserahkan ke antrian, menunggu evaluasi penjadwal. |
| RUNNABLE | N/A | N/A | Job antri dan siap untuk penjadwalan. Pekerjaan di negara bagian ini dimulai segera setelah sumber daya yang cukup tersedia di lingkungan layanan. Pekerjaan dapat tetap berada di negara bagian ini tanpa batas waktu ketika sumber daya yang cukup tidak tersedia. |
| SCHEDULED | InProgress | Pending | Pekerjaan layanan berhasil dikirimkan ke SageMaker AI |
| STARTING | InProgress | Downloading | SageMaker Pekerjaan pelatihan mengunduh data dan gambar. Kapasitas kerja pelatihan telah diperoleh dan inisialisasi pekerjaan dimulai. |
| RUNNING | InProgress | Training | SageMaker Algoritma pelaksana pekerjaan pelatihan |
| RUNNING | InProgress | Uploading | SageMaker Pekerjaan pelatihan mengunggah artefak keluaran setelah pelatihan selesai |
| SUCCEEDED | Completed | Completed | SageMaker Pekerjaan pelatihan diselesaikan dengan sukses. Artefak keluaran selesai diunggah. |
| FAILED | Failed | Failed | SageMaker Pekerjaan pelatihan mengalami kesalahan yang tidak dapat dipulihkan. |
| FAILED | Stopped | Stopped | SageMaker Pekerjaan pelatihan dihentikan secara manualStopTrainingJob. |
# Strategi coba lagi pekerjaan layanan di AWS Batch
Strategi coba lagi pekerjaan layanan memungkinkan AWS Batch untuk secara otomatis mencoba kembali pekerjaan layanan yang gagal dalam kondisi tertentu.
Pekerjaan layanan mungkin memerlukan beberapa upaya karena beberapa alasan:
+ **Masalah layanan sementara**: Kesalahan layanan internal, pembatasan, atau pemadaman sementara dapat menyebabkan pekerjaan gagal selama pengiriman atau eksekusi.
+ **Kegagalan inisialisasi pelatihan**: Masalah selama startup pekerjaan, seperti masalah penarikan gambar atau kesalahan inisialisasi, dapat diselesaikan saat mencoba lagi.
Dengan mengonfigurasi strategi coba ulang yang tepat, Anda dapat meningkatkan tingkat keberhasilan pekerjaan dan mengurangi kebutuhan akan intervensi manual, terutama untuk beban kerja pelatihan yang berjalan lama.
**catatan**
Pekerjaan layanan secara otomatis mencoba kembali jenis kegagalan tertentu, seperti kesalahan kapasitas yang tidak mencukupi, tanpa menghabiskan upaya percobaan ulang yang dikonfigurasi. Strategi coba ulang Anda terutama menangani jenis kegagalan lain seperti kesalahan algoritma atau masalah layanan.
## Mengkonfigurasi strategi coba lagi
Strategi coba lagi pekerjaan layanan dikonfigurasi menggunakan [ServiceJobRetryStrategy](https://docs.aws.amazon.com/batch/latest/APIReference/API_ServiceJobRetryStrategy.html), yang mendukung penghitungan coba lagi sederhana dan logika coba lagi bersyarat.
### Coba lagi konfigurasi
Strategi coba lagi yang paling sederhana menentukan jumlah upaya coba lagi yang harus dilakukan jika pekerjaan layanan gagal:
```
{
"retryStrategy": {
"attempts": 3
}
}
```
Konfigurasi ini memungkinkan pekerjaan layanan dicoba ulang hingga 3 kali jika gagal.
**penting**
`attempts`Nilai mewakili jumlah total kali pekerjaan dapat ditempatkan di `RUNNABLE` negara bagian, termasuk upaya awal. Nilai 3 berarti pekerjaan akan dicoba sekali pada awalnya, kemudian dicoba lagi hingga 2 kali tambahan jika gagal.
### Coba lagi konfigurasi dengan evaluateOnExit
Anda dapat menggunakan `evaluateOnExit` parameter untuk menentukan kondisi di mana pekerjaan harus dicoba ulang atau dibiarkan gagal. Ini berguna ketika berbagai jenis kegagalan memerlukan penanganan yang berbeda.
`evaluateOnExit`Array dapat berisi hingga 5 strategi coba lagi, masing-masing menentukan tindakan (`RETRY`atau`EXIT`) dan kondisi berdasarkan alasan status:
```
{
"retryStrategy": {
"attempts": 5,
"evaluateOnExit": [
{
"action": "RETRY",
"onStatusReason": "Received status from SageMaker: InternalServerError*"
},
{
"action": "EXIT",
"onStatusReason": "Received status from SageMaker: ValidationException*"
},
{
"action": "EXIT",
"onStatusReason": "*"
}
]
}
}
```
Konfigurasi ini:
+ Mencoba ulang pekerjaan yang gagal karena kesalahan server internal SageMaker AI
+ Segera gagal pekerjaan yang menemukan pengecualian validasi (kesalahan klien yang tidak akan diselesaikan dengan mencoba lagi)
+ Termasuk aturan catch-all untuk keluar untuk jenis kegagalan lainnya
#### Pencocokan pola alasan status
`onStatusReason`Parameter mendukung pencocokan pola hingga 512 karakter. Pola dapat menggunakan wildcard (\$1) dan cocok dengan alasan status yang dikembalikan oleh SageMaker AI.
Untuk pekerjaan layanan, pesan status dari SageMaker AI diawali dengan “Status diterima dari SageMaker:" untuk membedakannya dari pesan AWS Batch yang dihasilkan. Pola umum meliputi:
+ `Received status from SageMaker: InternalServerError*`- Cocokkan kesalahan layanan internal
+ `Received status from SageMaker: ValidationException*`- Cocokkan kesalahan validasi klien
+ `Received status from SageMaker: ResourceLimitExceeded*`- Kesalahan batas sumber daya yang cocok
+ `*CapacityError*`- Kegagalan terkait kapasitas kecocokan
**Tip**
Gunakan pencocokan pola tertentu untuk menangani jenis kesalahan yang berbeda dengan tepat. Misalnya, coba lagi kesalahan server internal tetapi segera gagal pada kesalahan validasi yang menunjukkan masalah dengan parameter pekerjaan.
# Pantau pekerjaan layanan dalam AWS Batch antrian
Anda dapat memantau status pekerjaan dalam antrian pekerjaan SageMaker Pelatihan Anda menggunakan`list-service-jobs`, dan`get-job-queue-snapshot`.
Lihat pekerjaan yang sedang berjalan dalam antrian Anda:
```
aws batch list-service-jobs \
--job-queue my-sm-training-fifo-jq \
--job-status RUNNING
```
Lihat pekerjaan yang menunggu dalam antrian:
```
aws batch list-service-jobs \
--job-queue my-sm-training-fifo-jq \
--job-status RUNNABLE
```
Lihat pekerjaan yang telah dikirimkan SageMaker tetapi belum berjalan:
```
aws batch list-service-jobs \
--job-queue my-sm-training-fifo-jq \
--job-status SCHEDULED
```
Dapatkan snapshot pekerjaan di depan antrian Anda:
```
aws batch get-job-queue-snapshot --job-queue my-sm-training-fifo-jq
```
Perintah ini menunjukkan urutan pekerjaan layanan yang akan datang dalam antrian Anda.
## Dapatkan informasi pekerjaan layanan terperinci
Gunakan [https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeServiceJob.html)operasi untuk mendapatkan informasi komprehensif tentang pekerjaan layanan tertentu, termasuk statusnya saat ini, pengidentifikasi sumber daya layanan, dan informasi upaya terperinci.
Lihat informasi terperinci tentang pekerjaan tertentu:
```
aws batch describe-service-job \
--job-id a4d6c728-8ee8-4c65-8e2a-9a5e8f4b7c3d
```
Perintah ini mengembalikan informasi komprehensif tentang pekerjaan, termasuk:
+ Job ARN dan status saat ini
+ Pengidentifikasi sumber daya layanan (seperti Arn pekerjaan SageMaker Pelatihan)
+ Prioritas penjadwalan dan coba lagi konfigurasi
+ Muatan permintaan layanan yang berisi parameter layanan asli
+ Informasi percobaan terperinci dengan waktu mulai dan berhenti
+ Pesan status dari layanan target
## Lowongan kerja Monitor SageMaker Training
Saat memantau pekerjaan SageMaker Pelatihan AWS Batch, Anda dapat mengakses informasi AWS Batch pekerjaan dan detail pekerjaan SageMaker Pelatihan yang mendasarinya.
Pengidentifikasi sumber daya layanan dalam detail pekerjaan berisi ARN pekerjaan SageMaker Pelatihan:
```
{
"latestAttempt": {
"serviceResourceId": {
"name": "TrainingJobArn",
"value": "arn:aws:sagemaker:us-east-1:123456789012:training-job/my-training-job"
}
}
}
```
Anda dapat menggunakan ARN ini untuk mendapatkan detail tambahan langsung dari: SageMaker
```
aws sagemaker describe-training-job \
--training-job-name my-training-job
```
Pantau kemajuan pekerjaan dengan memeriksa AWS Batch status dan status pekerjaan SageMaker Pelatihan. Status AWS Batch pekerjaan menunjukkan siklus hidup pekerjaan secara keseluruhan, sedangkan status pekerjaan SageMaker Pelatihan memberikan detail spesifik layanan tentang proses pelatihan.
# Hentikan pekerjaan layanan
Gunakan [https://docs.aws.amazon.com/batch/latest/APIReference/API_TerminateServiceJob.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_TerminateServiceJob.html)operasi untuk menghentikan pekerjaan layanan yang berjalan.
Mengakhiri pekerjaan layanan tertentu:
```
aws batch terminate-service-job \
--job-id a4d6c728-8ee8-4c65-8e2a-9a5e8f4b7c3d \
--reason "Job terminated by user request"
```
Ketika Anda mengakhiri pekerjaan layanan, AWS Batch hentikan pekerjaan dan beri tahu layanan target. Untuk pekerjaan SageMaker Pelatihan, ini akan menghentikan pekerjaan pelatihan di SageMaker AI juga.
# Status Job
Ketika Anda mengirimkan pekerjaan ke antrian AWS Batch pekerjaan, pekerjaan memasuki `SUBMITTED` negara bagian. Tugas kemudian melewati status-status berikut sampai berhasil (keluar dengan kode `0`) atau gagal (keluar dengan kode bukan nol). Tugas AWS Batch dapat memiliki status sebagai berikut:
`SUBMITTED`
Pekerjaan yang dikirimkan ke antrian, dan belum dievaluasi oleh penjadwal. Penjadwal mengevaluasi tugas untuk menentukan apakah tugas memiliki dependensi yang belum diselesaikan dengan keberhasilan penyelesaian tugas lain. Jika ada dependensi, tugas dipindahkan ke `PENDING`. Jika tidak ada dependensi, tugas dipindahkan ke `RUNNABLE`.
`PENDING`
Tugas yang berada dalam antrean dan belum dapat berjalan karena dependensi dengan tugas atau sumber daya lain. Setelah dependensi diselesaikan, tugas dipindahkan ke `RUNNABLE`.
Orang tua pekerjaan array diperbarui ke `PENDING` saat pekerjaan anak diperbarui `RUNNABLE` dan tetap dalam `PENDING` status saat pekerjaan anak berjalan. Untuk melihat pekerjaan ini, filter berdasarkan `PENDING` status hingga semua pekerjaan anak mencapai status terminal.
`RUNNABLE`
Tugas yang berada dalam antrean, tidak memiliki dependensi yang belum diselesaikan, dan karena itu siap dijadwalkan untuk host. Tugas dalam status ini dimulai segera setelah ada cukup sumber daya yang tersedia di salah satu lingkungan komputasi yang dipetakan ke antrean tugas. Namun, tugas dapat tetap berada dalam status ini tanpa batas waktu ketika sumber daya yang cukup tidak tersedia.
Jika pekerjaan Anda tidak berkembang`STARTING`, lihat [Pekerjaan terjebak dalam `RUNNABLE` status](job_stuck_in_runnable.md) di bagian pemecahan masalah.
`STARTING`
Tugas ini telah dijadwalkan untuk host dan operasi inisiasi kontainer yang relevan sedang berlangsung. Setelah citra kontainer ditarik dan kontainer sudah berjalan, tugas bertransisi ke `RUNNING`.
Durasi penarikan gambar, durasi penyelesaian InitContainer Amazon EKS, dan durasi resolusi Amazon ECS ContainerDependency terjadi dalam status MULAI. Jumlah waktu yang diperlukan untuk menarik gambar untuk pekerjaan Anda setara dengan jumlah waktu pekerjaan Anda akan berada dalam keadaan MULAI.
Misalnya, jika dibutuhkan tiga menit untuk menarik gambar untuk pekerjaan Anda, pekerjaan Anda akan berada dalam keadaan MULAI selama tiga menit. Jika InitContainers membutuhkan total sepuluh menit untuk diselesaikan, maka pekerjaan Amazon EKS Anda akan dimulai selama sepuluh menit. Jika Anda memiliki set Amazon ECS ContainerDependencies di pekerjaan Amazon ECS Anda, pekerjaan akan berada di STARTING hingga semua dependensi container (runtime) diselesaikan. MULAI tidak termasuk dalam batas waktu; durasi dimulai pada RUNNING. Untuk informasi selengkapnya, lihat [Status pekerjaan](https://docs.aws.amazon.com/batch/latest/userguide/job_states.html).
`RUNNING`
Tugas berjalan sebagai tugas kontainer di instans kontainer Amazon ECS dalam lingkungan komputasi. Ketika tugas kontainer keluar, kode keluar proses menentukan apakah tugas berhasil atau gagal. Kode keluar `0` menunjukkan keberhasilan, dan kode keluar bukan nol menunjukkan kegagalan. Jika tugas yang terkait dengan upaya yang gagal memiliki sisa upaya yang tersisa dalam konfigurasi strategi percobaan kembali opsional, tugas dipindahkan ke `RUNNABLE` lagi. Untuk informasi selengkapnya, lihat [Percobaan kembali tugas secara otomatis](job_retries.md).
Log untuk `RUNNING` pekerjaan tersedia di CloudWatch Log. Grup log adalah`/aws/batch/job`, dan format nama aliran log adalah sebagai berikut:`first200CharsOfJobDefinitionName/default/ecs_task_id`. Format ini mungkin berubah di masa depan.
Setelah pekerjaan mencapai `RUNNING` status, Anda dapat mengambil nama aliran lognya secara terprogram dengan operasi API. [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html) Untuk informasi selengkapnya, lihat [Melihat Data Log yang Dikirim ke CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) di *Panduan Pengguna CloudWatch Log Amazon*. Secara default, log ini tidak pernah kedaluwarsa. Namun, Anda dapat memodifikasi periode retensi. Untuk informasi selengkapnya, lihat [Mengubah Penyimpanan Data CloudWatch Log di Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) di *Panduan Pengguna CloudWatch Log Amazon*.
`SUCCEEDED`
Tugas telah berhasil diselesaikan dengan kode keluar `0`. Status pekerjaan untuk `SUCCEEDED` pekerjaan dipertahankan setidaknya AWS Batch selama 7 hari.
Log untuk `SUCCEEDED` pekerjaan tersedia di CloudWatch Log. Grup log adalah`/aws/batch/job`, dan format nama aliran log adalah sebagai berikut:`first200CharsOfJobDefinitionName/default/ecs_task_id`. Format ini dapat berubah di masa depan.
Setelah pekerjaan mencapai `RUNNING` status, Anda dapat mengambil nama aliran lognya secara terprogram dengan operasi API. [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html) Untuk informasi selengkapnya, lihat [Melihat Data Log yang Dikirim ke CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) di *Panduan Pengguna CloudWatch Log Amazon*. Secara default, log ini tidak pernah kedaluwarsa. Namun, Anda dapat memodifikasi periode retensi. Untuk informasi selengkapnya, lihat [Mengubah Penyimpanan Data CloudWatch Log di Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) di *Panduan Pengguna CloudWatch Log Amazon*.
`FAILED`
Tugas telah gagal dalam semua upaya yang tersedia. Status pekerjaan untuk `FAILED` pekerjaan dipertahankan setidaknya AWS Batch selama 7 hari.
Log untuk `FAILED` pekerjaan tersedia di CloudWatch Log. Grup log adalah`/aws/batch/job`, dan format nama aliran log adalah sebagai berikut:`first200CharsOfJobDefinitionName/default/ecs_task_id`. Format ini dapat berubah di masa depan.
Setelah pekerjaan mencapai `RUNNING` status, Anda dapat mengambil aliran lognya secara terprogram dengan operasi API. [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html) Untuk informasi selengkapnya, lihat [Melihat Data Log yang Dikirim ke CloudWatch Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/Working-with-log-groups-and-streams.html#ViewingLogData) di *Panduan Pengguna CloudWatch Log Amazon*. Secara default, log ini tidak pernah kedaluwarsa. Namun, Anda dapat memodifikasi periode retensi. Untuk informasi selengkapnya, lihat [Mengubah Penyimpanan Data CloudWatch Log di Log](https://docs.aws.amazon.com/AmazonCloudWatch/latest/logs/SettingLogRetention.html) di *Panduan Pengguna CloudWatch Log Amazon*.
# AWS Batch variabel lingkungan kerja
AWS Batch menetapkan variabel lingkungan tertentu dalam pekerjaan kontainer. Variabel lingkungan ini memberikan introspeksi untuk wadah di dalam pekerjaan. Anda dapat menggunakan nilai-nilai variabel-variabel ini dalam logika aplikasi Anda. Semua variabel yang AWS Batch ditetapkan dimulai dengan `AWS_BATCH_` awalan. Ini adalah awalan variabel lingkungan yang dilindungi. Anda tidak dapat menggunakan awalan ini untuk variabel Anda sendiri dalam definisi pekerjaan atau penggantian.
Variabel lingkungan berikut tersedia dalam kontainer tugas:
`AWS_BATCH_CE_NAME`
Variabel ini diatur ke nama lingkungan komputasi tempat pekerjaan Anda ditempatkan.
`AWS_BATCH_JOB_ARRAY_INDEX`
Variabel ini hanya ditetapkan dalam tugas array turunan. Indeks tugas array dimulai dari 0, dan setiap tugas turunan menerima nomor indeks yang unik. Misalnya, tugas array dengan 10 turunan memiliki nilai indeks 0-9. Anda dapat menggunakan nilai indeks ini untuk mengontrol cara turunan tugas array Anda dibedakan. Untuk informasi selengkapnya, lihat [Gunakan indeks pekerjaan array untuk mengontrol diferensiasi pekerjaan](array_index_example.md).
`AWS_BATCH_JOB_ARRAY_SIZE`
Variabel ini diatur ke ukuran pekerjaan array induk. Ukuran pekerjaan array induk diteruskan ke pekerjaan array anak dalam variabel ini.
`AWS_BATCH_JOB_ATTEMPT`
Variabel ini ditetapkan ke nomor upaya tugas. Upaya pertama diberi nomor 1. Untuk informasi selengkapnya, lihat [Percobaan kembali tugas secara otomatis](job_retries.md).
`AWS_BATCH_JOB_ID`
Variabel ini diatur ke ID AWS Batch pekerjaan.
`AWS_BATCH_JOB_KUBERNETES_NODE_UID`
Variabel ini ditetapkan sebagai Kubernetes UID dari objek node yang ada di cluster Kubernetes tempat pod berjalan. Variabel ini hanya disetel untuk pekerjaan yang berjalan di sumber daya Amazon EKS. Untuk informasi lebih lanjut, lihat [UIDs](https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids)di *Kubernetesdokumentasi*.
`AWS_BATCH_JOB_MAIN_NODE_INDEX`
Variabel ini hanya ditetapkan dalam tugas paralel multisimpul. Variabel ini ditetapkan ke nomor indeks simpul utama tugas. Kode aplikasi Anda dapat `AWS_BATCH_JOB_MAIN_NODE_INDEX` membandingkan dengan `AWS_BATCH_JOB_NODE_INDEX` pada node individual untuk menentukan apakah itu node utama.
`AWS_BATCH_JOB_MAIN_NODE_PRIVATE_IPV4_ADDRESS`
Variabel ini hanya diatur dalam node anak pekerjaan paralel multi-node. Variabel ini tidak hadir pada node utama, tetapi diatur ke IPv4 alamat pribadi dari node utama pekerjaan. Kode aplikasi simpul turunan Anda dapat menggunakan alamat ini untuk berkomunikasi dengan simpul utama.
`AWS_BATCH_JOB_NODE_INDEX`
Variabel ini hanya ditetapkan dalam tugas paralel multisimpul. Variabel ini ditetapkan ke nomor indeks simpul pada simpul. Indeks simpul dimulai dari 0, dan setiap simpul menerima nomor indeks yang unik. Misalnya, tugas paralel multisimpul dengan 10 turunan memiliki nilai indeks 0-9.
`AWS_BATCH_JOB_NUM_NODES`
Variabel ini hanya ditetapkan dalam tugas paralel multisimpul. Variabel ini diatur ke jumlah node yang Anda minta untuk pekerjaan paralel multi-node Anda.
`AWS_BATCH_JQ_NAME`
Variabel ini diatur ke nama antrian pekerjaan tempat pekerjaan Anda dikirimkan.
# Percobaan kembali tugas secara otomatis
Anda dapat menerapkan strategi percobaan kembali untuk tugas dan ketentuan tugas Anda yang memungkinkan tugas gagal untuk dicoba ulang secara otomatis. Skenario kegagalan yang mungkin termasuk yang berikut:
+ Kode keluar yang bukan nol dari tugas kontainer
+ Kegagalan atau pengakhiran instans Amazon EC2
+ Kesalahan atau pemadaman AWS layanan internal
Ketika pekerjaan diserahkan ke antrian pekerjaan dan ditempatkan ke `RUNNING` negara bagian yang dianggap sebagai upaya. Secara default, setiap tugas diberikan satu upaya untuk berpindah, baik ke status tugas `SUCCEEDED` maupun `FAILED`. Namun, definisi pekerjaan dan alur kerja pengiriman pekerjaan dapat digunakan untuk menentukan strategi coba lagi dengan antara 1 dan 10 upaya. Jika [evaluateOnExit](job_definition_parameters.md#retryStrategy-evaluateOnExit)ditentukan, dapat berisi hingga 5 strategi coba lagi. Jika [evaluateOnExit](https://docs.aws.amazon.com/batch/latest/APIReference/API_EvaluateOnExit.html)ditentukan, tetapi tidak ada strategi coba lagi yang cocok, maka pekerjaan itu dicoba lagi. Untuk pekerjaan yang tidak cocok untuk keluar, tambahkan entri akhir yang keluar karena alasan apa pun. Misalnya, `evaluateOnExit` objek ini memiliki dua entri yang dengan tindakan `RETRY` dan entri akhir dengan tindakan. `EXIT`
```
"evaluateOnExit": [
{
"action": "RETRY",
"onReason": "AGENT"
},
{
"action": "RETRY",
"onStatusReason": "Task failed to start"
},
{
"action": "EXIT",
"onReason": "*"
}
]
```
Pada saat waktu aktif, variabel lingkungan `AWS_BATCH_JOB_ATTEMPT` diatur ke jumlah upaya tugas yang sesuai dengan kontainer. Upaya pertama diberi nomor`1`, dan upaya selanjutnya dalam urutan menaik (misalnya, 2, 3, 4).
Misalnya, anggaplah upaya pekerjaan gagal karena alasan apa pun dan jumlah upaya yang ditentukan dalam konfigurasi coba lagi lebih besar dari `AWS_BATCH_JOB_ATTEMPT` jumlahnya. Kemudian, pekerjaan ditempatkan kembali di `RUNNABLE` negara bagian. Untuk informasi selengkapnya, lihat [Status Job](job_states.md).
**catatan**
Pekerjaan yang dibatalkan atau dihentikan tidak akan dicoba lagi. Juga, pekerjaan yang gagal karena definisi pekerjaan yang tidak valid tidak dicoba lagi.
Untuk informasi selengkapnya[Strategi percobaan kembali](job_definition_parameters.md#retryStrategy), lihat[Buat definisi pekerjaan simpul tunggal](create-job-definition.md), [Tutorial: kirimkan pekerjaan](submit_job.md) dan [Kode kesalahan tugas berhenti](https://docs.aws.amazon.com/AmazonECS/latest/userguide/stopped-task-error-codes.html).
# Dependensi Job
Saat Anda mengirimkan AWS Batch pekerjaan, Anda dapat menentukan pekerjaan IDs yang bergantung pada pekerjaan itu. Ketika Anda melakukannya, AWS Batch penjadwal memastikan bahwa pekerjaan Anda dijalankan hanya setelah dependensi yang ditentukan berhasil diselesaikan. Setelah dependensi berhasil, tugas yang bergantung akan bertransisi dari `PENDING` ke `RUNNABLE` dan kemudian ke `STARTING` dan `RUNNING`. Jika salah satu dependensi tugas gagal, tugas yang bergantung secara otomatis akan bertransisi dari `PENDING` ke `FAILED`.
Misalnya, Tugas A dapat mengekspresikan dependensi pada maksimum 20 tugas lain yang harus berhasil sebelum dapat Tugas A dapat berjalan. Anda kemudian dapat mengirimkan tugas tambahan yang memiliki dependensi pada Tugas A dan maksimum 19 tugas lainnya.
Untuk tugas array, Anda dapat menentukan tipe dependensi `SEQUENTIAL` tanpa menentukan ID tugas sehingga setiap tugas array turunan selesai secara berurutan, mulai dari indeks 0. Anda juga dapat menentukan tipe dependensi `N_TO_N` dengan ID tugas. Dengan cara itu, setiap turunan indeks dari tugas ini harus menunggu turunan indeks dari setiap dependensi selesai sebelum turunan tersebut dapat dimulai. Untuk informasi selengkapnya, lihat [Tugas array](array_jobs.md).
Untuk mengirimkan AWS Batch pekerjaan dengan dependensi, lihat. [Tutorial: kirimkan pekerjaan](submit_job.md)
[Penjadwalan sadar sumber daya](resource-aware-scheduling.md)memungkinkan Anda menjadwalkan pekerjaan berdasarkan sumber daya habis pakai yang diperlukan untuk menjalankan pekerjaan Anda. Anda menentukan sumber daya habis pakai yang diperlukan untuk menjalankan pekerjaan, dan Batch memperhitungkan dependensi sumber daya ini saat menjadwalkan pekerjaan. Anda dapat mengurangi kurangnya pemanfaatan sumber daya komputasi dengan mengalokasikan hanya pekerjaan yang memiliki semua sumber daya yang diperlukan tersedia. Penjadwalan sadar sumber daya tersedia untuk FIFO dan kebijakan penjadwalan berbagi adil dan dapat digunakan dengan semua platform komputasi yang didukung oleh Batch termasuk EKS, ECS, dan Fargate. Ini dapat digunakan dengan pekerjaan Array, pekerjaan Multi-node parallel (MNP), dan dengan pekerjaan Batch reguler.
# Batas waktu Job
Anda dapat mengonfigurasi durasi timeout untuk tugas Anda sehingga jika tugas berjalan lebih lama dari itu, AWS Batch akan mengakhiri tugas. Misalnya, Anda mungkin memiliki tugas yang Anda tahu hanya perlu waktu 15 menit untuk diselesaikan. Kadang-kadang aplikasi terjebak dalam perulangan dan berjalan tanpa henti, jadi Anda dapat mengatur batas waktu timeout 30 menit untuk mengakhiri tugas yang terjebak.
**penting**
Secara default, AWS Batch tidak memiliki batas waktu kerja. Jika Anda tidak menentukan batas waktu pekerjaan, pekerjaan akan berjalan hingga kontainer keluar.
Anda menentukan parameter `attemptDurationSeconds`, yang sedikitnya harus berjumlah 60 detik, dalam ketentuan tugas Anda atau ketika Anda mengirimkan tugas. Ketika jumlah detik ini telah berlalu setelah `startedAt` stempel waktu upaya pekerjaan, AWS Batch hentikan pekerjaan. Di sumber daya komputasi, kontainer tugas Anda menerima sinyal `SIGTERM` untuk memberi aplikasi Anda kesempatan untuk berhenti dengan baik. Jika kontainer masih berjalan setelah 30 detik, sinyal `SIGKILL` dikirim untuk menghentikan kontainer secara paksa.
Pengakhiran akibat timeout ditangani dengan dasar usaha terbaik. Anda sebaiknya tidak mengharapkan pengakhiran akibat timeout terjadi persis ketika waktu upaya tugas habis (mungkin diperlukan beberapa detik lebih lama). Jika aplikasi Anda memerlukan eksekusi timeout yang presisi, Anda harus menerapkan logika ini dalam aplikasi. Jika Anda memiliki sejumlah besar tugas yang mengalami timeout secara bersamaan, pengakhiran akibat timeout akan dilakukan dengan antrean first in first out (yang masuk terlebih dahulu akan keluar terlebih dahulu), dan tugas akan diakhiri dalam batch.
**catatan**
Tidak ada nilai batas waktu maksimum untuk suatu AWS Batch pekerjaan.
Jika tugas diakhiri karena melebihi durasi timeout, itu tidak akan dicoba lagi. Jika upaya tugas gagal dengan sendirinya, upaya dapat dicoba lagi jika percobaan kembali diaktifkan, dan hitung mundur timeout dimulai kembali untuk upaya yang baru.
**penting**
Pekerjaan yang berjalan pada sumber daya Fargate tidak dapat diharapkan berjalan selama lebih dari 14 hari. Jika durasi timeout melebihi 14 hari, sumber daya Fargate mungkin tidak lagi tersedia dan tugas akan dihentikan.
Untuk tugas array, tugas turunan memiliki konfigurasi timeout yang sama dengan tugas induk.
Untuk informasi tentang mengirimkan AWS Batch pekerjaan dengan konfigurasi batas waktu, lihat. [Tutorial: kirimkan pekerjaan](submit_job.md)
# Lowongan kerja Amazon EKS
Pekerjaan adalah unit kerja terkecil di AWS Batch. AWS Batch Pekerjaan di Amazon EKS memiliki one-to-one pemetaan ke Kubernetes pod. Definisi AWS Batch pekerjaan adalah templat untuk suatu AWS Batch pekerjaan. Saat Anda mengirimkan AWS Batch pekerjaan, Anda mereferensikan definisi pekerjaan, menargetkan antrian pekerjaan, dan memberikan nama untuk suatu pekerjaan. Dalam definisi pekerjaan AWS Batch pekerjaan di Amazon EKS, parameter [eksProperties](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksProperties.html) mendefinisikan kumpulan parameter yang didukung oleh pekerjaan di AWS Batch Amazon EKS. Dalam [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)permintaan, [eksPropertiesOverride](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPropertiesOverride.html)parameter memungkinkan penggantian ke beberapa parameter umum. Dengan cara ini, Anda dapat menggunakan templat definisi pekerjaan untuk banyak pekerjaan. Saat pekerjaan dikirim ke klaster Amazon EKS Anda, AWS Batch ubah pekerjaan menjadi `podspec` (). `Kind: Pod` `podspec`Menggunakan beberapa AWS Batch parameter tambahan untuk memastikan bahwa pekerjaan diskalakan dan dijadwalkan dengan benar. AWS Batch menggabungkan label dan taints untuk memastikan pekerjaan hanya berjalan pada node AWS Batch terkelola dan bahwa pod lain tidak berjalan pada node tersebut.
**penting**
Jika `hostNetwork` parameter tidak disetel secara eksplisit dalam definisi pekerjaan Amazon EKS, mode jaringan pod secara AWS Batch default ke mode host. Lebih khusus lagi, pengaturan berikut diterapkan: `hostNetwork=true` dan`dnsPolicy=ClusterFirstWithHostNet`.
AWS Batch membersihkan pod pekerjaan segera setelah pod menyelesaikan tugasnya. Untuk melihat log aplikasi pod, konfigurasikan layanan logging untuk klaster Anda. Untuk informasi selengkapnya, lihat [Gunakan CloudWatch Log untuk memantau pekerjaan AWS Batch Amazon EKS](batch-eks-cloudwatch-logs.md).
**Topics**
+ [Tutorial: Memetakan pekerjaan yang sedang berjalan ke pod dan node](eks-jobs-map-running-job.md)
+ [Tutorial: Petakan pod yang sedang berjalan kembali ke pekerjaannya](eks-jobs-map-running-pod-to-job.md)
# Tutorial: Memetakan pekerjaan yang sedang berjalan ke pod dan node
Pekerjaan `podProperties` yang sedang berjalan memiliki `podName` dan `nodeName` parameter yang ditetapkan untuk upaya pekerjaan saat ini. Gunakan operasi [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API untuk melihat parameter ini.
Berikut ini adalah output contoh.
```
$ aws batch describe-jobs --job 2d044787-c663-4ce6-a6fe-f2baf7e51b04
{
"jobs": [
{
"status": "RUNNING",
"jobArn": "arn:aws:batch:us-east-1:123456789012:job/2d044787-c663-4ce6-a6fe-f2baf7e51b04",
"jobDefinition": "arn:aws:batch:us-east-1:123456789012:job-definition/MyJobOnEks_SleepWithRequestsOnly:1",
"jobQueue": "arn:aws:batch:us-east-1:123456789012:job-queue/My-Eks-JQ1",
"jobId": "2d044787-c663-4ce6-a6fe-f2baf7e51b04",
"eksProperties": {
"podProperties": {
"nodeName": "ip-192-168-55-175.ec2.internal",
"containers": [
{
"image": "public.ecr.aws/amazonlinux/amazonlinux:2",
"resources": {
"requests": {
"cpu": "1",
"memory": "1024Mi"
}
}
}
],
"podName": "aws-batch.b0aca953-ba8f-3791-83e2-ed13af39428c"
}
}
}
]
}
```
Untuk pekerjaan dengan percobaan ulang diaktifkan, `podName` dan `nodeName` dari setiap upaya yang diselesaikan ada dalam parameter `eksAttempts` daftar operasi [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. `podName`Dan `nodeName` dari upaya yang sedang berjalan saat ini ada di `podProperties` objek.
# Tutorial: Petakan pod yang sedang berjalan kembali ke pekerjaannya
Sebuah pod memiliki label yang menunjukkan `jobId` dan `uuid` dari lingkungan komputasi yang dimilikinya. AWS Batch menyuntikkan variabel lingkungan sehingga runtime pekerjaan dapat mereferensikan informasi pekerjaan. Untuk informasi selengkapnya, lihat [AWS Batch variabel lingkungan kerja](job_env_vars.md). Anda dapat melihat informasi ini dengan menjalankan perintah berikut. Outputnya adalah sebagai berikut.
```
$ kubectl describe pod aws-batch.14638eb9-d218-372d-ba5c-1c9ab9c7f2a1 -n my-aws-batch-namespace
Name: aws-batch.14638eb9-d218-372d-ba5c-1c9ab9c7f2a1
Namespace: my-aws-batch-namespace
Priority: 0
Node: ip-192-168-45-88.ec2.internal/192.168.45.88
Start Time: Wed, 26 Oct 2022 00:30:48 +0000
Labels: batch.amazonaws.com/compute-environment-uuid=5c19160b-d450-31c9-8454-86cf5b30548f
batch.amazonaws.com/job-id=f980f2cf-6309-4c77-a2b2-d83fbba0e9f0
batch.amazonaws.com/node-uid=a4be5c1d-9881-4524-b967-587789094647
...
Status: Running
IP: 192.168.45.88
IPs:
IP: 192.168.45.88
Containers:
default:
Image: public.ecr.aws/amazonlinux/amazonlinux:2
...
Environment:
AWS_BATCH_JOB_KUBERNETES_NODE_UID: a4be5c1d-9881-4524-b967-587789094647
AWS_BATCH_JOB_ID: f980f2cf-6309-4c77-a2b2-d83fbba0e9f0
AWS_BATCH_JQ_NAME: My-Eks-JQ1
AWS_BATCH_JOB_ATTEMPT: 1
AWS_BATCH_CE_NAME: My-Eks-CE1
...
```
**Fitur yang didukung pekerjaan AWS Batch Amazon EKS**
Ini adalah fitur AWS Batch spesifik yang juga umum untuk Kubernetes pekerjaan yang berjalan di Amazon EKS:
+ [Dependensi Job](job_dependencies.md)
+ [Tugas array](array_jobs.md)
+ [Batas waktu Job](job_timeouts.md)
+ [Percobaan kembali tugas secara otomatis](job_retries.md)
+ [Gunakan penjadwalan berbagi adil untuk membantu menjadwalkan pekerjaan](fair-share-scheduling.md)
**Kubernetes dan `Secrets` `ServiceAccounts`**
AWS Batch mendukung referensi Kubernetes `Secrets` dan`ServiceAccounts`. Anda dapat mengonfigurasi pod untuk menggunakan peran Amazon EKS IAM untuk akun layanan. Untuk informasi selengkapnya, lihat [Mengonfigurasi pod untuk menggunakan akun Kubernetes layanan](https://docs.aws.amazon.com/eks/latest/userguide/pod-configuration.html) di [https://docs.aws.amazon.com/eks/latest/userguide/](https://docs.aws.amazon.com/eks/latest/userguide/).
**Dokumen terkait**
+ [Pertimbangan memori dan vCPU untuk Amazon AWS Batch EKS](memory-cpu-batch-eks.md)
+ [Jalankan lowongan kerja GPU](gpu-jobs.md)
+ [Pekerjaan terjebak dalam `RUNNABLE` status](job_stuck_in_runnable.md)
# Tugas paralel multisimpul
Anda dapat menggunakan pekerjaan paralel multi-node untuk menjalankan pekerjaan tunggal yang mencakup beberapa instans Amazon EC2. Dengan AWS Batch multi-node parallel jobs (juga dikenal sebagai *penjadwalan geng*), Anda dapat menjalankan aplikasi komputasi berkinerja tinggi skala besar dan pelatihan model GPU terdistribusi tanpa perlu meluncurkan, mengonfigurasi, dan mengelola sumber daya Amazon EC2 secara langsung. Pekerjaan paralel AWS Batch multi-node kompatibel dengan kerangka kerja apa pun yang mendukung komunikasi antar simpul berbasis IP. Contohnya termasuk Apache MXNet,, Caffe2 TensorFlow, atau Message Passing Interface (MPI).
Tugas paralel multisimpul dikirimkan sebagai tugas tunggal. Namun, ketentuan tugas Anda (atau timpaan simpul pengiriman tugas) menentukan jumlah simpul yang akan dibuat untuk tugas dan grup simpul apa yang akan dibuat. Setiap tugas paralel multisimpul berisi **simpul utama**, yang diluncurkan terlebih dahulu. Setelah simpul utama berjalan, simpul turunan diluncurkan dan dimulai. Pekerjaan selesai hanya jika node utama keluar. Semua node anak kemudian dihentikan. Untuk informasi selengkapnya, lihat [Grup simpul](mnp-node-groups.md).
Node pekerjaan paralel multi-node adalah penyewa tunggal. Ini berarti bahwa hanya satu wadah pekerjaan yang dijalankan di setiap instans Amazon EC2.
Status tugas akhir (`SUCCEEDED` atau `FAILED`) ditentukan oleh status tugas akhir dari simpul utama. Untuk mendapatkan status pekerjaan paralel multi-node, jelaskan pekerjaan dengan menggunakan ID pekerjaan yang dikembalikan saat Anda mengirimkan pekerjaan. Jika Anda memerlukan detail untuk node anak, jelaskan setiap node anak satu per satu. Anda dapat mengatasi node menggunakan `#N` notasi (dimulai dengan 0). Misalnya, untuk mengakses detail node kedua pekerjaan, jelaskan *aws\$1batch\$1job\$1id* \$11 menggunakan operasi AWS Batch [DescribeJobs](https://docs.aws.amazon.com/batch/latest/APIReference/API_DescribeJobs.html)API. Informasi `started`, `stoppedAt`, `statusReason`, dan `exit` untuk tugas paralel multisimpul diisi dari simpul utama.
Jika Anda menentukan percobaan ulang pekerjaan, kegagalan node utama menyebabkan upaya lain terjadi. Kegagalan simpul anak tidak menyebabkan lebih banyak upaya terjadi. Setiap upaya baru dari tugas paralel multisimpul akan memperbarui upaya yang sesuai dari simpul turunan yang terkait.
Untuk menjalankan tugas paralel multi-node AWS Batch, kode aplikasi Anda harus berisi kerangka kerja dan pustaka yang diperlukan untuk komunikasi terdistribusi.
**Topics**
+ [Variabel-variabel lingkungan](mnp-env-vars.md)
+ [Grup simpul](mnp-node-groups.md)
+ [Job lifecycle untuk lowongan kerja MNP](job-lifecycle.md)
+ [Hitung pertimbangan lingkungan untuk MNP dengan AWS Batch](mnp-ce.md)
# Variabel-variabel lingkungan
Saat runtime, setiap node dikonfigurasi variabel lingkungan standar yang diterima semua AWS Batch pekerjaan. Selain itu, node dikonfigurasi dengan variabel lingkungan berikut yang khusus untuk pekerjaan paralel multi-node:
`AWS_BATCH_JOB_MAIN_NODE_INDEX`
Variabel ini ditetapkan ke nomor indeks simpul utama tugas. Kode aplikasi Anda dapat `AWS_BATCH_JOB_MAIN_NODE_INDEX` membandingkan dengan `AWS_BATCH_JOB_NODE_INDEX` pada node individual untuk menentukan apakah itu node utama.
`AWS_BATCH_JOB_MAIN_NODE_PRIVATE_IPV4_ADDRESS`
Variabel ini hanya diatur dalam node anak pekerjaan paralel multi-node. Variabel ini tidak ada pada node utama. Variabel ini diatur ke IPv4 alamat pribadi dari node utama pekerjaan. Kode aplikasi simpul turunan Anda dapat menggunakan alamat ini untuk berkomunikasi dengan simpul utama.
`AWS_BATCH_JOB_NODE_INDEX`
Variabel ini ditetapkan ke nomor indeks simpul pada simpul. Indeks simpul dimulai dari 0, dan setiap simpul menerima nomor indeks yang unik. Misalnya, tugas paralel multisimpul dengan 10 turunan memiliki nilai indeks 0-9.
`AWS_BATCH_JOB_NUM_NODES`
Variabel ini ditetapkan ke jumlah simpul yang telah Anda minta untuk tugas paralel multisimpul Anda.
# Grup simpul
Grup node adalah grup node pekerjaan yang identik yang semuanya berbagi properti kontainer yang sama. Anda dapat menggunakan AWS Batch untuk menentukan hingga lima grup node yang berbeda untuk setiap pekerjaan.
Setiap grup dapat memiliki citra kontainer, perintah, variabel lingkungan, dan sebagainya sendiri. Misalnya, Anda dapat mengirimkan pekerjaan yang memerlukan satu `c5.xlarge` instance untuk node utama dan lima node `c5.xlarge` turunan instance. Masing-masing grup node yang berbeda ini dapat menentukan gambar atau perintah kontainer yang berbeda untuk dijalankan untuk setiap pekerjaan.
Atau, semua node dalam pekerjaan Anda dapat menggunakan satu grup node. Selain itu, kode aplikasi Anda dapat membedakan peran node seperti node utama dan node anak. Hal ini dilakukan dengan membandingkan variabel `AWS_BATCH_JOB_MAIN_NODE_INDEX` lingkungan terhadap nilainya sendiri untuk`AWS_BATCH_JOB_NODE_INDEX`. Anda dapat memiliki hingga 1.000 node dalam satu pekerjaan. Ini adalah batas default untuk instance di cluster Amazon ECS. Anda dapat [meminta untuk meningkatkan batas ini](https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html).
**catatan**
Saat ini semua grup simpul dalam tugas paralel multisimpul harus menggunakan tipe instans yang sama.
# Job lifecycle untuk lowongan kerja MNP
Saat Anda mengirimkan pekerjaan paralel multi-node, pekerjaan tersebut memasuki `SUBMITTED` status. Kemudian, pekerjaan menunggu dependensi pekerjaan selesai. Pekerjaan juga pindah ke `RUNNABLE` status. Terakhir, AWS Batch berikan kapasitas instans yang diperlukan untuk menjalankan pekerjaan Anda dan meluncurkan instans ini.
Setiap tugas paralel multisimpul berisi **simpul utama**. Node utama adalah subtugas tunggal yang AWS Batch memantau untuk menentukan hasil dari pekerjaan multi node yang dikirimkan. Simpul utama diluncurkan pertama dan berpindah ke status `STARTING`. Nilai batas waktu yang ditentukan dalam `attemptDurationSeconds` parameter berlaku untuk seluruh pekerjaan dan bukan ke node.
Ketika node utama mencapai `RUNNING` status setelah wadah node berjalan, node anak diluncurkan dan mereka juga pindah ke `STARTING` status. Simpul turunan muncul dalam urutan acak. Tidak ada jaminan terkait waktu atau urutan peluncuran simpul turunan. Untuk memastikan bahwa semua node pekerjaan berada dalam `RUNNING` status setelah penampung node berjalan, kode aplikasi Anda dapat melakukan kueri AWS Batch API untuk mendapatkan informasi node utama dan node anak. Atau, kode aplikasi dapat menunggu sampai semua node online sebelum memulai tugas pemrosesan terdistribusi. Alamat IP privat dari simpul utama tersedia sebagai variabel lingkungan `AWS_BATCH_JOB_MAIN_NODE_PRIVATE_IPV4_ADDRESS` di setiap simpul turunan. Kode aplikasi Anda dapat menggunakan informasi ini untuk mengoordinasikan dan mengomunikasikan data di antara setiap tugas.
Saat simpul individual keluar, simpul pindah ke `SUCCEEDED` atau `FAILED`, tergantung pada kode keluarnya. Jika simpul utama keluar, tugas dianggap selesai, dan semua simpul turunan dihentikan. Jika node anak mati, AWS Batch tidak mengambil tindakan apa pun pada node lain dalam pekerjaan. Jika Anda tidak ingin pekerjaan Anda berlanjut dengan jumlah node yang berkurang, Anda harus memasukkan ini ke dalam kode aplikasi Anda. Melakukan hal ini mengakhiri atau membatalkan pekerjaan.
# Hitung pertimbangan lingkungan untuk MNP dengan AWS Batch
Ada beberapa hal yang perlu dipertimbangkan ketika mengonfigurasi lingkungan komputasi untuk menjalankan tugas paralel multisimpul dengan AWS Batch.
+ Pekerjaan paralel multi-node tidak didukung pada lingkungan `UNMANAGED` komputasi.
+ Jika Anda ingin mengirimkan pekerjaan paralel multi-node ke lingkungan komputasi, buat grup penempatan *klaster* dalam satu Availability Zone dan kaitkan dengan sumber daya komputasi Anda. Ini membuat pekerjaan paralel multi-node Anda pada pengelompokan instans yang logis dekat dengan potensi aliran jaringan yang tinggi. Untuk informasi selengkapnya, lihat [Grup Penempatan](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html) di *Panduan Pengguna Amazon EC2*.
+ Pekerjaan paralel multi-node tidak didukung pada lingkungan komputasi yang menggunakan Instans Spot.
+ AWS Batch multi-node parallel jobs menggunakan mode `awsvpc` jaringan Amazon ECS, yang memberikan container kerja paralel multi-node Anda properti jaringan yang sama dengan instans Amazon EC2. Setiap kontainer tugas paralel multisimpul mendapat antarmuka jaringan elastis sendiri, alamat IP privat utama, dan nama host DNS internal. Antarmuka jaringan dibuat di subnet VPC yang sama dengan sumber daya komputasi host-nya.
+ Lingkungan komputasi Anda mungkin memiliki tidak lebih dari lima grup keamanan yang terkait dengannya. Antarmuka jaringan elastis yang dibuat dan dilampirkan ke tugas MNP akan menggunakan grup keamanan yang ditentukan dalam lingkungan komputasi Anda, Jika Anda tidak menentukan grup keamanan, grup keamanan default untuk VPC akan digunakan.
+ Mode `awsvpc` jaringan tidak menyediakan antarmuka jaringan elastis untuk pekerjaan paralel multi-node dengan alamat IP publik. Untuk mengakses internet, sumber daya komputasi Anda harus diluncurkan di subnet privat yang dikonfigurasi untuk menggunakan gateway NAT. Untuk informasi lebih lanjut, lihat [Gateway NAT](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html) dalam *Panduan Pengguna Amazon VPC*. Komunikasi antar node harus menggunakan alamat IP pribadi atau nama host DNS untuk node. Pekerjaan paralel multi-node yang berjalan pada sumber daya komputasi dalam subnet publik tidak memiliki akses jaringan keluar. Untuk membuat VPC dengan subnet privat dan gateway NAT, lihat [Buat virtual private cloud](create-public-private-vpc.md).
+ Antarmuka jaringan elastis yang dibuat dan dilampirkan ke sumber daya komputasi Anda tidak dapat dipisahkan secara manual atau dimodifikasi oleh akun Anda. Ini untuk mencegah penghapusan yang tidak disengaja dari elastic network interface yang terkait dengan pekerjaan yang sedang berjalan. Untuk melepaskan antarmuka jaringan elastis untuk tugas, akhiri tugas.
+ Lingkungan komputasi Anda harus memiliki v maksimum yang cukup CPUs untuk mendukung pekerjaan paralel multi-node Anda.
+ Kuota instans Amazon EC2 Anda mencakup jumlah instans yang diperlukan untuk menjalankan pekerjaan Anda. Misalnya, misalkan pekerjaan Anda memerlukan 30 instans, tetapi akun Anda hanya dapat menjalankan 20 instans di Wilayah. Kemudian, pekerjaan Anda akan terjebak dalam `RUNNABLE` status.
+ Jika Anda menentukan tipe instance untuk grup node dalam pekerjaan paralel multi-node, lingkungan komputasi Anda harus meluncurkan tipe instance tersebut.
# Pekerjaan paralel multi-node di Amazon EKS
*Anda dapat menggunakan Amazon Elastic Kubernetes Service AWS Batch di Amazon Elastic untuk menjalankan tugas multi-node parallel (MNP) (juga dikenal sebagai penjadwalan geng) pada cluster terkelola Anda.* Kubernetes Opsi ini biasanya digunakan untuk pekerjaan besar, berpasangan erat, dan berkinerja tinggi yang tidak dapat dijalankan pada satu instans Amazon Elastic Compute Cloud. Untuk informasi selengkapnya, lihat [Tugas paralel multisimpul](multi-node-parallel-jobs.md).
Anda dapat menggunakan fitur ini untuk menjalankan aplikasi komputasi berkinerja tinggi Kubernetes khusus yang dikelola Amazon EKS, pelatihan model bahasa besar, dan pekerjaan Artificial Intelligence (AI) /Machine Learning (ML) lainnya.
**Topics**
+ [Lowongan kerja Running MNP](mnp-eks-running-mnp-jobs.md)
+ [Buat definisi pekerjaan Amazon EKS MNP](mnp-eks-create-eks-mnp-job-definition.md)
+ [Kirim pekerjaan Amazon EKS MNP](mnp-eks-submit-eks-mnp-job.md)
+ [Ganti definisi pekerjaan Amazon EKS MNP](mnp-eks-override-eks-mnp-job-definition.md)
# Lowongan kerja Running MNP
AWS Batch mendukung pekerjaan MNP di Amazon Elastic Container Service dan Amazon EKS menggunakan Amazon EC2. Berikut ini memberikan lebih spesifik tentang parameter instance dan container untuk fitur tersebut.
## Kuota instans untuk MNP di Amazon EKS
+ Hingga 1000 instans dapat digunakan untuk satu pekerjaan MNP.
+ Hingga 5000 instans dapat bergabung dengan satu cluster Amazon EKS.
+ Hingga 5 lingkungan komputasi dapat dikelompokkan dan dilampirkan ke antrean pekerjaan.
Misalnya, Anda dapat menskalakan hingga 5 lingkungan komputasi yang dikelompokkan dalam antrian pekerjaan dan 1000 instance di setiap lingkungan komputasi.
Selain parameter instans, penting untuk dicatat bahwa Anda tidak dapat menggunakan Fargate untuk pekerjaan MNP melalui salah satu layanan.
Anda hanya dapat menggunakan satu jenis instance di setiap pekerjaan MNP. Anda dapat mengubah jenis instance dengan memperbarui lingkungan komputasi, atau saat Anda menentukan lingkungan komputasi baru. Anda juga dapat menentukan jenis instance, dan menyediakan persyaratan vCPU dan memori saat membuat definisi pekerjaan.
## Kuota kontainer untuk MNP di Amazon EKS
+ Sebuah multi-node parallel job mendukung satu pod per node.
+ Hingga 10 kontainer (atau 10 kontainer init. Untuk informasi selengkapnya, lihat [Init Containers](https://kubernetes.io/docs/concepts/workloads/pods/init-containers/) di *dokumentasi Kubernetes*.) di setiap pod.
+ Hingga 5 rentang node di setiap pekerjaan MNP.
+ Hingga 10 gambar kontainer yang berbeda di setiap rentang node.
Misalnya, Anda dapat menjalankan hingga maksimum 10.000 kontainer dalam satu pekerjaan MNP yang berisi 5 rentang node dan total 50 gambar unik.
## Menjalankan pekerjaan MNP di VPC Amazon pribadi dan kluster Amazon EKS
Pekerjaan MNP dapat berjalan di kluster Amazon EKS apa pun apakah itu memiliki Internet publik atau tidak. Saat menggunakan kluster Amazon EKS dengan hanya akses jaringan pribadi, pastikan bahwa AWS Batch dapat mengakses bidang kontrol Amazon EKS dan server Kubernetes API terkelola. Anda dapat memberikan akses yang diperlukan melalui titik akhir Amazon Virtual Private Cloud. Untuk informasi selengkapnya, lihat [Mengonfigurasi layanan titik akhir](https://docs.aws.amazon.com/vpc/latest/privatelink/configure-endpoint-service.html).
Pod cluster Amazon EKS tidak dapat mengunduh gambar dari sumber publik karena VPC pribadi tidak memiliki akses Internet. Cluster Amazon EKS Anda harus menarik gambar dari registri kontainer yang ada di dalam VPC Amazon Anda. Anda dapat membuat [Amazon Elastic Container Registry (Amazon ECR) di Amazon](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html) VPC Anda dan menyalin gambar kontainer ke sana untuk akses node Anda.
Anda juga dapat membuat aturan cache tarik melalui dengan Amazon ECR. Setelah aturan pull through cache dibuat untuk registri publik eksternal, Anda cukup menarik gambar dari registri publik eksternal menggunakan URI registri pribadi Amazon ECR Anda. Kemudian Amazon ECR membuat repositori dan menyimpan gambar. Ketika gambar yang di-cache ditarik menggunakan URI registri pribadi Amazon ECR, Amazon ECR memeriksa registri jarak jauh untuk melihat apakah ada versi baru gambar dan akan memperbarui registri pribadi Anda hingga satu kali setiap 24 jam. Untuk informasi selengkapnya, lihat [Membuat aturan cache tarik melalui di Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/pull-through-cache-creating-rule.html).
## Pemberitahuan kesalahan
Jika pekerjaan MNP Anda diblokir, Anda dapat menerima pemberitahuan melalui dan Konsol Manajemen AWS Amazon. EventBridge Misalnya, jika pekerjaan MNP macet di kepala antrian, Anda dapat diberi tahu tentang masalah tersebut bersama dengan informasi tentang penyebabnya sehingga Anda dapat mengambil tindakan segera untuk membuka blokir antrian pekerjaan Anda. Secara opsional, Anda dapat menghentikan pekerjaan MNP secara otomatis jika tidak ada tindakan yang diambil dalam jangka waktu tertentu, yang dapat ditentukan dalam templat antrian pekerjaan. Untuk informasi selengkapnya, lihat [Acara yang diblokir antrean pekerjaan](batch-job-queue-blocked-events.md)
# Buat definisi pekerjaan Amazon EKS MNP
Untuk menentukan dan menjalankan pekerjaan MNP di Amazon EKS, ada parameter baru dalam operasi [https://docs.aws.amazon.com/batch/latest/APIReference/API_RegisterJobDefinition.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_RegisterJobDefinition.html)dan [https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)API.
+ Gunakan [https://docs.aws.amazon.com/batch/latest/APIReference/API_EksProperties.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksProperties.html)di bawah [https://docs.aws.amazon.com/batch/latest/APIReference/API_NodeProperties.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_NodeProperties.html)bagian untuk menentukan definisi pekerjaan MNP Anda.
+ Gunakan [https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPropertiesOverride.html](https://docs.aws.amazon.com/batch/latest/APIReference/API_EksPropertiesOverride.html)di bawah [https://docs.aws.amazon.com//batch/latest/APIReference/API_NodePropertyOverride.html](https://docs.aws.amazon.com//batch/latest/APIReference/API_NodePropertyOverride.html)bagian untuk mengganti parameter yang ditentukan dalam definisi pekerjaan saat mengirimkan pekerjaan MNP.
Tindakan ini dapat didefinisikan melalui operasi API dan Konsol Manajemen AWS.
## Referensi: Daftarkan payload permintaan definisi pekerjaan Amazon EKS MNP
Contoh berikut menggambarkan bagaimana Anda dapat mendaftarkan definisi pekerjaan Amazon EKS MNP dengan dua node.
```
{
"jobDefinitionName": "MyEksMnpJobDefinition",
"type": "multinode",
"nodeProperties": {
"numNodes": 2,
"mainNode": 0,
"nodeRangeProperties": [
{
"targetNodes" : "0:",
"eksProperties": {
"podProperties": {
"containers": [
{
"name": "test-eks-container-1",
"image": "public.ecr.aws/amazonlinux/amazonlinux:2",
"command": [
"sleep",
"60"
],
"resources": {
"limits": {
"cpu": "1",
"memory": "1024Mi"
}
},
"securityContext":{
"runAsUser":1000,
"runAsGroup":3000,
"privileged":true,
"readOnlyRootFilesystem":true,
"runAsNonRoot":true
}
}
],
"initContainers": [
{
"name":"init-ekscontainer",
"image": "public.ecr.aws/amazonlinux/amazonlinux:2",
"command": [
"echo",
"helloWorld"
],
"resources": {
"limits": {
"cpu": "1",
"memory": "1024Mi"
}
}
}
],
"metadata": {
"labels": {
"environment" : "test"
}
}
}
}
}
]
}
}
```
Untuk mendaftarkan definisi pekerjaan menggunakan AWS CLI, salin definisi ke file lokal bernama *MyEksMnpJobDefinition.json* dan jalankan perintah berikut.
```
aws batch register-job-definition --cli-input-json file://MyEksMnpJobDefinition.json
```
Anda akan menerima tanggapan JSON berikut.
```
{
"jobDefinitionName": "MyEksMnpJobDefinition",
"jobDefinitionArn": "arn:aws:batch:us-east-1:0123456789:job-definition/MyEksMnpJobDefinition:1",
"revision": 1
}
```
# Kirim pekerjaan Amazon EKS MNP
Untuk mengirimkan pekerjaan menggunakan definisi pekerjaan terdaftar, masukkan perintah berikut. Ganti nilai dengan nama atau ARN dari antrian pekerjaan yang sudah ada sebelumnya yang terkait dengan lingkungan komputasi Amazon EKS.
```
aws batch submit-job --job-queue \
--job-definition MyEksMnpJobDefinition \
--job-name myFirstEksMnpJob
```
Anda akan menerima tanggapan JSON berikut.
```
{
"jobArn": "arn:aws:batch:region:account:job/9b979cce-9da0-446d-90e2-ffa16d52af68",
"jobName": "myFirstEksMnpJob",
"jobId": ""
}
```
Anda dapat memeriksa status pekerjaan menggunakan JoBid yang dikembalikan dengan perintah berikut.
```
aws batch describe-jobs --jobs
```
# Ganti definisi pekerjaan Amazon EKS MNP
Secara opsional, Anda dapat mengganti detail definisi pekerjaan (seperti mengubah ukuran pekerjaan MNP atau detail pekerjaan anak). Berikut ini memberikan contoh permintaan payload JSON untuk mengirimkan pekerjaan MNP lima node, dan perubahan pada perintah container. `test-eks-container-1`
```
{
"numNodes": 5,
"nodePropertyOverrides": [
{
"targetNodes": "0:",
"eksPropertiesOverride": {
"podProperties": {
"containers": [
{
"name": "test-eks-container-1",
"command": [
"sleep",
"150"
]
}
]
}
}
}
]
}
```
Untuk mengirimkan pekerjaan dengan penggantian ini, simpan contoh ke file lokal, *eks-mnp-job-nodeoverride.json*, dan gunakan AWS CLI untuk mengirimkan pekerjaan dengan penggantian.
# Tugas array
Pekerjaan array adalah pekerjaan yang berbagi parameter umum, seperti definisi pekerjaan, vCPUs, dan memori. Ini berjalan sebagai kumpulan pekerjaan dasar terkait namun terpisah yang mungkin didistribusikan di beberapa host dan mungkin berjalan secara bersamaan. Tugas array adalah cara yang paling efisien untuk menjalankan tugas yang sangat paralel, seperti simulasi Monte Carlo, sapuan parametrik, atau tugas render yang besar.
AWS Batch pekerjaan array dikirimkan seperti pekerjaan biasa. Namun, Anda menentukan ukuran array (antara 2 dan 10.000) untuk menentukan berapa banyak tugas turunan yang harus berjalan dalam array. Jika Anda mengirim tugas dengan ukuran array sebesar 1.000, satu tugas akan berjalan dan menghasilkan 1.000 tugas turunan. Tugas array adalah referensi atau penunjuk untuk mengelola semua tugas turunan. Dengan cara ini, Anda dapat mengirimkan beban kerja besar dengan satu kueri. Batas waktu yang ditentukan dalam `attemptDurationSeconds` parameter berlaku untuk setiap pekerjaan anak. Pekerjaan array induk tidak memiliki batas waktu.
Saat Anda mengirimkan pekerjaan array, pekerjaan array induk mendapatkan ID AWS Batch pekerjaan normal. Setiap pekerjaan anak memiliki ID dasar yang sama. Namun, indeks array untuk pekerjaan anak ditambahkan ke akhir ID induk, seperti `example_job_ID:0` untuk pekerjaan anak pertama dari array.
Pekerjaan array induk dapat memasukkan`SUBMITTED`,, `PENDING``FAILED`, atau `SUCCEEDED` status. Pekerjaan induk array diperbarui `PENDING` ketika setiap pekerjaan anak diperbarui ke`RUNNABLE`. Untuk informasi selengkapnya tentang dependensi pekerjaan, lihat. [Dependensi Job](job_dependencies.md)
Pada saat waktu aktif, variabel lingkungan `AWS_BATCH_JOB_ARRAY_INDEX` ditetapkan ke nomor indeks tugas array yang sesuai dengan kontainer. Indeks pekerjaan array pertama diberi nomor`0`, dan upaya selanjutnya dalam urutan menaik (misalnya, 1, 2, dan 3). Anda dapat menggunakan nilai indeks ini untuk mengontrol cara turunan tugas array Anda dibedakan. Untuk informasi selengkapnya, lihat [Gunakan indeks pekerjaan array untuk mengontrol diferensiasi pekerjaan](array_index_example.md).
Untuk dependensi tugas array, Anda dapat menentukan tipe untuk dependensi, misalnya `SEQUENTIAL` atau `N_TO_N`. Anda dapat menentukan tipe dependensi `SEQUENTIAL` (tanpa menentukan ID tugas) sehingga setiap tugas array turunan selesai secara berurutan, mulai dari indeks 0. Misalnya, jika Anda mengirimkan tugas array dengan ukuran array 100, dan menentukan dependensi dengan tipe `SEQUENTIAL`, 100 tugas turunan akan dihasilkan secara berurutan, dan tugas turunan pertama harus berhasil sebelum tugas turunan berikutnya dimulai. Gambar di bawah ini menunjukkan Tugas A, sebuah tugas array dengan ukuran array 10. Setiap tugas dalam indeks turunan Tugas A bergantung pada tugas turunan sebelumnya. Tugas A:1 tidak dapat mulai sebelum tugas A:0 selesai.
![\[Flowchart showing Job-A with sequential child jobs A:0 through A:9, connected by arrows.\]](http://docs.aws.amazon.com/id_id/batch/latest/userguide/images/sequential-dep.png)
Anda juga dapat menentukan ketergantungan `N_TO_N` tipe dengan ID pekerjaan untuk pekerjaan array. Dengan cara itu, setiap turunan indeks dari tugas ini harus menunggu turunan indeks dari setiap dependensi selesai sebelum turunan tersebut dapat dimulai. Gambar berikut menunjukkan Job A dan Job B, dua pekerjaan array dengan ukuran array masing-masing 10.000. Setiap tugas dalam indeks turunan Tugas B bergantung pada indeks yang sesuai di Tugas A. Tugas B:1 tidak dapat mulai sebelum tugas A:1 selesai.
![\[Two array jobs, Job-A and Job-B, with 10,000 indexed tasks each, showing N_TO_N dependency.\]](http://docs.aws.amazon.com/id_id/batch/latest/userguide/images/n-to-n-dep.png)
Jika Anda membatalkan atau menghentikan pekerjaan array induk, semua pekerjaan anak dibatalkan atau dihentikan dengannya. Anda dapat membatalkan atau menghentikan pekerjaan anak individu (yang memindahkan mereka ke `FAILED` status) tanpa mempengaruhi pekerjaan anak lainnya. Namun, jika pekerjaan array anak gagal (dengan sendirinya, atau dengan membatalkan atau menghentikan pekerjaan secara manual), pekerjaan induk juga gagal. Dalam skenario ini, pekerjaan orang tua beralih ke `FAILED` saat semua pekerjaan anak selesai.
Untuk informasi selengkapnya tentang mencari dan memfilter pekerjaan array, lihat[Cari pekerjaan dalam antrian pekerjaan](searching-filtering-jobs.md).
**Topics**
+ [Contoh alur kerja pekerjaan array](example_array_job.md)
+ [Gunakan indeks pekerjaan array untuk mengontrol diferensiasi pekerjaan](array_index_example.md)
# Contoh alur kerja pekerjaan array
Alur kerja umum bagi AWS Batch pelanggan adalah menjalankan pekerjaan penyiapan prasyarat, menjalankan serangkaian perintah terhadap sejumlah besar tugas input, dan kemudian menyimpulkan dengan pekerjaan yang mengumpulkan hasil dan menulis data ringkasan ke Amazon S3, DynamoDB, Amazon Redshift, atau Aurora.
Contoh:
+ `JobA`: Tugas standar non-array yang membuat daftar cepat dan metadata validasi objek dalam bucket Amazon S3, `BucketA`. Sintaks [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON adalah sebagai berikut.
```
{
"jobName": "JobA",
"jobQueue": "ProdQueue",
"jobDefinition": "JobA-list-and-validate:1"
}
```
+ `JobB`: Pekerjaan array dengan 10.000 salinan yang bergantung pada `JobA` yang menjalankan perintah intensif CPU terhadap setiap objek di `BucketA` dan mengunggah hasilnya. `BucketB` Sintaks [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON adalah sebagai berikut.
```
{
"jobName": "JobB",
"jobQueue": "ProdQueue",
"jobDefinition": "JobB-CPU-Intensive-Processing:1",
"containerOverrides": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "4096"
},
{
"type": "VCPU",
"value": "32"
}
]
}
"arrayProperties": {
"size": 10000
},
"dependsOn": [
{
"jobId": "JobA_job_ID"
}
]
}
```
+ `JobC`: Pekerjaan 10.000 salinan array lainnya yang bergantung `JobB` pada model `N_TO_N` ketergantungan, yang menjalankan perintah intensif memori terhadap setiap item di, menulis metadata ke DynamoDB`BucketB`, dan mengunggah output yang dihasilkan ke. `BucketC` Sintaks [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON adalah sebagai berikut.
```
{
"jobName": "JobC",
"jobQueue": "ProdQueue",
"jobDefinition": "JobC-Memory-Intensive-Processing:1",
"containerOverrides": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "32768"
},
{
"type": "VCPU",
"value": "1"
}
]
}
"arrayProperties": {
"size": 10000
},
"dependsOn": [
{
"jobId": "JobB_job_ID",
"type": "N_TO_N"
}
]
}
```
+ `JobD`: Pekerjaan array yang melakukan 10 langkah validasi yang masing-masing perlu kueri DynamoDB dan mungkin berinteraksi dengan salah satu bucket Amazon S3 di atas. Setiap langkah dalam `JobD` menjalankan perintah yang sama. Namun, perilakunya berbeda berdasarkan nilai variabel `AWS_BATCH_JOB_ARRAY_INDEX` lingkungan dalam wadah pekerjaan. Langkah-langkah validasi ini berjalan secara berurutan (misalnya, `JobD:0` dan kemudian). `JobD:1` Sintaks [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON adalah sebagai berikut.
```
{
"jobName": "JobD",
"jobQueue": "ProdQueue",
"jobDefinition": "JobD-Sequential-Validation:1",
"containerOverrides": {
"resourceRequirements": [
{
"type": "MEMORY",
"value": "32768"
},
{
"type": "VCPU",
"value": "1"
}
]
}
"arrayProperties": {
"size": 10
},
"dependsOn": [
{
"jobId": "JobC_job_ID"
},
{
"type": "SEQUENTIAL"
},
]
}
```
+ `JobE`: Tugas akhir non-array yang melakukan beberapa operasi pembersihan sederhana dan mengirimkan notifikasi Amazon SNS dengan pesan bahwa alur telah selesai dan tautan ke URL output. Sintaks [SubmitJob](https://docs.aws.amazon.com/batch/latest/APIReference/API_SubmitJob.html)JSON adalah sebagai berikut.
```
{
"jobName": "JobE",
"jobQueue": "ProdQueue",
"jobDefinition": "JobE-Cleanup-and-Notification:1",
"parameters": {
"SourceBucket": "s3://amzn-s3-demo-source-bucket",
"Recipient": "pipeline-notifications@mycompany.com"
},
"dependsOn": [
{
"jobId": "JobD_job_ID"
}
]
}
```
# Gunakan indeks pekerjaan array untuk mengontrol diferensiasi pekerjaan
Tutorial ini menjelaskan cara menggunakan variabel `AWS_BATCH_JOB_ARRAY_INDEX` lingkungan untuk membedakan pekerjaan anak. Setiap pekerjaan anak ditugaskan ke variabel ini. Contoh menggunakan nomor indeks pekerjaan anak untuk membaca baris tertentu dalam file. Kemudian, ia mengganti parameter yang terkait dengan nomor baris itu dengan perintah di dalam wadah pekerjaan. Hasilnya adalah Anda dapat memiliki beberapa AWS Batch pekerjaan yang menjalankan gambar Docker dan argumen perintah yang sama. Namun, hasilnya berbeda karena indeks pekerjaan array digunakan sebagai pengubah.
Dalam tutorial ini, Anda membuat file teks yang memiliki semua warna pelangi, dengan setiap warna memiliki barisnya masing-masing. Kemudian, Anda membuat skrip titik masuk untuk wadah Docker yang mengubah indeks menjadi nilai yang dapat digunakan untuk nomor baris dalam file warna. Indeks dimulai dari nol, tetapi nomor baris dimulai dari satu. Buat Dockerfile yang menyalin file warna dan indeks ke gambar kontainer dan set `ENTRYPOINT` untuk gambar ke skrip entrypoint. Dockerfile dan sumber daya dibangun ke image Docker yang didorong ke Amazon ECR. Anda kemudian mendaftarkan definisi pekerjaan yang menggunakan gambar kontainer baru Anda, mengirimkan pekerjaan AWS Batch array dengan definisi pekerjaan itu, dan melihat hasilnya.
**Topics**
+ [Prasyarat](array-tutorial-prereqs.md)
+ [Membangun gambar kontainer](build-index-container.md)
+ [Dorong gambar Anda ke Amazon ECR](push-array-image.md)
+ [Buat dan daftarkan definisi pekerjaan](create-array-job-def.md)
+ [Kirim pekerjaan AWS Batch array](submit-array-job.md)
+ [Lihat log pekerjaan array Anda](#array-tutorial-logs)
# Prasyarat
Alur kerja tutorial ini memiliki prasyarat berikut:
+ Lingkungan AWS Batch komputasi. Untuk informasi selengkapnya, lihat [Membuat lingkungan komputasi](create-compute-environment.md).
+ Antrian AWS Batch pekerjaan dan lingkungan komputasi terkait. Untuk informasi selengkapnya, lihat [Membuat antrean tugas](create-job-queue.md).
+ Yang AWS CLI diinstal pada sistem lokal Anda. Untuk informasi selengkapnya, lihat [>Memasang AWS Command Line Interface](https://docs.aws.amazon.com/cli/latest/userguide/installing.html) di *Panduan AWS Command Line Interface Pengguna*.
+ Docker yang diinstal di sistem lokal Anda. Untuk informasi selengkapnya, lihat [Tentang Docker CE](https://docs.docker.com/install/) dalam dokumentasi Docker.
# Membangun gambar kontainer
Anda dapat menggunakan definisi pekerjaan dalam parameter perintah. `AWS_BATCH_JOB_ARRAY_INDEX` Namun, kami menyarankan Anda membuat gambar kontainer yang menggunakan variabel dalam skrip entrypoint sebagai gantinya. Bagian ini menjelaskan cara membuat citra kontainer.
**Untuk membangun gambar kontainer Docker Anda**
1. Buat direktori baru untuk digunakan sebagai ruang kerja gambar Docker Anda dan buka direktori tersebut.
1. Buat file bernama `colors.txt` di direktori ruang kerja Anda dan tempelkan yang berikut ini ke dalamnya.
```
red
orange
yellow
green
blue
indigo
violet
```
1. Buat file bernama `print-color.sh` di direktori ruang kerja Anda dan tempelkan yang berikut ini ke dalamnya.
**catatan**
Variabel `LINE` diatur ke `AWS_BATCH_JOB_ARRAY_INDEX` \$1 1 karena indeks array dimulai dari 0, tetapi nomor baris dimulai dari 1. `COLOR`Variabel diatur ke warna `colors.txt` yang terkait dengan nomor barisnya.
```
#!/bin/sh
LINE=$((AWS_BATCH_JOB_ARRAY_INDEX + 1))
COLOR=$(sed -n ${LINE}p /tmp/colors.txt)
echo My favorite color of the rainbow is $COLOR.
```
1. Buat file bernama `Dockerfile` di direktori ruang kerja Anda dan tempelkan konten berikut ke dalamnya. Dockerfile ini menyalin file sebelumnya ke kontainer Anda dan menetapkan skrip entrypoint yang akan dijalankan ketika kontainer dimulai.
```
FROM busybox
COPY print-color.sh /tmp/print-color.sh
COPY colors.txt /tmp/colors.txt
RUN chmod +x /tmp/print-color.sh
ENTRYPOINT /tmp/print-color.sh
```
1. Bangun gambar Docker Anda.
```
$ docker build -t print-color .
```
1. Uji kontainer Anda dengan skrip berikut. Skrip ini menetapkan `AWS_BATCH_JOB_ARRAY_INDEX` variabel ke 0 secara lokal dan kemudian meningkatkannya untuk mensimulasikan apa yang dilakukan oleh pekerjaan array dengan tujuh anak.
```
$ AWS_BATCH_JOB_ARRAY_INDEX=0
while [ $AWS_BATCH_JOB_ARRAY_INDEX -le 6 ]
do
docker run -e AWS_BATCH_JOB_ARRAY_INDEX=$AWS_BATCH_JOB_ARRAY_INDEX print-color
AWS_BATCH_JOB_ARRAY_INDEX=$((AWS_BATCH_JOB_ARRAY_INDEX + 1))
done
```
Berikut ini adalah outputnya.
```
My favorite color of the rainbow is red.
My favorite color of the rainbow is orange.
My favorite color of the rainbow is yellow.
My favorite color of the rainbow is green.
My favorite color of the rainbow is blue.
My favorite color of the rainbow is indigo.
My favorite color of the rainbow is violet.
```
# Dorong gambar Anda ke Amazon ECR
Sekarang setelah Anda membangun dan menguji wadah Docker Anda, dorong ke repositori gambar. Contoh ini menggunakan Amazon ECR, tetapi Anda dapat menggunakan registri lain, seperti DockerHub.
1. Buat repositori citra Amazon ECR untuk menyimpan citra kontainer Anda. Contoh ini hanya menggunakan AWS CLI, tetapi Anda juga dapat menggunakan Konsol Manajemen AWS. Untuk informasi selengkapnya, lihat [Membuat Repositori](https://docs.aws.amazon.com/AmazonECR/latest/userguide/repository-create.html) dalam *Panduan Pengguna Amazon Elastic Container Registry*.
```
$ aws ecr create-repository --repository-name print-color
```
1. Beri tanda citra `print-color` dengan URI repositori Amazon ECR Anda yang dihasilkan dari langkah sebelumnya.
```
$ docker tag print-color aws_account_id.dkr.ecr.region.amazonaws.com/print-color
```
1. Masuk ke registri Amazon ECR Anda. Untuk informasi selengkapnya, lihat [Autentikasi Registri](https://docs.aws.amazon.com/AmazonECR/latest/userguide/Registries.html#registry_auth) dalam *Panduan Pengguna Amazon Elastic Container Registry*.
```
$ aws ecr get-login-password \
--region region | docker login \
--username AWS \
--password-stdin aws_account_id.dkr.ecr.region.amazonaws.com
```
1. Dorong gambar Anda ke Amazon ECR.
```
$ docker push aws_account_id.dkr.ecr.region.amazonaws.com/print-color
```
# Buat dan daftarkan definisi pekerjaan
Sekarang gambar Docker Anda ada di registri gambar, Anda dapat menentukannya dalam definisi AWS Batch pekerjaan. Kemudian, Anda dapat menggunakannya nanti untuk menjalankan pekerjaan array. Contoh ini hanya menggunakan AWS CLI. Namun, Anda juga dapat menggunakan Konsol Manajemen AWS. Untuk informasi selengkapnya, lihat [Buat definisi pekerjaan simpul tunggal](create-job-definition.md).
**Untuk membuat ketentuan tugas**
1. Buat file bernama `print-color-job-def.json` di direktori ruang kerja Anda dan tempelkan yang berikut ini ke dalamnya. Ganti URI repositori citra dengan URI citra Anda sendiri.
```
{
"jobDefinitionName": "print-color",
"type": "container",
"containerProperties": {
"image": "aws_account_id.dkr.ecr.region.amazonaws.com/print-color",
"resourceRequirements": [
{
"type": "MEMORY",
"value": "250"
},
{
"type": "VCPU",
"value": "1"
}
]
}
}
```
1. Daftarkan definisi pekerjaan dengan AWS Batch.
```
$ aws batch register-job-definition --cli-input-json file://print-color-job-def.json
```
# Kirim pekerjaan AWS Batch array
Setelah Anda mendaftarkan definisi pekerjaan Anda, Anda dapat mengirimkan pekerjaan AWS Batch array yang menggunakan gambar kontainer baru Anda.
**Untuk mengirimkan pekerjaan AWS Batch array**
1. Buat file bernama `print-color-job.json` di direktori ruang kerja Anda dan tempelkan yang berikut ini ke dalamnya.
**catatan**
Contoh ini menggunakan antrian pekerjaan yang disebutkan di [Prasyarat](array-tutorial-prereqs.md) bagian.
```
{
"jobName": "print-color",
"jobQueue": "existing-job-queue",
"arrayProperties": {
"size": 7
},
"jobDefinition": "print-color"
}
```
1. Kirim pekerjaan ke antrian AWS Batch pekerjaan Anda. Perhatikan ID pekerjaan yang dikembalikan dalam output.
```
$ aws batch submit-job --cli-input-json file://print-color-job.json
```
1. Deskripsikan status tugas dan tunggu tugas untuk berpindah ke `SUCCEEDED`.
## Lihat log pekerjaan array Anda
Setelah pekerjaan Anda mencapai `SUCCEEDED` status, Anda dapat melihat CloudWatch Log dari wadah pekerjaan.
**Untuk melihat log pekerjaan Anda di CloudWatch Log**
1. Buka AWS Batch konsol di [https://console.aws.amazon.com/batch/](https://console.aws.amazon.com/batch/).
1. Di panel navigasi kiri, pilih **Jobs** (Tugas).
1. Untuk **Job queue** (Antrean tugas), pilih antrean.
1. Di bagian **Status**, pilih **succeeded** (berhasil).
1. Untuk menampilkan semua tugas turunan untuk tugas array Anda, pilih ID tugas yang dikembalikan di bagian sebelumnya.
1. Untuk melihat log dari kontainer tugas, pilih salah satu tugas turunan dan pilih **View logs** (Lihat log).
![\[Log kontainer pekerjaan array\]](http://docs.aws.amazon.com/id_id/batch/latest/userguide/images/array-logs.png)
1. Lihat log tugas turunan lainnya. Setiap tugas mengembalikan warna pelangi yang berbeda.
# Jalankan lowongan kerja GPU
Pekerjaan GPU membantu Anda menjalankan pekerjaan yang menggunakan instans. GPUs
Berikut tipe instans Amazon EC2 berbasis GPU yang didukung. [https://aws.amazon.com/ec2/instance-types/trn1/](https://aws.amazon.com/ec2/instance-types/trn1/) [ 2 Instans Dl1, dan Instans](https://aws.amazon.com/ec2/instance-types/dl1/) [Amazon](https://aws.amazon.com/ec2/instance-types/dl2q/) EC2 Dl2.
| Tipe instans | GPUs | Memori GPU | v CPUs | Memori | Bandwith jaringan |
| --- | --- | --- | --- | --- | --- |
| g3s.xlarge | 1 | 8 GiB | 4 | 30,5 GiB | 10 Gbps |
| g3.4xlarge | 1 | 8 GiB | 16 | 122 GiB | Hingga 10 Gbps |
| g3.8xlarge | 2 | 16 GiB | 32 | 244 GiB | 10 Gbps |
| g3.16xlarge | 4 | 32 GiB | 64 | 488 GiB | 25 Gbps |
| g4dn.xlarge | 1 | 16 GiB | 4 | 16 GiB | Hingga 25 Gbps |
| g4dn.2xlarge | 1 | 16 GiB | 8 | 32 GiB | Hingga 25 Gbps |
| g4dn.4xlarge | 1 | 16 GiB | 16 | 64 GiB | Hingga 25 Gbps |
| g4dn.8xlarge | 1 | 16 GiB | 32 | 128 GiB | 50 Gbps |
| g4dn.12xlarge | 4 | 64 GiB | 48 | 192 GiB | 50 Gbps |
| g4dn.16xlarge | 1 | 16 GiB | 64 | 256 GiB | 50 Gbps |
| g5.xlarge | 1 | 24 GiB | 4 | 16 GiB | Hingga 10 Gbps |
| g5.2xlarge | 1 | 24 GiB | 8 | 32 GiB | Hingga 10 Gbps |
| g5.4xlarge | 1 | 24 GiB | 16 | 64 GiB | Hingga 25 Gbps |
| g5.8xlarge | 1 | 24 GiB | 32 | 128 GiB | 25 Gbps |
| g5.16xlarge | 1 | 24 GiB | 64 | 256 GiB | 25 Gbps |
| g5.12xlarge | 4 | 96 GiB | 48 | 192 GiB | 40 Gbps |
| g5.24xlarge | 4 | 96 GiB | 96 | 384 GiB | 50 Gbps |
| g5.48xlarge | 8 | 192 GiB | 192 | 768 GiB | 100 Gbps |
| g5g.xlarge | 1 | 16 GiB | 4 | 8 GiB | Hingga 10 Gbps |
| g5g.2xlarge | 1 | 16 GiB | 8 | 16 GiB | Hingga 10 Gbps |
| g5g.4xlarge | 1 | 16 GiB | 16 | 32 GiB | Hingga 10 Gbps |
| g5g.8xlarge | 1 | 16 GiB | 32 | 64 GiB | 12 Gbps |
| g5g.16xlarge | 2 | 32 GiB | 64 | 128 GiB | 25 Gbps |
| g5g.metal | 2 | 32 GiB | 64 | 128 GiB | 25 Gbps |
| g6.xlarge | 1 | 24 GiB | 4 | 16 GiB | Hingga 10 Gbps |
| g6.2xlarge | 1 | 24 GiB | 8 | 32 GiB | Hingga 10 Gbps |
| g6.4xlarge | 1 | 24 GiB | 16 | 64 GiB | Hingga 25 Gbps |
| g6.8xlarge | 1 | 24 GiB | 32 | 128 GiB | 25 Gbps |
| g6.16xlarge | 1 | 24 GiB | 64 | 256 GiB | 25 Gbps |
| g6.12xlarge | 4 | 96 GiB | 48 | 192 GiB | 40 Gbps |
| g6.24xlarge | 4 | 96 GiB | 96 | 384 GiB | 50 Gbps |
| g6.48xlarge | 8 | 192 GiB | 192 | 768 GiB | 100 Gbps |
| g6e.xlarge | 1 | 48 GiB | 4 | 32 GiB | Hingga 20 Gbps |
| g6e.2xlarge | 1 | 48 GiB | 8 | 64 GiB | Hingga 20 Gbps |
| g6e.4xlarge | 1 | 48 GiB | 16 | 128 GiB | 20 Gbps |
| g6e.8xlarge | 1 | 48 GiB | 32 | 256 GiB | 25 Gbps |
| g6e.16xlarge | 1 | 48 GiB | 64 | 512 GiB | 35 Gbps |
| g6e.12xlarge | 4 | 192 GiB | 48 | 384 GiB | 100 Gbps |
| g6e.24xlarge | 4 | 192 GiB | 96 | 768 GiB | 200 Gbps |
| g6e.48xlarge | 8 | 384 GiB | 192 | 1536 GiB | 400 Gbps |
| gr6.4xbesar | 1 | 24 GiB | 16 | 128 GiB | Hingga 25 Gbps |
| gr6.8xbesar | 1 | 24 GiB | 32 | 256 GiB | 25 Gbps |
| p2.xlarge | 1 | 12 GiB | 4 | 61 GiB | Tinggi |
| p2.8xlarge | 8 | 96 GiB | 32 | 488 GiB | 10 Gbps |
| p2.16xlarge | 16 | 192 GiB | 64 | 732 GiB | 20 Gbps |
| p3.2xlarge | 1 | 16 GiB | 8 | 61 GiB | Hingga 10 Gbps |
| p3.8xlarge | 4 | 64 GiB | 32 | 244 GiB | 10 Gbps |
| p3.16xlarge | 8 | 128 GiB | 64 | 488 GiB | 25 Gbps |
| p3dn.24xlarge | 8 | 256 GiB | 96 | 768 GiB | 100 Gbps |
| p4d.24xlarge | 8 | 320 GiB | 96 | 1152 GiB | 400 Gbps |
| p4de.24xlarge | 8 | 640 GiB | 96 | 1152 GiB | 400 Gbps |
| p5.48xlarge | 8 | 640 GiB | 192 | 2 TiB | 3200 Gbps |
| p5e.48xlarge | 8 | 1128 GiB | 192 | 2 TiB | 3200 Gbps |
| p5en.48xlarge | 8 | 1128 GiB | 192 | 2 TiB | 3200 Gbps |
| p6-b200.48xlarge | 8 | 1440 GiB | 192 | 2 TiB | 100 Gbps |
| trn1.2xlarge | 1 | 32 GiB | 8 | 32 GiB | Hingga 12,5 Gbps |
| trn1.32xlarge | 16 | 512 GiB | 128 | 512 GiB | 800 Gbps |
| trn1n.32xlarge | 16 | 512 GiB | 128 | 512 GiB | 1600 Gbps |
| trn2.48xlarge | 16 | 1.5 TIB | 192 | 2 TiB | 3,2 Tbps |
| inf1.xlarge | 1 | 8 GiB | 4 | 8 GiB | Hingga 25 Gbps |
| inf1.2xlarge | 1 | 8 GiB | 8 | 16 GiB | Hingga 25 Gbps |
| inf1.6xlarge | 4 | 32 GiB | 24 | 48 GiB | 25 Gbps |
| inf1.24xlarge | 16 | 128 GiB | 96 | 192 GiB | 100 Gbps |
| inf2.xlarge | 1 | 32 GiB | 4 | 16 GiB | Hingga 15 Gbps |
| inf2.8xlarge | 1 | 32 GiB | 32 | 128 GiB | Hingga 25 Gbps |
| inf2.24xlarge | 6 | 192 GiB | 96 | 384 GiB | 50 Gbps |
| inf2.48xlarge | 12 | 384 GiB | 192 | 768 GiB | 100 Gbps |
| dl1.24xlarge | 8 | 256 GiB | 96 | 768 GiB | 400 Gbps |
| dl2q.24xlarge | 8 | 128 GiB | 96 | 768 GiB | 100 Gbps |
**catatan**
Untuk pekerjaan GPU AWS Batch hanya mendukung jenis instans yang memiliki NVIDIA GPUs. Misalnya, [https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances](https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances)keluarga tidak didukung untuk penjadwalan GPU. Anda masih dapat menggunakannya [https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances](https://aws.amazon.com/ec2/instance-types/g4/#Amazon_EC2_G4ad_instances) AWS Batch dengan mendefinisikan hanya persyaratan vcpu dan memori dalam definisi pekerjaan, kemudian mengakses GPU host secara langsung melalui penyesuaian dalam [data pengguna template peluncuran Amazon EC2 dengan](launch-templates.md#lt-user-data.title) AMI yang dioptimalkan untuk komputasi Amazon ECS atau Amazon EKS, atau AMI yang disesuaikan untuk menggunakan AMD. GPUs
Jenis instans yang menggunakan ARM64 arsitektur didukung untuk pekerjaan GPU pada data pengguna yang AMIs disediakan khusus AWS Batch atau Amazon EC2 untuk mengakses kode dan GPUs konfigurasi yang disesuaikan. Misalnya, keluarga [https://aws.amazon.com/ec2/instance-types/g5g/](https://aws.amazon.com/ec2/instance-types/g5g/)contoh.
Parameter [ResourceRequirements](job_definition_parameters.md#ContainerProperties-resourceRequirements) untuk definisi pekerjaan menentukan jumlah yang akan disematkan GPUs ke wadah. Jumlah ini GPUs tidak tersedia untuk pekerjaan lain yang berjalan pada contoh itu selama durasi pekerjaan itu. Semua tipe instans dalam lingkungan komputasi yang menjalankan pekerjaan GPU harus berasal dari keluarga`p3`,,`p4`,`p5`,`p6`,`g3`,`g3s`, `g4``g5`, atau `g6` instance. Jika hal ini tidak dilakukan, tugas GPU mungkin akan terjebak di status `RUNNABLE`.
Pekerjaan yang tidak menggunakan GPUs dapat dijalankan pada instance GPU. Namun, mungkin diperlukan biaya lebih untuk menjalankannya di instans GPU daripada di instans non-GPU yang serupa. Tergantung pada vCPU, memori, dan waktu tertentu yang diperlukan, tugas non-GPU ini mungkin memblokir berjalannya tugas GPU.
**Topics**
+ [Buat Kubernetes cluster berbasis GPU di Amazon EKS](create-gpu-cluster-eks.md)
+ [Buat definisi pekerjaan GPU Amazon EKS](create-eks-gpu-job-definition.md)
+ [Jalankan pekerjaan GPU di cluster Amazon EKS Anda](run-gpu-job-eks-cluster.md)
# Buat Kubernetes cluster berbasis GPU di Amazon EKS
Sebelum Anda membuat Kubernetes cluster berbasis GPU di Amazon EKS, Anda harus telah menyelesaikan langkah-langkahnya. [Memulai dengan AWS Batch di Amazon EKS](getting-started-eks.md) Selain itu, pertimbangkan juga hal berikut:
+ AWS Batch mendukung jenis instance dengan NVIDIA GPUs.
+ Secara default, AWS Batch pilih AMI yang dipercepat Amazon EKS dengan Kubernetes versi yang cocok dengan versi bidang kontrol cluster Amazon EKS Anda.
```
$ cat < ./batch-eks-gpu-ce.json
{
"computeEnvironmentName": "My-Eks-GPU-CE1",
"type": "MANAGED",
"state": "ENABLED",
"eksConfiguration": {
"eksClusterArn": "arn:aws:eks:::cluster/",
"kubernetesNamespace": "my-aws-batch-namespace"
},
"computeResources": {
"type": "EC2",
"allocationStrategy": "BEST_FIT_PROGRESSIVE",
"minvCpus": 0,
"maxvCpus": 1024,
"instanceTypes": [
"p3dn.24xlarge",
"p4d.24xlarge"
],
"subnets": [
""
],
"securityGroupIds": [
""
],
"instanceRole": ""
}
}
EOF
$ aws batch create-compute-environment --cli-input-json file://./batch-eks-gpu-ce.json
```
AWS Batch tidak mengelola plugin perangkat NVIDIA GPU atas nama Anda. Anda harus menginstal plugin ini ke cluster Amazon EKS Anda dan membiarkannya menargetkan AWS Batch node. Untuk informasi selengkapnya, lihat [Mengaktifkan Dukungan GPU di Kubernetes](https://github.com/NVIDIA/k8s-device-plugin#enabling-gpu-support-in-kubernetes) aktif. GitHub
Untuk mengkonfigurasi plugin NVIDIA perangkat (`DaemonSet`) untuk menargetkan AWS Batch node, jalankan perintah berikut.
```
# pull nvidia daemonset spec
$ curl -O https://raw.githubusercontent.com/NVIDIA/k8s-device-plugin/v0.12.2/nvidia-device-plugin.yml
# using your favorite editor, add Batch node toleration
# this will allow the DaemonSet to run on Batch nodes
- key: "batch.amazonaws.com/batch-node"
operator: "Exists"
$ kubectl apply -f nvidia-device-plugin.yml
```
Kami tidak menyarankan Anda mencampur beban kerja berbasis komputasi (CPU dan memori) dengan beban kerja berbasis GPU dalam pasangan lingkungan komputasi dan antrian pekerjaan yang sama. Ini karena pekerjaan komputasi dapat menggunakan kapasitas GPU.
Untuk melampirkan antrian pekerjaan, jalankan perintah berikut.
```
$ cat < ./batch-eks-gpu-jq.json
{
"jobQueueName": "My-Eks-GPU-JQ1",
"priority": 10,
"computeEnvironmentOrder": [
{
"order": 1,
"computeEnvironment": "My-Eks-GPU-CE1"
}
]
}
EOF
$ aws batch create-job-queue --cli-input-json file://./batch-eks-gpu-jq.json
```
# Buat definisi pekerjaan GPU Amazon EKS
Hanya `nvidia.com/gpu` didukung saat ini dan nilai sumber daya yang Anda tetapkan harus berupa bilangan bulat. Anda tidak dapat menggunakan pecahan GPU. Untuk informasi selengkapnya, lihat [Jadwal GPUs](https://kubernetes.io/docs/tasks/manage-gpus/scheduling-gpus/) dalam *Kubernetesdokumentasi*.
Untuk mendaftarkan definisi pekerjaan GPU untuk Amazon EKS, jalankan perintah berikut.
```
$ cat < ./batch-eks-gpu-jd.json
{
"jobDefinitionName": "MyGPUJobOnEks_Smi",
"type": "container",
"eksProperties": {
"podProperties": {
"hostNetwork": true,
"containers": [
{
"image": "nvcr.io/nvidia/cuda:10.2-runtime-centos7",
"command": ["nvidia-smi"],
"resources": {
"limits": {
"cpu": "1",
"memory": "1024Mi",
"nvidia.com/gpu": "1"
}
}
}
]
}
}
}
EOF
$ aws batch register-job-definition --cli-input-json file://./batch-eks-gpu-jd.json
```
# Jalankan pekerjaan GPU di cluster Amazon EKS Anda
Sumber daya GPU tidak dapat dikompresi. AWS Batch **membuat spesifikasi pod untuk pekerjaan GPU di mana nilai **permintaan** sama dengan nilai limit.** Ini adalah Kubernetes persyaratan.
Untuk mengirimkan pekerjaan GPU, jalankan perintah berikut.
```
$ aws batch submit-job --job-queue My-Eks-GPU-JQ1 --job-definition MyGPUJobOnEks_Smi --job-name My-Eks-GPU-Job
# locate information that can help debug or find logs (if using Amazon CloudWatch Logs with Fluent Bit)
$ aws batch describe-jobs --job | jq '.jobs[].eksProperties.podProperties | {podName, nodeName}'
{
"podName": "aws-batch.f3d697c4-3bb5-3955-aa6c-977fcf1cb0ca",
"nodeName": "ip-192-168-59-101.ec2.internal"
}
```
# Lihat AWS Batch pekerjaan dalam antrian pekerjaan
Anda dapat melihat dan memfilter pekerjaan Anda di AWS Batch. Fitur ini menyediakan opsi untuk melihat antrian pekerjaan yang ada dan memfilter pekerjaannya dengan salah satu dari tiga opsi.
Pencarian dan filter dapat mengambil pekerjaan yang tidak dalam status terminal (`SUCCEEDED`atau`FAILED`). Setelah keadaan pekerjaan `SUCCEEDED` atau `FAILED` Anda harus dapat mengambil pekerjaan hingga tujuh hari. Anda masih dapat melihat EventBridge log pekerjaan CloudWatch atau Amazon.
Gunakan prosedur ini untuk mencantumkan semua pekerjaan dalam antrian pekerjaan di AWS Batch konsol. Secara opsional, gunakan bidang **Filter hasil** untuk mempersempit hasil berdasarkan kriteria yang Anda tentukan.
1. Navigasikan ke [konsol AWS Batch](https://console.aws.amazon.com/batch/home) tersebut.
1. Di panel Navigasi, pilih **Pekerjaan**.
1. Perluas daftar dropdown **antrian Job** dan pilih antrean pekerjaan yang ingin Anda cari.
**catatan**
Anda dapat mencari pekerjaan hanya dalam satu antrian pekerjaan pada satu waktu.
1. Di bidang **Filter hasil**, masukkan kata kunci untuk disertakan dalam hasil. Anda dapat menggunakan bidang ini untuk memfilter berdasarkan **nama Job**, **Status**, atau **ID Pekerjaan**. Tergantung pada properti, mungkin ada operator tambahan, seperti equals (=) atau contains (:) yang harus Anda tentukan.
**catatan**
SageMaker **Antrian pekerjaan pelatihan hanya mendukung penyaringan berdasarkan nama Job **dan Job ID****
1. Pilih **Cari**.
# AWS Batch Cari pekerjaan dalam antrian pekerjaan
Anda dapat mencari dan memfilter pekerjaan Anda AWS Batch menggunakan Job search. Fitur ini menyediakan opsi untuk mencari dalam antrian pekerjaan yang ada dan memfilter pekerjaannya.
Pencarian dan filter dapat mengambil pekerjaan yang tidak dalam status terminal (`SUCCEEDED`atau`FAILED`). Setelah keadaan pekerjaan `SUCCEEDED` atau `FAILED` Anda harus dapat mengambil pekerjaan hingga tujuh hari. Anda masih dapat melihat EventBridge log pekerjaan CloudWatch atau Amazon.
Untuk mencari menggunakan beberapa kriteria secara bersamaan, gunakan fitur **Pencarian lanjutan**. Misalnya, Anda dapat menyertakan salah satu atau semua filter berikut: **Status**, **Rentang tanggal**, dan **Kriteria tambahan** (seperti, nama pekerjaan, definisi pekerjaan, atau ID pekerjaan).
## Mencari AWS Batch pekerjaan (AWS Console)
Gunakan prosedur ini untuk mencari pekerjaan dalam antrian pekerjaan di AWS Batch konsol.
1. Navigasikan ke [konsol AWS Batch](https://console.aws.amazon.com/batch/home) tersebut.
1. Di panel Navigasi, pilih **Pekerjaan**.
1. Aktifkan **Pencarian lanjutan**.
1. Perluas daftar dropdown **antrian Job** dan pilih antrean pekerjaan yang ingin Anda cari.
**catatan**
Anda dapat mencari pekerjaan hanya dalam satu antrian pekerjaan pada satu waktu.
1. Untuk **opsi Penelusuran**:
1. Untuk daftar tarik-turun **Status**, Anda dapat memilih satu atau beberapa status untuk difilter. Untuk informasi selengkapnya, lihat [Status Job](job_states.md) dan [Status pekerjaan layanan](service-job-status.md).
**catatan**
Orang tua pekerjaan array diperbarui ke `PENDING` saat pekerjaan anak diperbarui `RUNNABLE` dan tetap dalam `PENDING` status saat pekerjaan anak berjalan. Untuk melihat pekerjaan ini, filter berdasarkan `PENDING` status hingga semua pekerjaan anak mencapai status terminal.
1. Pilih **Rentang tanggal** untuk memfilter hasil berdasarkan rentang tanggal dan waktu.
+ Pilih **mode Relatif** untuk mencari pekerjaan yang memiliki tanggal yang dibuat dalam rentang waktu yang dihitung mundur dari tanggal dan waktu saat ini.
+ Pilih **mode Absolute** untuk mencari pekerjaan yang memiliki tanggal yang dibuat dalam rentang tanggal dan waktu yang Anda tentukan.
1. Di bidang **Kriteria tambahan**, masukkan kata kunci untuk disertakan dalam hasil pencarian. Misalnya, Anda dapat menggunakan bidang ini untuk mencari berdasarkan **nama Job**, **definisi Job**, **ID Pekerjaan**, atau **pengenal Bagikan**. Tergantung pada properti, mungkin ada operator tambahan, seperti equals (=) atau contains (:) yang harus Anda tentukan.
**catatan**
SageMaker **Antrian pekerjaan pelatihan hanya mendukung penyaringan berdasarkan nama Job **dan Job ID****
**catatan**
Saat memfilter menurut **pengenal Bagikan**, Anda juga dapat menentukan status pekerjaan. Ini adalah pengecualian untuk pembatasan di mana filter lain mengecualikan pemfilteran status pekerjaan.
1. Pilih **Cari**.
## Cari dan filter AWS Batch lowongan kerja (AWS CLI)
Gunakan prosedur ini untuk daftar semua pekerjaan dalam antrian pekerjaan dengan. AWS CLI Secara opsional, gunakan parameter **-filters** untuk mempersempit hasil berdasarkan kriteria yang Anda tentukan.
------
#### [ Search job queue (AWS CLI) ]
Anda dapat menggunakan perintah [list-jobs](https://docs.aws.amazon.com/cli/latest/reference/batch/list-jobs.html) untuk mencari dan memfilter antrian pekerjaan.
Misalnya Anda dapat mencari antrian pekerjaan berdasarkan nama pekerjaan:
```
aws batch list-jobs \
--job-queue my-job-queue \
--filters name=JOB_NAME,values="my-job"
```
Filter pekerjaan berdasarkan pengenal berbagi:
```
aws batch list-jobs \
--job-queue my-job-queue \
--filters name=SHARE_IDENTIFIER,values="my-share"
```
Saat memfilter berdasarkan pengenal berbagi, Anda dapat menyertakan status pekerjaan:
```
aws batch list-jobs \
--job-queue my-job-queue \
--job-status RUNNING \
--filters name=SHARE_IDENTIFIER,values="my-share"
```
Di perintah sebelumnya, lakukan perubahan berikut:
+ Ganti *my-job-queue* dengan nama antrian pekerjaan Anda.
+ Ganti *my-job* dengan nama pekerjaan Anda.
+ Ganti *my-share* dengan pengenal berbagi yang ingin Anda filter.
------
#### [ Search service job queue (AWS CLI) ]
Anda dapat menggunakan [list-service-jobs](https://docs.aws.amazon.com/cli/latest/reference/batch/list-service-jobs.html)perintah untuk mencari dan memfilter antrian pekerjaan layanan.
Misalnya Anda dapat mencari antrian pekerjaan layanan berdasarkan nama pekerjaan:
```
aws batch list-service-jobs \
--job-queue my-sm-queue \
--filters name=JOB_NAME,values="my-sm-job"
```
Filter pekerjaan layanan dengan pengidentifikasi berbagi:
```
aws batch list-service-jobs \
--job-queue my-sm-queue \
--filters name=SHARE_IDENTIFIER,values="my-share"
```
Di perintah sebelumnya, lakukan perubahan berikut:
+ Ganti *my-sm-queue* dengan nama antrian pekerjaan layanan Anda.
+ Ganti *my-sm-job* dengan nama pekerjaan layanan Anda.
+ Ganti *my-share* dengan pengenal berbagi yang ingin Anda filter.
------
# Mode jaringan untuk AWS Batch pekerjaan
Tabel berikut menjelaskan mode jaringan dan penggunaan khas untuk jenis AWS Batch pekerjaan. Lihat tautan di kolom “Jenis pekerjaan” untuk detail selengkapnya mengenai pertimbangan dan perilaku.
| Jenis Job | Mode Jaringan yang Didukung | Penggunaan Khas |
| --- | --- | --- |
| [Pekerjaan sederhana ECS-EC2](jobs.md) | host | Digunakan untuk beban kerja batch paralel yang dapat diskalakan tertinggi yang hanya memerlukan jalan keluar ke vpc yang ditentukan dalam Lingkungan Komputasi. |
| [Pekerjaan paralel multi-node ECS-EC2](multi-node-parallel-jobs.md) | awsvpc | Digunakan untuk beban kerja terdistribusi multi-host (node) yang digabungkan secara ketat yang dimodelkan sebagai pekerjaan tunggal dengan komunikasi terkoordinasi antara node tugas. |
| [Pekerjaan sederhana ECS-Fargate](when-to-use-fargate.md) | awsvpc | Tanpa server sejati untuk beban kerja batch paralel yang memalukan. Biasanya TCO terendah dan model pekerjaan isolasi kontainer tertinggi. |
| [Pekerjaan sederhana EKS-EC2](eks-jobs.md) | host dan pod | Digunakan untuk beban kerja batch paralel yang sangat skalabel dan memalukan yang hanya memerlukan jalan keluar ke vpc yang ditentukan dalam Lingkungan Komputasi. Default adalah jaringan host. |
| [Pekerjaan paralel multi-node EKS-EC2](mnp-eks-jobs.md) | host dan pod | Digunakan untuk beban kerja terdistribusi multi-host (node) yang digabungkan secara ketat yang dimodelkan sebagai pekerjaan tunggal dengan komunikasi terkoordinasi antar node pod. Default adalah jaringan host. |
# Lihat log AWS Batch pekerjaan di CloudWatch Log
Anda dapat [mengonfigurasi AWS Batch pekerjaan Anda](using_cloudwatch_logs.md#using_cloudwatch_logs.title) untuk mengirim informasi log ke Amazon CloudWatch Logs. Dengan cara ini, Anda dapat melihat log yang berbeda dari pekerjaan Anda di satu lokasi yang nyaman. Untuk informasi selengkapnya, lihat [Menggunakan CloudWatch Log dengan AWS Batch](using_cloudwatch_logs.md).
Anda juga dapat menggunakan **log Job** di AWS Batch konsol untuk memantau atau memecahkan masalah pekerjaan. AWS Batch
1. Buka [konsol AWS Batch](https://console.aws.amazon.com/batch/home).
1. Pilih **Pekerjaan**. Untuk informasi lebih rinci tentang menyortir dan memfilter pekerjaan dalam antrian pekerjaan, lihat dan [Lihat AWS Batch pekerjaan dalam antrian pekerjaan](view-jobs.md) [Cari pekerjaan dalam antrian pekerjaan](searching-filtering-jobs.md)
1. Untuk **antrian Job**, pilih antrean pekerjaan yang Anda inginkan.
**Tip**
Jika ada beberapa pekerjaan dalam antrian pekerjaan, Anda dapat mengaktifkan **Mencari dan memfilter** untuk menemukan pekerjaan lebih cepat. Untuk informasi selengkapnya, lihat [AWS Batch Cari pekerjaan dalam antrian pekerjaan](searching-filtering-jobs.md).
1. Untuk **Status**, pilih status pekerjaan yang Anda inginkan.
1. Pilih pekerjaan yang Anda inginkan dan halaman **Detail** akan terbuka.
1. Pada halaman **Detail**, gulir ke bawah ke **nama aliran Log** dan pilih tautannya. Tautan membuka halaman Amazon CloudWatch Logs untuk pekerjaan itu.
1. (Opsional) Jika ini adalah pertama kalinya Anda melihat log, Anda mungkin akan diminta otorisasi.
Untuk **Otorisasi yang diperlukan**, masukkan**OK**, lalu pilih **Otorisasi untuk menerima** tagihan Amazon CloudWatch .
**catatan**
Untuk mencabut otorisasi Anda untuk biaya: CloudWatch
Di panel navigasi kiri, pilih **Izin**.
Untuk **log Job**, pilih **Edit**.
Kosongkan kotak CloudWatch centang **Otorisasi Batch untuk menggunakan**.
Pilih **Simpan perubahan**.
# Tinjau informasi AWS Batch pekerjaan
Anda dapat meninjau informasi AWS Batch pekerjaan seperti status, definisi pekerjaan, dan informasi wadah.
1. Buka [konsol AWS Batch](https://console.aws.amazon.com/batch/home).
1. Pilih **Pekerjaan**.
1. Untuk **antrian Job**, pilih antrean pekerjaan yang Anda inginkan.
**Tip**
Jika ada beberapa pekerjaan dalam antrian pekerjaan, Anda dapat mengaktifkan **Cari dan filter** untuk menemukan pekerjaan lebih cepat. Untuk informasi selengkapnya, lihat [AWS Batch Cari pekerjaan dalam antrian pekerjaan](searching-filtering-jobs.md).
1. Pilih pekerjaan yang Anda inginkan.
**catatan**
Anda juga dapat menggunakan AWS Command Line Interface (AWS CLI) untuk melihat detail tentang suatu AWS Batch pekerjaan. [Untuk informasi selengkapnya, lihat [mendeskripsikan pekerjaan di Referensi](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/batch/describe-jobs.html) Perintah.AWS CLI](https://docs.aws.amazon.com/cli/latest/reference/)