Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Memproses input dan output di Step Functions
**Mengelola status dengan variabel dan JSONata**
Step Functions baru-baru ini menambahkan variabel dan JSONata untuk mengelola status dan mengubah data.
Pelajari lebih lanjut di posting blog [Menyederhanakan pengalaman pengembang dengan variabel dan JSONata ](https://aws.amazon.com/blogs/compute/simplifying-developer-experience-with-variables-and-jsonata-in-aws-step-functions/) di AWS Step Functions
Ketika eksekusi Step Functions menerima input JSON, ia meneruskan data tersebut ke status pertama dalam alur kerja sebagai input.
Dengan JSONata, Anda dapat mengambil input status dari`$states.input`. Eksekusi mesin status Anda juga menyediakan data input awal di file. [Objek konteks](input-output-contextobject.md) Anda dapat mengambil input mesin status asli kapan saja dalam alur kerja Anda. `$states.context.Execution.Input`
*Saat status keluar, outputnya tersedia untuk status berikutnya di mesin negara Anda.* Input status Anda akan melewati sebagai output status secara default, kecuali Anda **memodifikasi** output status. Untuk data yang mungkin Anda perlukan di langkah selanjutnya, pertimbangkan untuk menyimpannya dalam variabel. Untuk info lebih lanjut, lihat[Melewati data antar negara bagian dengan variabel](workflow-variables.md).
**QueryLanguage rekomendasi**
Untuk mesin negara baru, kami merekomendasikan bahasa JSONata kueri. Di mesin status yang tidak menentukan bahasa kueri, mesin status default JSONPath untuk kompatibilitas mundur. Anda harus memilih JSONata untuk menggunakan mesin negara bagian Anda atau masing-masing negara bagian.
**Memproses input dan output dengan JSONata**
Dengan JSONata ekspresi, Anda dapat memilih dan mengubah data. Di `Arguments` bidang, Anda dapat menyesuaikan data yang dikirim ke tindakan. Hasilnya dapat diubah menjadi output status khusus di `Output` lapangan. Anda juga dapat menyimpan data dalam variabel di `Assign` bidang. Untuk info selengkapnya, lihat [Mengubah data dengan JSONata](transforming-data.md).
Diagram berikut menunjukkan bagaimana informasi JSON bergerak melalui status JSONata tugas.
![\[Diagram showing JSONata task state flow with input, arguments, output, and action components.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/vars-jsonata.png)
**Memproses input dan output dengan JSONPath**
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Untuk mesin state yang menggunakan JSONPath, bidang berikut mengontrol aliran data dari state ke state:`InputPath`,`Parameters`,`ResultSelector`,`ResultPath`, dan`OutputPath`. Setiap JSONPath bidang dapat memanipulasi JSON saat bergerak melalui setiap status dalam alur kerja Anda.
JSONPath bidang dapat menggunakan [jalur](amazon-states-language-paths.md) untuk memilih bagian dari JSON dari input atau hasilnya. Sebuah jalur adalah string, dimulai dengan `$`, yang mengidentifikasi simpul dalam teks JSON. Jalur Step Functions menggunakan [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)sintaks.
Diagram berikut menunjukkan bagaimana informasi JSON bergerak melalui status JSONPath tugas. `InputPath`Memilih bagian-bagian dari input JSON untuk diteruskan ke tugas `Task` negara (misalnya, AWS Lambda fungsi). Anda dapat menyesuaikan data yang dikirim ke tindakan Anda di `Parameters` lapangan. Kemudian, dengan`ResultSelector`, Anda dapat memilih bagian dari hasil tindakan untuk diteruskan. `ResultPath`kemudian memilih kombinasi input status dan hasil tugas untuk diteruskan ke output. `OutputPath`dapat memfilter output JSON untuk lebih membatasi informasi yang diteruskan ke output.
![\[Urutan filter: InputPath, Parameter, ResultSelector, ResultPath, dan OutputPath.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/vars-jsonpath.png)
**Topics**
+ [
# Melewati data antar negara bagian dengan variabel
](workflow-variables.md)
+ [
# Mengubah data dengan Step JSONata Functions
](transforming-data.md)
+ [
# Mengakses data eksekusi dari objek Context di Step Functions
](input-output-contextobject.md)
+ [
# Menggunakan JSONPath jalur
](amazon-states-language-paths.md)
+ [
# Memanipulasi parameter dalam alur kerja Step Functions
](input-output-inputpath-params.md)
+ [
# Contoh: Memanipulasi data status dengan jalur di alur kerja Step Functions
](input-output-example.md)
+ [
# Menentukan output status menggunakan Step ResultPath Functions
](input-output-resultpath.md)
+ [
# Memetakan bidang input dan output status di Step Functions
](input-output-fields-dist-map.md)
# Melewati data antar negara bagian dengan variabel
**Mengelola status dengan variabel dan JSONata**
Step Functions baru-baru ini menambahkan variabel dan JSONata untuk mengelola status dan mengubah data.
Pelajari lebih lanjut di posting blog [Menyederhanakan pengalaman pengembang dengan variabel dan JSONata ](https://aws.amazon.com/blogs/compute/simplifying-developer-experience-with-variables-and-jsonata-in-aws-step-functions/) di AWS Step Functions
Video berikut menjelaskan variabel dan JSONata dalam Step Functions dengan contoh DynamoDB:
Dengan variabel dan output status, Anda dapat meneruskan data di antara langkah-langkah alur kerja Anda.
Dengan menggunakan variabel alur kerja, Anda dapat menyimpan data dalam satu langkah dan mengambil data tersebut di langkah masa depan. Misalnya, Anda dapat menyimpan respons API yang berisi data yang mungkin Anda perlukan nanti. Sebaliknya, output status hanya dapat digunakan sebagai masukan ke langkah berikutnya.
## Tinjauan konseptual variabel
Dengan variabel alur kerja, Anda dapat menyimpan data untuk referensi nanti. Misalnya, Langkah 1 mungkin menyimpan hasil dari permintaan API sehingga bagian dari permintaan itu dapat digunakan kembali nanti di Langkah 5.
Dalam skenario berikut, mesin status mengambil data dari API sekali. Pada Langkah 1, alur kerja menyimpan data API yang dikembalikan (hingga 256 KiB per status) dalam variabel 'x' untuk digunakan dalam langkah selanjutnya.
Tanpa variabel, Anda harus meneruskan data melalui output dari Langkah 1 ke Langkah 2 ke Langkah 3 ke Langkah 4 untuk menggunakannya di Langkah 5. Bagaimana jika langkah-langkah perantara itu tidak membutuhkan data? Meneruskan data dari negara ke negara melalui output dan input akan menjadi upaya yang tidak perlu.
Dengan variabel, Anda dapat menyimpan data dan menggunakannya di setiap langkah masa depan. Anda juga dapat memodifikasi, mengatur ulang, atau menambahkan langkah-langkah tanpa mengganggu aliran data Anda. Mengingat fleksibilitas variabel, Anda mungkin hanya perlu menggunakan **Output** untuk mengembalikan data dari sub-alur kerja Paralel dan Peta, dan di akhir eksekusi mesin status Anda.
![\[Diagram showing step 1 assigning a value to $x, used in step 5.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/vars-diag-opt1.png)
**Menyatakan yang mendukung variabel**
Jenis status berikut mendukung `Assign` untuk mendeklarasikan dan menetapkan nilai ke variabel: *Lulus, Tugas, Peta, Paralel, Pilihan, Tunggu*.
Untuk mengatur variabel, berikan objek JSON dengan nama dan nilai variabel:
```
"Assign": {
"productName": "product1",
"count" : 42,
"available" : true
}
```
Untuk mereferensikan variabel, tambahkan nama dengan tanda dolar (`$`), misalnya,. `$productName`
## Variabel yang dicadangkan: \$1 negara
Step Functions mendefinisikan variabel cadangan tunggal yang disebut **`$states`**. Di JSONata negara bagian, struktur berikut ditugaskan `$states` untuk digunakan dalam JSONata ekspresi:
```
# Reserved $states variable in JSONata states
$states = {
"input": // Original input to the state
"result": // API or sub-workflow's result (if successful)
"errorOutput": // Error Output (only available in a Catch)
"context": // Context object
}
```
Pada entri status, Step Functions menetapkan input status ke **`$states.input`**. Nilai `$states.input` dapat digunakan di semua bidang yang menerima JSONata ekspresi. `$states.input`selalu mengacu pada input status asli.
Untuk`Task`,`Parallel`, dan `Map` menyatakan:
+ **`$states.result`**mengacu pada hasil mentah API atau sub-alur kerja jika berhasil.
+ **`$states.errorOutput`**mengacu pada Output Kesalahan jika API atau sub-alur kerja gagal.
`$states.errorOutput`dapat digunakan di `Catch` lapangan `Assign` atau`Output`.
Mencoba mengakses `$states.result` atau `$states.errorOutput` di bidang dan status di mana mereka tidak dapat diakses akan tertangkap saat pembuatan, pembaruan, atau validasi mesin status.
`$states.context`Objek memberikan informasi alur kerja Anda tentang eksekusi spesifik mereka, seperti, token tugas`StartTime`, dan input alur kerja awal. Untuk mempelajari selengkapnya, lihat [Mengakses data eksekusi dari objek Context di Step Functions](input-output-contextobject.md).
## Sintaks nama variabel
Nama variabel mengikuti aturan untuk Pengidentifikasi Unicode seperti yang dijelaskan dalam [Unicode® Standard](https://unicode.org/reports/tr31/) Annex \$131. Karakter pertama dari nama variabel harus karakter Unicode ID\$1Start, dan karakter kedua dan selanjutnya harus karakter Unicode ID\$1continue. Panjang maksimum nama variabel adalah 80.
Konvensi nama variabel mirip dengan aturan untuk JavaScript dan bahasa pemrograman lainnya.
## Lingkup variabel
Alur kerja Step Functions menghindari kondisi balapan dengan variabel dengan menggunakan lingkup *workflow-local*.
Lingkup workflow-local mencakup semua status di dalam bidang States mesin status, tetapi tidak **status** di dalam status Paralel atau Peta. Status di dalam status Paralel atau Peta dapat merujuk ke variabel lingkup luar, tetapi mereka membuat dan memelihara variabel dan nilai alur kerja-lokal mereka sendiri yang terpisah.
`Parallel`cabang dan `Map` iterasi dapat mengakses nilai variabel dari **lingkup luar**, tetapi mereka tidak memiliki akses ke nilai variabel dari cabang atau iterasi bersamaan lainnya. Saat menangani kesalahan, `Assign` bidang dalam a `Catch` dapat menetapkan nilai ke variabel di lingkup luar, yaitu ruang lingkup di mana Parallel/Map status ada.
Pengecualian: **Status Peta Terdistribusi** saat ini tidak dapat mereferensikan variabel di lingkup luar.
Variabel ada dalam lingkup jika ada negara bagian dalam lingkup yang memberikan nilai padanya. Untuk membantu menghindari kesalahan umum, variabel yang ditetapkan dalam lingkup dalam tidak dapat memiliki nama yang sama dengan yang ditetapkan dalam lingkup luar. Misalnya, jika lingkup tingkat atas memberikan nilai ke variabel yang dipanggil`myVariable`, maka tidak ada lingkup lain (di dalam`Map`,`Parallel`) yang dapat menetapkan juga. `myVariable`
Akses ke variabel tergantung pada ruang lingkup saat ini. Status Paralel dan Peta memiliki cakupannya sendiri, tetapi dapat mengakses variabel dalam lingkup luar.
Ketika status Paralel atau Peta selesai, semua variabelnya akan keluar dari cakupan dan berhenti dapat diakses. Gunakan **bidang Output** untuk meneruskan data dari cabang Paralel dan iterasi Peta.
## Tetapkan bidang di ASL
`Assign`Bidang di ASL digunakan untuk menetapkan nilai ke satu atau lebih variabel. `Assign`Bidang ini tersedia di tingkat atas setiap negara bagian (kecuali `Succeed` dan`Fail`), di dalam aturan `Choice` negara bagian, dan di dalam `Catch` bidang. Misalnya:
```
# Example of Assign with JSONata
"Store inputs": {
"Type": "Pass",
"Next": "Get Current Price",
"Comment": "Store the input desired price into a variable: $desiredPrice",
"Assign": {
"desiredPrice": "{% $states.input.desired_price %}",
"maximumWait": "{% $states.input.max_days %}"
}
},
```
`Assign`Bidang mengambil objek JSON. Setiap bidang tingkat atas memberi nama variabel untuk ditetapkan. Pada contoh sebelumnya, nama variabel adalah `desiredPrice` dan`maximumWait`. Saat menggunakan JSONata, `{% ... %}` menunjukkan JSONata ekspresi yang mungkin berisi variabel atau ekspresi yang lebih kompleks. Untuk informasi lebih lanjut tentang JSONata ekspresi, lihat [JSONatadokumentasi.org](https://docs.jsonata.org/overview.html).
Saat menggunakan **JSONata**sebagai bahasa query, diagram berikut menunjukkan bagaimana bidang **Assign** dan **Output** diproses secara paralel. Perhatikan implikasinya: *menetapkan nilai variabel tidak akan mempengaruhi keadaan* Output.
![\[Diagram showing a comparison of JSONPath and JSONata flow.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/vars-jsonata.png)
JSONata Contoh berikut mengambil `order.product` dari input status. Variabel `currentPrice` diatur ke nilai dari hasil tugas.
```
# Example of Task with JSONata assignment from result
{
"Type": "Task",
...
"Assign": {
"product": "{% $states.input.order.product %}",
"currentPrice": "{% $states.result.Payload.current_price %}"
},
"Next": "the next state"
}
```
Catatan: Anda **tidak dapat** menetapkan nilai ke bagian dari variabel. Misalnya, Anda bisa`"Assign":{"x":42}`, tetapi Anda tidak bisa `"Assign":{"x.y":42}` atau`"Assign":{"x[2]":42}`.
## Urutan evaluasi di bidang penetapan
Semua referensi variabel dalam status Step Functions menggunakan nilai seperti pada **entri status**.
Fakta sebelumnya penting untuk memahami bagaimana `Assign` bidang memberikan nilai ke satu atau lebih variabel. Pertama, nilai baru dihitung, kemudian Step Functions menetapkan nilai baru ke variabel. Nilai variabel baru akan tersedia dimulai dengan status **berikutnya**. Misalnya, perhatikan `Assign` bidang berikut:
```
# Starting values: $x=3, $a=6
"Assign": {
"x": "{% $a %}",
"nextX": "{% $x %}"
}
# Ending values: $x=6, $nextX=3
```
Dalam contoh sebelumnya, variabel ditugaskan dan `x` direferensikan.
Ingat, semua ekspresi ***dievaluasi terlebih dahulu***, kemudian tugas dibuat. Dan nilai yang baru ditetapkan akan tersedia di negara bagian **berikutnya**.
Mari kita lihat contoh secara rinci. Asumsikan bahwa dalam keadaan sebelumnya, `$x` diberi nilai tiga (3) dan `$a` diberi nilai enam (6). Langkah-langkah berikut menjelaskan proses:
1. Semua ekspresi dievaluasi, menggunakan nilai **saat ini** dari semua variabel.
Ekspresi `"{% $a %}"` akan mengevaluasi ke 6, dan `"{% $x %}"` akan mengevaluasi ke 3.
1. Selanjutnya, tugas dibuat:
`$x`akan diberi nilai enam (6)
`$nextX`akan diberikan tiga (3)
Catatan: Jika `$x` sebelumnya tidak ditetapkan, contoh akan **gagal** karena `$x` *tidak terdefinisi*.
Singkatnya, Step Functions mengevaluasi **semua** ekspresi dan kemudian membuat tugas. Urutan terjadinya variabel di `Assign` lapangan **tidak** masalah.
## Batas
Ukuran maksimum variabel tunggal adalah 256Kib, untuk alur kerja Standar dan Ekspres.
Ukuran gabungan maksimum untuk semua variabel dalam satu `Assign` bidang juga 256Kib. Misalnya, Anda dapat menetapkan X dan Y ke 128KiB, tetapi Anda tidak dapat menetapkan X dan Y ke 256KiB di bidang yang sama. `Assign`
Ukuran total semua variabel yang disimpan tidak dapat melebihi 10MiB per eksekusi.
## Menggunakan variabel di JSONPath negara bagian
Variabel juga tersedia di negara bagian yang digunakan JSONPath untuk bahasa kueri mereka.
Anda dapat mereferensikan variabel di bidang apa pun yang menerima JSONpath ekspresi (`$.`atau `$$.` sintaks), dengan pengecualian`ResultPath`, yang menentukan lokasi dalam input status untuk menyuntikkan hasil status. Variabel tidak dapat digunakan dalam`ResultPath`.
Dalam JSONPath, `$` simbol mengacu pada nilai 'saat ini' dan `$$` mewakili status objek Konteks. JSONPath ekspresi dapat dimulai dengan `$.` as in`$.customer.name`. Anda dapat mengakses konteks dengan `$$.` as in`$$.Execution.Id`.
Untuk referensi variabel, Anda juga menggunakan `$` simbol sebelum nama variabel, misalnya, `$x` atau`$order.numItems`.
Di ** JSONPath**bidang yang menerima fungsi intrinsik, variabel dapat digunakan dalam argumen, misalnya. `States.Format('The order number is {}', $order.number)`
Digram berikut menggambarkan bagaimana langkah penetapan dalam **JSONPath**tugas terjadi pada saat yang sama dengan: ResultSelector
![\[Logical diagram of a state that uses JSONPath query language.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/vars-jsonpath.png)
**Menetapkan variabel di JSONPath**
JSONPath tugas variabel berperilaku mirip dengan template payload. Bidang yang diakhiri dengan `.$` menunjukkan nilai adalah JSONPath ekspresi yang dievaluasi Step Functions ke nilai selama eksekusi mesin status (misalnya: `$.order..product` dan`$.order.total`).
```
# Example of Assign with JSONPath
{
"Type": "Task",
...
"Assign": {
"products.$": "$.order..product",
"orderTotal.$": "$.order.total"
},
"Next": "the next state"
}
```
Untuk JSONPath negara bagian, nilai `$` dalam `Assign` bidang tergantung pada jenis status. Dalam `Task,``Map`, `Parallel` menyatakan, `$` mengacu pada hasil API/Sub-alur kerja. In `Choice` and `Wait` state, `$` mengacu pada *input efektif*, yang merupakan nilai `InputPath` setelah diterapkan pada input status. Untuk`Pass`, `$` mengacu pada hasil, apakah yang dihasilkan oleh `Result` bidang atau `Parameters` bidang`InputPath`/.
JSONPath Contoh berikut menetapkan objek JSON ke `details` variabel, hasil JSONPath ekspresi `$.result.code` ke`resultCode`, dan hasil JSONPath ekspresi `States.Format('Hello {}', $customer.name)` untuk. `message` Jika ini dalam `Task` keadaan, maka `$` masuk `$.order.items` dan `$.result.code` mengacu pada hasil API. `startTime`Variabel diberikan dengan nilai dari objek Context,`$$.Execution.StartTime`.
```
"Assign": {
"details": {
"status": "SUCCESS",
"lineItems.$": "$.order.items"
},
"resultCode.$": "$.result.code",
"message.$": "States.Format('Hello {}', $customer.name)",
"startTime.$": "$$.Execution.StartTime"
}
```
# Mengubah data dengan Step JSONata Functions
Dengan JSONata, Anda mendapatkan kueri open source dan bahasa ekspresi yang kuat untuk **memilih** dan **mengubah** data dalam alur kerja Anda. Untuk pengantar singkat dan JSONata referensi lengkap, lihat [JSONatadokumentasi.org](https://docs.jsonata.org/overview.html).
**JSONata Versi yang didukung**
Step Functions mendukung JSONata versi 2.0.6.
Video berikut menjelaskan variabel dan JSONata dalam Step Functions dengan contoh DynamoDB:
Anda harus memilih untuk menggunakan bahasa JSONata kueri dan transformasi untuk alur kerja yang ada. Saat membuat alur kerja di konsol, kami sarankan memilih JSONata untuk mesin status tingkat atas. `QueryLanguage` Untuk alur kerja yang ada atau baru yang digunakan JSONPath, konsol menyediakan opsi untuk mengonversi status individual menjadi JSONata.
Setelah memilih JSONata, bidang alur kerja Anda akan dikurangi dari lima JSONPath bidang (`InputPath`,,`Parameters`, `ResultSelector``ResultPath`, dan`OutputPath`) menjadi hanya dua bidang: `Arguments` dan`Output`. Juga, Anda **tidak** akan menggunakan `.$` pada nama kunci objek JSON.
Jika Anda baru mengenal Step Functions, Anda hanya perlu tahu bahwa JSONata ekspresi menggunakan sintaks berikut:
**JSONata sintaks:** `"{% %}"`
Contoh kode berikut menunjukkan konversi dari JSONPath ke JSONata:
```
# Original sample using JSONPath
{
"QueryLanguage": "JSONPath", // Set explicitly; could be set and inherited from top-level
"Type": "Task",
...
"Parameters": {
"static": "Hello",
"title.$": "$.title",
"name.$": "$customerName", // With $customerName declared as a variable
"not-evaluated": "$customerName"
}
}
```
```
# Sample after conversion to JSONata
{
"QueryLanguage": "JSONata", // Set explicitly; could be set and inherited from top-level
"Type": "Task",
...
"Arguments": { // JSONata states do not have Parameters
"static": "Hello",
"title": "{% $states.input.title %}",
"name": "{% $customerName %}", // With $customerName declared as a variable
"not-evaluated": "$customerName"
}
}
```
Diberikan input `{ "title" : "Doctor" }` dan variabel yang `customerName` ditugaskan ke`"María"`, kedua mesin status akan menghasilkan hasil JSON berikut:
```
{
"static": "Hello",
"title": "Doctor",
"name": "María",
"not-evaluated": "$customerName"
}
```
Pada diagram berikutnya, Anda dapat melihat representasi grafis yang menunjukkan bagaimana mengonversi JSONPath (kiri) ke JSONata (kanan) akan mengurangi kompleksitas langkah-langkah di mesin status Anda:
![\[Diagram yang membandingkan bidang di JSONPath dan JSONata negara bagian.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/compare-jsonpath-jsonata.png)
Anda dapat (opsional) memilih dan mengubah data dari input status menjadi **Argumen** untuk dikirim ke tindakan terintegrasi Anda. **Dengan JSONata, Anda kemudian dapat (opsional) memilih dan mengubah **hasil** dari tindakan untuk menetapkan ke variabel dan untuk Output status.**
Catatan: Langkah **penetapan** dan **Output** terjadi **secara paralel**. Jika Anda memilih untuk mengubah data selama penetapan variabel, data yang diubah itu **tidak** akan tersedia di langkah Output. Anda harus menerapkan kembali JSONata transformasi dalam langkah Output.
![\[Diagram logis dari keadaan yang menggunakan bahasa JSONata kueri.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/vars-jsonata.png)
## QueryLanguage lapangan
Dalam definisi ASL alur kerja Anda, ada `QueryLanguage` bidang di tingkat atas definisi mesin negara dan di masing-masing negara bagian. Dengan menyetel `QueryLanguage` di dalam masing-masing status, Anda dapat secara bertahap mengadopsi JSONata di mesin status yang ada daripada memutakhirkan mesin status sekaligus.
`QueryLanguage`Bidang dapat diatur ke `"JSONPath"` atau`"JSONata"`. Jika `QueryLanguage` bidang tingkat atas dihilangkan, defaultnya adalah. `"JSONPath"` Jika status berisi `QueryLanguage` bidang tingkat status, Step Functions akan menggunakan bahasa kueri yang ditentukan untuk status tersebut. Jika negara tidak berisi `QueryLanguage` bidang, maka itu akan menggunakan bahasa kueri yang ditentukan di `QueryLanguage` bidang tingkat atas.
## Menulis JSONata ekspresi dalam string JSON
Ketika string dalam nilai bidang ASL, bidang objek JSON, atau elemen array JSON dikelilingi oleh `{% %}` karakter, string itu akan dievaluasi sebagai. JSONata Catatan, string harus dimulai `{%` dengan tanpa spasi utama, dan harus `%}` diakhiri tanpa spasi tambahan. Membuka atau menutup ekspresi dengan tidak benar akan menghasilkan kesalahan validasi.
Beberapa contoh:
+ `"TimeoutSeconds" : "{% $timeout %}"`
+ `"Arguments" : {"field1" : "{% $name %}"}`dalam suatu `Task` negara
+ `"Items": [1, "{% $two %}", 3]`dalam suatu `Map` negara
Tidak semua bidang ASL menerima JSONata. Misalnya, setiap `Type` bidang status harus disetel ke string konstan. Demikian pula, `Resource` bidang `Task` negara harus berupa string konstan. `Items`Bidang `Map` status akan menerima array JSON, objek JSON, atau JSONata ekspresi yang harus mengevaluasi ke array atau objek.
## Variabel yang dicadangkan: \$1 negara
Step Functions mendefinisikan variabel cadangan tunggal yang disebut **`$states`**. Di JSONata negara bagian, struktur berikut ditugaskan `$states` untuk digunakan dalam JSONata ekspresi:
```
# Reserved $states variable in JSONata states
$states = {
"input": // Original input to the state
"result": // API or sub-workflow's result (if successful)
"errorOutput": // Error Output (only available in a Catch)
"context": // Context object
}
```
Pada entri status, Step Functions menetapkan masukan status ke **`$states.input`**. Nilai `$states.input` dapat digunakan di semua bidang yang menerima JSONata ekspresi. `$states.input`selalu mengacu pada input status asli.
Untuk`Task`,`Parallel`, dan `Map` menyatakan:
+ **`$states.result`**mengacu pada hasil mentah API atau sub-alur kerja jika berhasil.
+ **`$states.errorOutput`**mengacu pada Output Kesalahan jika API atau sub-alur kerja gagal.
`$states.errorOutput`dapat digunakan di `Catch` lapangan `Assign` atau`Output`.
Mencoba mengakses `$states.result` atau `$states.errorOutput` di bidang dan status di mana mereka tidak dapat diakses akan tertangkap saat pembuatan, pembaruan, atau validasi mesin status.
`$states.context`Objek memberikan informasi alur kerja Anda tentang eksekusi spesifik mereka, seperti, token tugas`StartTime`, dan input alur kerja awal. Untuk mempelajari lebih lanjut, lihat[Mengakses data eksekusi dari objek Context di Step Functions](input-output-contextobject.md).
## Menangani kesalahan ekspresi
Saat runtime, evaluasi JSONata ekspresi mungkin gagal karena berbagai alasan, seperti:
+ **Jenis kesalahan** - Ekspresi, seperti`{% $x + $y %}`, akan gagal jika `$x` atau `$y` bukan angka.
+ **Ketidakcocokan tipe** - Ekspresi mungkin mengevaluasi tipe yang tidak akan diterima bidang. Misalnya, bidang `TimeoutSeconds` membutuhkan input numerik, sehingga ekspresi `{% $timeout %}` akan gagal jika `$timeout` mengembalikan string.
+ **Nilai di luar jangkauan** - Ekspresi yang menghasilkan nilai yang berada di luar rentang yang dapat diterima untuk suatu bidang akan gagal. Misalnya, ekspresi seperti `{% $evaluatesToNegativeNumber %}` akan gagal di `TimeoutSeconds` lapangan.
+ **Kegagalan untuk mengembalikan hasil** - JSON tidak dapat mewakili ekspresi nilai yang tidak ditentukan, sehingga ekspresi `{% $data.thisFieldDoesNotExist %}` akan menghasilkan kesalahan.
Dalam setiap kasus, penerjemah akan melempar kesalahan:`States.QueryEvaluationError`. Status Tugas, Peta, dan Paralel Anda dapat menyediakan `Catch` bidang untuk menangkap kesalahan, dan `Retry` bidang untuk mencoba lagi kesalahan tersebut.
## Konversi dari ke JSONPath JSONata
Bagian berikut membandingkan dan menjelaskan perbedaan antara kode yang ditulis dengan JSONPath dan JSONata.
### Tidak ada lagi bidang jalur
ASL mengharuskan pengembang menggunakan `Path` versi bidang, seperti dalam`TimeoutSecondsPath`, untuk memilih nilai dari data status saat menggunakan JSONPath. Saat Anda menggunakan JSONata, Anda tidak lagi menggunakan `Path` bidang karena ASL akan menafsirkan JSONata ekspresi `{% %}` -tertutup secara otomatis untuk Anda di bidang non-Path, seperti. `TimeoutSeconds`
+ JSONPath contoh warisan: `"TimeoutSecondsPath": "$timeout"`
+ JSONata : `"TimeoutSeconds": "{% $timeout %}"`
Demikian pula, `Map` keadaan `ItemsPath` telah diganti dengan `Items` bidang yang menerima array JSON, objek JSON, atau JSONata ekspresi yang harus mengevaluasi ke array atau objek.
### Objek JSON
ASL menggunakan istilah *template payload* untuk menggambarkan objek JSON yang dapat berisi JSONPath ekspresi untuk `Parameters` dan `ResultSelector` nilai bidang. ASL tidak akan menggunakan istilah template payload JSONata karena JSONata evaluasi terjadi untuk semua string apakah itu terjadi sendiri atau di dalam objek JSON atau array JSON.
### Tidak ada lagi. \$1
ASL mengharuskan Anda untuk menambahkan '`.$`' ke nama bidang di template payload untuk digunakan JSONPath dan Fungsi Intrinsik. Saat Anda menentukan`"QueryLanguage":"JSONata"`, Anda tidak lagi menggunakan konvensi '`.$`' untuk nama bidang objek JSON. Sebaliknya, Anda melampirkan JSONata ekspresi dalam `{% %}` karakter. Anda menggunakan konvensi yang sama untuk semua bidang bernilai string, terlepas dari seberapa dalam objek tersebut bersarang di dalam array atau objek lain.
### Argumen dan Bidang Output
Ketika `QueryLanguage` diatur ke`JSONata`, bidang I/O pemrosesan lama akan dinonaktifkan (`InputPath`,, `Parameters``ResultSelector`, `ResultPath` dan`OutputPath`) dan sebagian besar negara bagian akan mendapatkan dua bidang baru: `Arguments` dan`Output`.
JSONata menyediakan cara yang lebih sederhana untuk melakukan I/O transformasi dibandingkan dengan bidang yang digunakan. JSONPath JSONatafitur membuat `Arguments` dan `Output` lebih mampu daripada lima bidang sebelumnya dengan JSONPath. Nama bidang baru ini juga membantu menyederhanakan ASL Anda dan memperjelas model untuk meneruskan dan mengembalikan nilai.
`Output`Bidang `Arguments` and (dan bidang serupa lainnya seperti `Map` state`ItemSelector`) akan menerima objek JSON seperti:
```
"Arguments": {
"field1": 42,
"field2": "{% jsonata expression %}"
}
```
Atau, Anda dapat menggunakan JSONata ekspresi secara langsung, misalnya:
```
"Output": "{% jsonata expression %}"
```
Output juga dapat menerima semua jenis nilai JSON juga, misalnya:`"Output":true`,`"Output":42`.
`Output`Bidang `Arguments` dan hanya mendukung JSONata, jadi tidak valid untuk menggunakannya dengan alur kerja yang digunakan. JSONPath Sebaliknya,,`InputPath`,`Parameters`, `ResultSelector` `ResultPath``OutputPath`, dan JSONPath bidang lainnya hanya didukung di JSONPath, jadi tidak valid untuk menggunakan bidang berbasis jalur saat menggunakan JSONata sebagai alur kerja tingkat atas atau bahasa kueri status Anda.
### Status Lulus
**Hasil** opsional dalam status Pass sebelumnya diperlakukan sebagai *output* dari tugas virtual. Dengan JSONata dipilih sebagai alur kerja atau bahasa kueri status, Anda sekarang dapat menggunakan bidang **Output** baru.
### Negara pilihan
Saat menggunakan JSONPath, status pilihan memiliki input `Variable` dan banyak jalur perbandingan, seperti berikut ini`NumericLessThanEqualsPath`:
```
# JSONPath choice state sample, with Variable and comparison path
"Check Price": {
"Type": "Choice",
"Default": "Pause",
"Choices": [
{
"Variable": "$.current_price.current_price",
"NumericLessThanEqualsPath": "$.desired_price",
"Next": "Send Notification"
} ],
}
```
Dengan JSONata, status pilihan memiliki `Condition` tempat Anda dapat menggunakan JSONata ekspresi:
```
# Choice state after JSONata conversion
"Check Price": {
"Type": "Choice",
"Default": "Pause"
"Choices": [
{
"Condition": "{% $current_price <= $states.input.desired_priced %}",
"Next": "Send Notification"
} ]
```
Catatan: Variabel dan bidang perbandingan hanya tersedia untuk JSONPath. Kondisi hanya tersedia untuk JSONata.
## JSONata contoh
Contoh berikut dapat dibuat di Workflow Studio untuk bereksperimen JSONata. Anda dapat membuat dan menjalankan mesin status, atau menggunakan **status Uji** untuk meneruskan data dan bahkan memodifikasi definisi mesin status.
### Contoh: Input dan Output
Contoh ini menunjukkan `$states.input` cara menggunakan input status dan `Output` bidang untuk menentukan output status saat Anda memilih JSONata.
```
{
"Comment": "Input and Output example using JSONata",
"QueryLanguage": "JSONata",
"StartAt": "Basic Input and Output",
"States": {
"Basic Input and Output": {
"QueryLanguage": "JSONata",
"Type": "Succeed",
"Output": {
"lastName": "{% 'Last=>' & $states.input.customer.lastName %}",
"orderValue": "{% $states.input.order.total %}"
}
}
}
}
```
Ketika alur kerja dijalankan dengan berikut sebagai input:
```
{
"customer": {
"firstName": "Martha",
"lastName": "Rivera"
},
"order": {
"items": 7,
"total": 27.91
}
}
```
Uji status atau eksekusi mesin status akan mengembalikan output JSON berikut:
```
{
"lastName": "Last=>Rivera",
"orderValue": 27.91
}
```
![\[Screenshot yang menampilkan input dan output dari status yang sedang diuji.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/jsonata-basic-io.png)
### Contoh: Memfilter dengan JSONata
Anda dapat memfilter data Anda dengan [operator JSONata Path](https://docs.jsonata.org/path-operators). Misalnya, bayangkan Anda memiliki daftar produk untuk input, dan Anda hanya ingin memproses produk yang mengandung nol kalori. Anda dapat membuat definisi mesin status dengan ASL berikut dan menguji `FilterDietProducts` status dengan masukan sampel berikut.
**Definisi mesin negara untuk penyaringan dengan JSONata**
```
{
"Comment": "Filter products using JSONata",
"QueryLanguage": "JSONata",
"StartAt": "FilterDietProducts",
"States": {
"FilterDietProducts": {
"Type": "Pass",
"Output": {
"dietProducts": "{% $states.input.products[calories=0] %}"
},
"End": true
}
}
}
```
**Masukan sampel untuk pengujian**
```
{
"products": [
{
"calories": 140,
"flavour": "Cola",
"name": "Product-1"
},
{
"calories": 0,
"flavour": "Cola",
"name": "Product-2"
},
{
"calories": 160,
"flavour": "Orange",
"name": "Product-3"
},
{
"calories": 100,
"flavour": "Orange",
"name": "Product-4"
},
{
"calories": 0,
"flavour": "Lime",
"name": "Product-5"
}
]
}
```
**Keluaran dari pengujian langkah di mesin negara Anda**
```
{
"dietProducts": [
{
"calories": 0,
"flavour": "Cola",
"name": "Product-2"
},
{
"calories": 0,
"flavour": "Lime",
"name": "Product-5"
}
]
}
```
![\[Contoh output untuk JSONata ekspresi yang sedang diuji.\]](http://docs.aws.amazon.com/id_id/step-functions/latest/dg/images/test-state-jsonata.png)
## JSONata fungsi yang disediakan oleh Step Functions
JSONata berisi pustaka fungsi untuk fungsi String, Numerik, Agregasi, Boolean, Array, Objek, Tanggal/Waktu, dan Urutan Tinggi. Step Functions menyediakan JSONata fungsi tambahan yang dapat Anda gunakan dalam JSONata ekspresi Anda. Fungsi bawaan ini berfungsi sebagai pengganti fungsi intrinsik Step Functions. Fungsi intrinsik hanya tersedia di negara bagian yang menggunakan bahasa JSONPath kueri.
Catatan: JSONata Fungsi bawaan yang memerlukan nilai integer sebagai parameter akan secara otomatis membulatkan nomor non-integer yang disediakan.
**\$1partition -** JSONata setara dengan fungsi `States.ArrayPartition` intrinsik untuk mempartisi array besar.
Parameter pertama adalah array untuk partisi, parameter kedua adalah integer yang mewakili ukuran potongan. Nilai kembali akan menjadi array dua dimensi. Interpreter memotong array input menjadi beberapa array dari ukuran yang ditentukan oleh ukuran chunk. Panjang potongan array terakhir mungkin kurang dari panjang potongan array sebelumnya jika jumlah item yang tersisa dalam array lebih kecil dari ukuran potongan.
```
"Assign": {
"arrayPartition": "{% $partition([1,2,3,4], $states.input.chunkSize) %}"
}
```
**\$1range** - JSONata setara dengan fungsi `States.ArrayRange` intrinsik untuk menghasilkan array nilai.
Fungsi ini membutuhkan tiga argumen. Argumen pertama adalah integer yang mewakili elemen pertama dari array baru, argumen kedua adalah integer yang mewakili elemen akhir dari array baru, dan argumen ketiga adalah bilangan bulat nilai delta untuk elemen dalam array baru. Nilai kembali adalah larik nilai yang baru dihasilkan mulai dari argumen pertama fungsi hingga argumen kedua fungsi dengan elemen di antaranya disesuaikan dengan delta. Nilai delta bisa positif atau negatif yang akan menambah atau mengurangi setiap elemen dari yang terakhir sampai nilai akhir tercapai atau terlampaui.
```
"Assign": {
"arrayRange": "{% $range(0, 10, 2) %}"
}
```
**\$1hash** - JSONata setara dengan fungsi `States.Hash` intrinsik untuk menghitung nilai hash dari input yang diberikan.
Fungsi ini membutuhkan dua argumen. Argumen pertama adalah string sumber yang akan di-hash. Argumen kedua adalah string yang mewakili algoritma hashing untuk perhitungan hash. Algoritma hashing harus menjadi salah satu dari nilai berikut:`"MD5"`,,`"SHA-1"`, `"SHA-256"``"SHA-384"`,`"SHA-512"`. Nilai kembali adalah string dari hash yang dihitung dari data.
Fungsi ini dibuat karena JSONata tidak secara native mendukung kemampuan untuk menghitung hash.
```
"Assign": {
"myHash": "{% $hash($states.input.content, $hashAlgorithmName) %}"
}
```
**\$1random** - JSONata setara dengan fungsi `States.MathRandom` intrinsik untuk mengembalikan angka acak n dimana. `0 ≤ n < 1`
Fungsi ini mengambil argumen integer *opsional* yang mewakili nilai seed dari fungsi acak. Jika Anda menggunakan fungsi ini dengan nilai seed yang sama, ia mengembalikan angka yang identik.
Fungsi kelebihan beban ini dibuat karena JSONata fungsi bawaan [https://docs.jsonata.org/numeric-functions#random](https://docs.jsonata.org/numeric-functions#random)tidak menerima nilai seed.
```
"Assign": {
"randNoSeed": "{% $random() %}",
"randSeeded": "{% $random($states.input.seed) %}"
}
```
**\$1uuid** - JSONata versi fungsi intrinsik. `States.UUID`
Fungsi ini tidak membutuhkan argumen. Fungsi ini mengembalikan UUID v4.
Fungsi ini dibuat karena JSONata tidak secara native mendukung kemampuan untuk menghasilkan UUIDs.
```
"Assign": {
"uniqueId": "{% $uuid() %}"
}
```
**\$1parse** - JSONata berfungsi untuk deserialisasi string JSON.
Fungsi ini mengambil JSON stringified sebagai satu-satunya argumen.
JSONata mendukung fungsi ini melalui`$eval`; Namun, tidak `$eval` didukung dalam alur kerja Step Functions.
```
"Assign": {
"deserializedPayload": "{% $parse($states.input.json_string) %}"
}
```
# Mengakses data eksekusi dari objek Context di Step Functions
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Objek Context adalah struktur JSON internal yang tersedia selama eksekusi, dan berisi informasi tentang mesin dan eksekusi status Anda. Konteks memberikan informasi alur kerja Anda tentang eksekusi spesifiknya. Alur kerja Anda dapat mereferensikan objek Context dalam JSONata ekspresi dengan`$states.context`.
## Mengakses objek Context
**Untuk mengakses objek Context di JSONata**
Untuk mengakses objek Context dalam JSONata status, gunakan `$states.context` dalam JSONata ekspresi.
```
{
"ExecutionID" : "{% $states.context.Execution.Id %}"
}
```
**Untuk mengakses objek Context di JSONPath**
Untuk mengakses objek Context di JSONPath, pertama-tama Anda menambahkan `.$` ke akhir kunci untuk menunjukkan nilainya adalah jalur. Kemudian, tambahkan nilai dengan `$$.` untuk memilih node di objek Context.
```
{
"ExecutionID.$": "$$.Execution.Id"
}
```
JSONPath negara dapat merujuk ke konteks (`$$.`) dari JSONPath bidang-bidang berikut:
+ `InputPath`
+ `OutputPath`
+ `ItemsPath` (di status Peta)
+ `Variable` (di status Pilihan)
+ `ResultSelector`
+ `Parameters`
+ Operator perbandingan variabel ke variabel
## Bidang objek konteks
Objek Context mencakup informasi tentang state machine, state, execution, dan task. Objek Context JSON mencakup node untuk setiap jenis data dalam format berikut:
```
{
"Execution": {
"Id": "String",
"Input": {},
"Name": "String",
"RoleArn": "String",
"StartTime": "Format: ISO 8601",
"RedriveCount": Number,
"RedriveTime": "Format: ISO 8601"
},
"State": {
"EnteredTime": "Format: ISO 8601",
"Name": "String",
"RetryCount": Number
},
"StateMachine": {
"Id": "String",
"Name": "String"
},
"Task": {
"Token": "String"
}
}
```
Selama eksekusi, objek Context diisi dengan data yang relevan.
Kadang-kadang, bidang baru ditambahkan ke konteks. Jika Anda memproses konteks JSON secara langsung, kami sarankan membuat kode yang dapat menangani bidang baru yang tidak dikenal dengan anggun. Misalnya, jika menggunakan pustaka Jackson untuk unmarshalling JSON, sebaiknya setel `FAIL_ON_UNKNOWN_PROPERTIES` ke `false` in your `ObjectMapper` untuk mencegah file. `UnrecognizedPropertyException`
`RedriveTime`Objek konteks hanya tersedia jika Anda redriven memiliki eksekusi. Jika sudah [redriven a Map Run](redrive-map-run.md), objek `RedriveTime` konteks hanya tersedia untuk alur kerja anak dari tipe Standard. Untuk redriven Map Run dengan alur kerja turunan tipe Express, `RedriveTime` tidak tersedia.
Konten dari eksekusi yang sedang berjalan mencakup spesifikasi dalam format berikut:
```
{
"Execution": {
"Id": "arn:aws:states:region:123456789012:execution:stateMachineName:executionName",
"Input": {
"key": "value"
},
"Name": "executionName",
"RoleArn": "arn:aws:iam::123456789012:role...",
"StartTime": "2025-08-27T10:04:42Z"
},
"State": {
"EnteredTime": "2025-08-27T10:04:42.001Z",
"Name": "Test",
"RetryCount": 3
},
"StateMachine": {
"Id": "arn:aws:states:region:123456789012:stateMachine:stateMachineName",
"Name": "stateMachineName"
},
"Task": {
"Token": "h7XRiCdLtd/83p1E0dMccoxlzFhglsdkzpK9mBVKZsp7d9yrT1W"
}
}
```
**Format stempel waktu dengan detik pecahan**
Step Functions mengikuti ISO8601 spesifikasi yang menyatakan bahwa output bisa nol, tiga, enam atau sembilan digit yang diperlukan. Ketika stempel waktu memiliki nol detik pecahan, Step Functions menghapus angka nol yang tertinggal daripada melapisi output.
Jika Anda membuat kode yang menggunakan stempel waktu Step Functions, kode Anda harus dapat memproses sejumlah variabel detik pecahan.
## Data objek konteks untuk status Peta
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Saat memproses [`Map`status](state-map.md), konteksnya juga akan berisi`Index`,`Value`, dan`Source`.
Untuk setiap iterasi `Map` status, `Index` berisi nomor indeks untuk item array yang sedang diproses, `Value` berisi item array yang sedang diproses, dan `Source` akan menjadi InputType dari`CSV`,, `JSON``JSONL`, atau`PARQUET`.
Dalam `Map` keadaan, objek Context mencakup data berikut:
```
"Map": {
"Item": {
"Index" : Number,
"Key" : "String", // Only valid for JSON objects
"Value" : "String",
"Source": "String"
}
}
```
Ini hanya tersedia di `Map` negara bagian, dan dapat ditentukan di `ItemSelector (Peta)` lapangan.
**catatan**
Anda harus menentukan parameter dari objek Konteks di `ItemSelector` blok `Map` negara bagian utama, bukan dalam status yang termasuk dalam `ItemProcessor` bagian.
Mengingat mesin status menggunakan **JSONPath**`Map`status, Anda dapat menyuntikkan informasi dari objek Context sebagai berikut.
```
{
"StartAt": "ExampleMapState",
"States": {
"ExampleMapState": {
"Type": "Map",
"ItemSelector": {
"ContextIndex.$": "$$.Map.Item.Index",
"ContextValue.$": "$$.Map.Item.Value",
"ContextSource.$": "$$.Map.Item.Source"
},
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "INLINE"
},
"StartAt": "TestPass",
"States": {
"TestPass": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Untuk JSONata, informasi konteks status Peta tambahan dapat diakses dari `$states.context` variabel:
```
{
"StartAt": "ExampleMapState",
"States": {
"ExampleMapState": {
"Type": "Map",
"ItemSelector": {
"ContextIndex": "{% $states.context.Map.Item.Index %}",
"ContextValue": "{% $states.context.Map.Item.Value %}",
"ContextSource": "{% $states.context.Map.Item.Source %}"
},
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "INLINE"
},
"StartAt": "TestPass",
"States": {
"TestPass": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Jika Anda mengeksekusi mesin status sebelumnya dengan input berikut, `Index` dan `Value` dimasukkan dalam output.
```
[
{
"who": "bob"
},
{
"who": "meg"
},
{
"who": "joe"
}
]
```
Output untuk eksekusi mengembalikan nilai `Index` dan `Value` item untuk masing-masing dari tiga iterasi sebagai berikut:
```
[
{
"ContextIndex": 0,
"ContextValue": {
"who": "bob"
},
"ContextSource" : "STATE_DATA"
},
{
"ContextIndex": 1,
"ContextValue": {
"who": "meg"
},
"ContextSource" : "STATE_DATA"
},
{
"ContextIndex": 2,
"ContextValue": {
"who": "joe"
},
"ContextSource" : "STATE_DATA"
}
]
```
Perhatikan bahwa `$states.context.Map.Item.Source` akan menjadi salah satu dari berikut ini:
+ Untuk input status, nilainya adalah: `STATE_DATA`
+ Untuk `Amazon S3 LIST_OBJECTS_V2` with`Transformation=NONE`, nilainya akan menampilkan URI S3 untuk bucket. Sebagai contoh: `S3://bucket-name`.
+ Untuk semua jenis input lainnya, nilainya adalah URI Amazon S3. Misalnya: `S3://bucket-name/object-key`.
# Menggunakan JSONPath jalur
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Dalam Bahasa Status Amazon, *jalur* adalah string yang dimulai dengan `$` yang dapat Anda gunakan untuk mengidentifikasi komponen dalam teks JSON. Jalur mengikuti [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)sintaks, yang hanya tersedia ketika `QueryLanguage` diatur ke JSONPath. Anda dapat menentukan jalur untuk mengakses himpunan bagian dari input ketika menentukan nilai untuk `InputPath`, `ResultPath`, dan `OutputPath`.
Anda harus menggunakan notasi kurung siku jika nama bidang Anda berisi karakter apa pun yang tidak termasuk dalam `member-name-shorthand` definisi aturan [JsonPath ABNF](https://www.ietf.org/archive/id/draft-ietf-jsonpath-base-21.html#jsonpath-abnf). Oleh karena itu, untuk menyandikan karakter khusus, seperti tanda baca (tidak termasuk`_`), Anda harus menggunakan notasi braket siku. Misalnya, `$.abc.['def ghi']`.
## Jalur Referensi
*Jalur referensi* adalah jalur yang sintaksisterbatas sedemikian rupa sehingga dapat mengidentifikasi hanya satu simpul dalam struktur JSON:
+ Anda dapat mengakses bidang objek hanya menggunakan notasi titik (`.`) dan kurung persegi (`[ ]`).
+ Fungsi seperti `length()` tidak didukung.
+ Operator leksikal, yang non-simbolis, seperti `subsetof` tidak didukung.
+ Pemfilteran dengan ekspresi reguler atau dengan mereferensikan nilai lain dalam struktur JSON tidak didukung.
+ Operator`@`, `,``:`,, dan `?` tidak didukung
Misalnya, jika data input status berisi nilai berikut:
```
{
"foo": 123,
"bar": ["a", "b", "c"],
"car": {
"cdr": true
}
}
```
Jalur referensi berikut akan mengembalikan berikut.
```
$.foo => 123
$.bar => ["a", "b", "c"]
$.car.cdr => true
```
Status tertentu menggunakan jalur dan jalur referensi untuk mengontrol aliran mesin status atau mengonfigurasi pengaturan status atau opsi. Untuk informasi selengkapnya, lihat [Pemodelan alur kerja input dan pemrosesan jalur output dengan simulator aliran data](https://aws.amazon.com/blogs/compute/modeling-workflow-input-output-path-processing-with-data-flow-simulator/) dan [Menggunakan JSONPath secara efektif di AWS Step Functions](https://aws.amazon.com/blogs/compute/using-jsonpath-effectively-in-aws-step-functions/).
### Meratakan array array
Jika [Memetakan status alur kerja](state-map.md) status [Status alur kerja paralel](state-parallel.md) atau di mesin status Anda mengembalikan array array, Anda dapat mengubahnya menjadi array datar dengan [ResultSelector](input-output-inputpath-params.md#input-output-resultselector) bidang. Anda dapat menyertakan bidang ini di dalam definisi status Paralel atau Peta untuk memanipulasi hasil status ini.
Untuk meratakan array, gunakan sintaks: `[*]` di `ResultSelector` bidang seperti yang ditunjukkan pada contoh berikut.
```
"ResultSelector": {
"flattenArray.$": "$[*][*]"
}
```
Untuk contoh yang menunjukkan cara meratakan array, lihat *Langkah 3* dalam tutorial berikut:
+ [Memproses data batch dengan fungsi Lambda di Step Functions](tutorial-itembatcher-param-task.md)
+ [Memproses item individual dengan fungsi Lambda di Step Functions](tutorial-itembatcher-single-item-process.md)
# Memanipulasi parameter dalam alur kerja Step Functions
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Bidang `InputPath`, `Parameters` dan `ResultSelector` menyediakan cara untuk memanipulasi JSON saat bergerak melalui alur kerja Anda. `InputPath` dapat membatasi input yang diteruskan dengan memfilter notasi JSON dengan menggunakan jalur (lihat [Menggunakan JSONPath jalur](amazon-states-language-paths.md)). Dengan `Parameters` bidang ini, Anda dapat meneruskan kumpulan pasangan kunci-nilai, menggunakan nilai statis atau pilihan dari input menggunakan jalur.
Bidang `ResultSelector` menyediakan cara untuk memanipulasi hasil status sebelum `ResultPath` diterapkan.
AWS Step Functionsmenerapkan `InputPath` bidang terlebih dahulu, dan kemudian `Parameters` bidang. Pertama-tama Anda dapat memfilter input mentah Anda ke pilihan yang ingin Anda gunakan `InputPath`, lalu menerapkan `Parameters` untuk memanipulasi input itu lebih lanjut, atau menambahkan nilai-nilai baru. Kemudian Anda dapat menggunakan bidang `ResultSelector` untuk memanipulasi output status sebelum `ResultPath` diterapkan.
## InputPath
Gunakan `InputPath` untuk memilih sebagian dari input status.
Misalnya, anggap input ke status Anda meliputi berikut ini.
```
{
"comment": "Example for InputPath.",
"dataset1": {
"val1": 1,
"val2": 2,
"val3": 3
},
"dataset2": {
"val1": "a",
"val2": "b",
"val3": "c"
}
}
```
Anda dapat menerapkan `InputPath`.
```
"InputPath": "$.dataset2",
```
Dengan `InputPath` sebelumnya, berikut ini adalah JSON yang diteruskan sebagai input.
```
{
"val1": "a",
"val2": "b",
"val3": "c"
}
```
**catatan**
Sebuah jalur dapat menghasilkan pilihan nilai. Pertimbangkan contoh berikut.
```
{ "a": [1, 2, 3, 4] }
```
Jika Anda menerapkan jalur `$.a[0:2]`, berikut ini adalah hasilnya.
```
[ 1, 2 ]
```
## Parameter
Bagian ini menjelaskan berbagai cara Anda dapat menggunakan bidang Parameter.
### Pasangan kunci/nilai
Gunakan bidang `Parameters` untuk membuat kumpulan pasangan kunci-nilai yang diteruskan sebagai input. Nilai masing-masing dapat berupa nilai statis yang Anda sertakan dalam definisi mesin status Anda, atau dipilih dari input atau objek Konteks dengan jalur. Untuk pasangan kunci-nilai tempat nilai yang dipilih menggunakan jalur, nama kunci harus diakhiri `.$`.
Misalnya, anggap Anda memberikan input berikut.
```
{
"comment": "Example for Parameters.",
"product": {
"details": {
"color": "blue",
"size": "small",
"material": "cotton"
},
"availability": "in stock",
"sku": "2317",
"cost": "$23"
}
}
```
Untuk memilih beberapa informasi, Anda dapat menentukan parameter ini dalam ketentuan mesin status Anda.
```
"Parameters": {
"comment": "Selecting what I care about.",
"MyDetails": {
"size.$": "$.product.details.size",
"exists.$": "$.product.availability",
"StaticValue": "foo"
}
},
```
Mengingat input dan bidang `Parameters` sebelumnya, ini adalah JSON yang dilewatkan.
```
{
"comment": "Selecting what I care about.",
"MyDetails": {
"size": "small",
"exists": "in stock",
"StaticValue": "foo"
}
},
```
Selain input, Anda dapat mengakses objek JSON khusus, yang dikenal sebagai objek Context. Objek Context menyertakan informasi tentang eksekusi mesin state Anda. Lihat [Mengakses data eksekusi dari objek Context di Step Functions](input-output-contextobject.md).
### Sumber daya terhubung
Bidang `Parameters` juga dapat meneruskan informasi ke sumber daya yang terhubung. Misalnya, jika status tugas Anda mengatur AWS Batch pekerjaan, Anda dapat meneruskan parameter API yang relevan secara langsung ke tindakan API layanan tersebut. Untuk informasi lebih lanjut, lihat:
+ [Meneruskan parameter ke API layanan di Step Functions](connect-parameters.md)
+ [Integrasi layanan ](integrate-services.md)
### Amazon S3
Jika data fungsi Lambda yang Anda lewati antar status mungkin bertambah menjadi lebih dari 262.144 byte, sebaiknya gunakan Amazon S3 untuk menyimpan data, dan menerapkan salah satu metode berikut:
+ Gunakan *status Peta Terdistribusi* di alur kerja Anda sehingga `Map` status dapat membaca input langsung dari sumber data Amazon S3. Untuk informasi selengkapnya, lihat [Mode terdistribusi](state-map-distributed.md).
+ Parse Amazon Resource Name (ARN) bucket dalam `Payload` parameter untuk mendapatkan nama bucket dan nilai kunci. Untuk informasi selengkapnya, lihat [Menggunakan Amazon S3 ARNs alih-alih melewatkan muatan besar di Step Functions](sfn-best-practices.md#avoid-exec-failures).
Atau, Anda dapat menyesuaikan implementasi untuk meneruskan muatan yang lebih kecil dalam eksekusi Anda.
## ResultSelector
Gunakan bidang `ResultSelector` untuk memanipulasi hasil status sebelum `ResultPath` diterapkan. Bidang `ResultSelector` memungkinkan Anda membuat koleksi pasangan nilai kunci, yang mana nilai-nilainya statis atau dipilih dari hasil status. Dengan menggunakan `ResultSelector` bidang, Anda dapat memilih bagian mana dari hasil status yang ingin Anda lewatkan ke `ResultPath` bidang tersebut.
**catatan**
Dengan `ResultPath` bidang tersebut, Anda dapat menambahkan output `ResultSelector` bidang ke input asli.
`ResultSelector` adalah bidang opsional dalam status berikut:
+ [Memetakan status alur kerja](state-map.md)
+ [Status alur kerja tugas](state-task.md)
+ [Status alur kerja paralel](state-parallel.md)
Misalnya, integrasi layanan Step Functions mengembalikan metadata selain muatan dalam hasil. `ResultSelector` dapat memilih bagian dari hasil dan menggabungkannya dengan input status dengan `ResultPath`. Dalam contoh ini, kami ingin memilih hanya `resourceType` dan `ClusterId`, dan menggabungkannya dengan input status dari Amazon EMR createCluster.sync. Diberikan sebagai berikut:
```
{
"resourceType": "elasticmapreduce",
"resource": "createCluster.sync",
"output": {
"SdkHttpMetadata": {
"HttpHeaders": {
"Content-Length": "1112",
"Content-Type": "application/x-amz-JSON-1.1",
"Date": "Mon, 25 Nov 2019 19:41:29 GMT",
"x-amzn-RequestId": "1234-5678-9012"
},
"HttpStatusCode": 200
},
"SdkResponseMetadata": {
"RequestId": "1234-5678-9012"
},
"ClusterId": "AKIAIOSFODNN7EXAMPLE"
}
}
```
Anda kemudian dapat memilih `resourceType` dan `ClusterId` menggunakan `ResultSelector`:
```
"Create Cluster": {
"Type": "Task",
"Resource": "arn:aws:states:::elasticmapreduce:createCluster.sync",
"Parameters": {
},
"ResultSelector": {
"ClusterId.$": "$.output.ClusterId",
"ResourceType.$": "$.resourceType"
},
"ResultPath": "$.EMROutput",
"Next": "Next Step"
}
```
Dengan input yang diberikan, menggunakan `ResultSelector` menghasilkan:
```
{
"OtherDataFromInput": {},
"EMROutput": {
"ClusterId": "AKIAIOSFODNN7EXAMPLE",
"ResourceType": "elasticmapreduce",
}
}
```
### Meratakan array array
Jika [Memetakan status alur kerja](state-map.md) status [Status alur kerja paralel](state-parallel.md) atau di mesin status Anda mengembalikan array array, Anda dapat mengubahnya menjadi array datar dengan [ResultSelector](#input-output-resultselector) bidang. Anda dapat menyertakan bidang ini di dalam definisi status Paralel atau Peta untuk memanipulasi hasil status ini.
Untuk meratakan array, gunakan sintaks: `[*]` di `ResultSelector` bidang seperti yang ditunjukkan pada contoh berikut.
```
"ResultSelector": {
"flattenArray.$": "$[*][*]"
}
```
Untuk contoh yang menunjukkan cara meratakan array, lihat *Langkah 3* dalam tutorial berikut:
+ [Memproses data batch dengan fungsi Lambda di Step Functions](tutorial-itembatcher-param-task.md)
+ [Memproses item individual dengan fungsi Lambda di Step Functions](tutorial-itembatcher-single-item-process.md)
# Contoh: Memanipulasi data status dengan jalur di alur kerja Step Functions
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Topik ini berisi contoh cara memanipulasi input status dan output JSON menggunakan InputPath, ResultPath, dan OutputPath bidang.
Setiap negara selain [Status alur kerja gagal](state-fail.md) negara bagian atau [Status alur kerja yang berhasil](state-succeed.md) negara dapat mencakup bidang pemrosesan input dan output, seperti`InputPath`,`ResultPath`, atau`OutputPath`. Selain itu, [Tunggu status alur kerja](state-wait.md) dan [Status alur kerja pilihan](state-choice.md) negara bagian tidak mendukung `ResultPath` lapangan. Dengan bidang ini, Anda dapat menggunakan a [JsonPath](https://datatracker.ietf.org/wg/jsonpath/about/)untuk memfilter data JSON saat bergerak melalui alur kerja Anda.
Anda juga dapat menggunakan `Parameters` bidang untuk memanipulasi data JSON saat bergerak melalui alur kerja Anda. Untuk informasi tentang penggunaan`Parameters`, lihat[Memanipulasi parameter dalam alur kerja Step Functions](input-output-inputpath-params.md).
Misalnya, mulailah dengan AWS Lambda fungsi dan mesin status yang dijelaskan dalam [Membuat mesin status Step Functions yang menggunakan Lambda](tutorial-creating-lambda-state-machine.md) tutorial. Modifikasi mesin status sehingga termasuk `InputPath`, `ResultPath`, dan `OutputPath` berikut.
```
{
"Comment": "A Hello World example of the Amazon States Language using an AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:HelloFunction",
"InputPath": "$.lambda",
"ResultPath": "$.data.lambdaresult",
"OutputPath": "$.data",
"End": true
}
}
}
```
Mulai eksekusi menggunakan input berikut.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Asumsikan bahwa `extra` node `comment` dan dapat dibuang, tetapi Anda ingin menyertakan output dari fungsi Lambda, dan menyimpan informasi dalam node. `data`
Dalam mesin status yang diperbarui, status `Task` diubah untuk memproses input ke tugas.
```
"InputPath": "$.lambda",
```
Baris ini dalam ketentuan mesin status membatasi input tugas untuk hanya simpul `lambda` dari input status. Fungsi Lambda hanya menerima objek JSON `{"who": "AWS Step Functions"}` sebagai input.
```
"ResultPath": "$.data.lambdaresult",
```
Ini `ResultPath` memberitahu mesin status untuk memasukkan hasil dari fungsi Lambda ke simpul bernama `lambdaresult`, sebagai anak dari simpul `data` dalam input mesin status asli. Karena Anda tidak melakukan manipulasi lain pada input asli dan hasilnya menggunakan`OutputPath`, output status sekarang menyertakan hasil fungsi Lambda dengan input asli.
```
{
"comment": "An input comment.",
"data": {
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
},
"extra": "foo",
"lambda": {
"who": "AWS Step Functions"
}
}
```
Tapi, tujuan kami adalah untuk hanya mempertahankan simpul `data`, dan termasuk hasil fungsi Lambda. `OutputPath` memfilter JSON gabungan ini sebelum meneruskannya ke output status.
```
"OutputPath": "$.data",
```
Ini hanya memilih simpul `data` dari input asli (termasuk anak `lambdaresult` yang disisipkan oleh `ResultPath`) untuk diteruskan ke output. Output status difilter ke berikut ini.
```
{
"val1": 23,
"val2": 17,
"lambdaresult": "Hello, AWS Step Functions!"
}
```
Dalam status `Task` ini:
1. `InputPath` hanya mengirimkan simpul `lambda` dari input ke fungsi Lambda.
1. `ResultPath` menyisipkan hasilnya sebagai anak dari simpul `data` dalam input asli.
1. `OutputPath` memfilter input status (yang sekarang termasuk hasil dari fungsi Lambda) sehingga hanya meneruskan simpul `data` ke output status.
**Example untuk memanipulasi input mesin keadaan asli, hasil, dan output akhir menggunakan JsonPath**
Pertimbangkan mesin negara berikut yang memverifikasi identitas dan alamat pemohon asuransi.
Untuk melihat contoh lengkapnya, lihat [Cara menggunakan JSON Path di Step Functions](https://github.com/aws-samples/serverless-account-signup-service).
```
{
"Comment": "Sample state machine to verify an applicant's ID and address",
"StartAt": "Verify info",
"States": {
"Verify info": {
"Type": "Parallel",
"End": true,
"Branches": [
{
"StartAt": "Verify identity",
"States": {
"Verify identity": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:check-identity:$LATEST"
},
"End": true
}
}
},
{
"StartAt": "Verify address",
"States": {
"Verify address": {
"Type": "Task",
"Resource": "arn:aws:states:::lambda:invoke",
"Parameters": {
"Payload.$": "$",
"FunctionName": "arn:aws:lambda:us-east-2:111122223333:function:check-address:$LATEST"
},
"End": true
}
}
}
]
}
}
}
```
Jika Anda menjalankan mesin status ini menggunakan input berikut, eksekusi gagal karena fungsi Lambda yang melakukan verifikasi hanya mengharapkan data yang perlu diverifikasi sebagai input. Oleh karena itu, Anda harus menentukan node yang berisi informasi yang akan diverifikasi menggunakan yang sesuai JsonPath.
```
{
"data": {
"firstname": "Jane",
"lastname": "Doe",
"identity": {
"email": "jdoe@example.com",
"ssn": "123-45-6789"
},
"address": {
"street": "123 Main St",
"city": "Columbus",
"state": "OH",
"zip": "43219"
},
"interests": [
{
"category": "home",
"type": "own",
"yearBuilt": 2004
},
{
"category": "boat",
"type": "snowmobile",
"yearBuilt": 2020
},
{
"category": "auto",
"type": "RV",
"yearBuilt": 2015
},
]
}
}
```
Untuk menentukan node yang harus digunakan fungsi `check-identity` Lambda, gunakan `InputPath` bidang sebagai berikut:
```
"InputPath": "$.data.identity"
```
Dan untuk menentukan node yang harus digunakan fungsi `check-address` Lambda, gunakan `InputPath` bidang sebagai berikut:
```
"InputPath": "$.data.address"
```
Sekarang jika Anda ingin menyimpan hasil verifikasi dalam input mesin status asli, gunakan `ResultPath` bidang sebagai berikut:
```
"ResultPath": "$.results"
```
Namun, jika Anda hanya membutuhkan identitas dan hasil verifikasi dan membuang input asli, gunakan `OutputPath` bidang sebagai berikut:
```
"OutputPath": "$.results"
```
Untuk informasi selengkapnya, lihat [Memproses input dan output di Step Functions](concepts-input-output-filtering.md).
## Memfilter output status menggunakan OutputPath
Dengan `OutputPath` Anda dapat memilih sebagian dari output negara untuk diteruskan ke keadaan berikutnya. Dengan pendekatan ini, Anda dapat menyaring informasi yang tidak diinginkan, dan hanya meneruskan sebagian JSON yang Anda butuhkan.
Jika Anda tidak menentukan `OutputPath` nilai default-nya adalah `$`. Ini meneruskan seluruh simpul JSON (ditentukan oleh input status, hasil tugas, dan `ResultPath`) ke status berikutnya.
# Menentukan output status menggunakan Step ResultPath Functions
**Mengelola status dan mengubah data**
Halaman ini mengacu pada JSONPath. Step Functions baru-baru ini menambahkan variabel dan JSONata untuk mengelola status dan mengubah data.
Pelajari tentang [Melewati data dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Output dari suatu status dapat menjadi salinan inputnya, hasilnya menghasilkan (misalnya, output dari fungsi Lambda status `Task`), atau kombinasi dari input dan hasilnya. Gunakan `ResultPath` untuk kombinasi mana dari ini yang diteruskan ke output status.
Tipe negara berikut dapat menghasilkan hasil dan dapat mencakup `ResultPath:`
+ [Lulus status alur kerja](state-pass.md)
+ [Status alur kerja tugas](state-task.md)
+ [Status alur kerja paralel](state-parallel.md)
+ [Memetakan status alur kerja](state-map.md)
Gunakan `ResultPath` untuk menggabungkan hasil tugas dengan input tugas, atau untuk memilih salah satu dari ini. Jalan yang Anda berikan untuk `ResultPath` mengontrol informasi apa yang diteruskan ke output.
**catatan**
`ResultPath`terbatas untuk menggunakan [jalur referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths), yang membatasi ruang lingkup sehingga jalur harus mengidentifikasi hanya satu simpul di JSON. Lihat [Jalur Referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths) di [Bahasa Status Amazon](concepts-amazon-states-language.md).
## Gunakan ResultPath untuk mengganti input dengan hasil tugas
Jika Anda tidak menentukan`ResultPath`, perilaku defaultnya sama dengan`"ResultPath": "$"`. Negara akan mengganti seluruh input status dengan hasil dari tugas.
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": "$"
# Task result
"Hello, Step Functions!"
# State Output
"Hello, Step Functions!"
```
**catatan**
`ResultPath` digunakan untuk memasukkan konten dari hasil dengan input, sebelum meneruskannya ke output. Tapi, jika `ResultPath` tidak ditentukan, tindakan defaultnya adalah mengganti seluruh input.
## Buang hasilnya dan simpan input asli
Jika Anda mengatur `ResultPath` ke`null`, status akan meneruskan **input asli** ke output. Muatan masukan negara akan disalin langsung ke output, tanpa memperhatikan hasil tugas.
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": null
# Task result
"Hello, Step Functions!"
# State Output
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
```
## Gunakan ResultPath untuk memasukkan hasil dengan input
Jika Anda menentukan jalur untuk ResultPath, output status akan menggabungkan input status dan hasil tugas:
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": "$.taskresult"
# Task result
"Hello, Step Functions!"
# State Output
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions",
"taskresult" : "Hello, Step Functions!"
}
```
Anda juga dapat memasukkan hasilnya ke simpul anak dari input. Atur `ResultPath` ke hal berikut.
```
"ResultPath": "$.strings.lambdaresult"
```
Diberikan masukan berikut:
```
{
"comment": "An input comment.",
"strings": {
"string1": "foo",
"string2": "bar",
"string3": "baz"
},
"who": "AWS Step Functions"
}
```
Hasil tugas akan dimasukkan sebagai anak dari `strings` node di input.
```
{
"comment": "An input comment.",
"strings": {
"string1": "foo",
"string2": "bar",
"string3": "baz",
"lambdaresult": "Hello, Step Functions!"
},
"who": "AWS Step Functions"
}
```
Output status sekarang termasuk input asli JSON dengan hasil sebagai simpul anak.
## Gunakan ResultPath untuk memperbarui node di input dengan hasilnya
Jika Anda menentukan node yang ada untuk ResultPath, hasil tugas akan menggantikan node yang ada:
```
# State Input
{
"comment": "This is a test",
"details": "Default example",
"who" : "Step Functions"
}
# Path
"ResultPath": "$.comment"
# Task result
"Hello, Step Functions!"
# State Output
{
"comment": "Hello, Step Functions!",
"details": "Default example",
"who" : "Step Functions"
}
```
## Gunakan ResultPath untuk memasukkan kesalahan dan masukan dalam `Catch`
Dalam beberapa kasus, Anda mungkin ingin mempertahankan input asli dengan kesalahan. Gunakan `ResultPath` dalam `Catch` untuk memasukkan kesalahan dengan input asli, bukan menggantikannya.
```
"Catch": [{
"ErrorEquals": ["States.ALL"],
"Next": "NextTask",
"ResultPath": "$.error"
}]
```
Jika pernyataan `Catch` sebelumnya menangkap kesalahan, pernyataan itu mencakup hasil dalam simpul `error` dalam input status. Sebagai contoh, dengan input berikut:
```
{"foo": "bar"}
```
Output status saat menangkap kesalahan adalah sebagai berikut.
```
{
"foo": "bar",
"error": {
"Error": "Error here"
}
}
```
Untuk informasi selengkapnya tentang penanganan kesalahan, lihat hal berikut:
+ [Menangani kesalahan dalam alur kerja Step Functions](concepts-error-handling.md)
+ [Menangani kondisi kesalahan di mesin status Step Functions](tutorial-handling-error-conditions.md)
# Memetakan bidang input dan output status di Step Functions
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Status peta mengulangi koleksi item dalam kumpulan data. Contoh kumpulan data meliputi:
+ Array JSON dan objek dari status sebelumnya.
+ File data individual yang disimpan di Amazon S3 dalam format seperti: JSON, JSONL, CSV, file Parket.
+ Referensi ke beberapa objek, seperti: manifes Athena dan file inventaris Amazon S3
Peta mengulangi serangkaian langkah untuk setiap item dalam kumpulan data. Anda dapat mengonfigurasi input yang `Map state` diterima dan output yang dihasilkan peta menggunakan berbagai opsi konfigurasi. Step Functions menerapkan setiap opsi dalam *status Peta Terdistribusi* Anda dalam urutan yang ditunjukkan dalam daftar berikut. Tergantung pada kasus penggunaan Anda, Anda mungkin tidak perlu menerapkan semua bidang.
1. [ItemReader (Peta)](input-output-itemreader.md)- Digunakan untuk membaca item data Anda
1. [ItemsPath (Peta, JSONPath hanya)](input-output-itemspath.md)atau **Items (JSONata)** - opsional; digunakan untuk menentukan item dalam dataset Anda
1. [ItemSelector (Peta)](input-output-itemselector.md)- opsional; digunakan untuk memilih dan memodifikasi item dalam kumpulan data
1. [ItemBatcher (Peta)](input-output-itembatcher.md)- digunakan untuk memproses kelompok item saat memproses set item yang besar
1. [ResultWriter (Peta)](input-output-resultwriter.md)- menyediakan opsi untuk hasil output dari alur kerja anak
# ItemReader (Peta)
`ItemReader`Bidang adalah objek JSON, yang menentukan dataset dan lokasinya. *Status Peta Terdistribusi* menggunakan kumpulan data ini sebagai inputnya.
Contoh berikut menunjukkan sintaks `ItemReader` bidang dalam alur kerja **JSONPathberbasis**, untuk kumpulan data dalam file teks yang dibatasi yang disimpan dalam bucket Amazon S3.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "FIRST_ROW"
},
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "csvDataset/ratings.csv",
"VersionId": "BcK42coT2jE1234VHLUvBV1yLNod2OEt"
}
}
```
Dalam alur kerja **JSONataberbasis** berikut, perhatikan bahwa `Parameters` diganti dengan **Argumen**.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "FIRST_ROW"
},
"Resource": "arn:aws:states:::s3:getObject",
"Arguments": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "csvDataset/ratings.csv"
"VersionId": "BcK42coT2jE1234VHLUvBV1yLNod2OEt"
}
}
```
## Isi ItemReader lapangan
Bergantung pada kumpulan data Anda, isi `ItemReader` bidang bervariasi. Misalnya, jika kumpulan data Anda adalah array JSON yang diteruskan dari langkah sebelumnya dalam alur kerja, `ItemReader` bidang tersebut dihilangkan. Jika kumpulan data Anda adalah sumber data Amazon S3, bidang ini berisi sub-bidang berikut.
**`Resource`**
Tindakan integrasi Amazon S3 API yang akan digunakan Step Functions, seperti `arn:aws:states:::s3:getObject`
**`Arguments (JSONata) or Parameters (JSONPath)`**
Objek JSON yang menentukan nama bucket Amazon S3 dan kunci objek tempat kumpulan data disimpan.
Jika bucket mengaktifkan versi, Anda juga dapat menyediakan versi objek Amazon S3.
**`ReaderConfig`**
Sebuah objek JSON yang menentukan rincian berikut:
+ `InputType`
Menerima salah satu nilai berikut:`CSV`,,`JSON`, `JSONL``PARQUET`,`MANIFEST`.
Menentukan jenis sumber data Amazon S3, seperti file yang dibatasi teks `CSV` (), objek, file JSON, Garis JSON, file Parket, manifes Athena, atau daftar inventaris Amazon S3. Di Workflow Studio, Anda dapat memilih jenis input dari sumber **item S3**.
Sebagian besar jenis input yang menggunakan `S3GetObject` pengambilan juga mendukung `ExpectedBucketOwner` dan `VersionId` bidang dalam parameternya. File parket adalah satu pengecualian yang tidak mendukung`VersionId`.
File input mendukung jenis kompresi eksternal berikut: GZIP, ZSTD.
Contoh nama file: `myObject.jsonl.gz` dan`myObject.csv.zstd`.
Catatan: File parket adalah jenis file biner yang dikompresi secara internal. Kompresi GZIP, ZSTD, dan Snappy didukung.
+ `Transformation`
*Opsional*. Nilai akan menjadi salah satu atau `NONE` atau`LOAD_AND_FLATTEN`.
Jika tidak ditentukan, `NONE` akan diasumsikan. Ketika diatur ke`LOAD_AND_FLATTEN`, Anda juga harus mengatur`InputType`.
Perilaku default, peta akan mengulangi **objek metadata** yang dikembalikan dari panggilan ke. `S3:ListObjectsV2` Ketika diatur ke`LOAD_AND_FLATTEN`, peta akan membaca dan memproses **objek data** aktual yang direferensikan dalam daftar hasil.
+ `ManifestType`
*Opsional*. Nilai akan menjadi salah satu atau `ATHENA_DATA` atau`S3_INVENTORY`.
Catatan: Jika disetel ke`S3_INVENTORY`, Anda juga **tidak** harus menentukan `InputType` karena jenis diasumsikan`CSV`.
+ `CSVDelimiter`
Anda dapat menentukan bidang `InputType` ini kapan `CSV` atau`MANIFEST`.
Menerima salah satu nilai berikut: `COMMA` (default),,`PIPE`, `SEMICOLON``SPACE`,`TAB`.
**catatan**
Dengan `CSVDelimiter` bidang, `ItemReader` dapat memproses file yang dibatasi oleh karakter selain koma. Referensi ke “file CSV” juga mencakup file yang menggunakan pembatas alternatif yang ditentukan oleh bidang. `CSVDelimiter`
+ `CSVHeaderLocation`
Anda dapat menentukan bidang `InputType` ini kapan `CSV` atau`MANIFEST`.
Menerima salah satu nilai berikut untuk menentukan lokasi header kolom:
+ `FIRST_ROW`— Gunakan opsi ini jika baris pertama file adalah header.
+ `GIVEN`— Gunakan opsi ini untuk menentukan header dalam definisi mesin negara.
Misalnya, jika file Anda berisi data berikut.
```
1,307,3.5,1256677221
1,481,3.5,1256677456
1,1091,1.5,1256677471
...
```
Anda dapat memberikan array JSON berikut sebagai header CSV:
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "GIVEN",
"CSVHeaders": [
"userId",
"movieId",
"rating",
"timestamp"
]
}
}
```
**Ukuran header CSV**
Step Functions mendukung header hingga 10 KiB untuk file yang dibatasi teks.
+ `ItemsPointer`
*Opsional*. Anda dapat menentukan bidang `InputType` ini kapan`JSON`.
`ItemsPointer`menggunakan JSONPointer sintaks untuk memilih array atau objek tertentu yang bersarang di dalam file JSON Anda. JSONPointer adalah sintaks standar yang dirancang khusus untuk menavigasi dan mereferensikan lokasi dalam dokumen JSON.
JSONPointer sintaks menggunakan garis miring maju (/) untuk memisahkan setiap tingkat bersarang, dengan indeks array direpresentasikan sebagai angka tanpa tanda kurung. Contoh:
+ `/Data/Contents`- referensi array Isi dalam objek Data
+ `/Data/Contents/0`- referensi elemen pertama dari array Isi
Posisi awal array target harus berada dalam 16MB pertama dari file JSON, dan JSONPointer jalur harus kurang dari 2000 karakter panjangnya.
Misalnya, jika file JSON Anda berisi:
```
{"data": {"items": [{"id": 1}, {"id": 2}]}}
```
Anda akan menentukan `"ItemsPointer": "/data/items"` untuk memproses array item.
+ `MaxItems`
Secara default, `Map` status mengulangi semua item dalam kumpulan data yang ditentukan. Dengan menyetel`MaxItems`, Anda dapat membatasi jumlah item data yang diteruskan ke `Map` status. Misalnya, jika Anda memberikan file dibatasi teks yang berisi 1.000 baris, dan Anda menetapkan batas 100, penerjemah *hanya* meneruskan 100 baris ke status Peta *Terdistribusi*. `Map`Status memproses item dalam urutan berurutan, dimulai setelah baris header.
Untuk **JSONPath**alur kerja, Anda dapat menggunakan `MaxItemsPath` dan *jalur referensi* ke pasangan kunci-nilai dalam input status yang menyelesaikan ke bilangan bulat. Perhatikan bahwa Anda dapat menentukan salah satu `MaxItems` atau`MaxItemsPath`, tetapi tidak **keduanya**.
**catatan**
Anda dapat menentukan batas hingga 100.000.000 setelah itu `Distributed Map` berhenti membaca item.
**Persyaratan untuk akun dan wilayah**
Bucket Amazon S3 Anda harus sama Akun AWS dan Wilayah AWS sebagai mesin negara bagian Anda.
*Perhatikan bahwa meskipun mesin status Anda mungkin dapat mengakses file dalam bucket di berbagai Akun AWS yang sama Wilayah AWS, Step Functions hanya mendukung daftar objek di bucket Amazon S3 yang Akun AWS sama dan sama dengan mesin status.* Wilayah AWS
## Memproses kumpulan data bersarang (diperbarui 11 Sep 2025)
Dengan `Transformation` parameter baru, Anda dapat menentukan nilai `LOAD_AND_FLATTEN` dan peta akan membaca objek data **aktual** yang direferensikan dalam daftar hasil dari panggilan ke`S3:ListObjectsV2`.
Sebelum rilis ini, Anda perlu membuat Peta Terdistribusi bersarang untuk **mengambil** metadata dan kemudian **memproses** data aktual. Peta pertama akan mengulangi **metadata** yang dikembalikan oleh `S3:ListObjectsV2` dan memanggil alur kerja anak. Peta lain dalam setiap mesin status anak akan membaca **data aktual** dari masing-masing file. Dengan opsi transformasi, Anda dapat menyelesaikan kedua langkah sekaligus.
Bayangkan Anda ingin menjalankan audit harian pada 24 file log terakhir yang diproduksi sistem Anda setiap jam dan disimpan di Amazon S3. Status Peta Terdistribusi Anda dapat mencantumkan file log`S3:ListObjectsV2`, lalu mengulang *metadata* setiap objek, atau sekarang dapat memuat dan menganalisis objek **data aktual** yang disimpan di bucket Amazon S3 Anda.
Menggunakan `LOAD_AND_FLATTEN` opsi ini dapat meningkatkan skalabilitas, mengurangi jumlah Map Run yang terbuka, dan memproses beberapa objek secara bersamaan. Pekerjaan EMR Athena dan Amazon biasanya menghasilkan output yang dapat diproses dengan konfigurasi baru.
Berikut ini adalah contoh parameter dalam `ItemReader` definisi:
```
{
"QueryLanguage": "JSONata",
"States": {
...
"Map": {
...
"ItemReader": {
"Resource": "arn:aws:states:::s3:listObjectsV2",
"ReaderConfig": {
// InputType is required if Transformation is LOAD_AND_FLATTEN.
"InputType": "CSV | JSON | JSONL | PARQUET",
// Transformation is OPTIONAL and defaults to NONE if not present
"Transformation": "NONE | LOAD_AND_FLATTEN"
},
"Arguments": {
"Bucket": "amzn-s3-demo-bucket1",
"Prefix": "{% $states.input.PrefixKey %}"
}
},
...
}
}
```
## Contoh dataset
Anda dapat menentukan salah satu opsi berikut sebagai kumpulan data Anda:
+ [Data JSON dari langkah sebelumnya](#itemsource-json-array)
+ [Daftar objek Amazon S3](#itemsource-example-s3-object-data)
+ [Objek Amazon S3 diubah oleh LOAD\$1AND\$1FLATTEN](#itemsource-example-s3-object-data-flatten)
+ [File JSON dalam ember Amazon S3](#itemsource-example-json-data)
+ [File JSON Lines dalam ember Amazon S3](#itemsource-example-json-lines-data)
+ [File CSV dalam ember Amazon S3](#itemsource-example-csv-data)
+ [File parket dalam ember Amazon S3](#itemsource-example-parquet-data)
+ [Manifes Athena (memproses beberapa item)](#itemsource-example-athena-manifest-data)
+ [Inventaris Amazon S3 (memproses beberapa item)](#itemsource-example-s3-inventory)
**catatan**
Step Functions memerlukan izin yang sesuai untuk mengakses kumpulan data Amazon S3 yang Anda gunakan. Untuk informasi tentang kebijakan IAM untuk kumpulan data, lihat. [Rekomendasi kebijakan IAM untuk kumpulan data](#itemreader-iam-policies)
### Data JSON dari langkah sebelumnya
*Status Peta Terdistribusi* dapat menerima input JSON yang diteruskan dari langkah sebelumnya dalam alur kerja.
Input dapat berupa array JSON, objek JSON, atau array dalam node dari objek JSON.
Step Functions akan iterasi langsung di atas elemen array, atau pasangan kunci-nilai dari objek JSON.
Untuk memilih node tertentu yang berisi array JSON bersarang atau objek dari input, Anda dapat menggunakan `ItemsPath (Peta, JSONPath hanya)` atau menggunakan JSONata ekspresi di `Items` bidang untuk JSONata status.
Untuk memproses item individual, *status Peta Terdistribusi* memulai eksekusi alur kerja anak untuk setiap item. Tab berikut menunjukkan contoh input yang diteruskan ke `Map` status dan input yang sesuai ke eksekusi alur kerja anak.
**catatan**
`ItemReader`Bidang tidak diperlukan saat dataset Anda adalah data JSON dari langkah sebelumnya.
------
#### [ Input passed to the Map state ]
Pertimbangkan array JSON berikut dari tiga item.
```
"facts": [
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
},
{
"verdict": "mostly-true",
"statement_date": "5/18/2016",
"statement_source": "news"
}
]
```
------
#### [ Input passed to a child workflow execution ]
*Status Peta Terdistribusi* memulai tiga eksekusi alur kerja anak. Setiap eksekusi menerima item array sebagai input. Contoh berikut menunjukkan input yang diterima oleh eksekusi alur kerja anak.
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
------
### Daftar objek Amazon S3
*Status Peta Terdistribusi* dapat mengulang objek yang disimpan dalam bucket Amazon S3. Saat eksekusi alur kerja mencapai `Map` status, Step Functions memanggil aksi [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html) API, yang mengembalikan array metadata objek Amazon **S3**. Dalam array ini, setiap item berisi data, seperti **ETag**dan **Key**, untuk data aktual yang disimpan dalam bucket.
Untuk memproses item individual dalam array, *status Peta Terdistribusi* memulai eksekusi alur kerja anak. Misalnya, ember Amazon S3 Anda berisi 100 gambar. Kemudian, array yang dikembalikan setelah menjalankan aksi `ListObjectsV2` API berisi 100 item metadata. *Status Peta Terdistribusi* kemudian memulai 100 eksekusi alur kerja anak untuk memproses setiap item.
**Untuk memproses objek data secara langsung, tanpa alur kerja bersarang, Anda dapat memilih opsi Transformasi LOAD\$1AND\$1FLATTEN untuk memproses item secara langsung.**
**catatan**
**Step Functions juga akan menyertakan item untuk setiap **folder** yang dibuat di bucket Amazon S3 menggunakan konsol Amazon S3.** Item folder menghasilkan dimulainya eksekusi alur kerja anak tambahan.
Untuk menghindari membuat eksekusi alur kerja anak tambahan untuk setiap folder, kami sarankan Anda menggunakan AWS CLI untuk membuat folder. Untuk informasi selengkapnya, lihat Perintah [Amazon S3 tingkat tinggi](https://docs.aws.amazon.com/cli/latest/userguide/cli-services-s3-commands.html#using-s3-commands-managing-buckets-creating) di Panduan Pengguna *AWS Command Line Interface .*
Step Functions memerlukan izin yang sesuai untuk mengakses kumpulan data Amazon S3 yang Anda gunakan. Untuk informasi tentang kebijakan IAM untuk kumpulan data, lihat. [Rekomendasi kebijakan IAM untuk kumpulan data](#itemreader-iam-policies)
Tab berikut menunjukkan contoh sintaks `ItemReader` bidang dan masukan yang diteruskan ke eksekusi alur kerja anak untuk kumpulan data ini.
------
#### [ ItemReader syntax ]
Dalam contoh ini, Anda telah mengatur data Anda, yang mencakup gambar, file JSON, dan objek, dalam awalan yang dinamai `processData` dalam bucket Amazon S3 bernama. `amzn-s3-demo-bucket`
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:listObjectsV2",
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Prefix": "processData"
}
}
```
------
#### [ Input passed to a child workflow execution ]
*Status Peta Terdistribusi* memulai eksekusi alur kerja anak sebanyak jumlah item metadata yang ada di bucket Amazon S3. Contoh berikut menunjukkan input yang diterima oleh eksekusi alur kerja anak.
```
{
"Etag": "\"05704fbdccb224cb01c59005bebbad28\"",
"Key": "processData/images/n02085620_1073.jpg",
"LastModified": 1668699881,
"Size": 34910,
"StorageClass": "STANDARD"
}
```
------
### Objek Amazon S3 diubah oleh `LOAD_AND_FLATTEN`
Dengan dukungan yang disempurnakan untuk S3 ListObjects V2 sebagai sumber input di Peta Terdistribusi, mesin status Anda dapat membaca dan memproses beberapa **objek data** dari bucket Amazon S3 secara langsung, sehingga tidak perlu peta bersarang untuk memproses metadata\$1
Dengan `LOAD_AND_FLATTEN` opsi tersebut, mesin negara Anda akan melakukan hal berikut:
+ Baca **konten aktual** dari setiap objek yang terdaftar oleh panggilan Amazon S3`ListObjectsV2`.
+ Parse konten berdasarkan InputType (CSV, JSON, JSONL, Parquet).
+ Buat item dari isi file (baris/catatan) daripada metadata.
Dengan opsi transformasi, Anda tidak lagi memerlukan Peta Terdistribusi bersarang untuk memproses metadata. Menggunakan opsi LOAD\$1AND\$1FLATTEN meningkatkan skalabilitas, mengurangi jumlah run map aktif, dan memproses beberapa objek secara bersamaan.
Konfigurasi berikut menunjukkan pengaturan untuk`ItemReader`:
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:listObjectsV2",
"ReaderConfig": {
"InputType": "JSON",
"Transformation": "LOAD_AND_FLATTEN"
},
"Arguments": {
"Bucket": "S3_BUCKET_NAME",
"Prefix": "S3_BUCKET_PREFIX"
}
}
```
**Rekomendasi awalan ember**
Sebaiknya sertakan garis miring pada awalan Anda. Misalnya, jika Anda memilih data dengan awalan`folder1`, mesin status Anda akan memproses keduanya `folder1/myData.csv` dan`folder10/myData.csv`. Menggunakan hanya `folder1/` akan memproses satu folder.
### File JSON dalam ember Amazon S3
*Status Peta Terdistribusi* dapat menerima file JSON yang disimpan di bucket Amazon S3 sebagai kumpulan data. File JSON harus berisi array atau objek JSON.
Ketika eksekusi alur kerja mencapai `Map` status, Step Functions memanggil aksi [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API untuk mengambil file JSON yang ditentukan.
Jika file JSON berisi struktur objek bersarang, Anda dapat memilih node tertentu dengan kumpulan data Anda dengan file. `ItemsPointer` Misalnya, konfigurasi berikut akan mengekstrak daftar bersarang *produk unggulan* dalam *inventaris*.
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "JSON",
"ItemsPointer": "/inventory/products/featured"
},
"Arguments": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "nested-data-file.json"
}
}
```
`Map`Status kemudian mengulangi setiap item dalam array dan memulai eksekusi alur kerja anak untuk setiap item. Misalnya, jika file JSON Anda berisi 1000 item array, `Map` status memulai 1000 eksekusi alur kerja anak.
**catatan**
Input eksekusi yang digunakan untuk memulai eksekusi alur kerja anak tidak dapat melebihi 256 KiB. Namun, Step Functions mendukung membaca item hingga 8 MB dari file teks yang dibatasi, JSON, atau file JSON Lines jika Anda kemudian menerapkan `ItemSelector` bidang opsional untuk mengurangi ukuran item.
Step Functions mendukung 10 GB sebagai ukuran maksimum file individual di Amazon S3.
Step Functions memerlukan izin yang sesuai untuk mengakses kumpulan data Amazon S3 yang Anda gunakan. Untuk informasi tentang kebijakan IAM untuk kumpulan data, lihat. [Rekomendasi kebijakan IAM untuk kumpulan data](#itemreader-iam-policies)
Tab berikut menunjukkan contoh sintaks `ItemReader` bidang dan masukan yang diteruskan ke eksekusi alur kerja anak untuk kumpulan data ini.
Untuk contoh ini, bayangkan Anda memiliki file JSON bernama`factcheck.json`. Anda telah menyimpan file ini dalam awalan bernama `jsonDataset` dalam bucket Amazon S3. Berikut ini adalah contoh dari dataset JSON.
```
[
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
},
{
"verdict": "mostly-true",
"statement_date": "5/18/2016",
"statement_source": "news"
},
...
]
```
------
#### [ ItemReader syntax ]
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "JSON"
},
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "jsonDataset/factcheck.json"
}
}
```
------
#### [ Input to a child workflow execution ]
*Status Peta Terdistribusi* memulai eksekusi alur kerja anak sebanyak jumlah item array yang ada dalam file JSON. Contoh berikut menunjukkan input yang diterima oleh eksekusi alur kerja anak.
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
------
### File JSON Lines dalam ember Amazon S3
*Status Peta Terdistribusi* dapat menerima file JSON Lines yang disimpan di bucket Amazon S3 sebagai kumpulan data.
**catatan**
Input eksekusi yang digunakan untuk memulai eksekusi alur kerja anak tidak dapat melebihi 256 KiB. Namun, Step Functions mendukung membaca item hingga 8 MB dari file teks yang dibatasi, JSON, atau file JSON Lines jika Anda kemudian menerapkan `ItemSelector` bidang opsional untuk mengurangi ukuran item.
Step Functions mendukung 10 GB sebagai ukuran maksimum file individual di Amazon S3.
Step Functions memerlukan izin yang sesuai untuk mengakses kumpulan data Amazon S3 yang Anda gunakan. Untuk informasi tentang kebijakan IAM untuk kumpulan data, lihat. [Rekomendasi kebijakan IAM untuk kumpulan data](#itemreader-iam-policies)
Tab berikut menunjukkan contoh sintaks `ItemReader` bidang dan masukan yang diteruskan ke eksekusi alur kerja anak untuk kumpulan data ini.
Untuk contoh ini, bayangkan Anda memiliki file JSON Lines bernama`factcheck.jsonl`. Anda telah menyimpan file ini dalam awalan bernama `jsonlDataset` dalam bucket Amazon S3. Berikut ini adalah contoh isi file.
```
{"verdict": "true", "statement_date": "6/11/2008", "statement_source": "speech"}
{"verdict": "false", "statement_date": "6/7/2022", "statement_source": "television"}
{"verdict": "mostly-true", "statement_date": "5/18/2016", "statement_source": "news"}
```
------
#### [ ItemReader syntax ]
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "JSONL"
},
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "jsonlDataset/factcheck.jsonl"
}
}
```
------
#### [ Input to a child workflow execution ]
*Status Peta Terdistribusi* memulai eksekusi alur kerja anak sebanyak jumlah baris yang ada dalam file JSONL. Contoh berikut menunjukkan input yang diterima oleh eksekusi alur kerja anak.
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
------
### File CSV dalam ember Amazon S3
**catatan**
Dengan `CSVDelimiter` bidang, `ItemReader` dapat memproses file yang dibatasi oleh karakter selain koma. Referensi ke “file CSV” juga mencakup file yang menggunakan pembatas alternatif yang ditentukan oleh bidang. `CSVDelimiter`
*Status Peta Terdistribusi* dapat menerima file teks yang dibatasi yang disimpan dalam bucket Amazon S3 sebagai kumpulan data. Jika Anda menggunakan file yang dibatasi teks sebagai kumpulan data Anda, Anda perlu menentukan header kolom. Untuk informasi tentang cara menentukan header, lihat[Isi ItemReader lapangan](#itemreader-field-contents).
Step Functions mem-parsing file teks yang dibatasi berdasarkan aturan berikut:
+ Pembatas yang memisahkan bidang ditentukan oleh in. `CSVDelimiter` *ReaderConfig* Delimiter default ke. `COMMA`
+ **Baris baru adalah pembatas yang memisahkan catatan.**
+ Bidang diperlakukan sebagai string. Untuk konversi tipe data, gunakan fungsi `States.StringToJson` intrinsik di. [ItemSelector (Peta)](input-output-itemselector.md)
+ Tanda kutip ganda (” “) tidak diperlukan untuk melampirkan string. Namun, string yang diapit oleh tanda kutip ganda dapat berisi koma dan baris baru tanpa bertindak sebagai pembatas rekaman.
+ Anda dapat mempertahankan tanda kutip ganda dengan mengulanginya.
+ Backslashes (\$1) adalah cara lain untuk melarikan diri dari karakter khusus. Garis miring terbalik hanya berfungsi dengan garis miring terbalik lainnya, tanda kutip ganda, dan pemisah bidang yang dikonfigurasi seperti koma atau pipa. Garis miring terbalik yang diikuti oleh karakter lain dihapus secara diam-diam.
+ Anda dapat mempertahankan garis miring terbalik dengan mengulanginya. Contoh:
```
path,size
C:\\Program Files\\MyApp.exe,6534512
```
+ Garis miring terbalik yang lolos dari tanda kutip ganda (`\"`), hanya berfungsi jika disertakan dalam pasangan, jadi kami sarankan untuk menghindari tanda kutip ganda dengan mengulanginya:. `""`
+ Jika jumlah bidang dalam satu baris **kurang** dari jumlah bidang di header, Step Functions menyediakan **string kosong** untuk nilai yang hilang.
+ Jika jumlah bidang dalam satu baris **lebih** dari jumlah bidang di header, **Step Functions melewatkan** bidang tambahan.
Untuk informasi selengkapnya tentang cara Step Functions mem-parsing file teks yang dibatasi, lihat. [Example of parsing an input CSV file](example-csv-parse-dist-map.md#example-csv-parse)
Saat eksekusi alur kerja mencapai `Map` status, Step Functions memanggil aksi [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API untuk mengambil file yang ditentukan. `Map`Status kemudian mengulangi setiap baris dalam file dan memulai eksekusi alur kerja anak untuk memproses item di setiap baris. Misalnya, misalkan Anda menyediakan file teks yang dibatasi yang berisi 100 baris sebagai input. Kemudian, penerjemah meneruskan setiap baris ke `Map` negara bagian. `Map`Status memproses item dalam urutan serial, dimulai setelah baris header.
**catatan**
Input eksekusi yang digunakan untuk memulai eksekusi alur kerja anak tidak dapat melebihi 256 KiB. Namun, Step Functions mendukung membaca item hingga 8 MB dari file teks yang dibatasi, JSON, atau file JSON Lines jika Anda kemudian menerapkan `ItemSelector` bidang opsional untuk mengurangi ukuran item.
Step Functions mendukung 10 GB sebagai ukuran maksimum file individual di Amazon S3.
Step Functions memerlukan izin yang sesuai untuk mengakses kumpulan data Amazon S3 yang Anda gunakan. Untuk informasi tentang kebijakan IAM untuk kumpulan data, lihat. [Rekomendasi kebijakan IAM untuk kumpulan data](#itemreader-iam-policies)
Tab berikut menunjukkan contoh sintaks `ItemReader` bidang dan masukan yang diteruskan ke eksekusi alur kerja anak untuk kumpulan data ini.
------
#### [ ItemReader syntax ]
Misalnya, katakanlah Anda memiliki file CSV bernama`ratings.csv`. Kemudian, Anda telah menyimpan file ini dalam awalan yang dinamai `csvDataset` dalam bucket Amazon S3.
```
"ItemReader": {
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "FIRST_ROW",
"CSVDelimiter": "PIPE"
},
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "csvDataset/ratings.csv"
}
}
```
------
#### [ Input to a child workflow execution ]
*Status Peta Terdistribusi* memulai eksekusi alur kerja anak sebanyak jumlah baris yang ada dalam file CSV, tidak termasuk baris header, jika dalam file. Contoh berikut menunjukkan input yang diterima oleh eksekusi alur kerja anak.
```
{
"rating": "3.5",
"movieId": "307",
"userId": "1",
"timestamp": "1256677221"
}
```
------
### File parket dalam ember Amazon S3
File parket dapat digunakan sebagai sumber input. File Apache Parquet yang disimpan di Amazon S3 menyediakan pemrosesan data kolumnar yang efisien dalam skala besar.
Saat menggunakan file Parket, ketentuan berikut berlaku:
+ 256MB adalah ukuran row-group maksimum, dan 5MB adalah ukuran footer maksimum. Jika Anda memberikan file input yang melebihi batas mana pun, mesin status Anda akan mengembalikan kesalahan runtime.
+ `VersionId`Bidang ini **tidak** didukung untuk`InputType=Parquet`.
+ Kompresi data internal GZIP, ZSTD, dan Snappy didukung secara native. Tidak ada ekstensi nama file yang diperlukan.
Berikut ini menunjukkan contoh konfigurasi ASL untuk `InputType` diatur ke Parket:
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "PARQUET"
},
"Arguments": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "my-parquet-data-file-1.parquet"
}
}
```
**Pemrosesan pekerjaan skala besar**
Untuk pekerjaan skala yang sangat besar, Step Functions akan menggunakan banyak pembaca input. Pembaca meninggalkan pemrosesan mereka, yang mungkin mengakibatkan beberapa pembaca berhenti sementara yang lain maju. Kemajuan intermiten adalah perilaku yang diharapkan dalam skala.
### Manifes Athena (memproses beberapa item)
Anda dapat menggunakan file manifes Athena, yang dihasilkan dari hasil `UNLOAD` kueri, untuk menentukan **sumber** file data untuk status Peta Anda. Anda mengatur `ManifestType` ke`ATHENA_DATA`, dan `InputType` ke salah satu`CSV`,`JSONL`, atau`Parquet`.
Saat menjalankan `UNLOAD` kueri, Athena menghasilkan file manifes data selain objek data aktual. File manifes menyediakan daftar CSV terstruktur dari file data. File manifes dan data disimpan ke lokasi hasil kueri Athena Anda di Amazon S3.
```
UNLOAD () TO 'S3_URI_FOR_STORING_DATA_OBJECT' WITH (format = 'JSON')
```
Tinjauan konseptual proses, secara singkat:
1. Pilih data Anda dari Tabel menggunakan `UNLOAD` kueri di Athena.
1. Athena akan menghasilkan file manifes (CSV) dan objek data di Amazon S3.
1. Konfigurasikan Step Functions untuk membaca file manifes dan memproses input.
Fitur ini dapat memproses format keluaran CSV, JSONL, dan Parket dari Athena. Semua objek yang direferensikan dalam satu file manifes harus InputType format yang sama. Perhatikan bahwa objek CSV yang diekspor oleh `UNLOAD` kueri **tidak** menyertakan header di baris pertama. Lihat `CSVHeaderLocation` apakah Anda perlu memberikan header kolom.
Konteks peta juga akan menyertakan `$states.context.Map.Item.Source` sehingga Anda dapat menyesuaikan pemrosesan berdasarkan sumber data.
Berikut ini adalah contoh konfigurasi yang `ItemReader` dikonfigurasi untuk menggunakan manifes Athena:
```
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"ManifestType": "ATHENA_DATA",
"InputType": "CSV | JSONL | PARQUET"
},
"Arguments": {
"Bucket": "",
"Key": "-manifest.csv"
}
}
```
**Menggunakan pola manifes Athena di Workflow Studio**
Skenario umum untuk pemrosesan data menerapkan Peta ke data yang bersumber dari kueri Athena UNLOAD. Peta memanggil fungsi Lambda untuk memproses setiap item yang dijelaskan dalam manifes Athena. Step Functions Workflow Studio menyediakan pola siap pakai yang menggabungkan semua komponen ini menjadi blok seret ke kanvas mesin status Anda.
### Persediaan S3 (memproses beberapa item)
*Status Peta Terdistribusi* dapat menerima file manifes inventaris Amazon S3 yang disimpan di bucket Amazon S3 sebagai kumpulan data.
Saat eksekusi alur kerja mencapai `Map` status, Step Functions akan memanggil tindakan [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)API untuk mengambil file manifes inventaris Amazon S3 yang ditentukan.
Secara default, `Map` status kemudian mengulangi **objek** dalam inventaris untuk mengembalikan array metadata objek inventaris Amazon S3.
Jika Anda menentukan ManifestType adalah S3\$1INVENTORY maka InputType tidak dapat ditentukan.
**catatan**
Step Functions mendukung 10 GB sebagai ukuran maksimum file individual dalam laporan inventaris Amazon S3 setelah dekompresi. Namun, Step Functions dapat memproses lebih dari 10 GB jika setiap file individu di bawah 10 GB.
Step Functions memerlukan izin yang sesuai untuk mengakses kumpulan data Amazon S3 yang Anda gunakan. Untuk informasi tentang kebijakan IAM untuk kumpulan data, lihat. [Rekomendasi kebijakan IAM untuk kumpulan data](#itemreader-iam-policies)
Berikut ini adalah contoh file inventaris dalam format CSV. File ini menyertakan objek bernama `csvDataset` dan`imageDataset`, yang disimpan dalam bucket Amazon S3 yang diberi nama. `amzn-s3-demo-source-bucket`
```
"amzn-s3-demo-source-bucket","csvDataset/","0","2022-11-16T00:27:19.000Z"
"amzn-s3-demo-source-bucket","csvDataset/titles.csv","3399671","2022-11-16T00:29:32.000Z"
"amzn-s3-demo-source-bucket","imageDataset/","0","2022-11-15T20:00:44.000Z"
"amzn-s3-demo-source-bucket","imageDataset/n02085620_10074.jpg","27034","2022-11-15T20:02:16.000Z"
...
```
**penting**
Step Functions tidak mendukung laporan inventaris Amazon S3 yang ditentukan pengguna sebagai kumpulan data.
Format keluaran laporan inventaris Amazon S3 Anda harus CSV.
[Untuk informasi selengkapnya tentang inventaris Amazon S3 dan cara mengaturnya, lihat Inventaris Amazon S3.](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html)
Contoh berikut dari file manifes inventaris Amazon S3 menunjukkan header CSV untuk metadata objek inventaris.
```
{
"sourceBucket" : "amzn-s3-demo-source-bucket",
"destinationBucket" : "arn:aws:s3:::amzn-s3-demo-inventory",
"version" : "2016-11-30",
"creationTimestamp" : "1668560400000",
"fileFormat" : "CSV",
"fileSchema" : "Bucket, Key, Size, LastModifiedDate",
"files" : [ {
"key" : "amzn-s3-demo-bucket/destination-prefix/data/20e55de8-9c21-45d4-99b9-46c732000228.csv.gz",
"size" : 7300,
"MD5checksum" : "a7ff4a1d4164c3cd55851055ec8f6b20"
} ]
}
```
Tab berikut menunjukkan contoh sintaks `ItemReader` bidang dan masukan yang diteruskan ke eksekusi alur kerja anak untuk kumpulan data ini.
------
#### [ ItemReader syntax ]
```
"ItemReader": {
"ReaderConfig": {
"InputType": "MANIFEST"
},
"Resource": "arn:aws:states:::s3:getObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Key": "destination-prefix/amzn-s3-demo-bucket/config-id/YYYY-MM-DDTHH-MMZ/manifest.json"
}
}
```
------
#### [ Input to a child workflow execution ]
```
{
"LastModifiedDate": "2022-11-16T00:29:32.000Z",
"Bucket": "amzn-s3-demo-source-bucket",
"Size": "3399671",
"Key": "csvDataset/titles.csv"
}
```
Bergantung pada bidang yang Anda pilih saat mengonfigurasi laporan inventaris Amazon S3, konten file `manifest.json` Anda mungkin berbeda dari contoh.
------
## Rekomendasi kebijakan IAM untuk kumpulan data
Saat Anda membuat alur kerja dengan konsol Step Functions, Step Functions dapat secara otomatis menghasilkan kebijakan IAM berdasarkan sumber daya dalam definisi alur kerja Anda. Kebijakan yang dihasilkan mencakup hak istimewa paling sedikit yang diperlukan untuk memungkinkan peran mesin status menjalankan tindakan `[StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)` API untuk *status Peta Terdistribusi* dan AWS sumber daya akses, seperti bucket dan objek Amazon S3, serta fungsi Lambda.
Kami merekomendasikan untuk memasukkan hanya izin yang diperlukan dalam kebijakan IAM Anda. Misalnya, jika alur kerja Anda menyertakan `Map` status dalam mode Terdistribusi, cakup kebijakan Anda ke bucket dan folder Amazon S3 tertentu yang berisi data Anda.
**penting**
Jika Anda menentukan bucket dan objek Amazon S3, atau awalan, dengan [jalur referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths) ke pasangan nilai kunci yang ada di input *status Peta Terdistribusi*, pastikan Anda memperbarui kebijakan IAM untuk alur kerja Anda. Cakupan kebijakan hingga ke bucket dan nama objek yang diselesaikan jalur saat runtime.
[Contoh berikut menunjukkan teknik untuk memberikan hak istimewa paling sedikit yang diperlukan untuk mengakses kumpulan data Amazon S3 Anda menggunakan ListObjects tindakan V2 dan API. [GetObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html)](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html)
**Example kondisi menggunakan objek Amazon S3 sebagai kumpulan data**
Kondisi berikut memberikan hak istimewa paling sedikit untuk mengakses objek di `processImages` folder bucket Amazon S3.
```
"Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ],
"Condition": {
"StringLike": {
"s3:prefix": [ "processImages" ]
}
}
```
**Example menggunakan file CSV sebagai kumpulan data**
Contoh berikut menunjukkan tindakan yang diperlukan untuk mengakses file CSV bernama`ratings.csv`.
```
"Action": [ "s3:GetObject" ],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket/csvDataset/ratings.csv"
]
```
**Example menggunakan inventaris Amazon S3 sebagai kumpulan data**
Berikut ini menunjukkan contoh sumber daya untuk manifes inventaris Amazon S3 dan file data.
```
"Resource": [
"arn:aws:s3:::myPrefix/amzn-s3-demo-bucket/myConfig-id/YYYY-MM-DDTHH-MMZ/manifest.json",
"arn:aws:s3:::myPrefix/amzn-s3-demo-bucket/myConfig-id/data/*"
]
```
**Example menggunakan ListObjects V2 untuk membatasi ke awalan folder**
Saat menggunakan [ListObjectsV2](https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html), dua kebijakan akan dibuat. Satu diperlukan untuk mengizinkan **daftar** konten bucket (`ListBucket`) dan kebijakan lain akan memungkinkan **pengambilan objek** di bucket (`GetObject`).
Berikut ini menunjukkan contoh tindakan, sumber daya, dan kondisi:
```
"Action": [ "s3:ListBucket" ],
"Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket" ],
"Condition": {
"StringLike": {
"s3:prefix": [ "/path/to/your/json/" ]
}
}
```
```
"Action": [ "s3:GetObject" ],
"Resource": [ "arn:aws:s3:::amzn-s3-demo-bucket/path/to/your/json/*" ]
```
Perhatikan bahwa tidak `GetObject` akan dicakup dan Anda akan menggunakan wildcard (`*`) untuk objek.
# ItemsPath (Peta, JSONPath hanya)
**Mengelola status dan mengubah data**
Halaman ini mengacu pada JSONPath. Step Functions baru-baru ini menambahkan variabel dan JSONata untuk mengelola status dan mengubah data.
Pelajari tentang [Melewati data dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Dalam keadaan JSONPath berbasis, gunakan `ItemsPath` bidang untuk memilih array atau objek dalam input JSON yang diberikan ke `Map` status. Secara default, `Map` status disetel `ItemsPath` ke`$`, yang memilih seluruh input.
+ Jika input ke `Map` status adalah array JSON, ia menjalankan iterasi untuk setiap item dalam array, meneruskan item itu ke iterasi sebagai input
+ Jika input ke `Map` status adalah objek JSON, ia menjalankan iterasi untuk setiap pasangan kunci-nilai dalam objek, meneruskan pasangan ke iterasi sebagai input
**catatan**
Anda dapat menggunakan `ItemsPath` dalam *status Peta Terdistribusi* hanya jika Anda menggunakan input JSON yang diteruskan dari status sebelumnya dalam alur kerja.
Nilai `ItemsPath` harus berupa [Jalur Referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths), dan jalur itu harus mengevaluasi ke array atau objek JSON. Misalnya, pertimbangkan input ke status `Map` yang mencakup dua array, seperti contoh berikut.
```
{
"ThingsPiratesSay": [
{
"say": "Avast!"
},
{
"say": "Yar!"
},
{
"say": "Walk the Plank!"
}
],
"ThingsGiantsSay": [
{
"say": "Fee!"
},
{
"say": "Fi!"
},
{
"say": "Fo!"
},
{
"say": "Fum!"
}
]
}
```
Dalam hal ini, Anda dapat menentukan array mana yang akan digunakan untuk iterasi `Map` status dengan memilihnya. `ItemsPath` Definisi mesin status berikut menentukan `ThingsPiratesSay` array dalam input menggunakan `ItemsPath` .It kemudian menjalankan iterasi status `SayWord` pass untuk setiap item dalam array. `ThingsPiratesSay`
```
{
"StartAt": "PiratesSay",
"States": {
"PiratesSay": {
"Type": "Map",
"ItemsPath": "$.ThingsPiratesSay",
"ItemProcessor": {
"StartAt": "SayWord",
"States": {
"SayWord": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Untuk objek JSON bersarang, Anda dapat menggunakan `ItemsPath` untuk memilih objek tertentu dalam input. Pertimbangkan masukan berikut dengan data konfigurasi bersarang:
```
{
"environment": "production",
"servers": {
"web": {
"server1": {"port": 80, "status": "active"},
"server2": {"port": 8080, "status": "inactive"}
},
"database": {
"primary": {"host": "db1.example.com", "port": 5432},
"replica": {"host": "db2.example.com", "port": 5432}
}
}
}
```
Untuk mengulangi objek server web, Anda akan mengatur `ItemsPath` ke`$.servers.web`:
```
{
"StartAt": "ProcessWebServers",
"States": {
"ProcessWebServers": {
"Type": "Map",
"ItemsPath": "$.servers.web",
"ItemProcessor": {
"StartAt": "CheckServer",
"States": {
"CheckServer": {
"Type": "Pass",
"End": true
}
}
},
"End": true
}
}
}
```
Saat memproses input, `Map` status berlaku `ItemsPath` setelahnya [`InputPath`](input-output-inputpath-params.md#input-output-inputpath). Ini beroperasi pada input efektif ke negara setelah `InputPath` menyaring input.
Untuk informasi selengkapnya tentang status `Map`, lihat hal berikut:
+ [Status peta](state-map.md)
+ [Mode pemrosesan status peta](state-map.md#concepts-map-process-modes)
+ [Ulangi tindakan dengan Peta Inline](tutorial-map-inline.md)
+ [Pemrosesan input dan output `Map` status sebaris](state-map-inline.md#inline-map-state-output)
# ItemSelector (Peta)
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Secara default, input efektif untuk `Map` status adalah kumpulan item data individual yang ada dalam input status mentah. Dengan `ItemSelector` bidang tersebut, Anda dapat mengganti nilai item data sebelum diteruskan ke status. `Map`
Untuk mengganti nilai, tentukan input JSON valid yang berisi kumpulan pasangan kunci-nilai. Pasangan dapat berupa nilai statis yang disediakan dalam definisi mesin status Anda, nilai yang dipilih dari input status menggunakan [jalur](amazon-states-language-paths.md), atau nilai yang diakses dari [objek Context](input-output-contextobject.md).
Jika Anda menentukan pasangan kunci-nilai menggunakan jalur atau objek Konteks, nama kunci harus diakhiri. `.$`
**catatan**
`ItemSelector`Bidang menggantikan `Parameters` bidang di dalam `Map` negara bagian. Jika Anda menggunakan `Parameters` bidang dalam definisi `Map` status Anda untuk membuat input khusus, kami sarankan Anda menggantinya dengan`ItemSelector`.
Anda dapat menentukan `ItemSelector` bidang dalam status Peta *Sebaris dan status Peta* *Terdistribusi*.
Misalnya, pertimbangkan input JSON berikut yang berisi array tiga item dalam `imageData` node. Untuk setiap *iterasi `Map` status*, item array diteruskan ke iterasi sebagai input.
```
[
{
"resize": "true",
"format": "jpg"
},
{
"resize": "false",
"format": "png"
},
{
"resize": "true",
"format": "jpg"
}
]
```
Menggunakan `ItemSelector` bidang, Anda dapat menentukan input JSON kustom untuk mengganti input asli seperti yang ditunjukkan pada contoh berikut. Step Functions kemudian meneruskan input kustom ini ke setiap *iterasi `Map` status*. Masukan kustom berisi nilai statis untuk `size` dan nilai data objek Konteks untuk `Map` status. Objek `$$.Map.Item.Value` Konteks berisi nilai setiap item data individu.
```
{
"ItemSelector": {
"size": 10,
"value.$": "$$.Map.Item.Value"
}
}
```
Contoh berikut menunjukkan masukan yang diterima oleh satu iterasi dari status *Peta Inline*:
```
{
"size": 10,
"value": {
"resize": "true",
"format": "jpg"
}
}
```
**Tip**
Untuk contoh lengkap *status Peta Terdistribusi* yang menggunakan `ItemSelector` bidang, lihat[Salin CSV skala besar menggunakan Peta Terdistribusi](tutorial-map-distributed.md).
# ItemBatcher (Peta)
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
`ItemBatcher`Bidang adalah objek JSON, yang menentukan untuk memproses sekelompok item dalam eksekusi alur kerja anak tunggal. Gunakan batching saat memproses file CSV besar atau array JSON, atau kumpulan besar objek Amazon S3.
Contoh berikut menunjukkan sintaks `ItemBatcher` bidang. Dalam sintaks berikut, jumlah maksimum item yang harus diproses oleh setiap eksekusi alur kerja anak diatur ke 100.
```
{
"ItemBatcher": {
"MaxItemsPerBatch": 100
}
}
```
Secara default, setiap item dalam kumpulan data diteruskan sebagai input ke eksekusi alur kerja anak individu. Misalnya, asumsikan Anda menentukan file JSON sebagai masukan yang berisi array berikut:
```
[
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
},
{
"verdict": "true",
"statement_date": "5/18/2016",
"statement_source": "news"
},
...
]
```
Untuk input yang diberikan, setiap eksekusi alur kerja anak menerima item array sebagai inputnya. Contoh berikut menunjukkan masukan eksekusi alur kerja anak:
```
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
}
```
Untuk membantu mengoptimalkan kinerja dan biaya pekerjaan pemrosesan Anda, pilih ukuran batch yang menyeimbangkan jumlah item terhadap waktu pemrosesan item. Jika Anda menggunakan batching, Step Functions menambahkan item ke array **Items**. Kemudian meneruskan array sebagai input ke setiap eksekusi alur kerja anak. Contoh berikut menunjukkan batch dari dua item yang diteruskan sebagai masukan ke eksekusi alur kerja anak:
```
{
"Items": [
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
}
]
}
```
**Tip**
Untuk mempelajari lebih lanjut tentang menggunakan `ItemBatcher` bidang dalam alur kerja Anda, coba tutorial dan lokakarya berikut:
[Memproses seluruh kumpulan data dalam fungsi Lambda](tutorial-itembatcher-param-task.md)
[Ulangi item dalam batch di dalam eksekusi alur kerja anak](tutorial-itembatcher-single-item-process.md)
[Peta terdistribusi dan sumber daya terkait](https://catalog.workshops.aws/stepfunctions/use-cases/distributed-map) di *The AWS Step Functions Workshop*
**Contents**
+ [
## Bidang untuk menentukan pengelompokan item
](#input-output-itembatcher-subfields)
## Bidang untuk menentukan pengelompokan item
Untuk mengelompokkan item, tentukan jumlah maksimum item yang akan dikumpulkan, ukuran batch maksimum, atau keduanya. Anda harus menentukan salah satu nilai ini ke item batch.
**Maks item per batch**
Menentukan jumlah maksimum item yang setiap proses eksekusi alur kerja anak. Penerjemah membatasi jumlah item yang dikumpulkan dalam `Items` array ke nilai ini. Jika Anda menentukan nomor dan ukuran batch, penerjemah mengurangi jumlah item dalam batch untuk menghindari melebihi batas ukuran batch yang ditentukan.
Jika Anda tidak menentukan nilai ini tetapi memberikan nilai untuk ukuran batch maksimum, Step Functions akan memproses sebanyak mungkin item dalam setiap eksekusi alur kerja anak tanpa melebihi ukuran batch maksimum dalam byte.
Misalnya, bayangkan Anda menjalankan eksekusi dengan file JSON input yang berisi 1130 node. Jika Anda menentukan nilai item maksimum untuk setiap batch 100, Step Functions akan membuat 12 batch. Dari jumlah tersebut, 11 batch berisi 100 item masing-masing, sedangkan batch kedua belas berisi 30 item yang tersisa.
Atau, Anda dapat menentukan item maksimum untuk setiap batch sebagai [jalur referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths) ke pasangan nilai kunci yang ada di masukan *status Peta Terdistribusi* Anda. Jalur ini harus menyelesaikan ke bilangan bulat positif.
Misalnya, diberikan input berikut:
```
{
"maxBatchItems": 500
}
```
Anda dapat menentukan jumlah maksimum item yang akan dikumpulkan menggunakan jalur referensi (**JSONPath hanya**) sebagai berikut:
```
{
...
"Map": {
"Type": "Map",
"MaxConcurrency": 2000,
"ItemBatcher": {
"MaxItemsPerBatchPath": "$.maxBatchItems"
}
...
...
}
}
```
Untuk status **JSONataberbasis**, Anda juga dapat memberikan JSONata ekspresi yang mengevaluasi ke bilangan bulat positif.
Anda dapat menentukan salah satu `MaxItemsPerBatch` atau `MaxItemsPerBatchPath (JSONPath only)` sub-bidang, tetapi tidak keduanya.
**Maks KiB per batch**
Menentukan ukuran maksimum batch dalam byte, hingga 256 KiB. Jika Anda menentukan nomor dan ukuran batch maksimum, Step Functions mengurangi jumlah item dalam batch untuk menghindari melebihi batas ukuran batch yang ditentukan.
Atau, Anda dapat menentukan ukuran batch maksimum sebagai [jalur referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths) ke pasangan nilai kunci yang ada di masukan *status Peta Terdistribusi* Anda. Jalur ini harus menyelesaikan ke bilangan bulat positif.
Jika Anda menggunakan batching dan tidak menentukan ukuran batch maksimum, penerjemah memproses sebanyak mungkin item yang dapat diproses hingga 256 KiB di setiap eksekusi alur kerja anak.
Misalnya, diberikan input berikut:
```
{
"batchSize": 131072
}
```
Anda dapat menentukan ukuran batch maksimum menggunakan jalur referensi sebagai berikut:
```
{
...
"Map": {
"Type": "Map",
"MaxConcurrency": 2000,
"ItemBatcher": {
"MaxInputBytesPerBatchPath": "$.batchSize"
}
...
...
}
}
```
Untuk status **JSONataberbasis**, Anda juga dapat memberikan JSONata ekspresi yang mengevaluasi ke bilangan bulat positif.
Anda dapat menentukan sub-bidang `MaxInputBytesPerBatch` atau `MaxInputBytesPerBatchPath` (JSONPath hanya), tetapi tidak keduanya.
**Masukan Batch**
Secara opsional, Anda juga dapat menentukan input JSON tetap untuk disertakan dalam setiap batch yang diteruskan ke setiap eksekusi alur kerja anak. Step Functions menggabungkan input ini dengan input untuk setiap eksekusi alur kerja anak individu. Misalnya, diberikan masukan tetap berikut dari tanggal pemeriksaan fakta pada array item:
```
"ItemBatcher": {
"BatchInput": {
"factCheck": "December 2022"
}
}
```
Setiap eksekusi alur kerja anak menerima yang berikut ini sebagai masukan:
```
{
"BatchInput": {
"factCheck": "December 2022"
},
"Items": [
{
"verdict": "true",
"statement_date": "6/11/2008",
"statement_source": "speech"
},
{
"verdict": "false",
"statement_date": "6/7/2022",
"statement_source": "television"
},
...
]
}
```
Untuk status **JSONataberbasis**, Anda dapat memberikan JSONata ekspresi langsung ke BatchInput, atau menggunakan JSONata ekspresi di dalam objek atau array JSON.
# ResultWriter (Peta)
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
`ResultWriter`Bidang adalah objek JSON yang menyediakan opsi untuk hasil keluaran eksekusi alur kerja anak yang dimulai oleh status Peta Terdistribusi. Anda dapat menentukan opsi pemformatan yang berbeda untuk hasil keluaran bersama dengan lokasi Amazon S3 untuk menyimpannya jika Anda memilih untuk mengekspornya. Step Functions tidak mengekspor hasil ini secara default.
**Topics**
+ [
## Isi ResultWriter lapangan
](#input-output-resultwriter-field-contents)
+ [Contoh](#input-output-resultwriter-examples)
+ [
## Mengekspor ke Amazon S3
](#input-output-resultwriter-exporting-to-S3)
+ [
## Kebijakan IAM untuk ResultWriter
](#resultwriter-iam-policies)
## Isi ResultWriter lapangan
`ResultWriter`Bidang berisi sub-bidang berikut. Pilihan bidang menentukan bagaimana output diformat dan apakah itu diekspor ke Amazon S3.
**`ResultWriter`**
Sebuah objek JSON yang menentukan rincian berikut:
+ `Resource`
Tindakan Amazon S3 API yang dipanggil Step Functions untuk mengekspor hasil eksekusi.
+ `Parameters`
Objek JSON yang menentukan nama bucket Amazon S3 dan awalan yang menyimpan output eksekusi.
+ `WriterConfig`
Bidang ini memungkinkan Anda untuk mengkonfigurasi opsi berikut.
+ `Transformation`
+ `NONE`- mengembalikan output dari eksekusi alur kerja anak tidak berubah, selain metadata alur kerja. Default saat mengekspor hasil eksekusi alur kerja anak ke Amazon S3 `WriterConfig` dan tidak ditentukan.
+ `COMPACT`- mengembalikan output dari eksekusi alur kerja anak. Default ketika `ResultWriter` tidak ditentukan.
+ `FLATTEN`- mengembalikan output dari eksekusi alur kerja anak. Jika eksekusi alur kerja anak mengembalikan array, opsi ini meratakan array, sebelum mengembalikan hasilnya ke output status atau menulis hasilnya ke objek Amazon S3.
**catatan**
Jika eksekusi alur kerja anak gagal, Step Functions mengembalikan hasil eksekusinya tidak berubah. Hasilnya akan setara dengan menyetel `Transformation` ke`NONE`.
+ `OutputType`
+ `JSON`- memformat hasil sebagai array JSON.
+ `JSONL`- memformat hasil sebagai JSON Lines.
**Kombinasi bidang yang diperlukan**
`ResultWriter`Bidang tidak bisa kosong. Anda harus menentukan salah satu dari kumpulan sub-bidang ini.
+ `WriterConfig`- untuk melihat pratinjau output yang diformat, tanpa menyimpan hasilnya ke Amazon S3.
+ `Resource`dan `Parameters` - untuk menyimpan hasil ke Amazon S3 tanpa pemformatan tambahan.
+ Ketiga bidang:`WriterConfig`, `Resource` dan `Parameters` - untuk memformat output dan menyimpannya ke Amazon S3.
## Contoh konfigurasi dan output transformasi
Topik berikut menunjukkan kemungkinan pengaturan konfigurasi `ResultWriter` dan contoh hasil yang diproses dari opsi transformasi yang berbeda.
+ [ResultWriter konfigurasi](#input-output-resultwriter-example-configurations)
+ [Transformasi](#input-output-resultwriter-example-transformations)
### Contoh ResultWriter konfigurasi
Contoh berikut menunjukkan konfigurasi dengan kemungkinan kombinasi dari tiga bidang:`WriterConfig`, `Resources` dan`Parameters`.
**Hanya *WriterConfig***
Contoh ini mengonfigurasi bagaimana output status disajikan dalam pratinjau, dengan format output dan transformasi yang ditentukan di `WriterConfig` bidang. *Tidak ada `Resource` dan `Parameters` bidang, yang akan menyediakan spesifikasi bucket Amazon S3, menyiratkan sumber daya keluaran status.* Hasilnya diteruskan ke keadaan berikutnya.
```
"ResultWriter": {
"WriterConfig": {
"Transformation": "FLATTEN",
"OutputType": "JSON"
}
}
```
**Hanya *Sumber Daya* dan *Parameter***
Contoh ini mengekspor output status ke bucket Amazon S3 yang ditentukan, tanpa pemformatan dan transformasi tambahan yang akan ditentukan oleh bidang yang `WriterConfig` tidak ada.
```
"ResultWriter": {
"Resource": "arn:aws:states:::s3:putObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
```
**Ketiga bidang: *WriterConfig*, *Sumber Daya* dan *Parameter***
Contoh ini memformat output status sesuai spesifikasi di `WriterConfig` lapangan. Itu juga mengekspornya ke ember Amazon S3 sesuai dengan spesifikasi di bidang `Resource` dan`Parameters`.
```
"ResultWriter": {
"WriterConfig": {
"Transformation": "FLATTEN",
"OutputType": "JSON"
},
"Resource": "arn:aws:states:::s3:putObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
}
```
### Contoh transformasi
Untuk contoh ini asumsikan bahwa setiap eksekusi alur kerja anak mengembalikan output, yang merupakan array objek.
```
[
{
"customer_id": "145538",
"order_id": "100000"
},
{
"customer_id": "898037",
"order_id": "100001"
}
]
```
Contoh-contoh ini menunjukkan output yang diformat untuk `Transformation` nilai yang berbeda, dengan `OutputType` dari. `JSON`
**Transformasi TIDAK ADA**
Ini adalah contoh hasil yang diproses saat Anda menggunakan `NONE` transformasi. Outputnya tidak berubah, dan itu termasuk metadata alur kerja.
```
[
{
"ExecutionArn": "arn:aws:states:region:account-id:execution:orderProcessing/getOrders:da4e9fc7-abab-3b27-9a77-a277e463b709",
"Input": ...,
"InputDetails": {
"Included": true
},
"Name": "da4e9fc7-abab-3b27-9a77-a277e463b709",
"Output": "[{\"customer_id\":\"145538\",\"order_id\":\"100000\"},{\"customer_id\":\"898037\",\"order_id\":\"100001\"}]",
"OutputDetails": {
"Included": true
},
"RedriveCount": 0,
"RedriveStatus": "NOT_REDRIVABLE",
"RedriveStatusReason": "Execution is SUCCEEDED and cannot be redriven",
"StartDate": "2025-02-04T01:49:50.099Z",
"StateMachineArn": "arn:aws:states:region:account-id:stateMachine:orderProcessing/getOrders",
"Status": "SUCCEEDED",
"StopDate": "2025-02-04T01:49:50.163Z"
},
...
{
"ExecutionArn": "arn:aws:states:region:account-id:execution:orderProcessing/getOrders:f43a56f7-d21e-3fe9-a40c-9b9b8d0adf5a",
"Input": ...,
"InputDetails": {
"Included": true
},
"Name": "f43a56f7-d21e-3fe9-a40c-9b9b8d0adf5a",
"Output": "[{\"customer_id\":\"169881\",\"order_id\":\"100005\"},{\"customer_id\":\"797471\",\"order_id\":\"100006\"}]",
"OutputDetails": {
"Included": true
},
"RedriveCount": 0,
"RedriveStatus": "NOT_REDRIVABLE",
"RedriveStatusReason": "Execution is SUCCEEDED and cannot be redriven",
"StartDate": "2025-02-04T01:49:50.135Z",
"StateMachineArn": "arn:aws:states:region:account-id:stateMachine:orderProcessing/getOrders",
"Status": "SUCCEEDED",
"StopDate": "2025-02-04T01:49:50.227Z"
}
]
```
**Transformasi COMPACT**
Ini adalah contoh hasil yang diproses saat Anda menggunakan `COMPACT` transformasi. Perhatikan bahwa ini adalah output gabungan dari eksekusi alur kerja anak dengan struktur array asli.
```
[
[
{
"customer_id": "145538",
"order_id": "100000"
},
{
"customer_id": "898037",
"order_id": "100001"
}
],
...,
[
{
"customer_id": "169881",
"order_id": "100005"
},
{
"customer_id": "797471",
"order_id": "100006"
}
]
]
```
**Transformasi FLATTEN**
Ini adalah contoh hasil yang diproses saat Anda menggunakan `FLATTEN` transformasi. Perhatikan bahwa ini adalah output gabungan dari array eksekusi alur kerja anak yang diratakan menjadi satu array.
```
[
{
"customer_id": "145538",
"order_id": "100000"
},
{
"customer_id": "898037",
"order_id": "100001"
},
...
{
"customer_id": "169881",
"order_id": "100005"
},
{
"customer_id": "797471",
"order_id": "100006"
}
]
```
## Mengekspor ke Amazon S3
**penting**
Pastikan bucket Amazon S3 yang Anda gunakan untuk mengekspor hasil Map Run berada di bawah yang sama Akun AWS dan Wilayah AWS sebagai mesin status Anda. Jika tidak, eksekusi mesin status Anda akan gagal dengan `States.ResultWriterFailed` kesalahan tersebut.
Mengekspor hasil ke bucket Amazon S3 sangat membantu jika ukuran payload output Anda melebihi 256 KiB. Step Functions mengkonsolidasikan semua data eksekusi alur kerja anak, seperti input dan output eksekusi, ARN, dan status eksekusi. Kemudian mengekspor eksekusi dengan status yang sama ke file masing-masing di lokasi Amazon S3 yang ditentukan.
Contoh berikut, menggunakan **JSONPath**, menunjukkan sintaks `ResultWriter` bidang dengan `Parameters` untuk mengekspor hasil eksekusi alur kerja anak. Dalam contoh ini, Anda menyimpan hasilnya dalam bucket bernama `amzn-s3-demo-destination-bucket` dalam awalan yang disebut`csvProcessJobs`.
```
{
"ResultWriter": {
"Resource": "arn:aws:states:::s3:putObject",
"Parameters": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
}
}
```
Untuk **JSONata**negara bagian, `Parameters` akan diganti dengan`Arguments`.
```
{
"ResultWriter": {
"Resource": "arn:aws:states:::s3:putObject",
"Arguments": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Prefix": "csvProcessJobs"
}
}
}
```
**Tip**
Di Workflow Studio, Anda dapat mengekspor hasil eksekusi alur kerja turunan dengan memilih **Hasil status Peta Ekspor ke Amazon S3**. Kemudian, berikan nama bucket Amazon S3 dan awalan tempat Anda ingin mengekspor hasilnya.
Step Functions membutuhkan izin yang sesuai untuk mengakses bucket dan folder tempat Anda ingin mengekspor hasilnya. Untuk informasi tentang kebijakan IAM yang diperlukan, lihat[Kebijakan IAM untuk ResultWriter](#resultwriter-iam-policies).
Jika Anda mengekspor hasil eksekusi alur kerja turunan, eksekusi *status Peta Terdistribusi* akan menampilkan ARN Jalankan Peta dan data tentang lokasi ekspor Amazon S3 dalam format berikut:
```
{
"MapRunArn": "arn:aws:states:us-east-2:account-id:mapRun:csvProcess/Map:ad9b5f27-090b-3ac6-9beb-243cd77144a7",
"ResultWriterDetails": {
"Bucket": "amzn-s3-demo-destination-bucket",
"Key": "csvProcessJobs/ad9b5f27-090b-3ac6-9beb-243cd77144a7/manifest.json"
}
}
```
Step Functions mengekspor eksekusi dengan status yang sama ke file masing-masing. Misalnya, jika eksekusi alur kerja anak Anda menghasilkan 500 keberhasilan dan 200 hasil kegagalan, Step Functions akan membuat dua file di lokasi Amazon S3 yang ditentukan untuk hasil keberhasilan dan kegagalan. Dalam contoh ini, file hasil sukses berisi 500 hasil keberhasilan, sedangkan file hasil kegagalan berisi 200 hasil kegagalan.
Untuk upaya eksekusi tertentu, Step Functions membuat file berikut di lokasi Amazon S3 yang ditentukan tergantung pada output eksekusi Anda:
+ `manifest.json`— Berisi metadata Map Run, seperti lokasi ekspor, Map Run ARN, dan informasi tentang file hasil.
Jika Anda [redriven](redrive-map-run.md)memiliki Map Run, `manifest.json` file tersebut, berisi referensi ke semua eksekusi alur kerja anak yang berhasil di semua upaya Map Run. Namun, file ini berisi referensi ke eksekusi yang gagal dan tertunda untuk yang spesifikredrive.
+ `SUCCEEDED_n.json`— Berisi data konsolidasi untuk semua eksekusi alur kerja anak yang berhasil. *n* mewakili nomor indeks file. Nomor indeks dimulai dari 0. Misalnya, `SUCCEEDED_1.json`.
+ `FAILED_n.json`— Berisi data konsolidasi untuk semua eksekusi alur kerja anak yang gagal, habis waktu, dan dibatalkan. Gunakan file ini untuk memulihkan dari eksekusi yang gagal. *n* mewakili indeks file. Nomor indeks dimulai dari 0. Misalnya, `FAILED_1.json`.
+ `PENDING_n.json`— Berisi data konsolidasi untuk semua eksekusi alur kerja anak yang tidak dimulai karena Map Run gagal atau dibatalkan. *n* mewakili indeks file. Nomor indeks dimulai dari 0. Misalnya, `PENDING_1.json`.
Step Functions mendukung file hasil individual hingga 5 GB. Jika ukuran file melebihi 5 GB, Step Functions membuat file lain untuk menulis hasil eksekusi yang tersisa dan menambahkan nomor indeks ke nama file. Misalnya, jika ukuran `SUCCEEDED_0.json` file melebihi 5 GB, Step Functions membuat `SUCCEEDED_1.json` file untuk merekam hasil yang tersisa.
Jika Anda tidak menentukan untuk mengekspor hasil eksekusi alur kerja anak, eksekusi mesin status mengembalikan larik hasil eksekusi alur kerja anak seperti yang ditunjukkan pada contoh berikut:
```
[
{
"statusCode": 200,
"inputReceived": {
"show_id": "s1",
"release_year": "2020",
"rating": "PG-13",
"type": "Movie"
}
},
{
"statusCode": 200,
"inputReceived": {
"show_id": "s2",
"release_year": "2021",
"rating": "TV-MA",
"type": "TV Show"
}
},
...
]
```
**catatan**
Jika ukuran output yang dikembalikan melebihi 256 KiB, eksekusi mesin status gagal dan mengembalikan `States.DataLimitExceeded` kesalahan.
## Kebijakan IAM untuk ResultWriter
Saat Anda membuat alur kerja dengan konsol Step Functions, Step Functions dapat secara otomatis menghasilkan kebijakan IAM berdasarkan sumber daya dalam definisi alur kerja Anda. Kebijakan yang dihasilkan mencakup hak istimewa paling sedikit yang diperlukan untuk memungkinkan peran mesin status menjalankan tindakan `[StartExecution](https://docs.aws.amazon.com/step-functions/latest/apireference/API_StartExecution.html)` API untuk *status Peta Terdistribusi* dan AWS sumber daya akses, seperti bucket dan objek Amazon S3, serta fungsi Lambda.
Kami merekomendasikan untuk memasukkan hanya izin yang diperlukan dalam kebijakan IAM Anda. Misalnya, jika alur kerja Anda menyertakan `Map` status dalam mode Terdistribusi, cakup kebijakan Anda ke bucket dan folder Amazon S3 tertentu yang berisi data Anda.
**penting**
Jika Anda menentukan bucket dan objek Amazon S3, atau awalan, dengan [jalur referensi](amazon-states-language-paths.md#amazon-states-language-reference-paths) ke pasangan nilai kunci yang ada di input *status Peta Terdistribusi*, pastikan Anda memperbarui kebijakan IAM untuk alur kerja Anda. Cakupan kebijakan hingga ke bucket dan nama objek yang diselesaikan jalur saat runtime.
Contoh kebijakan IAM berikut memberikan hak istimewa paling sedikit yang diperlukan untuk menulis hasil eksekusi alur kerja turunan Anda ke folder bernama dalam bucket *csvJobs* Amazon S3 menggunakan tindakan API. `[PutObject](https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html)`
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:ListMultipartUploadParts",
"s3:AbortMultipartUpload"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-destination-bucket/csvJobs/*"
]
}
]
}
```
Jika bucket Amazon S3 tempat Anda menulis hasil eksekusi alur kerja turunan dienkripsi menggunakan AWS Key Management Service (AWS KMS) kunci, Anda harus menyertakan AWS KMS izin yang diperlukan dalam kebijakan IAM Anda. Lihat informasi yang lebih lengkap di [Izin IAM untuk bucket AWS KMS key Amazon S3 terenkripsi](iam-policies-eg-dist-map.md#multiupload-dmap-result-policy).
# Bagaimana Step Functions mem-parsing file CSV masukan
**Mengelola status dan mengubah data**
Pelajari tentang [Melewati data antar status dengan variabel](workflow-variables.md) dan [Mengubah data dengan JSONata](transforming-data.md).
Step Functions mem-parsing file teks yang dibatasi berdasarkan aturan berikut:
+ Pembatas yang memisahkan bidang ditentukan oleh in. `CSVDelimiter` *ReaderConfig* Delimiter default ke. `COMMA`
+ **Baris baru adalah pembatas yang memisahkan catatan.**
+ Bidang diperlakukan sebagai string. Untuk konversi tipe data, gunakan fungsi `States.StringToJson` intrinsik di. [ItemSelector (Peta)](input-output-itemselector.md)
+ Tanda kutip ganda (” “) tidak diperlukan untuk melampirkan string. Namun, string yang diapit oleh tanda kutip ganda dapat berisi koma dan baris baru tanpa bertindak sebagai pembatas rekaman.
+ Anda dapat mempertahankan tanda kutip ganda dengan mengulanginya.
+ Backslashes (\$1) adalah cara lain untuk melarikan diri dari karakter khusus. Garis miring terbalik hanya berfungsi dengan garis miring terbalik lainnya, tanda kutip ganda, dan pemisah bidang yang dikonfigurasi seperti koma atau pipa. Garis miring terbalik yang diikuti oleh karakter lain dihapus secara diam-diam.
+ Anda dapat mempertahankan garis miring terbalik dengan mengulanginya. Contoh:
```
path,size
C:\\Program Files\\MyApp.exe,6534512
```
+ Garis miring terbalik yang lolos dari tanda kutip ganda (`\"`), hanya berfungsi jika disertakan dalam pasangan, jadi kami sarankan untuk menghindari tanda kutip ganda dengan mengulanginya:. `""`
+ Jika jumlah bidang dalam satu baris **kurang** dari jumlah bidang di header, Step Functions menyediakan **string kosong** untuk nilai yang hilang.
+ Jika jumlah bidang dalam satu baris **lebih** dari jumlah bidang di header, **Step Functions melewatkan** bidang tambahan.
**Contoh penguraian file CSV masukan**
Katakanlah Anda telah menyediakan file CSV bernama `myCSVInput.csv` yang berisi satu baris sebagai input. Kemudian, Anda telah menyimpan file ini di bucket Amazon S3 yang diberi nama. `amzn-s3-demo-bucket` File CSV adalah sebagai berikut.
```
abc,123,"This string contains commas, a double quotation marks (""), and a newline (
)",{""MyKey"":""MyValue""},"[1,2,3]"
```
Mesin status berikut membaca file CSV ini dan digunakan [ItemSelector (Peta)](input-output-itemselector.md) untuk mengonversi tipe data dari beberapa bidang.
```
{
"StartAt": "Map",
"States": {
"Map": {
"Type": "Map",
"ItemProcessor": {
"ProcessorConfig": {
"Mode": "DISTRIBUTED",
"ExecutionType": "STANDARD"
},
"StartAt": "Pass",
"States": {
"Pass": {
"Type": "Pass",
"End": true
}
}
},
"End": true,
"Label": "Map",
"MaxConcurrency": 1000,
"ItemReader": {
"Resource": "arn:aws:states:::s3:getObject",
"ReaderConfig": {
"InputType": "CSV",
"CSVHeaderLocation": "GIVEN",
"CSVHeaders": [
"MyLetters",
"MyNumbers",
"MyString",
"MyObject",
"MyArray"
]
},
"Parameters": {
"Bucket": "amzn-s3-demo-bucket",
"Key": "myCSVInput.csv"
}
},
"ItemSelector": {
"MyLetters.$": "$$.Map.Item.Value.MyLetters",
"MyNumbers.$": "States.StringToJson($$.Map.Item.Value.MyNumbers)",
"MyString.$": "$$.Map.Item.Value.MyString",
"MyObject.$": "States.StringToJson($$.Map.Item.Value.MyObject)",
"MyArray.$": "States.StringToJson($$.Map.Item.Value.MyArray)"
}
}
}
}
```
Ketika Anda menjalankan mesin status ini, menghasilkan output berikut.
```
[
{
"MyNumbers": 123,
"MyObject": {
"MyKey": "MyValue"
},
"MyString": "This string contains commas, a double quote (\"), and a newline (\n)",
"MyLetters": "abc",
"MyArray": [
1,
2,
3
]
}
]
```