Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Menangani kesalahan dalam alur kerja Step Functions
Semua status, kecuali `Pass` dan `Wait` status, dapat mengalami kesalahan runtime. Kesalahan dapat terjadi karena berbagai alasan, termasuk yang berikut:
+ **Masalah definisi mesin negara** - seperti status Pilihan tanpa aturan yang cocok
+ **Kegagalan tugas** - seperti pengecualian dalam suatu AWS Lambda fungsi
+ **Masalah sementara** - seperti peristiwa partisi jaringan
Ketika status melaporkan kesalahan, Step Functions default gagal **seluruh** eksekusi mesin status. Step Functions juga memiliki fitur penanganan kesalahan yang lebih canggih. Anda dapat mengatur mesin status Anda untuk menangkap kesalahan, mencoba lagi status gagal, dan menerapkan protokol penanganan kesalahan dengan anggun.
Penangkap Step Functions tersedia untuk status **Tugas**, **Paralel**, dan **Peta**, tetapi tidak untuk kegagalan eksekusi mesin status tingkat atas. Untuk menangani eksekusi yang Anda antisipasi mungkin gagal, penelepon Anda dapat menangani kesalahan, atau Anda mungkin menyarangkan eksekusi tersebut di dalam alur kerja anak untuk menangkap kesalahan di dalam alur kerja induk Anda. Atau, Anda dapat memilih untuk mendengarkan `TIMED_OUT` peristiwa dari alur kerja Standar dengan EventBridge bus dan menjalankan tindakan untuk menangani eksekusi yang gagal.
**Contoh praktis untuk menangani kesalahan**
*Untuk menerapkan contoh alur kerja yang mencakup penanganan kesalahan, lihat [Menangani kondisi kesalahan di mesin status Step Functions](tutorial-handling-error-conditions.md) tutorial dalam panduan ini, dan [Penanganan Kesalahan](https://catalog.workshops.aws/stepfunctions/handling-errors) di Workshop. AWS Step Functions *
## Nama kesalahan
*Step Functions mengidentifikasi kesalahan menggunakan string case-sensitive, yang dikenal sebagai nama kesalahan.* Bahasa Status Amazon menentukan satu set string built-in yang menamai kesalahan terkenal, semua dimulai dengan prefiks `States.`.
Status dapat melaporkan kesalahan dengan nama lain. Namun, nama kesalahan tidak dapat dimulai dengan `States.` awalan.
Pastikan kode produksi Anda dapat menangani pengecualian AWS Lambda layanan (`Lambda.ServiceException`dan`Lambda.SdkClientException`). Untuk informasi selengkapnya, lihat cara melakukannya [Menangani pengecualian layanan Lambda sementara](sfn-best-practices.md#bp-lambda-serviceexception) di *Praktik terbaik*.
** `States.ALL` **
Sebuah wildcard yang cocok dengan nama kesalahan yang dikenal.
Jenis `States.ALL` kesalahan harus muncul sendiri di a `Catcher` dan tidak dapat menangkap kesalahan `States.DataLimitExceeded` terminal atau jenis `Runtime` kesalahan.
Untuk informasi selengkapnya, lihat [`States.DataLimitExceeded`](#error-data-limit-exceed) dan [`States.Runtime`](#states-runtime-error).
** `States.DataLimitExceeded` **
Kesalahan terminal yang tidak dapat ditangkap oleh jenis `States.ALL` kesalahan.
Dilaporkan karena kondisi berikut:
+ Output konektor lebih besar dari kuota ukuran payload.
+ Output suatu negara lebih besar dari kuota ukuran payload.
+ Setelah `Parameters` diproses, masukan suatu negara lebih besar dari kuota ukuran payload.
Untuk informasi lebih lanjut tentang kuota, lihat [Kuota layanan Step Functions](service-quotas.md).
**`States.ExceedToleratedFailureThreshold`**
`Map`Status gagal karena jumlah item yang gagal melebihi ambang batas yang ditentukan dalam definisi mesin status. Untuk informasi selengkapnya, lihat [Menyetel ambang kegagalan untuk status Peta Terdistribusi di Step Functions](state-map-distributed.md#maprun-fail-threshold).
** `States.HeartbeatTimeout` **
Sebuah `Task` negara gagal mengirim detak jantung untuk jangka waktu yang lebih lama dari `HeartbeatSeconds` nilainya.
`HeartbeatTimeout`tersedia di dalam `Catch` dan `Retry` bidang.
** `States.Http.Socket` **
Terjadi ketika tugas HTTP habis setelah 60 detik. Lihat [Kuota yang terkait dengan HTTP Task](service-quotas.md#service-limits-http-task).
**`States.ItemReaderFailed`**
`Map`Status gagal karena tidak dapat membaca dari sumber item yang ditentukan di `ItemReader` bidang. Untuk informasi selengkapnya, lihat `ItemReader (Peta)`.
** `States.Permissions` **
`Task`Status gagal karena memiliki hak istimewa yang tidak memadai untuk menjalankan kode yang ditentukan.
**`States.ResultWriterFailed`**
`Map`Status gagal karena tidak dapat menulis hasil ke tujuan yang ditentukan di `ResultWriter` bidang. Untuk informasi selengkapnya, lihat `ResultWriter (Peta)`.
**`States.Runtime`**
Eksekusi gagal karena beberapa pengecualian yang tidak dapat diproses. Sering kali ini disebabkan oleh kesalahan saat waktu aktif, seperti mencoba untuk menerapkan `InputPath` atau `OutputPath` pada muatan JSON null. `States.Runtime`Kesalahan tidak dapat diambil kembali, dan akan selalu menyebabkan eksekusi gagal. Sebuah retry atau catch on `States.ALL` won't catch `States.Runtime` error.
** `States.TaskFailed` **
Status `Task` gagal selama eksekusi. Ketika digunakan dalam coba lagi atau menangkap, `States.TaskFailed` bertindak sebagai wildcard yang cocok dengan nama kesalahan yang diketahui kecuali untuk `States.Timeout`.
** `States.Timeout` **
Dilaporkan ketika `Task` status berjalan lebih lama dari `TimeoutSeconds` nilai atau gagal mengirim detak jantung untuk jangka waktu yang lebih lama dari `HeartbeatSeconds` nilainya.
Jika *mesin status bersarang* melempar a`States.Timeout`, induk akan menerima kesalahan. `States.TaskedFailed`
`States.Timeout`Kesalahan juga dilaporkan ketika seluruh eksekusi mesin status berjalan lebih lama dari `TimeoutSeconds` nilai yang ditentukan.
**catatan**
Kesalahan yang tidak tertangani dalam runtime Lambda secara historis dilaporkan hanya sebagai. `Lambda.Unknown` Di runtime yang lebih baru, batas waktu dilaporkan seperti `Sandbox.Timedout` pada keluaran kesalahan.
Ketika Lambda melebihi jumlah maksimum pemanggilan, kesalahan yang dilaporkan akan terjadi. `Lambda.TooManyRequestsException`
Cocokkan `Lambda.Unknown``Sandbox.Timedout`,, dan `States.TaskFailed` untuk menangani kemungkinan kesalahan. Anda juga dapat menggunakan`States.ALL`, tetapi harus sendiri dan di akhir daftar.
Untuk informasi lebih lanjut tentang kesalahan `Handled` dan `Unhandled` Lambda, lihat `FunctionError` dalam [Panduan Developer AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html#API_Invoke_ResponseSyntax).
## Mencoba kembali setelah kesalahan
`Task`,`Parallel`, dan `Map` status dapat memiliki bidang bernama`Retry`, yang nilainya harus berupa array objek yang dikenal sebagai *retrier.* Pengulang individual merepresentasikan sejumlah percobaan kembali, biasanya pada interval waktu yang meningkat.
Ketika salah satu status ini melaporkan kesalahan dan ada `Retry` bidang, Step Functions memindai melalui retrier dalam urutan yang tercantum dalam array. Ketika nama kesalahan muncul di nilai `ErrorEquals` bidang retrier, mesin status melakukan upaya coba lagi seperti yang didefinisikan di `Retry` bidang.
Jika redriven eksekusi Anda menjalankan ulang [status[Status alur kerja tugas](state-task.md),[Status alur kerja paralel](state-parallel.md), atau Peta Sebaris](state-map-inline.md), yang telah Anda tetapkan [percobaan ulang](#error-handling-retrying-after-an-error), jumlah upaya coba lagi untuk status ini disetel ulang ke 0 untuk memungkinkan jumlah upaya maksimum. redrive Untuk redriven eksekusi, Anda dapat melacak upaya percobaan ulang individual dari status ini menggunakan konsol. Untuk informasi selengkapnya, lihat [Coba lagi perilaku eksekusi redriven](redrive-executions.md#redrive-retry-behavior) di [Memulai ulang eksekusi mesin status dengan redrive in Step Functions](redrive-executions.md).
Retrier berisi bidang-bidang berikut:
** `ErrorEquals` (Wajib)**
Sebuah array string nonkosong yang cocok dengan nama kesalahan. Ketika status melaporkan kesalahan, Step Functions memindai melalui retrier. Ketika nama kesalahan muncul dalam array ini, array menerapkan kebijakan coba lagi yang dijelaskan dalam retier ini.
** `IntervalSeconds` (Opsional)**
Sebuah bilangan bulat positif yang mewakili jumlah detik sebelum percobaan ulang pertama (secara `1` default). `IntervalSeconds`memiliki nilai maksimum 99999999.
** `MaxAttempts` (Opsional)**
Sebuah bilangan bulat positif yang mewakili jumlah maksimum percobaan coba lagi (`3` secara default). Jika kesalahan berulang kali lebih dari yang ditentukan, percobaan ulang berhenti dan penanganan kesalahan normal dilanjutkan. Nilai `0` menentukan bahwa kesalahan tidak pernah dicoba lagi. `MaxAttempts`memiliki nilai maksimum 99999999.
** `BackoffRate` (Opsional)**
Pengganda dimana interval coba lagi dilambangkan dengan `IntervalSeconds` peningkatan setelah setiap upaya coba lagi. Secara default, nilai `BackoffRate` meningkat sebesar `2.0`.
Misalnya, katakanlah Anda `IntervalSeconds` adalah 3, `MaxAttempts` adalah 3, dan `BackoffRate` 2. Upaya coba lagi pertama dilakukan tiga detik setelah kesalahan terjadi. Percobaan kedua berlangsung enam detik setelah upaya coba lagi pertama. Sedangkan percobaan ulang ketiga berlangsung 12 detik setelah upaya coba lagi kedua.
** `MaxDelaySeconds` (Opsional) **
Bilangan bulat positif yang menetapkan nilai maksimum, dalam hitungan detik, hingga interval coba lagi dapat meningkat. Bidang ini berguna untuk digunakan dengan `BackoffRate` bidang. Nilai yang Anda tentukan di bidang ini membatasi waktu tunggu eksponensial yang dihasilkan dari pengganda tingkat backoff yang diterapkan pada setiap upaya percobaan ulang berturut-turut. Anda harus menentukan nilai yang lebih besar dari 0 dan kurang dari 31622401 untuk. `MaxDelaySeconds`
Jika Anda tidak menentukan nilai ini, Step Functions tidak membatasi waktu tunggu antara percobaan ulang.
** `JitterStrategy` (Opsional) **
String yang menentukan apakah akan menyertakan jitter dalam waktu tunggu antara upaya coba lagi berturut-turut. Jitter mengurangi upaya percobaan ulang simultan dengan menyebarkannya melalui interval penundaan acak. String ini menerima `FULL` atau `NONE` sebagai nilainya. Nilai default-nya adalah `NONE`.
Misalnya, Anda telah menetapkan `MaxAttempts` sebagai 3, `IntervalSeconds` sebagai 2, dan `BackoffRate` sebagai 2. Upaya coba ulang yang pertama dilakukan dua detik setelah kesalahan terjadi. Coba ulang kedua dilakukan empat detik setelah upaya coba ulang pertama dan upaya coba ulang ketiga dilakukan delapan detik setelah upaya coba ulang kedua. Jika Anda menetapkan `JitterStrategy` sebagai`FULL`, interval coba ulang pertama diacak antara 0 dan 2 detik, interval coba lagi kedua diacak antara 0 dan 4 detik, dan interval coba ulang ketiga diacak antara 0 dan 8 detik.
**catatan**
Percobaan ulang diperlakukan sebagai transisi status. Untuk informasi tentang cara transisi status mempengaruhi penagihan, lihat [Harga Step Functions](https://aws.amazon.com/step-functions/pricing/).
### Coba lagi contoh bidang
Bagian ini mencakup contoh `Retry` bidang berikut.
+ [Retry with BackoffRate](#retrybackoffrate)
+ [Retry with MaxDelaySeconds](#retrymaxdelayseconds)
+ [Retry all errors except States.Timeout](#retrytimeout)
+ [Complex retry scenario](#complexretryeg)
**Contoh 1 — Coba lagi dengan BackoffRate**
Contoh berikut ini `Retry` membuat dua percobaan lagi dengan percobaan ulang pertama terjadi setelah menunggu selama tiga detik. Berdasarkan yang `BackoffRate` Anda tentukan, Step Functions meningkatkan interval antara setiap percobaan ulang hingga jumlah maksimum percobaan ulang tercapai. Dalam contoh berikut, upaya coba lagi kedua dimulai setelah menunggu selama tiga detik setelah percobaan ulang pertama.
```
"Retry": [ {
"ErrorEquals": [ "States.Timeout" ],
"IntervalSeconds": 3,
"MaxAttempts": 2,
"BackoffRate": 1
} ]
```
**Contoh 2 — Coba lagi dengan MaxDelaySeconds**
Contoh berikut membuat tiga upaya coba lagi dan membatasi waktu tunggu yang dihasilkan dari `BackoffRate` 5 detik. Upaya coba ulang yang pertama dilakukan setelah menunggu selama tiga detik. Upaya coba ulang kedua dan ketiga dilakukan setelah menunggu selama lima detik setelah upaya coba ulang sebelumnya karena batas waktu tunggu maksimum yang ditetapkan oleh `MaxDelaySeconds`.
```
"Retry": [ {
"ErrorEquals": [ "States.Timeout" ],
"IntervalSeconds": 3,
"MaxAttempts": 3,
"BackoffRate":2,
"MaxDelaySeconds": 5,
"JitterStrategy": "FULL"
} ]
```
Tanpa `MaxDelaySeconds`, upaya coba ulang kedua akan dilakukan enam detik setelah upaya coba ulang yang pertama, dan upaya coba ulang ketiga akan dilakukan 12 detik setelah upaya coba ulang kedua.
**Contoh 3 - Coba lagi semua kesalahan kecuali States.Timeout**
Nama terpesan `States.ALL` yang muncul di bidang `ErrorEquals` adalah wildcard yang cocok dengan setiap nama kesalahan. Ini harus muncul sendirian di array `ErrorEquals` dan harus muncul dalam retrier terakhir di array `Retry`. Nama `States.TaskFailed` juga bertindak wildcard dan cocok dengan kesalahan kecuali untuk`States.Timeout`.
Contoh `Retry` bidang berikut mencoba ulang kesalahan apa pun kecuali`States.Timeout`.
```
"Retry": [ {
"ErrorEquals": [ "States.Timeout" ],
"MaxAttempts": 0
}, {
"ErrorEquals": [ "States.ALL" ]
} ]
```
**Contoh 4 - Skenario coba lagi yang kompleks**
Parameter retrier A ini berlaku di semua kunjungan ke retrier dalam konteks eksekusi status tunggal.
Pertimbangkan status `Task` berikut.
```
"X": {
"Type": "Task",
"Resource": "arn:aws:states:region:123456789012:task:X",
"Next": "Y",
"Retry": [ {
"ErrorEquals": [ "ErrorA", "ErrorB" ],
"IntervalSeconds": 1,
"BackoffRate": 2.0,
"MaxAttempts": 2
}, {
"ErrorEquals": [ "ErrorC" ],
"IntervalSeconds": 5
} ],
"Catch": [ {
"ErrorEquals": [ "States.ALL" ],
"Next": "Z"
} ]
}
```
Tugas ini gagal empat kali berturut-turut, mengeluarkan nama kesalahan ini:`ErrorA`,, `ErrorB``ErrorC`, dan. `ErrorB` Berikut ini terjadi sebagai hasilnya:
+ Dua kesalahan pertama cocok dengan retrier pertama dan menyebabkan menunggu satu dan dua detik.
+ Kesalahan ketiga cocok dengan retrier kedua dan menyebabkan menunggu lima detik.
+ Kesalahan keempat juga cocok dengan retrier pertama. Namun, itu sudah mencapai maksimum dua percobaan ulang (`MaxAttempts`) untuk kesalahan tertentu. Oleh karena itu, retrier itu gagal dan eksekusi mengalihkan alur kerja ke `Z` status melalui bidang. `Catch`
## Status fallback
`Task`, `Map` dan `Parallel` negara masing-masing dapat memiliki bidang bernama`Catch`. Nilai bidang ini harus berupa array obyek, yang dikenal sebagai *penangkap*.
Penangkap berisi bidang berikut.
** `ErrorEquals` (Wajib)**
Sebuah array string non-kosong yang cocok dengan nama kesalahan, ditentukan persis seperti mereka dengan bidang retrier dengan nama yang sama.
** `Next` (Wajib)**
Sebuah string yang harus sama persis dengan salah satu nama status mesin status.
** `ResultPath`(JSONPath, Opsional)**
[Jalur](concepts-input-output-filtering.md) yang menentukan input apa yang dikirimkan oleh penangkap ke status yang ditentukan di `Next` bidang.
Ketika status melaporkan kesalahan dan tidak ada bidang `Retry`, atau jika mencoba ulang gagal untuk menyelesaikan kesalahan, Step Functions memindai penangkap dalam urutan yang tercantum dalam array. Ketika nama kesalahan muncul dalam nilai bidang `ErrorEquals` penangkap, mesin status bertransisi ke status bernama dalam bidang `Next`.
Nama terpesan `States.ALL` yang muncul di bidang `ErrorEquals` penangkap adalah wildcard yang cocok dengan nama kesalahan. Ini harus muncul sendirian di array `ErrorEquals` dan harus muncul di penangkap terakhir di array `Catch`. Nama `States.TaskFailed` juga bertindak wildcard dan cocok dengan kesalahan kecuali untuk `States.Timeout`.
Contoh berikut dari bidang transisi `Catch` ke status bernama `RecoveryState` ketika fungsi Lambda meng-output pengecualian Java yang tidak tertangani. Jika tidak, bidang ini bertransisi ke status `EndState`.
```
"Catch": [ {
"ErrorEquals": [ "java.lang.Exception" ],
"ResultPath": "$.error-info",
"Next": "RecoveryState"
}, {
"ErrorEquals": [ "States.ALL" ],
"Next": "EndState"
} ]
```
**Berapa banyak kesalahan yang dapat ditangkap oleh catcher?**
Setiap penangkap dapat menentukan **beberapa kesalahan** untuk ditangani.
### Output kesalahan
Ketika Step Functions bertransisi ke status yang ditentukan dalam nama penangkapan, objek biasanya berisi bidang `Cause`. Nilai bidang ini adalah deskripsi yang dapat dibaca manusia dari kesalahan. Objek ini dikenal sebagai *output kesalahan*.
Pada JSONPath contoh sebelumnya, penangkap pertama berisi `ResultPath` bidang. Ini bekerja sama dengan `ResultPath` di tingkat atas status, menghasilkan dua kemungkinan:
+ Ambil hasil eksekusi negara itu dan timpa semua, atau sebagian, masukan status.
+ Ambil hasilnya dan tambahkan ke input. Dalam kasus kesalahan yang ditangani oleh penangkap, hasil eksekusi status adalah output kesalahan.
Jadi, untuk penangkap pertama dalam contoh, penangkap menambahkan output kesalahan ke input sebagai bidang bernama `error-info` jika belum ada bidang dengan nama ini di input. Kemudian, penangkap mengirimkan seluruh input ke`RecoveryState`. Untuk penangkap kedua, output kesalahan menimpa input dan penangkap hanya mengirimkan output kesalahan ke. `EndState`
Untuk JSONPath alur kerja, jika Anda tidak menentukan `ResultPath` bidang, itu default ke`$`, yang memilih dan menimpa seluruh input.
Ketika status memiliki keduanya `Retry` dan `Catch` bidang, Step Functions menggunakan retrier yang sesuai terlebih dahulu. Jika kebijakan coba lagi gagal menyelesaikan kesalahan, Step Functions akan menerapkan transisi penangkap yang cocok.
### Muatan penyebab dan integrasi layanan
Sebuah penangkap mengembalikan muatan string sebagai output. Saat bekerja dengan integrasi layanan seperti Amazon Athena AWS CodeBuild atau, Anda mungkin ingin mengonversi string ke `Cause` JSON. Contoh berikut dari `Pass` keadaan dengan fungsi intrinsik menunjukkan bagaimana untuk mengkonversi `Cause` string ke JSON.
```
"Handle escaped JSON with JSONtoString": {
"Type": "Pass",
"Parameters": {
"Cause.$": "States.StringToJson($.Cause)"
},
"Next": "Pass State with Pass Processing"
},
```
## Contoh mesin negara menggunakan Coba Ulang dan Tangkap
Mesin-mesin status yang ditentukan dalam contoh berikut memakai dua fungsi Lambda: salah satu yang selalu gagal dan satu yang menunggu cukup lama untuk mengizinkan batas waktu yang ditentukan dalam mesin status terjadi.
Ini adalah definisi dari fungsi Lambda Node.js yang selalu gagal, mengembalikan pesan. `error` Dalam contoh mesin status yang mengikuti, fungsi Lambda ini bernama `FailFunction`. Untuk informasi tentang membuat fungsi Lambda, lihat [Langkah 1: Membuat fungsi Lambda](tutorial-creating-lambda-state-machine.md#create-lambda-function) bagian.
```
exports.handler = (event, context, callback) => {
callback("error");
};
```
Ini adalah definisi dari fungsi Lambda Node.js yang tidur selama 10 detik. Dalam contoh mesin status yang mengikuti, fungsi Lambda ini bernama `sleep10`.
```
exports.handler = (event, context, callback) => {
setTimeout(function(){
}, 11000);
};
```
**Pengaturan batas waktu untuk fungsi**
Saat Anda membuat fungsi Lambda untuk contoh, ingatlah untuk mengatur `Timeout` nilai dalam pengaturan lanjutan menjadi 11 detik.
### Menangani kegagalan menggunakan Coba Lagi
Mesin status ini menggunakan `Retry` untuk mencoba kembali fungsi yang gagal dan output nama kesalahan `HandledError`. Ini mencoba ulang fungsi ini dua kali dengan backoff eksponensial antara percobaan ulang.
```
{
"Comment": "A Hello World example invoking Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
"Retry": [ {
"ErrorEquals": ["HandledError"],
"IntervalSeconds": 1,
"MaxAttempts": 2,
"BackoffRate": 2.0
} ],
"End": true
}
}
}
```
Varian ini menggunakan kode kesalahan yang telah ditentukan `States.TaskFailed`, yang cocok dengan kesalahan yang fungsi Lambda output.
```
{
"Comment": "Hello World example which invokes a AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
"Retry": [ {
"ErrorEquals": ["States.TaskFailed"],
"IntervalSeconds": 1,
"MaxAttempts": 2,
"BackoffRate": 2.0
} ],
"End": true
}
}
}
```
**Praktik terbaik untuk menangani pengecualian Lambda**
Tugas yang mereferensikan fungsi Lambda harus menangani pengecualian layanan Lambda. Untuk informasi selengkapnya, lihat [Menangani pengecualian layanan Lambda sementara](sfn-best-practices.md#bp-lambda-serviceexception) di Praktik Terbaik.
### Menangani kegagalan menggunakan Catch
Contoh ini menggunakan bidang `Catch`. Ketika fungsi Lambda mengeluarkan kesalahan, ia menangkap kesalahan dan mesin status bertransisi ke status. `fallback`
```
{
"Comment": "Hello World example which invokes a AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
"Catch": [ {
"ErrorEquals": ["HandledError"],
"Next": "fallback"
} ],
"End": true
},
"fallback": {
"Type": "Pass",
"Result": "Hello, AWS Step Functions!",
"End": true
}
}
}
```
Varian ini menggunakan kode kesalahan yang telah ditetapkan `States.TaskFailed`, yang cocok dengan kesalahan yang fungsi Lambda output.
```
{
"Comment": "Hello World example which invokes a AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:FailFunction",
"Catch": [ {
"ErrorEquals": ["States.TaskFailed"],
"Next": "fallback"
} ],
"End": true
},
"fallback": {
"Type": "Pass",
"Result": "Hello, AWS Step Functions!",
"End": true
}
}
}
```
### Menangani batas waktu menggunakan Retry
Mesin status ini menggunakan `Retry` bidang untuk mencoba kembali `Task` status yang habis waktu, berdasarkan nilai batas waktu yang ditentukan dalam. `TimeoutSeconds` Step Functions mencoba ulang pemanggilan fungsi Lambda dalam status `Task` ini dua kali, dengan backoff eksponensial di antara percobaan ulang.
```
{
"Comment": "Hello World example which invokes a AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:sleep10",
"TimeoutSeconds": 2,
"Retry": [ {
"ErrorEquals": ["States.Timeout"],
"IntervalSeconds": 1,
"MaxAttempts": 2,
"BackoffRate": 2.0
} ],
"End": true
}
}
}
```
### Menangani batas waktu menggunakan Catch
Contoh ini menggunakan bidang `Catch`. Ketika batas waktu terjadi, mesin status bertransisi ke status `fallback`.
```
{
"Comment": "Hello World example which invokes a AWS Lambda function",
"StartAt": "HelloWorld",
"States": {
"HelloWorld": {
"Type": "Task",
"Resource": "arn:aws:lambda:region:123456789012:function:sleep10",
"TimeoutSeconds": 2,
"Catch": [ {
"ErrorEquals": ["States.Timeout"],
"Next": "fallback"
} ],
"End": true
},
"fallback": {
"Type": "Pass",
"Result": "Hello, AWS Step Functions!",
"End": true
}
}
}
```
**Melestarikan input status dan kesalahan di JSONPath**
Di JSONPath, Anda dapat mempertahankan input status dan kesalahan dengan menggunakan`ResultPath`. Lihat [Gunakan ResultPath untuk memasukkan kesalahan dan masukan dalam `Catch`](input-output-resultpath.md#input-output-resultpath-catch).