

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

# Gunakan kerangka dokumen AWSTOE komponen untuk komponen kustom
<a name="toe-use-documents"></a>

Untuk membangun komponen menggunakan framework komponen AWS Task Orchestrator and Executor (AWSTOE), Anda harus menyediakan dokumen berbasis YAML yang mewakili fase dan langkah yang berlaku untuk komponen yang Anda buat. Layanan AWS gunakan komponen Anda saat mereka membuat Amazon Machine Image (AMI) atau image container baru.

**Topics**
+ [Alur kerja dokumen komponen](#component-doc-workflow)
+ [Pencatatan komponen](#component-logging)
+ [Rantai input dan output](#document-chaining)
+ [Skema dan definisi dokumen](#document-schema)
+ [Contoh dokumen](#document-example)
+ [Gunakan variabel dalam dokumen komponen kustom Anda](toe-user-defined-variables.md)
+ [Gunakan konstruksi bersyarat di AWSTOE](toe-conditional-constructs.md)
+ [Gunakan operator perbandingan dalam dokumen AWSTOE komponen](toe-comparison-operators.md)
+ [Gunakan operator logis dalam dokumen AWSTOE komponen](toe-logical-operators.md)
+ [Gunakan konstruksi perulangan di AWSTOE](toe-looping-constructs.md)

## Alur kerja dokumen komponen
<a name="component-doc-workflow"></a>

Dokumen AWSTOE komponen menggunakan fase dan langkah untuk mengelompokkan tugas terkait, dan mengatur tugas-tugas tersebut ke dalam alur kerja logis untuk komponen.

**Tip**  
Layanan yang menggunakan komponen Anda untuk membuat image mungkin menerapkan aturan tentang fase apa yang akan digunakan untuk proses pembuatannya, dan kapan fase tersebut diizinkan untuk dijalankan. Ini penting untuk dipertimbangkan ketika Anda mendesain komponen Anda.

**Fase**  
Fase mewakili perkembangan alur kerja Anda melalui proses pembuatan gambar. Misalnya, layanan Image Builder menggunakan `build` dan melakukan `validate` fase selama *tahap build* untuk gambar yang dihasilkannya. Ini menggunakan `container-host-test` fase `test` dan selama *tahap pengujian* untuk memastikan bahwa snapshot gambar atau gambar kontainer menghasilkan hasil yang diharapkan sebelum membuat AMI akhir atau mendistribusikan gambar kontainer.

Ketika komponen berjalan, perintah terkait untuk setiap fase diterapkan dalam urutan yang muncul dalam dokumen komponen.

**Aturan untuk fase**
+ Setiap nama fase harus unik dalam dokumen.
+ Anda dapat menentukan banyak fase dalam dokumen Anda.
+ Anda harus menyertakan setidaknya satu dari tahapan berikut dalam dokumen Anda:
  + **build** — untuk Image Builder, fase ini umumnya digunakan selama *tahap build*.
  + **validate** — untuk Image Builder, fase ini umumnya digunakan selama *tahap build*.
  + **test** — untuk Image Builder, fase ini umumnya digunakan selama *tahap pengujian*.
+ Fase selalu berjalan dalam urutan yang didefinisikan dalam dokumen. Urutan di mana mereka ditentukan untuk AWSTOE perintah di tidak AWS CLI berpengaruh.

**Langkah-langkah**  
Langkah-langkah adalah unit kerja individu yang menentukan alur kerja dalam setiap fase. Langkah-langkah berjalan secara berurutan. Namun, input atau output untuk satu langkah juga dapat dimasukkan ke langkah berikutnya sebagai input. Ini disebut “rantai”.

**Aturan untuk langkah-langkah**
+ Nama langkah harus unik untuk fase tersebut.
+ Langkah harus menggunakan tindakan yang didukung (modul tindakan) yang mengembalikan kode keluar.

  Untuk daftar lengkap modul tindakan yang didukung, cara kerjanya, input/output nilai, dan contoh, lihat[Modul aksi yang didukung oleh manajer AWSTOE komponen](toe-action-modules.md).

## Pencatatan komponen
<a name="component-logging"></a>

AWSTOE membuat folder log baru pada instance EC2 yang digunakan untuk membangun dan menguji gambar baru, setiap kali komponen Anda berjalan. Untuk gambar kontainer, folder log disimpan dalam wadah.

Untuk membantu pemecahan masalah jika terjadi kesalahan selama proses pembuatan gambar, dokumen input dan semua file output yang AWSTOE dibuat saat menjalankan komponen disimpan di folder log.

Nama folder log terdiri dari bagian-bagian berikut:

1. **Direktori log** — ketika sebuah layanan menjalankan AWSTOE komponen, ia melewati direktori log, bersama dengan pengaturan lain untuk perintah. Untuk contoh berikut, kami menunjukkan format file log yang digunakan Image Builder.
   + **Linux dan macOS**: `/var/lib/amazon/toe/`
   + **Windows**: `$env:ProgramFiles\Amazon\TaskOrchestratorAndExecutor\`

1. **Awalan file** — Ini adalah awalan standar yang digunakan untuk semua komponen: "”`TOE_`.

1. **Run time** - Ini adalah stempel waktu dalam format YYYY-MM-DD \$1HH-MM-SS\$1UTC-0.

1. **Execution ID** — Ini adalah GUID yang ditetapkan ketika AWSTOE menjalankan satu atau beberapa komponen.

Contoh: `/var/lib/amazon/toe/TOE_2021-07-01_12-34-56_UTC-0_a1bcd2e3-45f6-789a-bcde-0fa1b2c3def4`

AWSTOE menyimpan file inti berikut di folder log:

**Berkas masukan**
+ **document.yaml** — Dokumen yang digunakan sebagai input untuk perintah. Setelah komponen berjalan, file ini disimpan sebagai artefak.

**Berkas keluaran**
+ **application.log** - Log aplikasi berisi informasi tingkat debug stempel waktu dari AWSTOE tentang apa yang terjadi saat komponen sedang berjalan.
+ **detailedoutput.json** — File JSON ini memiliki informasi rinci tentang status run, input, output, dan kegagalan untuk semua dokumen, fase, dan langkah-langkah yang berlaku untuk komponen saat berjalan.
+ **console.log** - Log konsol berisi semua informasi standar keluar (stdout) dan kesalahan standar (stderr) yang AWSTOE menulis ke konsol saat komponen sedang berjalan.
+ **chaining.json - File JSON** ini mewakili pengoptimalan yang diterapkan untuk menyelesaikan ekspresi rantai. AWSTOE 

**catatan**  
Folder log mungkin juga berisi file sementara lainnya yang tidak tercakup di sini.

## Rantai input dan output
<a name="document-chaining"></a>

Aplikasi manajemen AWSTOE konfigurasi menyediakan fitur untuk merantai input dan output dengan menulis referensi dalam format berikut:

`{{ phase_name.step_name.inputs/outputs.variable }}`

atau

`{{ phase_name.step_name.inputs/outputs[index].variable }}`

Fitur chaining memungkinkan Anda untuk mendaur ulang kode dan meningkatkan pemeliharaan dokumen.

**Aturan untuk rantai**
+ Ekspresi rantai hanya dapat digunakan di bagian input dari setiap langkah.
+ Pernyataan dengan ekspresi rantai harus dilampirkan dalam tanda kutip. Contoh:
  + **Ekspresi tidak valid**: `echo {{ phase.step.inputs.variable }}`
  + **Ekspresi yang valid**: `"echo {{ phase.step.inputs.variable }}"`
  + **Ekspresi yang valid**: `'echo {{ phase.step.inputs.variable }}'`
+ Ekspresi rantai dapat mereferensikan variabel dari langkah dan fase lain dalam dokumen yang sama. Namun, layanan panggilan mungkin memiliki aturan yang memerlukan ekspresi rantai untuk beroperasi hanya dalam konteks satu tahap. Misalnya, Image Builder tidak mendukung chaining dari *tahap build ke tahap* *pengujian, karena Image* Builder menjalankan setiap tahap secara independen.
+ Indeks dalam ekspresi rantai mengikuti pengindeksan berbasis nol. Indeks dimulai dengan nol (0) untuk referensi elemen pertama.

**Contoh**

Untuk merujuk ke variabel sumber pada entri kedua dari langkah contoh berikut, pola rantai adalah`{{ build.SampleS3Download.inputs[1].source }}`.

```
phases:
  - name: 'build'
    steps:
      - name: SampleS3Download
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://sample-bucket/sample1.ps1'
            destination: 'C:\sample1.ps1'
          - source: 's3://sample-bucket/sample2.ps1'
            destination: 'C:\sample2.ps1'
```

Untuk merujuk ke variabel output (sama dengan “Halo”) dari langkah contoh berikut, pola rantai adalah`{{ build.SamplePowerShellStep.outputs.stdout }}`.

```
phases:
  - name: 'build'
    steps:
      - name: SamplePowerShellStep
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          commands:
            - 'Write-Host "Hello"'
```

## Skema dan definisi dokumen
<a name="document-schema"></a>

Berikut ini adalah skema YAMM untuk dokumen.

```
name: (optional)
description: (optional)
schemaVersion: "string"

phases:
  - name: "string"
    steps:
      - name: "string"
        action: "string"
        timeoutSeconds: integer
        onFailure: "Abort|Continue|Ignore"
        maxAttempts: integer
        inputs:
```

Definisi skema untuk dokumen adalah sebagai berikut.


| Bidang | Deskripsi | Tipe | Diperlukan | 
| --- | --- | --- | --- | 
| name | Nama dokumen. | String | Tidak | 
| deskripsi | Deskripsi dokumen. | String |  Tidak  | 
| schemaVersion | Versi skema dokumen, saat ini 1.0. | Tali |  Ya  | 
| fase | Daftar fase dengan langkah-langkahnya. |  Daftar  |  Ya  | 

Definisi skema untuk suatu fase adalah sebagai berikut.


| Bidang | Deskripsi | Tipe | Diperlukan | 
| --- | --- | --- | --- | 
| name | Nama fase. | Tali | Ya | 
| langkah | Daftar langkah-langkah dalam fase. | Daftar  |  Ya  | 

Definisi skema untuk suatu langkah adalah sebagai berikut.


| Bidang | Deskripsi | Tipe | Diperlukan | Nilai default | 
| --- | --- | --- | --- | --- | 
| name | Nama yang ditentukan pengguna untuk langkah tersebut. | String |  |  | 
| tindakan | Kata kunci yang berkaitan dengan modul yang menjalankan langkah. | String |  |  | 
| timeoutSeconds |  Jumlah detik langkah berjalan sebelum gagal atau mencoba lagi.  Juga, mendukung -1 nilai, yang menunjukkan batas waktu tak terbatas. 0 dan nilai negatif lainnya tidak diperbolehkan.  | Bilangan Bulat |  Tidak  | 7.200 detik (120 menit) | 
| onFailure |  Menentukan apa yang harus dilakukan langkah jika terjadi kegagalan. Nilai yang valid adalah sebagai berikut:  [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/imagebuilder/latest/userguide/toe-use-documents.html)  |  String  |  Tidak  | Batalkan | 
| maxAttempts | Jumlah maksimum upaya yang diizinkan sebelum gagal langkah. | Bilangan Bulat |  Tidak  | 1 | 
| masukan | Berisi parameter yang diperlukan oleh modul tindakan untuk menjalankan langkah. | Dikte |  Ya  |  | 

## Contoh dokumen
<a name="document-example"></a>

Contoh berikut menunjukkan dokumen AWSTOE komponen yang melakukan tugas untuk sistem operasi target.

------
#### [ Linux ]

**Contoh 1: Jalankan file biner kustom**  
Berikut ini adalah contoh dokumen yang men-download dan menjalankan file biner kustom pada instance Linux.

```
name: LinuxBin
description: Download and run a custom Linux binary file.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://<replaceable>amzn-s3-demo-source-bucket</replaceable>/<replaceable>myapplication</replaceable>
            destination: /tmp/<replaceable>myapplication</replaceable>
      - name: Enable
        action: ExecuteBash
        onFailure: Continue
        inputs:
          commands:
            - 'chmod u+x {{ build.Download.inputs[0].destination }}'
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: '{{ build.Download.inputs[0].destination }}'
          arguments:
            - '--install'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

------
#### [ Windows ]

**Contoh 1: Instal pembaruan Windows**  
Berikut ini adalah contoh dokumen yang menginstal semua pembaruan Windows yang tersedia, menjalankan skrip konfigurasi, memvalidasi perubahan sebelum AMI dibuat, dan menguji perubahan setelah AMI dibuat.

```
name: RunConfig_UpdateWindows
description: 'This document will install all available Windows updates and run a config script. It will then validate the changes before an AMI is created. Then after AMI creation, it will test all the changes.'
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: DownloadConfigScript
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://customer-bucket/config.ps1'
            destination: 'C:\config.ps1'

      - name: RunConfigScript
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          file: '{{build.DownloadConfigScript.inputs[0].destination}}'

      - name: Cleanup
        action: DeleteFile
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - path: '{{build.DownloadConfigScript.inputs[0].destination}}'

      - name: RebootAfterConfigApplied
        action: Reboot
        inputs:
          delaySeconds: 60

      - name: InstallWindowsUpdates
        action: UpdateOS

  - name: validate
    steps:
      - name: DownloadTestConfigScript
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://customer-bucket/testConfig.ps1'
            destination: 'C:\testConfig.ps1'

      - name: ValidateConfigScript
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          file: '{{validate.DownloadTestConfigScript.inputs[0].destination}}'

      - name: Cleanup
        action: DeleteFile
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - path: '{{validate.DownloadTestConfigScript.inputs[0].destination}}'

  - name: test
    steps:
      - name: DownloadTestConfigScript
        action: S3Download
        timeoutSeconds: 60
        onFailure: Abort
        maxAttempts: 3
        inputs:
          - source: 's3://customer-bucket/testConfig.ps1'
            destination: 'C:\testConfig.ps1'

      - name: ValidateConfigScript
        action: ExecutePowerShell
        timeoutSeconds: 120
        onFailure: Abort
        maxAttempts: 3
        inputs:
          file: '{{test.DownloadTestConfigScript.inputs[0].destination}}'
```

**Contoh 2: Instal AWS CLI pada instance Windows**  
Berikut ini adalah contoh dokumen yang menginstal AWS CLI pada instance Windows, menggunakan file setup.

```
name: InstallCLISetUp
description: Install &CLI; using the setup file
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://aws-cli/AWSCLISetup.exe
            destination: C:\Windows\temp\AWSCLISetup.exe
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: '{{ build.Download.inputs[0].destination }}'
          arguments:
            - '/install'
            - '/quiet'
            - '/norestart'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

**Contoh 3: Instal AWS CLI dengan installer MSI**  
Berikut ini adalah contoh dokumen yang menginstal AWS CLI dengan installer MSI.

```
name: InstallCLIMSI
description: Install &CLI; using the MSI installer
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://aws-cli/AWSCLI64PY3.msi
            destination: C:\Windows\temp\AWSCLI64PY3.msi
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: 'C:\Windows\System32\msiexec.exe'
          arguments:
            - '/i'
            - '{{ build.Download.inputs[0].destination }}'
            - '/quiet'
            - '/norestart'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

------
#### [ macOS ]

**Contoh 1: Jalankan file biner macOS kustom**  
Berikut ini adalah contoh dokumen yang mengunduh dan menjalankan file biner kustom pada instance macOS.

```
name: macOSBin
description: Download and run a binary file on macOS.
schemaVersion: 1.0
phases:
  - name: build
    steps:
      - name: Download
        action: S3Download
        inputs:
          - source: s3://<replaceable>amzn-s3-demo-source-bucket</replaceable>/<replaceable>myapplication</replaceable>
            destination: /tmp/<replaceable>myapplication</replaceable>
      - name: Enable
        action: ExecuteBash
        onFailure: Continue
        inputs:
          commands:
            - 'chmod u+x {{ build.Download.inputs[0].destination }}'
      - name: Install
        action: ExecuteBinary
        onFailure: Continue
        inputs:
          path: '{{ build.Download.inputs[0].destination }}'
          arguments:
            - '--install'
      - name: Delete
        action: DeleteFile
        inputs:
          - path: '{{ build.Download.inputs[0].destination }}'
```

------

# Gunakan variabel dalam dokumen komponen kustom Anda
<a name="toe-user-defined-variables"></a>

Variabel menyediakan cara untuk memberi label data dengan nama yang bermakna yang dapat digunakan di seluruh aplikasi. Anda dapat menentukan variabel kustom dengan format sederhana dan mudah dibaca untuk alur kerja yang kompleks, dan mereferensikannya dalam dokumen komponen aplikasi YAMM untuk komponen. AWSTOE 

Bagian ini menyediakan informasi untuk membantu Anda menentukan variabel untuk AWSTOE komponen Anda dalam dokumen komponen aplikasi YAMAL, termasuk sintaks, batasan nama, dan contoh.

## Konstanta
<a name="user-defined-vars-constants"></a>

Konstanta adalah variabel yang tidak dapat diubah yang tidak dapat dimodifikasi atau diganti setelah ditentukan. Konstanta dapat didefinisikan menggunakan nilai-nilai di `constants` bagian AWSTOE dokumen.

**Aturan untuk nama konstan**
+ Nama harus antara 3 dan 128 karakter panjangnya.
+ Nama hanya dapat berisi karakter alfanumerik (a-z, A-Z, 0-9), tanda hubung (-), atau garis bawah (\$1).
+ Nama harus unik di dalam dokumen.
+ Nama harus ditentukan sebagai string YAMM.

**Sintaksis**

```
constants:
  - <name>:
      type: <constant type>
      value: <constant value>
```


| Nama kunci | Diperlukan | Deskripsi | 
| --- | --- | --- | 
|  `name`  |  Ya  | Nama konstanta. Harus unik untuk dokumen (tidak boleh sama dengan nama parameter atau konstanta lainnya). | 
| `value` | Ya | Nilai konstanta. | 
| `type` | Ya | Jenis konstanta. Tipe yang didukung adalahstring. | 

**Referensi nilai konstan dalam dokumen**  
Anda dapat mereferensikan konstanta dalam input langkah atau loop di dalam dokumen YAMM Anda, sebagai berikut:
+ Referensi konstan peka huruf besar/kecil, dan namanya harus sama persis.
+ Nama harus dilampirkan dalam kawat gigi keriting ganda. `{{` *MyConstant* `}}`
+ Spasi diperbolehkan di dalam kurung kurawal, dan secara otomatis dipangkas. Misalnya, semua referensi berikut ini valid:

  `{{ MyConstant }}`, `{{ MyConstant}}`, `{{MyConstant }}`, `{{MyConstant}}`
+ Referensi dalam dokumen YAMAL harus ditentukan sebagai string (terlampir dalam tanda kutip tunggal atau ganda).

  Misalnya: `- {{ MyConstant }}` tidak valid, karena tidak diidentifikasi sebagai string.

  Namun, referensi berikut ini valid: `- '{{ MyConstant }}'` dan`- "{{ MyConstant }}"`.

**Contoh**  
Konstan direferensikan dalam input langkah

```
name: Download AWS CLI version 2
schemaVersion: 1.0
constants:
  - Source:
      type: string
      value: https://awscli.amazonaws.com/AWSCLIV2.msi
phases:
  - name: build
    steps:
      - name: Download
        action: WebDownload
        inputs:
          - source: '{{ Source }}'
            destination: 'C:\Windows\Temp\AWSCLIV2.msi'
```

Konstan direferensikan dalam input loop

```
name: PingHosts
schemaVersion: 1.0
constants:
  - Hosts:
      type: string
      value: 127.0.0.1,amazon.com
phases:
  - name: build
    steps:
      - name: Ping
        action: ExecuteBash
        loop:
          forEach:
            list: '{{ Hosts }}'
            delimiter: ','
        inputs:
          commands:
            - ping -c 4 {{ loop.value }}
```

## Parameter
<a name="user-defined-vars-parameters"></a>

Parameter adalah variabel yang dapat berubah, dengan pengaturan yang dapat disediakan aplikasi pemanggilan saat runtime. Anda dapat menentukan parameter di `Parameters` bagian dokumen YAMB.

**Aturan untuk nama parameter**
+ Nama harus antara 3 dan 128 karakter panjangnya.
+ Nama hanya dapat berisi karakter alfanumerik (a-z, A-Z, 0-9), tanda hubung (-), atau garis bawah (\$1).
+ Nama harus unik di dalam dokumen.
+ Nama harus ditentukan sebagai string YAMM.

### Sintaksis
<a name="vars-parameters-syntax"></a>

```
parameters:
  - <name>:
      type: <parameter type>
      default: <parameter value>
      description: <parameter description>
```


| Nama kunci | Diperlukan | Deskripsi | 
| --- | --- | --- | 
| `name` | Ya | Nama parameter. Harus unik untuk dokumen (tidak boleh sama dengan nama parameter atau konstanta lainnya). | 
| `type` | Ya | Tipe data parameter. Jenis yang didukung meliputi:`string`. | 
| `default` | Tidak | Nilai default untuk parameter. | 
| `description` | Tidak | Menjelaskan parameternya. | 

### Nilai parameter referensi dalam dokumen
<a name="vars-parameters-referencing"></a>

Anda dapat mereferensikan parameter dalam input langkah atau loop di dalam dokumen YAMM Anda, sebagai berikut:
+ Referensi parameter peka huruf besar/kecil, dan namanya harus sama persis.
+ Nama harus dilampirkan dalam kawat gigi keriting ganda. `{{` *MyParameter* `}}`
+ Spasi diperbolehkan di dalam kurung kurawal, dan secara otomatis dipangkas. Misalnya, semua referensi berikut ini valid:

  `{{ MyParameter }}`, `{{ MyParameter}}`, `{{MyParameter }}`, `{{MyParameter}}`
+ Referensi dalam dokumen YAMAL harus ditentukan sebagai string (terlampir dalam tanda kutip tunggal atau ganda).

  Misalnya: `- {{ MyParameter }}` tidak valid, karena tidak diidentifikasi sebagai string.

  Namun, referensi berikut ini valid: `- '{{ MyParameter }}'` dan`- "{{ MyParameter }}"`.

**Contoh**  
Contoh berikut menunjukkan cara menggunakan parameter dalam dokumen YAMM Anda:
+ Lihat parameter dalam input langkah:

  ```
  name: Download AWS CLI version 2
  schemaVersion: 1.0
  parameters:
    - Source:
        type: string
        default: 'https://awscli.amazonaws.com/AWSCLIV2.msi'
        description: The AWS CLI installer source URL.
  phases:
    - name: build
      steps:
        - name: Download
          action: WebDownload
          inputs:
            - source: '{{ Source }}'
              destination: 'C:\Windows\Temp\AWSCLIV2.msi'
  ```
+ Lihat parameter dalam input loop:

  ```
  name: PingHosts
  schemaVersion: 1.0
  parameters:
    - Hosts:
        type: string
        default: 127.0.0.1,amazon.com
        description: A comma separated list of hosts to ping.
  phases:
    - name: build
      steps:
        - name: Ping
          action: ExecuteBash
          loop:
            forEach:
              list: '{{ Hosts }}'
              delimiter: ','
          inputs:
            commands:
              - ping -c 4 {{ loop.value }}
  ```

### Ganti parameter saat runtime
<a name="vars-parameters-set-at-runtime"></a>

Anda dapat menggunakan `--parameters` opsi dari AWS CLI with a key-value pair untuk menetapkan nilai parameter saat runtime.
+ <name><value>Tentukan pasangan kunci-nilai parameter sebagai nama dan nilai, dipisahkan oleh tanda sama dengan (=).
+ Beberapa parameter harus dipisahkan dengan koma.
+ Nama parameter yang tidak ditemukan dalam dokumen komponen YAMB diabaikan.
+ Nama parameter dan nilai keduanya diperlukan.

**penting**  
Parameter komponen adalah nilai teks biasa, dan masuk AWS CloudTrail. Kami menyarankan Anda menggunakan AWS Secrets Manager atau AWS Systems Manager Parameter Store untuk menyimpan rahasia Anda. Untuk informasi selengkapnya tentang Secrets Manager, lihat [Apa itu Secrets Manager?](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html) dalam *AWS Secrets Manager User Guide*. Untuk informasi selengkapnya tentang AWS Systems Manager Parameter Store, lihat [AWS Systems Manager Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) di *Panduan AWS Systems Manager Pengguna*.

#### Sintaksis
<a name="vars-runtime-parameters-syntax"></a>

```
--parameters name1=value1,name2=value2...
```


| Opsi CLI | Diperlukan | Deskripsi | 
| --- | --- | --- | 
| --parameter *name* =*value*,... | Tidak | Opsi ini mengambil daftar pasangan kunci-nilai, dengan nama parameter sebagai kunci. | 

**Contoh**  
Contoh berikut menunjukkan cara menggunakan parameter dalam dokumen YAMM Anda:
+ Pasangan nilai kunci parameter yang ditentukan dalam `--parameter` opsi ini tidak valid:

  ```
  --parameters ntp-server=
  ```
+ Tetapkan satu parameter pasangan kunci-nilai dengan `--parameter` opsi di: AWS CLI

  ```
  --parameters ntp-server=ntp-server-windows-qe.us-east1.amazon.com
  ```
+ Tetapkan beberapa pasangan nilai kunci parameter dengan `--parameter` opsi di: AWS CLI

  ```
  --parameters ntp-server=ntp-server.amazon.com,http-url=https://internal-us-east1.amazon.com
  ```

## Gunakan parameter Systems Manager Parameter Store
<a name="toe-ssm-parameters"></a>

Anda dapat mereferensikan AWS Systems Manager parameter Parameter Store (parameter SSM) dalam dokumen komponen Anda dengan awalan variabel. `aws:ssm` Misalnya, 

`{{ aws:ssm:/my/param }}`menyelesaikan ke nilai parameter SSM. `/my/param`

Fitur ini mendukung jenis parameter SSM berikut:
+ String - Peta ke tipe AWSTOE string.
+ StringList — Peta ke AWSTOE `stringList` jenis.
+ SecureString — Peta ke tipe AWSTOE string.

Untuk informasi selengkapnya tentang Parameter Store lihat [AWS Systems Manager Parameter Menyimpan](https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.html) di *Panduan AWS Systems Manager Pengguna*.

Anda juga dapat mereferensikan AWS Secrets Manager rahasia menggunakan parameter `SecureString` SSM. Sebagai contoh: `{{ aws:ssm:/aws/reference/secretsmanager/test/test-secret }}`. Untuk informasi selengkapnya, lihat [Mereferensikan AWS Secrets Manager rahasia dari parameter Parameter Store](https://docs.aws.amazon.com/systems-manager/latest/userguide/integration-ps-secretsmanager.html).

**penting**  
Image Builder mengecualikan resolusi `SecureString` parameter dari lognya. Namun, Anda juga bertanggung jawab untuk memastikan bahwa informasi sensitif tidak dicatat melalui perintah yang dikeluarkan dalam dokumen komponen. Misalnya, jika Anda menggunakan `echo` perintah dengan string aman, perintah menulis nilai plaintext ke log.

### Izin IAM yang diperlukan
<a name="toe-ssm-parameters-permissions"></a>

Untuk menggunakan parameter Systems Manager di komponen Anda, peran instans Anda harus memiliki `ssm:GetParameter` izin untuk ARN sumber daya parameter. Contoh:

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

****  

```
{
	"Version":"2012-10-17",		 	 	 
	"Statement": [
		{
			"Effect": "Allow",
			"Action": "ssm:GetParameter",
			"Resource": "arn:aws:ssm:*:111122223333:parameter/ImageBuilder-*"
		}
	]
}
```

------

Untuk mengakses nilai terenkripsi, Anda juga memerlukan izin berikut:
+ Tambahkan `kms:Decrypt` `SecureString` parameter atau AWS Secrets Manager nilai yang dienkripsi dengan pelanggan yang dikelola. AWS KMS key
+ Tambahkan `secretsmanager:GetSecretValue` jika Anda mereferensikan rahasia Secrets Manager.

### Referensi parameter SSM dalam dokumen komponen
<a name="toe-ssm-parameters-example"></a>

Contoh berikut menunjukkan cara mereferensikan parameter Systems Manager Parameter Store parameter Systems Manager dalam komponen:

```
name: UseSSMParameterVariable
description: This is a sample component document that prints out the value of an SSM Parameter. Never do this for a SecureString parameter.
schemaVersion: 1.0

phases:
  - name: verify
    steps:
      - name: EchoParameterValue
        action: ExecuteBash
        inputs:
          commands:
            - echo "Log SSM parameter name: /my/test/param, value {{ aws:ssm:/my/test/param }}."
```

### Resolusi variabel runtime dinamis untuk parameter SSM
<a name="toe-dynamic-vars"></a>

AWSTOE menyediakan fungsi bawaan berikut yang dapat Anda gunakan dalam referensi variabel untuk memanipulasi atau mengubah nilai saat runtime.

#### menyelesaikan fungsi
<a name="toe-function-resolve"></a>

`resolve`Fungsi ini menyelesaikan referensi variabel di dalam referensi variabel lain, memungkinkan untuk referensi nama variabel dinamis. Ini berguna saat bekerja dengan parameter SSM di mana bagian dari jalur parameter dapat bervariasi dan diteruskan sebagai parameter dokumen.

`resolve`Fungsi ini hanya mendukung resolusi dinamis dari bagian nama parameter SSM.

##### Sintaksis
<a name="toe-function-resolve-syntax"></a>

`dynamic_variable`Dalam contoh berikut mewakili nama parameter SSM, dan harus salah satu dari berikut ini:
+ Referensi parameter SSM (misalnya,`aws:ssm:/my/param`)
+ Referensi parameter dokumen komponen (misalnya,`parameter-name`)

```
{{ aws:ssm:resolve(dynamic_variable) }}
```

##### Contoh: Menyelesaikan parameter SSM saat runtime
<a name="toe-function-resolve-examples"></a>

Contoh berikut menunjukkan cara menggunakan `resolve` fungsi dalam dokumen komponen YAMM:

```
name: SsmParameterTest
description: This component verifies an SSM parameter variable reference with the echo command.
schemaVersion: 1.0

parameters:
  - parameter-name:
      type: string
      description: "test"

phases:
  - name: validate
    steps:
      - name: PrintDynamicVariable
        action: ExecuteBash
        inputs:
          commands:
            - echo "{{ aws:ssm:resolve(parameter-name) }}"
```

# Gunakan konstruksi bersyarat di AWSTOE
<a name="toe-conditional-constructs"></a>

Konstruksi bersyarat melakukan tindakan yang berbeda dalam dokumen komponen Anda berdasarkan apakah ekspresi kondisional yang ditentukan mengevaluasi atau. `true` `false` Anda dapat menggunakan `if` konstruksi untuk mengontrol aliran eksekusi dalam dokumen komponen Anda.

## jika Membangun
<a name="toe-conditional-if"></a>

Anda dapat menggunakan `if` konstruksi untuk mengevaluasi apakah suatu langkah harus dijalankan atau tidak. Secara default, ketika ekspresi `if` kondisional mengevaluasi`true`, AWSTOE menjalankan langkah, dan ketika kondisi dievaluasi`false`, AWSTOE lewati langkah. Jika sebuah langkah dilewati, itu diperlakukan sebagai langkah yang berhasil ketika AWSTOE mengevaluasi apakah fase dan dokumen berjalan dengan sukses.

**catatan**  
`if`Pernyataan hanya dievaluasi satu kali, bahkan jika langkah tersebut memicu restart. Jika sebuah langkah dimulai ulang, ia mengakui bahwa `if` pernyataan tersebut telah dievaluasi, dan berlanjut di mana ia berhenti.

### Sintaksis
<a name="toe-conditional-if-syntax"></a>

```
if:
  - <conditional expression>:
      [then: <step action>]
      [else: <step action>]
```


| Nama kunci | Diperlukan | Deskripsi | 
| --- | --- | --- | 
| ekspresi bersyarat | Ya |  Ekspresi kondisional dapat berisi persis salah satu jenis operator berikut di tingkat atas. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/imagebuilder/latest/userguide/toe-conditional-constructs.html) Jika ekspresi Anda harus memenuhi beberapa kondisi, gunakan operator logis untuk menentukan kondisi Anda.  | 
| lalu | Tidak |  Mendefinisikan tindakan yang harus diambil jika ekspresi kondisional mengevaluasi. `true`  | 
| lain | Tidak |  Mendefinisikan tindakan yang harus diambil jika ekspresi kondisional mengevaluasi. `false`  | 
| langkah tindakan | Bersyarat |  Saat Anda menggunakan `then` atau`else`, Anda harus menentukan salah satu tindakan langkah berikut: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/imagebuilder/latest/userguide/toe-conditional-constructs.html)  | 

**Contoh 1: Instal paket**  
Contoh langkah berikut dari dokumen AWSTOE komponen menggunakan operator logis untuk menguji nilai parameter dan menjalankan perintah manajer paket yang sesuai untuk menginstal aplikasi jika paket di-unzip.

```
    - name: InstallUnzipAptGet
      action: ExecuteBash
      if:
        and:
            - binaryExists: 'apt-get'
            - not:
                binaryExists: 'unzip'
      inputs:
        commands:
            - sudo apt-get update
            - sudo apt-get install -y unzip

    - name: InstallUnzipYum
      action: ExecuteBash
      if:
        and:
            - binaryExists: 'yum'
            - not:
                binaryExists: 'unzip'
      inputs:
        commands:
            - sudo yum install -y unzip

    - name: InstallUnzipZypper
      action: ExecuteBash
      if:
        and:
            - binaryExists: 'zypper'
            - not:
                binaryExists: 'unzip'
      inputs:
        commands:
            - sudo zypper refresh
            - sudo zypper install -y unzip
```

**Contoh 2: Lewati satu langkah**  
Contoh berikut menunjukkan dua cara untuk melewati satu langkah. Satu menggunakan operator logis, dan satu menggunakan operator perbandingan dengan tindakan `Skip` langkah.

```
# Creates a file if it does not exist using not
- name: CreateMyConfigFile-1
  action: ExecuteBash
  if:
    not:
      fileExists: '/etc/my_config'
  inputs:
    commands:
      - echo "Hello world" > '/etc/my_config'

# Creates a file if it does not exist using then and else
- name: CreateMyConfigFile-2
  action: ExecuteBash
  if:
    fileExists: '/etc/my_config'
    then: Skip
    else: Execute
  inputs:
    commands:
      - echo "Hello world" > '/etc/my_config'
```

# Gunakan operator perbandingan dalam dokumen AWSTOE komponen
<a name="toe-comparison-operators"></a>

Anda dapat menggunakan operator perbandingan berikut dengan modul **[Menegaskan](toe-action-modules.md#action-modules-assertion)** tindakan dan dengan ekspresi bersyarat yang menggunakan. [jika MembangunSintaksis](toe-conditional-constructs.md#toe-conditional-if) Operator perbandingan dapat beroperasi pada satu nilai, misalnya`stringIsEmpty`, atau dapat membandingkan nilai dasar dengan nilai kedua (nilai variabel) untuk menentukan apakah ekspresi kondisional mengevaluasi atau. `true` `false`

Jika perbandingan beroperasi pada dua nilai, nilai kedua dapat berupa variabel rantai.

Saat membandingkan nilai dari jenis yang berbeda, konversi nilai berikut dapat terjadi sebelum perbandingan:
+ Untuk perbandingan numerik, jika nilai variabel adalah string, AWSTOE mengkonversi string ke angka sebelum evaluasi. Jika konversi tidak memungkinkan, perbandingan kembali`false`. Misalnya, jika nilai variabelnya`"1.0"`, konversi berfungsi, tetapi jika nilai variabelnya adalah `"a10"` konversi gagal.
+ Untuk perbandingan string, jika nilai variabel adalah angka, AWSTOE mengubahnya menjadi string sebelum evaluasi.

## Bandingkan string
<a name="toe-compare-strings"></a>

Operator perbandingan berikut bekerja dengan string untuk membandingkan nilai, untuk menguji spasi atau string kosong, atau untuk membandingkan nilai input dengan pola regex. Perbandingan string tidak peka huruf besar/kecil, dan tidak memangkas spasi dari awal atau akhir input string.

**Operator perbandingan string**
+ [stringIsEmpty](#stringIsEmpty)
+ [stringIsWhitespace](#stringIsWhitespace)
+ [stringEquals](#stringEquals)
+ [stringLessThan](#stringLessThan)
+ [stringLessThanEquals](#stringLessThanEquals)
+ [stringGreaterThan](#stringGreaterThan)
+ [stringGreaterThanEquals](#stringGreaterThanEquals)
+ [patternMatches](#patternMatches)

**stringIsEmpty**  
`stringIsEmpty`Operator kembali `true` jika string tertentu tidak mengandung karakter apapun. Contoh:  

```
# Evaluates to true
stringIsEmpty: ""

# Evaluates to false
stringIsEmpty: " "
				
# Evaluates to false
stringIsEmpty: "Hello."
```

**stringIsWhitespace**  
Tes jika string ditentukan untuk hanya `stringIsWhitespace` berisi spasi. Contoh:  

```
# Evaluates to true
stringIsWhitespace: "   "

# Evaluates to false
stringIsWhitespace: ""
				
# Evaluates to false
stringIsWhitespace: " Hello?"
```

**StringEquals**  
Tes jika string ditentukan untuk `stringEquals` adalah sama persis untuk string yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true
stringEquals: 'Testing, testing...'
value: 'Testing, testing...'

# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'Hello again.'

# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'TESTING, TESTING....'

# Evaluates to false
stringEquals: 'Testing, testing...'
value: '   Testing, testing...'
				
# Evaluates to false
stringEquals: 'Testing, testing...'
value: 'Testing, testing...   '
```

**stringLessThan**  
Tes jika string yang `stringLessThan` ditentukan untuk kurang dari string yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true
# This comparison operator isn't case sensitive
stringlessThan: 'A'
value: 'a'

# Evaluates to true - 'a' is less than 'b'
stringlessThan: 'b'
value: 'a'

# Evaluates to true
# Numeric strings compare as less than alphabetic strings
stringlessThan: 'a'
value: '0'

# Evaluates to false
stringlessThan: '0'
value: 'a'
```

**stringLessThanSama dengan**  
Tes jika string yang `stringLessThanEquals` ditentukan untuk kurang dari atau sama dengan string yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true - 'a' is equal to 'a'
stringLessThanEquals: 'a'
value: 'a'

# Evaluates to true - since the comparison isn't case sensitive, 'a' is equal to 'A'
stringLessThanEquals: 'A'
value: 'a'

# Evaluates to true - 'a' is less than 'b'
stringLessThanEquals: 'b'
value: 'a'

# Evaluates to true - '0' is less than 'a'
stringLessThanEquals: 'a'
value: '0'

# Evaluates to false - 'a' is greater than '0'
stringLessThanEquals: '0'
value: 'a'
```

**stringGreaterThan**  
Tes jika string ditentukan untuk `stringGreaterThan` lebih besar dari string yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to false - since the comparison isn't case sensitive, 'A' is equal to 'a'
stringGreaterThan: 'a'
value: 'A'

# Evaluates to true - 'b' is greater than 'a'
stringGreaterThan: 'a'
value: 'b'

# Evaluates to true - 'a' is greater than '0'
stringGreaterThan: '0'
value: 'a'

# Evaluates to false - '0' is less than 'a'
stringGreaterThan: 'a'
value: '0'
```

**stringGreaterThanSama dengan**  
Tes jika string yang `stringGreaterThanEquals` ditentukan untuk lebih besar dari atau sama dengan string yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true - 'a' is equal to 'A'
stringGreaterThanEquals: 'A'
value: 'a'

# Evaluates to true - 'b' is greater than 'a'
stringGreaterThanEquals: 'a'
value: 'b'

# Evaluates to true - 'a' is greater than '0'
stringGreaterThanEquals: '0'
value: 'a'

# Evaluates to false - '0' is less than 'a'
stringGreaterThanEquals: 'a'
value: '0'
```

**Pola Pertandingan**  
Menguji apakah string yang ditentukan dalam `value` parameter cocok dengan pola regex yang ditentukan untuk. `patternMatches` Perbandingan menggunakan [paket regexp Golang](https://pkg.go.dev/regexp), yang sesuai dengan sintaks. RE2 Untuk informasi selengkapnya tentang RE2 aturan, lihat repositori [google/re2](https://github.com/google/re2/wiki/Syntax) di. *GitHub*  
Contoh berikut menunjukkan kecocokan pola yang mengembalikan`true`:  

```
patternMatches: '^[a-z]+$'
value: 'ThisIsValue'
```

## Bandingkan angka
<a name="toe-compare-numbers"></a>

Operator perbandingan berikut bekerja dengan angka. Nilai yang diberikan untuk operator ini harus salah satu dari jenis berikut, sesuai dengan spesifikasi YAMAL. Support untuk perbandingan numerik menggunakan operator perbandingan paket besar golang, misalnya: [func](https://pkg.go.dev/math/big#Float.Cmp) (\$1Float) Cmp.
+ Bilangan Bulat
+ Float (berdasarkan float64, yang mendukung angka dari -1.7e\$1308 hingga\$11.7e\$1308)
+ String yang cocok dengan pola regex berikut: `^[-+]?([0-9]+[.])?[0-9]+$`

**Operator perbandingan angka**
+ [numberEquals](#numberEquals)
+ [numberLessThan](#numberLessThan)
+ [numberLessThanEquals](#numberLessThanEquals)
+ [numberGreaterThan](#numberGreaterThan)
+ [numberGreaterThanEquals](#numberGreaterThanEquals)

**NumberSama**  
Tes jika nomor yang `numberEquals` ditentukan untuk sama dengan angka yang ditentukan dalam `value` parameter. Semua contoh perbandingan berikut kembali: `true`  

```
# Values provided as a positive number
numberEquals: 1
value: 1

# Comparison value provided as a string
numberEquals: '1'
value: 1

# Value provided as a string
numberEquals: 1
value: '1'

# Values provided as floats
numberEquals: 5.0
value: 5.0

# Values provided as a negative number
numberEquals: -1
value: -1
```

**numberLessThan**  
Tes jika nomor yang `numberLessThan` ditentukan untuk kurang dari angka yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true
numberLessThan: 2
value: 1

# Evaluates to true
numberLessThan: 2
value: 1.9

# Evaluates to false
numberLessThan: 2
value: '2'
```

**numberLessThanSama dengan**  
Tes jika angka yang `numberLessThanEquals` ditentukan untuk kurang dari atau sama dengan angka yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true
numberLessThanEquals: 2
value: 1

# Evaluates to true
numberLessThanEquals: 2
value: 1.9

# Evaluates to true
numberLessThanEquals: 2
value: '2'

# Evaluates to false
numberLessThanEquals: 2
value: 2.1
```

**numberGreaterThan**  
Tes jika angka yang `numberGreaterThan` ditentukan untuk lebih besar dari angka yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true
numberGreaterThan: 1
value: 2

# Evaluates to true
numberGreaterThan: 1
value: 1.1

# Evaluates to false
numberGreaterThan: 1
value: '1'
```

**numberGreaterThanSama dengan**  
Tes jika angka yang `numberGreaterThanEquals` ditentukan untuk lebih besar dari atau sama dengan angka yang ditentukan dalam `value` parameter. Contoh:  

```
# Evaluates to true
numberGreaterThanEquals: 1
value: 2

# Evaluates to true
numberGreaterThanEquals: 1
value: 1.1

# Evaluates to true
numberGreaterThanEquals: 1
value: '1'

# Evaluates to false
numberGreaterThanEquals: 1
value: 0.8
```

## Periksa file
<a name="toe-check-files"></a>

Operator perbandingan berikut memeriksa hash file atau memeriksa apakah ada file atau folder.

**Operator file dan folder**
+ [binaryExists](#binaryExists)
+ [fileExists](#fileExists)
+ [folderExists](#folderExists)
+ [fileMD5Equals](#fileMD5Equals)
+ [fileSHA1Equals](#fileSHA1Equals)
+ [fileSHA256Equals](#fileSHA256Equals)
+ [fileSHA512Equals](#fileSHA512Equals)

**BinaryExists**  
Menguji apakah aplikasi tersedia di jalur saat ini. Contoh:  

```
binaryExists: 'foo'
```
Pada sistem Linux dan macOS, untuk aplikasi bernama*foo*, ini bekerja sama dengan perintah bash berikut:**type *foo* >/dev/null 2>&1**, di mana **\$1? == 0** menunjukkan perbandingan yang berhasil.  
Pada sistem Windows, untuk aplikasi bernama*foo*, ini berfungsi sama dengan PowerShell perintah di **& C:\$1Windows\$1System32\$1where.exe /Q *foo*** mana **\$1LASTEXITCODE = 0** menunjukkan perbandingan yang berhasil.

**FileExists**  
Menguji apakah file ada di jalur yang ditentukan. Anda dapat memberikan jalur absolut atau relatif. Jika lokasi yang Anda tentukan ada dan merupakan file, perbandingan akan dievaluasi. `true` Contoh:  

```
fileExists: '/path/to/file'
```
Pada sistem Linux dan macOS, ini bekerja sama dengan perintah bash berikut:**-d */path/to/file***, di mana **\$1? == 0** menunjukkan perbandingan yang berhasil.  
Pada sistem Windows, ini bekerja sama dengan PowerShell perintah**Test-Path -Path '*C:\$1path\$1to\$1file*' -PathType 'Leaf'**.

**FolderExists**  
Menguji apakah folder ada di jalur yang ditentukan. Anda dapat memberikan jalur absolut atau relatif. Jika lokasi yang Anda tentukan ada dan merupakan folder, perbandingan akan dievaluasi. `true` Contoh:  

```
folderExists: '/path/to/folder'
```
Pada sistem Linux dan macOS, ini bekerja sama dengan perintah bash berikut:**-d */path/to/folder***, di mana **\$1? == 0** menunjukkan perbandingan yang berhasil.  
Pada sistem Windows, ini bekerja sama dengan PowerShell perintah**Test-Path -Path '*C:\$1path\$1to\$1folder*' -PathType 'Container'**.

**Berkas MD5 Sama**  
Menguji apakah MD5 hash file sama dengan nilai tertentu. Contoh:  

```
fileMD5Equals: '<MD5Hash>'
path: '/path/to/file'
```

**Berkas SHA1 Sama**  
Menguji apakah SHA1 hash file sama dengan nilai tertentu. Contoh:  

```
fileSHA1Equals: '<SHA1Hash>'
path: '/path/to/file'
```

**Berkas SHA256 Sama**  
Menguji apakah SHA256 hash file sama dengan nilai tertentu. Contoh:  

```
fileSHA256Equals: '<SHA256Hash>'
path: '/path/to/file'
```

**Berkas SHA512 Sama**  
Menguji apakah SHA512 hash file sama dengan nilai tertentu. Contoh:  

```
fileSHA512Equals: '<SHA512Hash>'
path: '/path/to/file'
```

# Gunakan operator logis dalam dokumen AWSTOE komponen
<a name="toe-logical-operators"></a>

Anda dapat menggunakan operator logika berikut untuk menambahkan atau memodifikasi ekspresi bersyarat dalam dokumen komponen Anda. AWSTOE mengevaluasi ekspresi bersyarat dalam urutan kondisi yang ditentukan. Untuk informasi selengkapnya tentang operator perbandingan untuk dokumen komponen, lihat[Gunakan operator perbandingan dalam dokumen AWSTOE komponen](toe-comparison-operators.md).

**dan**  
Dengan `and` operator, Anda dapat mengevaluasi dua atau lebih perbandingan sebagai ekspresi tunggal. Ekspresi mengevaluasi `true` kapan semua kondisi dalam daftar benar. Jika tidak, ekspresi mengevaluasi. `false`  
**Contoh:**  
Contoh berikut melakukan dua perbandingan - string dan angka. Kedua perbandingan itu benar, sehingga ekspresi dievaluasi menjadi benar.

```
and:
  - stringEquals: 'test_string'
    value: 'test_string'
  - numberEquals: 1
    value: 1
```
Contoh berikut juga melakukan dua perbandingan. Perbandingan pertama salah, di mana evaluasi berhenti dan perbandingan kedua dilewati. Ekspresi mengevaluasi. `false`  

```
and:
  - stringEquals: 'test_string'
    value: 'Hello world!'
  - numberEquals: 1
    value: 1
```

**atau**  
Dengan `or` operator, Anda dapat mengevaluasi dua atau lebih perbandingan sebagai ekspresi tunggal. Ekspresi mengevaluasi `true` kapan salah satu perbandingan yang ditentukan benar. Jika tidak ada perbandingan yang ditentukan yang dievaluasi`true`, ekspresi mengevaluasi. `false`  
**Contoh:**  
Contoh berikut melakukan dua perbandingan - string dan angka. Perbandingan pertama benar, sehingga ekspresi dievaluasi `true` dan perbandingan kedua dilewati.

```
or:
  - stringEquals: 'test_string'
    value: 'test_string'
  - numberEquals: 1
    value: 3
```
Contoh berikut juga melakukan dua perbandingan. Perbandingan pertama salah, dan evaluasi berlanjut. Perbandingan kedua benar, sehingga ekspresi mengevaluasi. `true`  

```
or:
  - stringEquals: 'test_string'
    value: 'Hello world!'
  - numberEquals: 1
    value: 1
```
Dalam contoh terakhir, kedua perbandingan itu salah, sehingga ekspresi dievaluasi. `false`  

```
or:
  - stringEquals: 'test_string'
    value: 'Hello world!'
  - numberEquals: 1
    value: 3
```

**tidak**  
Dengan `not` operator, Anda dapat meniadakan satu perbandingan. Ekspresi mengevaluasi `true` apakah perbandingannya salah. Jika perbandingannya benar, maka ekspresi dievaluasi. `false`  
**Contoh:**  
Contoh berikut melakukan perbandingan string. Perbandingannya salah, sehingga ekspresi mengevaluasi`true`.

```
not:
  - stringEquals: 'test_string'
    value: 'Hello world!'
```
Contoh berikut juga melakukan perbandingan string. Perbandingannya benar, sehingga ekspresi mengevaluasi`false`.  

```
not:
  - stringEquals: 'test_string'
    value: 'test_string'
```

# Gunakan konstruksi perulangan di AWSTOE
<a name="toe-looping-constructs"></a>

Bagian ini memberikan informasi untuk membantu Anda membuat konstruksi perulangan di. AWSTOE Konstruksi perulangan mendefinisikan urutan instruksi yang berulang. Anda dapat menggunakan jenis konstruksi perulangan berikut di: AWSTOE
+ `for`konstruksi - Iterasi atas urutan bilangan bulat yang dibatasi.
+ `forEach`membangun
  + `forEach`loop dengan daftar masukan - Iterasi atas kumpulan string yang terbatas. 
  + `forEach`loop dengan daftar terbatas - Iterasi di atas kumpulan string terbatas yang bergabung dengan pembatas.

**catatan**  
Konstruksi perulangan hanya mendukung tipe data string.

**Topics**
+ [Variabel iterasi referensi](#toe-loop-iteration-variables)
+ [Jenis konstruksi perulangan](#toe-loop-types)
+ [Bidang langkah](#toe-loop-step-fields)
+ [Output langkah dan iterasi](#toe-loop-step-output)

## Variabel iterasi referensi
<a name="toe-loop-iteration-variables"></a>

Untuk merujuk pada indeks dan nilai variabel iterasi saat ini, ekspresi referensi `{{ loop.* }}` harus digunakan dalam badan input dari langkah yang berisi konstruksi perulangan. Ekspresi ini tidak dapat digunakan untuk merujuk ke variabel iterasi dari konstruksi perulangan dari langkah lain.

Ekspresi referensi terdiri dari anggota berikut:
+ `{{ loop.index }}`— Posisi ordinal dari iterasi saat ini, yang diindeks di. `0` 
+ `{{ loop.value }}`— Nilai yang terkait dengan variabel iterasi saat ini. 

### Nama loop
<a name="toe-loop-iteration-variables-names"></a>

 Semua konstruksi perulangan memiliki bidang nama opsional untuk identifikasi. Jika nama loop disediakan, dapat digunakan untuk merujuk ke variabel iterasi di badan input langkah. Untuk merujuk pada indeks iterasi dan nilai loop bernama, gunakan `{{ <loop_name>.* }}` dengan `{{ loop.* }}` di badan input langkah. Ekspresi ini tidak dapat digunakan untuk merujuk pada konstruksi perulangan bernama dari langkah lain. 

Ekspresi referensi terdiri dari anggota berikut:
+ `{{ <loop_name>.index }}`— Posisi ordinal dari iterasi saat ini dari loop bernama, yang diindeks di. `0`
+ `{{ <loop_name>.value }}`— Nilai yang terkait dengan variabel iterasi saat ini dari loop bernama.

### Selesaikan ekspresi referensi
<a name="toe-loop-iteration-variables-expressions"></a>

 AWSTOE Mengatasi ekspresi referensi sebagai berikut: 
+ `{{ <loop_name>.* }}`— AWSTOE menyelesaikan ekspresi ini menggunakan logika berikut:
  + Jika loop dari langkah yang sedang berjalan cocok dengan `<loop_name>` nilainya, maka ekspresi referensi menyelesaikan konstruksi perulangan dari langkah yang sedang berjalan.
  + `<loop_name>`menyelesaikan ke konstruksi perulangan bernama jika muncul dalam langkah yang sedang berjalan.
+ `{{ loop.* }}`— AWSTOE menyelesaikan ekspresi menggunakan konstruksi perulangan yang ditentukan dalam langkah yang sedang berjalan.

Jika ekspresi referensi digunakan dalam langkah yang tidak mengandung loop, maka AWSTOE tidak menyelesaikan ekspresi dan mereka muncul di langkah tanpa penggantian. 

**catatan**  
Ekspresi referensi harus diapit tanda kutip ganda untuk ditafsirkan dengan benar oleh kompiler YAMAL.

## Jenis konstruksi perulangan
<a name="toe-loop-types"></a>

Bagian ini memberikan informasi dan contoh tentang jenis konstruksi perulangan yang dapat digunakan dalam. AWSTOE

**Topics**
+ [`for`lingkaran](#toe-loop-types-for)
+ [`forEach`loop dengan daftar input](#toe-loop-types-foreach)
+ [`forEach`loop dengan daftar terbatas](#toe-loop-types-foreach-delimited)

### `for`lingkaran
<a name="toe-loop-types-for"></a>

`for`Loop iterasi pada rentang bilangan bulat yang ditentukan dalam batas yang diuraikan oleh awal dan akhir variabel. Nilai iterasi ada di set `[start, end]` dan termasuk nilai batas.

AWSTOE memverifikasi`start`,`end`, dan `updateBy` nilai untuk memastikan bahwa kombinasi tidak menghasilkan loop tak terbatas.

`for`skema lingkaran

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      for:
        start: int
        end: int
        updateBy: int
inputs:
  ...
```


**`for`masukan loop**  

| Bidang | Deskripsi | Tipe | Diperlukan | Default | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nama unik dari loop. Itu harus unik dibandingkan dengan nama loop lain dalam fase yang sama. |  String  |  Tidak  |  ""  | 
|  `start`  | Nilai awal iterasi. Tidak menerima ekspresi rantai.  |  Bilangan Bulat  |  Ya  |  T/A  | 
| `end` | Nilai akhir iterasi. Tidak menerima ekspresi rantai.  | Bilangan Bulat | Ya | T/A | 
| `updateBy` | Perbedaan dimana nilai iterasi diperbarui melalui penambahan. Itu harus nilai negatif atau positif bukan nol. Tidak menerima ekspresi rantai.  | Bilangan Bulat | Ya | T/A | 

`for`contoh masukan loop

```
  - name: "CalculateFileUploadLatencies"
    action: "ExecutePowerShell"
    loop:
      for:
        start: 100000
        end: 1000000
        updateBy: 100000
    inputs:
      commands:
        - |
          $f = new-object System.IO.FileStream c:\temp\test{{ loop.index }}.txt, Create, ReadWrite
          $f.SetLength({{ loop.value }}MB)
          $f.Close()
        - c:\users\administrator\downloads\latencyTest.exe --file c:\temp\test{{ loop.index }}.txt
        - AWS s3 cp c:\users\administrator\downloads\latencyMetrics.json s3://bucket/latencyMetrics.json
        - |
          Remove-Item -Path c:\temp\test{{ loop.index }}.txt
          Remove-Item -Path c:\users\administrator\downloads\latencyMetrics.json
```

### `forEach`loop dengan daftar input
<a name="toe-loop-types-foreach"></a>

`forEach`Loop iterasi pada daftar eksplisit nilai, yang dapat berupa string dan ekspresi dirantai. 

`forEach`loop dengan skema daftar masukan

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      forEach:
        - "string"
    inputs:
  ...
```


**`forEach`loop dengan masukan daftar masukan**  

| Bidang | Deskripsi | Tipe | Diperlukan | Default | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nama unik dari loop. Itu harus unik dibandingkan dengan nama loop lain dalam fase yang sama. |  String  |  Tidak  |  ""  | 
|  Daftar string loop `forEach`  |  Daftar string untuk iterasi. Menerima ekspresi berantai sebagai string dalam daftar. Ekspresi berantai harus diapit oleh tanda kutip ganda agar kompiler YAMAL dapat menafsirkannya dengan benar.  |  Daftar string  |  Ya  |  T/A  | 

`forEach`loop dengan contoh daftar masukan 1

```
  - name: "ExecuteCustomScripts"
    action: "ExecuteBash"
    loop:
      name: BatchExecLoop
      forEach:
        - /tmp/script1.sh
        - /tmp/script2.sh
        - /tmp/script3.sh
    inputs:
      commands:
        - echo "Count {{ BatchExecLoop.index }}"
        - sh "{{ loop.value }}"
        - |
          retVal=$?
          if [ $retVal -ne 0 ]; then
            echo "Failed"
          else
            echo "Passed"
         fi
```

`forEach`loop dengan contoh daftar masukan 2

```
  - name: "RunMSIWithDifferentArgs"
    action: "ExecuteBinary"
    loop:
      name: MultiArgLoop
      forEach:
        - "ARG1=C:\Users ARG2=1"
        - "ARG1=C:\Users"
        - "ARG1=C:\Users ARG3=C:\Users\Administrator\Documents\f1.txt"
    inputs:
      commands:
        path: "c:\users\administrator\downloads\runner.exe"
        args:
          - "{{ MultiArgLoop.value }}"
```

`forEach`loop dengan contoh daftar masukan 3

```
  - name: "DownloadAllBinaries"
    action: "S3Download"
    loop:
      name: MultiArgLoop
      forEach:
        - "bin1.exe"
        - "bin10.exe"
        - "bin5.exe"
    inputs:
      - source: "s3://bucket/{{ loop.value }}"
        destination: "c:\temp\{{ loop.value }}"
```

### `forEach`loop dengan daftar terbatas
<a name="toe-loop-types-foreach-delimited"></a>

Loop iterasi atas string yang berisi nilai-nilai yang dipisahkan oleh pembatas. Untuk mengulangi konstituen string, AWSTOE gunakan pembatas untuk membagi string menjadi array yang cocok untuk iterasi. 

`forEach`loop dengan skema daftar yang dibatasi

```
  - name: "StepName"
    action: "ActionModule"
    loop:
      name: "string"
      forEach:
        list: "string"
        delimiter: ".,;:\n\t -_"
    inputs:
  ...
```


**`forEach`loop dengan input daftar yang dibatasi**  

| Bidang | Deskripsi | Tipe | Diperlukan | Default | 
| --- | --- | --- | --- | --- | 
|  `name`  | Nama unik yang diberikan ke loop. Ini harus unik jika dibandingkan dengan nama loop lain dalam fase yang sama. |  String  |  Tidak  |  ""  | 
|  `list`  | String yang terdiri dari string konstituen bergabung dengan karakter pembatas umum. Juga menerima ekspresi dirantai. Dalam kasus ekspresi berantai, pastikan bahwa ekspresi tersebut diapit oleh tanda kutip ganda untuk interpretasi yang benar oleh kompiler YAMAL. | Tali |  Ya  |  T/A  | 
| `delimiter` | Karakter yang digunakan untuk memisahkan string dalam blok. Default adalah karakter koma. Hanya satu karakter pembatas yang diizinkan dari daftar yang diberikan: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/id_id/imagebuilder/latest/userguide/toe-looping-constructs.html) Ekspresi rantai tidak dapat digunakan. | String | Tidak | Koma: "," | 

**catatan**  
Nilai diperlakukan sebagai `list` string yang tidak dapat diubah. Jika sumber `list` diubah selama runtime, itu tidak akan tercermin selama menjalankan.

`forEach`loop dengan daftar yang dibatasi contoh 1

Contoh ini menggunakan pola ekspresi rantai berikut untuk merujuk ke output langkah lain:`<phase_name>.<step_name>.[inputs | outputs].<var_name>`.

```
  - name: "RunMSIs"
    action: "ExecuteBinary"
    loop:
      forEach:
        list: "{{ build.GetAllMSIPathsForInstallation.outputs.stdout }}"
        delimiter: "\n"
    inputs:
      commands:
        path: "{{ loop.value }}"
```

`forEach`loop dengan contoh daftar terbatas 2

```
  - name: "UploadMetricFiles"
    action: "S3Upload"
    loop:
      forEach:
        list: "/tmp/m1.txt,/tmp/m2.txt,/tmp/m3.txt,..."
    inputs:
      commands:
        - source: "{{ loop.value }}"
          destination: "s3://bucket/key/{{ loop.value }}"
```

## Bidang langkah
<a name="toe-loop-step-fields"></a>

Loop adalah bagian dari langkah. Bidang apa pun yang terkait dengan menjalankan langkah tidak diterapkan pada iterasi individu. Bidang langkah hanya berlaku pada tingkat langkah, sebagai berikut:
+ *TimeoutSeconds* - Semua iterasi loop harus dijalankan dalam jangka waktu yang ditentukan oleh bidang ini. Jika loop AWSTOE habis waktu, jalankan kebijakan coba lagi langkah tersebut dan setel ulang parameter batas waktu untuk setiap upaya baru. Jika loop run melebihi nilai batas waktu setelah mencapai jumlah maksimum percobaan ulang, pesan kegagalan langkah menyatakan bahwa loop run telah habis waktunya. 
+ *OnFailure* - Penanganan kegagalan diterapkan pada langkah sebagai berikut:
  + Jika *onFailure* disetel ke`Abort`, AWSTOE keluar dari loop dan mencoba ulang langkah sesuai dengan kebijakan coba lagi. Setelah jumlah maksimum percobaan ulang, AWSTOE tandai langkah saat ini sebagai gagal, dan berhenti menjalankan proses.

    AWSTOE menetapkan kode status untuk fase induk dan dokumen ke`Failed`.
**catatan**  
Tidak ada langkah lebih lanjut yang berjalan setelah langkah gagal.
  + Jika *onFailure* disetel ke`Continue`, AWSTOE keluar dari loop dan mencoba ulang langkah sesuai dengan kebijakan coba lagi. Setelah jumlah maksimum percobaan ulang, AWSTOE tandai langkah saat ini sebagai gagal, dan lanjutkan untuk menjalankan langkah berikutnya.

    AWSTOE menetapkan kode status untuk fase induk dan dokumen ke`Failed`.
  + Jika *onFailure* disetel ke`Ignore`, AWSTOE keluar dari loop dan mencoba ulang langkah sesuai dengan kebijakan coba lagi. Setelah jumlah maksimum percobaan ulang, AWSTOE tandai langkah saat ini sebagai`IgnoredFailure`, dan lanjutkan untuk menjalankan langkah berikutnya.

    AWSTOE menetapkan kode status untuk fase induk dan dokumen ke`SuccessWithIgnoredFailure`.
**catatan**  
Ini masih dianggap sebagai proses yang berhasil, tetapi termasuk informasi untuk memberi tahu Anda bahwa satu atau lebih langkah gagal dan diabaikan.
+ *MaxAttracts — Untuk setiap percobaan* ulang, seluruh langkah dan semua iterasi dijalankan dari awal.
+ *status* — Status keseluruhan dari menjalankan langkah. `status`tidak mewakili status iterasi individu. Status langkah dengan loop ditentukan sebagai berikut:
  + Jika iterasi tunggal gagal dijalankan, status langkah menunjuk ke kegagalan.
  + Jika semua iterasi berhasil, status langkah menunjukkan kesuksesan.
+ *StartTime* — Waktu mulai keseluruhan dari menjalankan langkah. Tidak mewakili waktu mulai iterasi individu.
+ *EndTime* — Waktu akhir keseluruhan dari menjalankan langkah. Tidak mewakili waktu akhir iterasi individu.
+ *FailureMessage* — Termasuk indeks iterasi yang gagal jika terjadi kesalahan non-timeout. Jika terjadi kesalahan batas waktu, pesan menyatakan bahwa loop run telah gagal. Pesan kesalahan individual untuk setiap iterasi tidak disediakan untuk meminimalkan ukuran pesan kegagalan.

## Output langkah dan iterasi
<a name="toe-loop-step-output"></a>

Setiap iterasi berisi output. Pada akhir loop run, AWSTOE mengkonsolidasikan semua output iterasi yang berhasil di. `detailedOutput.json` Output konsolidasi adalah pengumpulan nilai yang termasuk dalam kunci output yang sesuai seperti yang didefinisikan dalam skema output modul tindakan. Contoh berikut menunjukkan bagaimana output dikonsolidasikan:

**Output dari `ExecuteBash` untuk Iterasi 1**

```
{
	"stdout":"Hello"
}
```

**Output dari `ExecuteBash` untuk Iterasi 2**

```
{
	"stdout":"World"
}
```

**Output dari `ExecuteBash` untuk Langkah**

```
{
	"stdout":"Hello\nWorld"
}
```

Misalnya,, `ExecuteBash``ExecutePowerShell`, dan `ExecuteBinary` merupakan modul tindakan yang kembali `STDOUT` sebagai output modul tindakan. `STDOUT`pesan digabungkan dengan karakter baris baru untuk menghasilkan output keseluruhan dari langkah masuk`detailedOutput.json`.

AWSTOE tidak akan mengkonsolidasikan output dari iterasi yang gagal.