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

# Gunakan indeks pekerjaan array untuk mengontrol diferensiasi pekerjaan
<a name="array_index_example"></a>

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
<a name="array-tutorial-prereqs"></a>

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
<a name="build-index-container"></a>

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
<a name="push-array-image"></a>

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
<a name="create-array-job-def"></a>

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
<a name="submit-array-job"></a>

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
<a name="array-tutorial-logs"></a>

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.