Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Lambda fungsi tahan lama
Fungsi Lambda yang tahan lama memungkinkan Anda membangun aplikasi multi-langkah yang tangguh dan alur kerja AI yang dapat dijalankan hingga satu tahun sambil mempertahankan kemajuan yang andal meskipun ada gangguan. Ketika fungsi tahan lama berjalan, siklus hidup lengkap ini disebut eksekusi tahan lama, yang menggunakan pos pemeriksaan untuk melacak kemajuan dan secara otomatis pulih dari kegagalan melalui pemutaran ulang, mengeksekusi ulang dari awal sambil melewatkan pekerjaan yang telah selesai.
Dalam setiap fungsi, Anda menggunakan operasi yang tahan lama sebagai blok bangunan mendasar. Langkah-langkah mengeksekusi logika bisnis dengan percobaan ulang dan pelacakan kemajuan bawaan, sementara menunggu menangguhkan eksekusi tanpa menimbulkan biaya komputasi, menjadikannya ideal untuk proses yang berjalan lama seperti alur kerja atau polling dependensi eksternal. human-in-the-loop Baik Anda memproses pesanan, mengoordinasikan layanan mikro, atau mengatur aplikasi AI agen, fungsi tahan lama mempertahankan status secara otomatis dan pulih dari kegagalan saat Anda menulis kode dalam bahasa pemrograman yang sudah dikenal.
## Manfaat utama
**Tulis kode tangguh secara alami:** Dengan konstruksi pemrograman yang sudah dikenal, Anda menulis kode yang menangani kegagalan secara otomatis. Pemeriksaan bawaan, percobaan ulang transparan, dan pemulihan otomatis berarti logika bisnis Anda tetap bersih dan fokus.
**Bayar hanya untuk apa yang Anda gunakan:** Selama operasi tunggu, fungsi Anda ditangguhkan tanpa menimbulkan biaya komputasi. Untuk alur kerja yang berjalan lama yang menunggu berjam-jam atau berhari-hari, Anda hanya membayar untuk waktu pemrosesan aktual, bukan menunggu idle.
**Kesederhanaan operasional:** Dengan model tanpa server Lambda, Anda mendapatkan penskalaan otomatis, termasuk scale-to-zero, tanpa mengelola infrastruktur. Fungsi tahan lama menangani manajemen status, coba kembali logika, dan pemulihan kegagalan secara otomatis, mengurangi overhead operasional.
## Kapan menggunakan fungsi yang tahan lama
**Koordinasi jangka pendek:** Mengkoordinasikan pembayaran, inventaris, dan pengiriman di berbagai layanan dengan pengembalian otomatis pada kegagalan. Memproses pesanan melalui validasi, otorisasi pembayaran, alokasi inventaris, dan pemenuhan dengan jaminan penyelesaian.
**Memproses pembayaran dengan percaya diri:** Membangun arus pembayaran tangguh yang mempertahankan status transaksi melalui kegagalan dan menangani percobaan ulang secara otomatis. Mengkoordinasikan otorisasi multi-langkah, pemeriksaan penipuan, dan penyelesaian di seluruh penyedia pembayaran dengan auditabilitas penuh di seluruh langkah.
**Bangun alur kerja AI yang andal:** Buat alur kerja AI multi-langkah yang memanggil model rantai, menggabungkan umpan balik manusia, dan menangani tugas yang berjalan lama secara deterministik selama kegagalan. Secara otomatis melanjutkan setelah penangguhan, dan hanya membayar untuk waktu eksekusi aktif.
**Mengatur pemenuhan pesanan yang kompleks:** Mengkoordinasikan pemrosesan pesanan di seluruh inventaris, pembayaran, pengiriman, dan sistem notifikasi dengan ketahanan bawaan. Secara otomatis menangani kegagalan sebagian, mempertahankan status pesanan meskipun ada gangguan, dan secara efisien menunggu peristiwa eksternal tanpa menghabiskan sumber daya komputasi.
**Otomatiskan alur kerja bisnis multi-langkah:** Bangun alur kerja yang andal untuk orientasi karyawan, persetujuan pinjaman, dan proses kepatuhan yang berlangsung berhari-hari atau berminggu-minggu. Pertahankan status alur kerja di seluruh persetujuan manusia, integrasi sistem, dan tugas terjadwal sambil memberikan visibilitas penuh ke dalam status dan riwayat proses.
### Bagaimana fungsi tahan lama dibandingkan dengan Step Functions
Keduanya, fungsi tahan lama dan Step Functions, menyediakan orkestrasi alur kerja dengan manajemen status otomatis. Perbedaan utama adalah di mana mereka berjalan dan bagaimana Anda mendefinisikan alur kerja:
+ **Fungsi tahan lama:** Jalankan dalam Lambda, gunakan bahasa pemrograman standar, dikelola dalam lingkungan Lambda
+ **Step Functions:** Layanan mandiri, DSL berbasis grafik atau desainer visual, dikelola sepenuhnya tanpa pemeliharaan
Fungsi tahan lama sangat ideal untuk pengembangan aplikasi di Lambda di mana alur kerja digabungkan erat dengan logika bisnis. Step Functions unggul dalam orkestrasi alur kerja di seluruh AWS layanan di mana Anda memerlukan desain visual, integrasi asli ke 220\$1 layanan, dan infrastruktur tanpa pemeliharaan.
Untuk perbandingan mendetail, lihat [Fungsi tahan lama atau Step Functions](durable-step-functions.md).
## Cara kerjanya
Di bawah kap, fungsi tahan lama adalah fungsi Lambda biasa menggunakan checkpoint/replay mekanisme untuk melacak kemajuan dan mendukung operasi yang berjalan lama melalui titik suspensi yang ditentukan pengguna, yang biasa disebut sebagai eksekusi tahan lama. Setelah fungsi Anda dilanjutkan dari jeda atau gangguan, sistem melakukan pemutaran ulang. Selama pemutaran ulang, kode Anda berjalan dari awal tetapi melompati pos pemeriksaan yang telah selesai, menggunakan hasil yang disimpan alih-alih mengeksekusi ulang operasi yang telah selesai. Mekanisme pemutaran ulang ini memastikan konsistensi sekaligus memungkinkan eksekusi yang berjalan lama.
Untuk memanfaatkan checkpoint-and-replay mekanisme ini dalam aplikasi Anda, Lambda menyediakan SDK eksekusi yang tahan lama. SDK mengabstraksi kompleksitas pengelolaan pos pemeriksaan dan pemutaran ulang, memperlihatkan primitif sederhana yang disebut operasi tahan lama yang Anda gunakan dalam kode Anda. SDK tersedia untuk JavaScript, Python dan Java (Pratinjau) TypeScript, terintegrasi secara mulus dengan alur kerja pengembangan Lambda Anda yang ada.
Dengan SDK, Anda membungkus event handler Lambda Anda, yang kemudian menyediakan DurableContext di samping acara Anda. Konteks ini memberi Anda akses ke operasi yang tahan lama seperti langkah dan menunggu. Anda menulis logika fungsi Anda sebagai kode sekuensial normal, tetapi alih-alih memanggil layanan secara langsung, Anda membungkus panggilan tersebut dalam langkah-langkah untuk pemeriksaan otomatis dan percobaan ulang. Ketika Anda perlu menjeda eksekusi, Anda menambahkan menunggu yang menangguhkan fungsi Anda tanpa menimbulkan biaya. SDK menangani semua kompleksitas manajemen status dan pemutaran ulang di belakang layar, sehingga kode Anda tetap bersih dan mudah dibaca.
![\[Filter for Amazon Inspector results related to Lambda functions\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/how_durable_works.png)
## Langkah selanjutnya
+ [Memulai dengan fungsi yang tahan lama](durable-getting-started.md)
+ [Jelajahi SDK eksekusi yang tahan lama](durable-execution-sdk.md)
+ [Fungsi tahan lama atau Step Functions](durable-step-functions.md)
+ [Memantau dan men-debug fungsi yang tahan lama](durable-monitoring.md)
+ [Tinjau keamanan dan izin](durable-security.md)
+ [Ikuti praktik terbaik](durable-best-practices.md)
# Konsep Basic
Lambda menyediakan eksekusi yang tahan lama SDKs untuk JavaScript, TypeScript, dan Python. Ini SDKs adalah fondasi untuk membangun fungsi yang tahan lama, menyediakan primitif yang Anda butuhkan untuk memeriksa kemajuan, menangani percobaan ulang, dan mengelola alur eksekusi. Untuk dokumentasi dan contoh SDK lengkap, lihat SDK [JavaScript/TypeScript SDK](https://github.com/aws/aws-durable-execution-sdk-js) dan [Python](https://github.com/aws/aws-durable-execution-sdk-python) aktif. GitHub
## Eksekusi tahan lama
**Eksekusi yang tahan lama** mewakili siklus hidup lengkap fungsi tahan lama Lambda, menggunakan mekanisme pos pemeriksaan dan pemutaran ulang untuk melacak kemajuan logika bisnis, menangguhkan eksekusi, dan memulihkan dari kegagalan. Ketika fungsi dilanjutkan setelah penangguhan atau interupsi, pos pemeriksaan yang telah selesai sebelumnya diputar ulang dan fungsi melanjutkan eksekusi.
Siklus hidup dapat mencakup beberapa pemanggilan fungsi Lambda untuk menyelesaikan eksekusi, terutama setelah penangguhan atau pemulihan kegagalan. Pendekatan ini memungkinkan fungsi Anda berjalan untuk waktu yang lama (hingga satu tahun) sambil mempertahankan kemajuan yang dapat diandalkan meskipun ada gangguan.
**Cara kerja replay**
Lambda menyimpan log berjalan dari semua operasi tahan lama (langkah, menunggu, dan operasi lainnya) saat fungsi Anda dijalankan. Ketika fungsi Anda perlu menjeda atau mengalami gangguan, Lambda menyimpan log pos pemeriksaan ini dan menghentikan eksekusi. Ketika tiba waktunya untuk melanjutkan, Lambda memanggil fungsi Anda lagi dari awal dan memutar ulang log pos pemeriksaan, menggantikan nilai yang disimpan untuk operasi yang telah selesai. Ini berarti kode Anda berjalan lagi, tetapi langkah yang telah diselesaikan sebelumnya tidak dijalankan kembali. Hasil tersimpan mereka digunakan sebagai gantinya.
Mekanisme replay ini sangat penting untuk memahami fungsi yang tahan lama. Kode Anda harus deterministik selama pemutaran ulang, artinya menghasilkan hasil yang sama dengan input yang sama. Hindari operasi dengan efek samping (seperti menghasilkan angka acak atau mendapatkan waktu saat ini) di luar langkah, karena ini dapat menghasilkan nilai yang berbeda selama pemutaran ulang dan menyebabkan perilaku non-deterministik.
## DurableContext
**DurableContext**adalah objek konteks yang diterima fungsi tahan lama Anda. Ini menyediakan metode untuk operasi tahan lama seperti langkah-langkah dan menunggu yang membuat pos pemeriksaan dan mengelola alur eksekusi.
Fungsi tahan lama Anda menerima `DurableContext` bukan konteks Lambda default:
------
#### [ TypeScript ]
```
import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const result = await context.step(async () => {
return "step completed";
});
return result;
},
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
@durable_step
def my_step(step_context, data):
# Your business logic
return result
@durable_execution
def handler(event, context: DurableContext):
result = context.step(my_step(event["data"]))
return result
```
------
Python SDK untuk fungsi tahan lama menggunakan metode sinkron dan tidak mendukung. `await` TypeScript SDK menggunakan`async/await`.
## Langkah-langkah
**Langkah-langkah** menjalankan logika bisnis dengan percobaan ulang bawaan dan pos pemeriksaan otomatis. Setiap langkah menyimpan hasilnya, memastikan fungsi Anda dapat dilanjutkan dari langkah yang diselesaikan setelah interupsi.
------
#### [ TypeScript ]
```
// Each step is automatically checkpointed
const order = await context.step(async () => processOrder(event));
const payment = await context.step(async () => processPayment(order));
const result = await context.step(async () => completeOrder(payment));
```
------
#### [ Python ]
```
# Each step is automatically checkpointed
order = context.step(lambda: process_order(event))
payment = context.step(lambda: process_payment(order))
result = context.step(lambda: complete_order(payment))
```
------
## Tunggu Negara
**Status tunggu** adalah jeda yang direncanakan di mana fungsi Anda berhenti berjalan (dan berhenti mengisi daya) hingga waktunya untuk melanjutkan. Gunakan mereka untuk menunggu periode waktu, panggilan balik eksternal, atau kondisi tertentu.
------
#### [ TypeScript ]
```
// Wait for 1 hour without consuming resources
await context.wait({ seconds:3600 });
// Wait for external callback
const approval = await context.waitForCallback(
async (callbackId) => sendApprovalRequest(callbackId)
);
```
------
#### [ Python ]
```
# Wait for 1 hour without consuming resources
context.wait(3600)
# Wait for external callback
approval = context.wait_for_callback(
lambda callback_id: send_approval_request(callback_id)
)
```
------
Saat fungsi Anda mengalami penantian atau perlu dijeda, Lambda menyimpan log pos pemeriksaan dan menghentikan eksekusi. Ketika tiba waktunya untuk melanjutkan, Lambda memanggil fungsi Anda lagi dan memutar ulang log pos pemeriksaan, menggantikan nilai yang disimpan untuk operasi yang telah selesai.
Untuk alur kerja yang lebih kompleks, fungsi Lambda yang tahan lama juga dilengkapi dengan operasi lanjutan `parallel()` seperti untuk eksekusi bersamaan, untuk memproses array`map()`, untuk operasi bersarang`runInChildContext()`, dan untuk polling. `waitForCondition()` Lihat [Contoh](durable-examples.md) untuk contoh terperinci dan panduan tentang kapan harus menggunakan setiap operasi.
## Memanggil fungsi lainnya
**Invoke** memungkinkan fungsi yang tahan lama untuk memanggil fungsi Lambda lainnya dan menunggu hasilnya. Fungsi pemanggilan ditangguhkan saat fungsi yang dipanggil dijalankan, menciptakan pos pemeriksaan yang mempertahankan hasilnya. Hal ini memungkinkan Anda untuk membangun alur kerja modular di mana fungsi khusus menangani tugas-tugas tertentu.
Gunakan `context.invoke()` untuk memanggil fungsi lain dari dalam fungsi tahan lama Anda. Pemanggilan diperiksa, jadi jika fungsi Anda terputus setelah fungsi yang dipanggil selesai, ia dilanjutkan dengan hasil yang disimpan tanpa memanggil kembali fungsi tersebut.
------
#### [ TypeScript ]
```
// Invoke another function and wait for result
const customerData = await context.invoke(
'validate-customer',
'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
{ customerId: event.customerId }
);
// Use the result in subsequent steps
const order = await context.step(async () => {
return processOrder(customerData);
});
```
------
#### [ Python ]
```
# Invoke another function and wait for result
customer_data = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
{'customerId': event['customerId']},
name='validate-customer'
)
# Use the result in subsequent steps
order = context.step(
lambda: process_order(customer_data),
name='process-order'
)
```
------
Fungsi yang dipanggil dapat berupa fungsi Lambda yang tahan lama atau standar. Jika Anda menjalankan fungsi yang tahan lama, fungsi pemanggilan menunggu eksekusi yang tahan lama selesai. Pola ini umum dalam arsitektur layanan mikro di mana setiap fungsi menangani domain tertentu, memungkinkan Anda menyusun alur kerja yang kompleks dari fungsi khusus yang dapat digunakan kembali.
**catatan**
Pemanggilan lintas akun tidak didukung. Fungsi yang dipanggil harus berada di AWS akun yang sama dengan fungsi pemanggilan.
## Konfigurasi fungsi yang tahan lama
Fungsi tahan lama memiliki pengaturan konfigurasi khusus yang mengontrol perilaku eksekusi dan retensi data. Pengaturan ini terpisah dari konfigurasi fungsi Lambda standar dan berlaku untuk seluruh siklus hidup eksekusi yang tahan lama.
**DurableConfig**Objek mendefinisikan konfigurasi untuk fungsi tahan lama:
```
{
"ExecutionTimeout": Integer,
"RetentionPeriodInDays": Integer
}
```
### Batas waktu pelaksanaan
Batas **waktu eksekusi** mengontrol berapa lama eksekusi yang tahan lama dapat berjalan dari awal hingga selesai. Ini berbeda dengan batas waktu fungsi Lambda, yang mengontrol berapa lama pemanggilan fungsi tunggal dapat berjalan.
Eksekusi yang tahan lama dapat mencakup beberapa pemanggilan fungsi Lambda saat berlangsung melalui pos pemeriksaan, menunggu, dan memutar ulang. Batas waktu eksekusi berlaku untuk total waktu yang telah berlalu dari eksekusi tahan lama, bukan untuk pemanggilan fungsi individual.
**Memahami perbedaannya**
Batas waktu fungsi Lambda (maksimum 15 menit) membatasi setiap pemanggilan individu dari fungsi Anda. Batas waktu eksekusi yang tahan lama (maksimum 1 tahun) membatasi total waktu dari saat eksekusi dimulai hingga selesai, gagal, atau habis waktu. Selama periode ini, fungsi Anda mungkin dipanggil beberapa kali saat memproses langkah, menunggu, dan pulih dari kegagalan.
Misalnya, jika Anda menetapkan batas waktu eksekusi tahan lama 24 jam dan batas waktu fungsi Lambda 5 menit:
+ Setiap pemanggilan fungsi harus selesai dalam waktu 5 menit
+ Seluruh eksekusi yang tahan lama dapat berjalan hingga 24 jam
+ Fungsi Anda dapat dipanggil berkali-kali selama 24 jam tersebut
+ Operasi tunggu tidak dihitung terhadap batas waktu fungsi Lambda tetapi dihitung terhadap batas waktu eksekusi
Anda dapat mengonfigurasi batas waktu eksekusi saat membuat fungsi tahan lama menggunakan konsol Lambda AWS CLI,, atau. AWS SAM Di konsol Lambda, pilih fungsi Anda, lalu Konfigurasi, Eksekusi tahan lama. Atur nilai batas waktu eksekusi dalam hitungan detik (default: 86400 detik/ 24 jam, minimum: 60 detik, maksimum: 31536000 detik/ 1 tahun).
**catatan**
Batas waktu eksekusi dan batas waktu fungsi Lambda adalah pengaturan yang berbeda. Batas waktu fungsi Lambda mengontrol berapa lama setiap pemanggilan individu dapat berjalan (maksimum 15 menit). Batas waktu eksekusi mengontrol total waktu yang telah berlalu untuk seluruh eksekusi tahan lama (maksimum 1 tahun).
### Periode retensi
**Periode retensi** mengontrol berapa lama Lambda mempertahankan riwayat eksekusi dan data pos pemeriksaan setelah eksekusi yang tahan lama selesai. Data ini mencakup hasil langkah, status eksekusi, dan log pos pemeriksaan lengkap.
Setelah periode retensi berakhir, Lambda menghapus riwayat eksekusi dan data pos pemeriksaan. Anda tidak dapat lagi mengambil detail eksekusi atau memutar ulang eksekusi. Periode retensi dimulai ketika eksekusi mencapai status terminal (BERHASIL, GAGAL, BERHENTI, atau TIMED\$1OUT).
Anda dapat mengonfigurasi periode retensi saat membuat fungsi tahan lama menggunakan konsol Lambda, AWS CLI, atau. AWS SAM Di konsol Lambda, pilih fungsi Anda, lalu Konfigurasi, Eksekusi tahan lama. Tetapkan nilai periode Retensi dalam beberapa hari (default: 14 hari, minimum: 1 hari, maksimum: 90 hari).
Pilih periode retensi berdasarkan persyaratan kepatuhan Anda, kebutuhan debugging, dan pertimbangan biaya. Periode retensi yang lebih lama memberikan lebih banyak waktu untuk debugging dan audit tetapi meningkatkan biaya penyimpanan.
## Lihat juga
+ [Fungsi tahan lama atau Step Functions](durable-step-functions.md) — Bandingkan fungsi tahan lama dengan Step Functions untuk memahami kapan setiap pendekatan paling efektif.
# Membuat fungsi Lambda yang tahan lama
Untuk memulai dengan fungsi Lambda yang tahan lama, gunakan konsol Lambda untuk membuat fungsi yang tahan lama. Dalam beberapa menit, Anda dapat membuat dan menerapkan fungsi tahan lama yang menggunakan langkah-langkah dan menunggu untuk menunjukkan eksekusi berbasis pos pemeriksaan.
Saat Anda menjalankan tutorial, Anda akan mempelajari konsep fungsi dasar yang tahan lama, seperti cara menggunakan `DurableContext` objek, membuat pos pemeriksaan dengan langkah-langkah, dan menjeda eksekusi dengan menunggu. Anda juga akan mempelajari cara kerja replay saat fungsi Anda dilanjutkan setelah menunggu.
Untuk menjaga hal-hal sederhana, tutorial ini menunjukkan kepada Anda cara membuat fungsi Anda menggunakan runtime Python atau Node.js. Dengan bahasa yang ditafsirkan ini, Anda dapat mengedit kode fungsi langsung di editor kode bawaan konsol.
Fungsi tahan lama di Java (Pratinjau) saat ini hanya dapat digunakan melalui gambar kontainer. Untuk informasi selengkapnya tentang membuat fungsi tahan lama dari gambar kontainer, lihat [Waktu proses yang didukung untuk fungsi tahan lama atau Menerapkan fungsi tahan lama](durable-supported-runtimes.md) [Lambda dengan Infrastruktur sebagai Kode](durable-getting-started-iac.md).
**catatan**
Fungsi tahan lama saat ini mendukung runtime Python dan Node.js (JavaScript/TypeScript) dan gambar kontainer (OCI), seperti Java. Untuk daftar lengkap versi runtime yang didukung dan opsi gambar kontainer, lihat [Runtime yang didukung untuk fungsi tahan lama](durable-supported-runtimes.md). Untuk informasi selengkapnya tentang penggunaan gambar kontainer dengan Lambda, lihat Membuat gambar [kontainer Lambda di](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) Panduan Pengembang Lambda.
**Tip**
Untuk mempelajari cara membuat **solusi tanpa server**, lihat Panduan Pengembang Tanpa [Server](https://docs.aws.amazon.com/serverless/latest/devguide/).
## Prasyarat
### Mendaftar untuk Akun AWS
Jika Anda tidak memiliki Akun AWS, selesaikan langkah-langkah berikut untuk membuatnya.
**Untuk mendaftar untuk Akun AWS**
1. Buka [https://portal.aws.amazon.com/billing/pendaftaran.](https://portal.aws.amazon.com/billing/signup)
1. Ikuti petunjuk online.
Bagian dari prosedur pendaftaran melibatkan menerima panggilan telepon atau pesan teks dan memasukkan kode verifikasi pada keypad telepon.
Saat Anda mendaftar untuk sebuah Akun AWS, sebuah *Pengguna root akun AWS*dibuat. Pengguna root memiliki akses ke semua Layanan AWS dan sumber daya di akun. Sebagai praktik keamanan terbaik, tetapkan akses administratif ke pengguna, dan gunakan hanya pengguna root untuk melakukan [tugas yang memerlukan akses pengguna root](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).
AWS mengirimi Anda email konfirmasi setelah proses pendaftaran selesai. Kapan saja, Anda dapat melihat aktivitas akun Anda saat ini dan mengelola akun Anda dengan masuk [https://aws.amazon.com.rproxy.goskope.comke/](https://aws.amazon.com/) dan memilih **Akun Saya**.
### Buat pengguna dengan akses administratif
Setelah Anda mendaftar Akun AWS, amankan Pengguna root akun AWS, aktifkan AWS IAM Identity Center, dan buat pengguna administratif sehingga Anda tidak menggunakan pengguna root untuk tugas sehari-hari.
**Amankan Anda Pengguna root akun AWS**
1. Masuk ke [Konsol Manajemen AWS](https://console.aws.amazon.com/)sebagai pemilik akun dengan memilih **pengguna Root** dan memasukkan alamat Akun AWS email Anda. Di laman berikutnya, masukkan kata sandi.
Untuk bantuan masuk dengan menggunakan pengguna root, lihat [Masuk sebagai pengguna root](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) di *AWS Sign-In Panduan Pengguna*.
1. Mengaktifkan autentikasi multi-faktor (MFA) untuk pengguna root Anda.
Untuk petunjuk, lihat [Mengaktifkan perangkat MFA virtual untuk pengguna Akun AWS root (konsol) Anda](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) di Panduan Pengguna *IAM*.
**Buat pengguna dengan akses administratif**
1. Aktifkan Pusat Identitas IAM.
Untuk mendapatkan petunjuk, silakan lihat [Mengaktifkan AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) di *Panduan Pengguna AWS IAM Identity Center *.
1. Di Pusat Identitas IAM, berikan akses administratif ke pengguna.
Untuk tutorial tentang menggunakan Direktori Pusat Identitas IAM sebagai sumber identitas Anda, lihat [Mengkonfigurasi akses pengguna dengan default Direktori Pusat Identitas IAM](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) di *Panduan AWS IAM Identity Center Pengguna*.
**Masuk sebagai pengguna dengan akses administratif**
+ Untuk masuk dengan pengguna Pusat Identitas IAM, gunakan URL masuk yang dikirim ke alamat email saat Anda membuat pengguna Pusat Identitas IAM.
Untuk bantuan masuk menggunakan pengguna Pusat Identitas IAM, lihat [Masuk ke portal AWS akses](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) di *Panduan AWS Sign-In Pengguna*.
**Tetapkan akses ke pengguna tambahan**
1. Di Pusat Identitas IAM, buat set izin yang mengikuti praktik terbaik menerapkan izin hak istimewa paling sedikit.
Untuk petunjuknya, lihat [Membuat set izin](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) di *Panduan AWS IAM Identity Center Pengguna*.
1. Tetapkan pengguna ke grup, lalu tetapkan akses masuk tunggal ke grup.
Untuk petunjuk, lihat [Menambahkan grup](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) di *Panduan AWS IAM Identity Center Pengguna*.
## Buat fungsi Lambda yang tahan lama dengan konsol
Dalam contoh ini, fungsi tahan lama Anda memproses pesanan melalui beberapa langkah dengan pos pemeriksaan otomatis. Fungsi mengambil objek JSON yang berisi ID pesanan, memvalidasi pesanan, memproses pembayaran, dan mengonfirmasi pesanan. Setiap langkah secara otomatis diperiksa, jadi jika fungsi terganggu, itu dilanjutkan dari langkah terakhir yang diselesaikan.
Fungsi Anda juga menunjukkan operasi tunggu, menghentikan eksekusi untuk waktu yang singkat untuk mensimulasikan menunggu konfirmasi eksternal.
**Untuk membuat fungsi yang tahan lama dengan konsol**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih **Buat fungsi**.
1. Pilih **Penulis dari awal**.
1. Di panel **Informasi dasar**, untuk **nama Fungsi**, masukkan`myDurableFunction`.
1. Untuk **Runtime**, pilih **Node.js 24 atau **Python** 3.14**.
1. Pilih **Aktifkan eksekusi yang tahan lama**.
Lambda membuat fungsi tahan lama Anda dengan [peran eksekusi](lambda-intro-execution-role.md) yang menyertakan izin untuk operasi pos pemeriksaan (dan). `lambda:CheckpointDurableExecutions` `lambda:GetDurableExecutionState`
**catatan**
Runtime Lambda menyertakan Durable Execution SDK, sehingga Anda dapat menguji fungsi yang tahan lama tanpa dependensi kemasan. Namun, sebaiknya sertakan SDK dalam paket penerapan Anda untuk produksi. Ini memastikan konsistensi versi dan menghindari kemungkinan pembaruan runtime yang mungkin memengaruhi fungsi Anda.
Gunakan editor kode bawaan konsol untuk menambahkan kode fungsi tahan lama Anda.
------
#### [ Node.js ]
**Untuk memodifikasi kode di konsol**
1. Pilih tab **Kode**.
Di editor kode bawaan konsol, Anda akan melihat kode fungsi yang dibuat Lambda. Jika Anda tidak melihat tab **index.mjs** di editor kode, pilih **index.mjs di file explorer seperti yang ditunjukkan** pada diagram berikut.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/durable-nodejs.png)
1. Tempelkan kode berikut ke tab **index.mjs**, ganti kode yang dibuat Lambda.
```
import {
DurableContext,
withDurableExecution,
} from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event, context) => {
const orderId = event.orderId;
// Step 1: Validate order
const validationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Validating order ${orderId}`);
return { orderId, status: "validated" };
});
// Step 2: Process payment
const paymentResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Processing payment for order ${orderId}`);
return { orderId, status: "paid", amount: 99.99 };
});
// Wait for 10 seconds to simulate external confirmation
await context.wait({ seconds: 10 });
// Step 3: Confirm order
const confirmationResult = await context.step(async (stepContext) => {
stepContext.logger.info(`Confirming order ${orderId}`);
return { orderId, status: "confirmed" };
});
return {
orderId: orderId,
status: "completed",
steps: [validationResult, paymentResult, confirmationResult]
};
}
);
```
1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Memahami kode fungsi tahan lama Anda**
Sebelum Anda pindah ke langkah berikutnya, mari kita lihat kode fungsi dan pahami konsep fungsi kunci yang tahan lama.
+ `withDurableExecution`Pembungkusnya:
Fungsi tahan lama Anda dibungkus dengan`withDurableExecution`. Pembungkus ini memungkinkan eksekusi yang tahan lama dengan menyediakan `DurableContext` objek dan mengelola operasi pos pemeriksaan.
+ `DurableContext`Objek:
Alih-alih konteks Lambda standar, fungsi Anda menerima file. `DurableContext` Objek ini menyediakan metode untuk operasi tahan lama seperti `step()` dan `wait()` yang membuat pos pemeriksaan.
+ Langkah-langkah dan pos pemeriksaan:
Setiap `context.step()` panggilan membuat pos pemeriksaan sebelum dan sesudah eksekusi. Jika fungsi Anda terganggu, itu dilanjutkan dari pos pemeriksaan terakhir yang selesai. Fungsi ini tidak menjalankan kembali langkah-langkah yang telah selesai. Ini menggunakan hasil yang disimpan sebagai gantinya.
+ Tunggu operasi:
`context.wait()`Panggilan menjeda eksekusi tanpa menghabiskan sumber daya komputasi. Ketika menunggu selesai, Lambda memanggil fungsi Anda lagi dan memutar ulang log pos pemeriksaan, menggantikan nilai yang disimpan untuk langkah-langkah yang telah diselesaikan.
+ Mekanisme replay:
Ketika fungsi Anda dilanjutkan setelah menunggu atau interupsi, Lambda menjalankan kode Anda dari awal. Namun, langkah yang diselesaikan tidak dijalankan ulang. Lambda memutar ulang hasil mereka dari log pos pemeriksaan. Inilah sebabnya mengapa kode Anda harus deterministik.
------
#### [ Python ]
**Untuk memodifikasi kode di konsol**
1. Pilih tab **Kode**.
Di editor kode bawaan konsol, Anda akan melihat kode fungsi yang dibuat Lambda. Jika Anda tidak melihat tab **lambda\$1function.py** di editor kode, pilih **lambda\$1function.py** di file explorer seperti yang ditunjukkan pada diagram berikut.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/durable-python.png)
1. Tempelkan kode berikut ke tab **lambda\$1function.py**, ganti kode yang dibuat Lambda.
```
from aws_durable_execution_sdk_python import (
DurableContext,
durable_execution,
durable_step,
)
from aws_durable_execution_sdk_python.config import Duration
@durable_step
def validate_order(step_context, order_id):
step_context.logger.info(f"Validating order {order_id}")
return {"orderId": order_id, "status": "validated"}
@durable_step
def process_payment(step_context, order_id):
step_context.logger.info(f"Processing payment for order {order_id}")
return {"orderId": order_id, "status": "paid", "amount": 99.99}
@durable_step
def confirm_order(step_context, order_id):
step_context.logger.info(f"Confirming order {order_id}")
return {"orderId": order_id, "status": "confirmed"}
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
# Step 1: Validate order
validation_result = context.step(validate_order(order_id))
# Step 2: Process payment
payment_result = context.step(process_payment(order_id))
# Wait for 10 seconds to simulate external confirmation
context.wait(Duration.from_seconds(10))
# Step 3: Confirm order
confirmation_result = context.step(confirm_order(order_id))
return {
"orderId": order_id,
"status": "completed",
"steps": [validation_result, payment_result, confirmation_result]
}
```
1. Di bagian **DEPLOY**, pilih **Deploy** untuk memperbarui kode fungsi Anda:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png)
**Memahami kode fungsi tahan lama Anda**
Sebelum Anda pindah ke langkah berikutnya, mari kita lihat kode fungsi dan pahami konsep fungsi kunci yang tahan lama.
+ `@durable_execution`Dekorator:
Fungsi handler Anda dihiasi dengan`@durable_execution`. Dekorator ini memungkinkan eksekusi yang tahan lama dengan menyediakan `DurableContext` objek dan mengelola operasi pos pemeriksaan.
+ `@durable_step`Dekorator:
Setiap fungsi langkah dihiasi dengan`@durable_step`. Dekorator ini menandai fungsi sebagai langkah tahan lama yang menciptakan pos pemeriksaan.
+ `DurableContext`Objek:
Alih-alih konteks Lambda standar, fungsi Anda menerima file. `DurableContext` Objek ini menyediakan metode untuk operasi tahan lama seperti `step()` dan `wait()` yang membuat pos pemeriksaan.
+ Langkah-langkah dan pos pemeriksaan:
Setiap `context.step()` panggilan membuat pos pemeriksaan sebelum dan sesudah eksekusi. Jika fungsi Anda terganggu, itu dilanjutkan dari pos pemeriksaan terakhir yang selesai. Fungsi ini tidak menjalankan kembali langkah-langkah yang telah selesai. Ini menggunakan hasil yang disimpan sebagai gantinya.
+ Tunggu operasi:
`context.wait()`Panggilan menjeda eksekusi tanpa menghabiskan sumber daya komputasi. Ketika menunggu selesai, Lambda memanggil fungsi Anda lagi dan memutar ulang log pos pemeriksaan, menggantikan nilai yang disimpan untuk langkah-langkah yang telah diselesaikan.
+ Python SDK sinkron:
Perhatikan bahwa Python SDK tidak digunakan. `await` Semua operasi tahan lama adalah panggilan metode sinkron.
------
## Memanggil fungsi tahan lama menggunakan editor kode konsol
Jika tidak ada versi eksplisit yang ditentukan (atau dipublikasikan), konsol akan memanggil fungsi tahan lama menggunakan kualifikasi `$LATEST` versi. Namun, untuk eksekusi deterministik kode Anda, Anda harus selalu menggunakan ARN yang memenuhi syarat yang menunjuk ke versi stabil.
**Untuk mempublikasikan versi fungsi Anda**
1. Pilih tab **Versi**.
1. Pilih**Publikasikan versi baru**.
1. Untuk **deskripsi Versi**, masukkan **Initial version** (opsional).
1. Pilih **Terbitkan**.
1. Lambda membuat versi 1 dari fungsi Anda. Perhatikan bahwa fungsi ARN sekarang termasuk `:1` di akhir, menunjukkan ini adalah versi 1.
Sekarang buat acara uji untuk dikirim ke fungsi Anda. Acara ini adalah dokumen berformat JSON yang berisi ID pesanan.
**Untuk membuat acara pengujian**
1. Di bagian **TEST EVENTS** pada editor kode konsol, pilih **Buat acara pengujian**.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/test-event.png)
1. Untuk **Nama Acara**, masukkan**myTestEvent**.
1. Di bagian **Event JSON**, ganti JSON default dengan yang berikut:
```
{
"orderId": "order-12345"
}
```
1. Pilih **Simpan**.
**Untuk menguji fungsi tahan lama Anda dan melihat eksekusi**
Di bagian **TEST EVENTS** pada editor kode konsol, pilih ikon jalankan di sebelah acara pengujian Anda:
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/getting-started-tutorial/run-test-event.png)
Fungsi tahan lama Anda mulai dijalankan. Karena ini termasuk menunggu 10 detik, pemanggilan awal selesai dengan cepat, dan fungsi dilanjutkan setelah periode tunggu. Anda dapat melihat progres eksekusi di tab **Eksekusi tahan lama**.
**Untuk melihat eksekusi fungsi tahan lama**
1. Pilih tab **Eksekusi tahan lama**.
1. Temukan eksekusi Anda dalam daftar. Eksekusi menunjukkan status saat ini (Berjalan, Berhasil, atau Gagal).
1. Pilih ID eksekusi untuk melihat detail, termasuk:
+ Garis waktu eksekusi menunjukkan kapan setiap langkah selesai
+ Sejarah pos pemeriksaan
+ Periode tunggu
+ Hasil langkah
Anda juga dapat melihat log fungsi Anda di CloudWatch Log untuk melihat keluaran konsol dari setiap langkah.
**Untuk melihat catatan pemanggilan fungsi Anda di Log CloudWatch**
1. Buka halaman [Grup log](https://console.aws.amazon.com/cloudwatch/home#logs:) CloudWatch konsol.
1. Pilih grup log untuk fungsi Anda (`/aws/lambda/myDurableFunction`).
1. Gulir ke bawah dan pilih **aliran Log** untuk pemanggilan fungsi yang ingin Anda lihat.
![\[\]](http://docs.aws.amazon.com/id_id/lambda/latest/dg/images/log-stream.png)
Anda akan melihat entri log untuk setiap pemanggilan fungsi Anda, termasuk eksekusi awal dan pemutaran ulang setelah menunggu.
**catatan**
Saat Anda menggunakan logger dari `DurableContext` (seperti `context.logger` atau`stepContext.logger`), log juga muncul dalam eksekusi tahan lama dan tampilan langkah di konsol Lambda. Log ini mungkin membutuhkan waktu beberapa saat untuk dimuat.
## Bersihkan
Setelah Anda selesai bekerja dengan contoh fungsi tahan lama, hapus. Anda juga dapat menghapus grup log yang menyimpan log fungsi, dan [peran eksekusi](lambda-intro-execution-role.md) yang dibuat konsol.
**Untuk menghapus fungsi Lambda**
1. Buka [halaman Fungsi](https://console.aws.amazon.com/lambda/home#/functions) di konsol Lambda.
1. Pilih fungsi yang Anda buat.
1. Pilih **Tindakan**, **Hapus**.
1. Ketik **confirm** kolom input teks dan pilih **Hapus**.
**Untuk menghapus grup log**
1. Buka halaman [Grup log](https://console.aws.amazon.com/cloudwatch/home#logs:) CloudWatch konsol.
1. Pilih grup log fungsi (`/aws/lambda/myDurableFunction`).
1. Pilih **Tindakan**, **Hapus grup log**.
1. Di kotak dialog **Hapus grup log**, pilih **Hapus**.
**Untuk menghapus peran eksekusi**
1. Buka [halaman Peran](https://console.aws.amazon.com/iam/home?#/roles) konsol AWS Identity and Access Management (IAM).
1. Pilih peran eksekusi fungsi (misalnya,`myDurableFunction-role-31exxmpl`).
1. Pilih **Hapus**.
1. Di kotak dialog **Hapus peran**, masukkan nama peran, lalu pilih **Hapus**.
## Sumber daya tambahan dan langkah selanjutnya
Sekarang setelah Anda membuat dan menguji fungsi tahan lama sederhana menggunakan konsol, ambil langkah berikut:
+ Pelajari tentang kasus penggunaan umum untuk fungsi tahan lama, termasuk transaksi terdistribusi, pemrosesan pesanan, dan alur kerja tinjauan manusia. Lihat [Contoh](durable-examples.md).
+ Pahami cara memantau eksekusi fungsi yang tahan lama dengan CloudWatch metrik dan riwayat eksekusi. Lihat [Monitoring dan debugging](durable-monitoring.md).
+ Pelajari tentang menjalankan fungsi tahan lama secara sinkron dan asinkron, serta mengelola eksekusi yang berjalan lama. Lihat [Memanggil fungsi yang tahan lama](durable-invoking.md).
+ Ikuti praktik terbaik untuk menulis kode deterministik, mengelola ukuran pos pemeriksaan, dan mengoptimalkan biaya. Lihat [Praktik terbaik](durable-best-practices.md).
+ Pelajari cara menguji fungsi tahan lama secara lokal dan di cloud. Lihat [Menguji fungsi tahan lama](durable-testing.md).
+ Bandingkan fungsi tahan lama dengan Step Functions untuk memahami kapan setiap pendekatan paling efektif. Lihat [Fungsi tahan lama atau Step Functions](durable-step-functions.md).
# Menyebarkan dan menjalankan fungsi Lambda yang tahan lama dengan AWS CLI
Gunakan AWS CLI untuk membuat dan menerapkan fungsi tahan lama Lambda dengan perintah imperatif. Pendekatan ini memberi Anda kontrol langsung atas setiap langkah proses penyebaran.
## Prasyarat
+ Instal dan konfigurasikan AWS CLI. Untuk petunjuk, lihat [Menginstal AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ Buat paket penerapan dengan kode fungsi Anda dan SDK eksekusi yang tahan lama.
+ Buat peran eksekusi IAM dengan izin pos pemeriksaan.
## Buat peran eksekusi
Buat peran IAM dengan izin untuk eksekusi Lambda dasar dan operasi pos pemeriksaan.
**Untuk membuat peran eksekusi**
1. Buat dokumen kebijakan kepercayaan yang memungkinkan Lambda untuk mengambil peran. Simpan ini sebagai`trust-policy.json`:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "lambda.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
1. Buat peran:
```
aws iam create-role \
--role-name durable-function-role \
--assume-role-policy-document file://trust-policy.json
```
1. Lampirkan kebijakan eksekusi tahan lama untuk operasi pos pemeriksaan dan eksekusi dasar:
```
aws iam attach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
```
Kebijakan `AWSLambdaBasicDurableExecutionRolePolicy` terkelola mencakup izin yang diperlukan untuk operasi pos pemeriksaan (`lambda:CheckpointDurableExecutions`dan`lambda:GetDurableExecutionState`) dan eksekusi Lambda dasar.
## Buat fungsi yang tahan lama
Buat fungsi tahan lama Anda dengan `--durable-config` parameter.
**Untuk membuat fungsi yang tahan lama**
1. Package kode fungsi Anda dengan dependensi ke dalam file.zip:
```
zip -r function.zip index.mjs node_modules/
```
1. Buat fungsi dengan eksekusi tahan lama diaktifkan:
```
aws lambda create-function \
--function-name myDurableFunction \
--runtime nodejs22.x \
--role arn:aws:iam::123456789012:role/durable-function-role \
--handler index.handler \
--zip-file fileb://function.zip \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
**catatan**
Anda hanya dapat mengaktifkan eksekusi yang tahan lama saat membuat fungsi. Anda tidak dapat mengaktifkannya pada fungsi yang ada.
**catatan**
Saat ini fungsi Durable di Java (Preview) saat ini hanya dapat dibuat melalui gambar kontainer. Untuk informasi selengkapnya tentang membuat fungsi tahan lama dari gambar kontainer, lihat [Waktu proses yang didukung untuk fungsi tahan lama](durable-supported-runtimes.md).
## Publikasikan versi
Meskipun fungsi tahan lama dapat dipanggil menggunakan kualifikasi `$LATEST` versi, Anda harus selalu menggunakan ARN yang memenuhi syarat yang menunjuk ke versi stabil untuk memastikan eksekusi kode Anda secara deterministik.
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Initial version"
```
Perintah mengembalikan versi ARN. Perhatikan nomor versi (misalnya,`:1`) di akhir ARN.
Secara opsional, buat alias yang menunjuk ke versi:
```
aws lambda create-alias \
--function-name myDurableFunction \
--name prod \
--function-version 1
```
## Memanggil fungsi tahan lama
Panggil fungsi tahan lama Anda menggunakan ARN yang memenuhi syarat (versi atau alias).
**catatan**
**Pemanggilan idempoten:** Untuk mencegah eksekusi duplikat saat mencoba kembali pemanggilan yang gagal, Anda dapat memberikan nama eksekusi yang memastikan semantik eksekusi. at-most-once Lihat [Idempotency](durable-execution-idempotency.md) untuk detailnya.
**Invokasi sinkron**
Untuk eksekusi yang selesai dalam 15 menit, gunakan pemanggilan sinkron:
```
aws lambda invoke \
--function-name myDurableFunction:1 \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
Atau menggunakan alias:
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
**Invokasi asinkron**
Untuk eksekusi yang berjalan lama, gunakan pemanggilan asinkron:
```
aws lambda invoke \
--function-name myDurableFunction:prod \
--invocation-type Event \
--payload '{"orderId": "order-12345"}' \
--cli-binary-format raw-in-base64-out \
response.json
```
Dengan pemanggilan asinkron, Lambda segera kembali. Fungsi terus dijalankan di latar belakang.
**catatan**
Anda dapat menggunakan `$LATEST` untuk membuat prototipe dan pengujian di konsol. Untuk beban kerja produksi, gunakan versi atau alias yang diterbitkan.
## Kelola eksekusi yang tahan lama
Gunakan perintah berikut untuk mengelola dan memantau eksekusi fungsi yang tahan lama.
**Daftar eksekusi**
Daftar semua eksekusi untuk fungsi yang tahan lama:
```
aws lambda list-durable-executions-by-function \
--function-name myDurableFunction
```
**Dapatkan detail eksekusi**
Dapatkan detail tentang eksekusi tertentu:
```
aws lambda get-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**Dapatkan riwayat eksekusi**
Lihat riwayat pos pemeriksaan untuk eksekusi:
```
aws lambda get-durable-execution-history \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
**Hentikan eksekusi**
Hentikan eksekusi tahan lama yang berjalan:
```
aws lambda stop-durable-execution \
--durable-execution-arn arn:aws:lambda:us-east-1:123456789012:function:myDurableFunction:my-function-version/durable-execution/my-execution-name/my-execution-id
```
## Perbarui kode fungsi
Perbarui kode fungsi tahan lama Anda dan publikasikan versi baru:
**Untuk memperbarui dan mempublikasikan versi baru**
1. Perbarui kode fungsi:
```
aws lambda update-function-code \
--function-name myDurableFunction \
--zip-file fileb://function.zip
```
1. Tunggu pembaruan selesai:
```
aws lambda wait function-updated \
--function-name myDurableFunction
```
1. Publikasikan versi baru:
```
aws lambda publish-version \
--function-name myDurableFunction \
--description "Updated order processing logic"
```
1. Perbarui alias untuk menunjuk ke versi baru:
```
aws lambda update-alias \
--function-name myDurableFunction \
--name prod \
--function-version 2
```
**penting**
Menjalankan eksekusi terus menggunakan versi yang mereka mulai. Pemanggilan baru menggunakan versi alias yang diperbarui.
## Lihat log fungsi
Lihat log fungsi tahan lama Anda di CloudWatch Log:
```
aws logs tail /aws/lambda/myDurableFunction --follow
```
Filter log untuk eksekusi tertentu:
```
aws logs filter-log-events \
--log-group-name /aws/lambda/myDurableFunction \
--filter-pattern "exec-abc123"
```
## Pembersihan sumber daya
Hapus fungsi tahan lama dan sumber daya terkait:
```
# Delete the function
aws lambda delete-function --function-name myDurableFunction
# Delete the IAM role policies
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicExecutionRole
aws iam detach-role-policy \
--role-name durable-function-role \
--policy-arn arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
# Delete the role
aws iam delete-role --role-name durable-function-role
```
## Langkah selanjutnya
Setelah menerapkan fungsi tahan lama Anda dengan: AWS CLI
+ Memantau eksekusi menggunakan perintah `list-durable-executions` dan `get-durable-execution`
+ Lihat operasi pos pemeriksaan dalam peristiwa AWS CloudTrail data
+ Siapkan CloudWatch alarm untuk kegagalan eksekusi atau eksekusi yang berjalan lama
+ Mengotomatiskan penerapan menggunakan skrip shell atau pipeline CI/CD
Untuk informasi selengkapnya tentang AWS CLI perintah untuk Lambda, lihat Referensi [AWS CLI Perintah](https://docs.aws.amazon.com/cli/latest/reference/lambda/index.html).
# Terapkan fungsi Lambda yang tahan lama dengan Infrastruktur sebagai Kode
Anda dapat menerapkan fungsi tahan lama Lambda menggunakan alat Infrastructure as Code (IAc) AWS CloudFormation seperti AWS CDK,, AWS Serverless Application Model, atau Terraform. Alat ini memungkinkan Anda menentukan fungsi, peran eksekusi, dan izin dalam kode, membuat penerapan dapat diulang dan dikontrol versi.
Ketiga alat mengharuskan Anda untuk:
+ Aktifkan eksekusi yang tahan lama pada fungsi
+ Berikan izin pos pemeriksaan untuk peran eksekusi
+ Publikasikan versi atau buat alias (fungsi tahan lama membutuhkan kualifikasi ARNs)
## Fungsi tahan lama dari ZIP
### AWS CloudFormation
Gunakan CloudFormation untuk menentukan fungsi tahan lama Anda dalam template. Contoh berikut membuat fungsi tahan lama dengan izin yang diperlukan.
```
AWSTemplateFormatVersion: '2010-09-09'
Description: Lambda durable function example
Resources:
DurableFunctionRole:
Type: AWS::IAM::Role
Properties:
AssumeRolePolicyDocument:
Version: '2012-10-17'
Statement:
- Effect: Allow
Principal:
Service: lambda.amazonaws.com
Action: sts:AssumeRole
ManagedPolicyArns:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
DurableFunction:
Type: AWS::Lambda::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
Role: !GetAtt DurableFunctionRole.Arn
Code:
ZipFile: |
// Your durable function code here
export const handler = async (event, context) => {
return { statusCode: 200 };
};
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
DurableFunctionVersion:
Type: AWS::Lambda::Version
Properties:
FunctionName: !Ref DurableFunction
Description: Initial version
DurableFunctionAlias:
Type: AWS::Lambda::Alias
Properties:
FunctionName: !Ref DurableFunction
FunctionVersion: !GetAtt DurableFunctionVersion.Version
Name: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunctionAlias
```
**Untuk menyebarkan template**
```
aws cloudformation deploy \
--template-file template.yaml \
--stack-name my-durable-function-stack \
--capabilities CAPABILITY_IAM
```
### AWS CDK
AWS CDK memungkinkan Anda menentukan infrastruktur menggunakan bahasa pemrograman. Contoh berikut menunjukkan cara membuat fungsi tahan lama menggunakan TypeScript dan Python.
------
#### [ TypeScript ]
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.Function(this, 'DurableFunction', {
runtime: lambda.Runtime.NODEJS_22_X,
handler: 'index.handler',
code: lambda.Code.fromAsset('lambda'),
functionName: 'myDurableFunction',
durableConfig: { executionTimeout: Duration.hours(1), retentionPeriod: Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
------
#### [ Python ]
```
from aws_cdk import (
Stack,
aws_lambda as lambda_,
aws_iam as iam,
CfnOutput,
)
from constructs import Construct
class DurableFunctionStack(Stack):
def __init__(self, scope: Construct, id: str, **kwargs):
super().__init__(scope, id, **kwargs)
# Create the durable function
durable_function = lambda_.Function(
self, 'DurableFunction',
runtime=lambda_.Runtime.NODEJS_22_X,
handler='index.handler',
code=lambda_.Code.from_asset('lambda'),
function_name='myDurableFunction',
durable_execution={execution_timeout: Duration.hours(1), retention_period: Duration.days(30)}
)
# Add durable execution managed policy for checkpoint permissions
durable_function.role.add_managed_policy(
iam.ManagedPolicy.from_aws_managed_policy_name('service-role/AWSLambdaBasicDurableExecutionRolePolicy')
)
# Create version and alias
version = durable_function.current_version
alias = lambda_.Alias(
self, 'ProdAlias',
alias_name='prod',
version=version
)
# Output the alias ARN
CfnOutput(
self, 'FunctionAliasArn',
value=alias.function_arn,
description='Use this ARN to invoke the durable function'
)
```
------
**Untuk menyebarkan tumpukan CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM menyederhanakan CloudFormation template untuk aplikasi tanpa server. Template berikut menciptakan fungsi yang tahan lama dengan AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
Runtime: nodejs22.x
Handler: index.handler
CodeUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Untuk menyebarkan template SAM**
```
sam build
sam deploy --guided
```
### Terraform
Terraform adalah alat iAc open-source populer yang mendukung sumber daya. AWS Contoh berikut membuat fungsi tahan lama dengan Terraform menggunakan AWS penyedia versi 6.25.0 atau yang lebih baru.
```
terraform {
required_version = ">= 1.0"
required_providers {
aws = {
source = "hashicorp/aws"
version = ">= 6.25.0"
}
}
}
provider "aws" {
region = "us-east-2"
}
# IAM Role for Lambda Function
resource "aws_iam_role" "lambda_role" {
name = "durable-function-role"
assume_role_policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Action = "sts:AssumeRole"
Effect = "Allow"
Principal = {
Service = "lambda.amazonaws.com"
}
}]
})
}
# Attach durable execution policy for checkpoint operations
resource "aws_iam_role_policy_attachment" "lambda_durable" {
policy_arn = "arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy"
role = aws_iam_role.lambda_role.name
}
# Lambda Function with Durable Execution enabled
resource "aws_lambda_function" "durable_function" {
filename = "function.zip"
function_name = "myDurableFunction"
role = aws_iam_role.lambda_role.arn
handler = "index.handler"
runtime = "nodejs22.x"
timeout = 30
memory_size = 512
durable_config {
execution_timeout = 900
retention_period = 7
}
}
# Publish a version
resource "aws_lambda_alias" "prod" {
name = "prod"
function_name = aws_lambda_function.durable_function.function_name
function_version = aws_lambda_function.durable_function.version
}
output "function_arn" {
description = "ARN of the Lambda function"
value = aws_lambda_function.durable_function.arn
}
output "alias_arn" {
description = "ARN of the function alias (use this for invocations)"
value = aws_lambda_alias.prod.arn
}
```
**Untuk menyebarkan dengan Terraform**
```
terraform init
terraform plan
terraform apply
```
**catatan**
Dukungan Terraform untuk fungsi tahan lama Lambda memerlukan versi AWS penyedia 6.25.0 atau yang lebih baru. Perbarui versi penyedia Anda jika Anda menggunakan versi yang lebih lama.
## Fungsi tahan lama dari gambar kontainer OCI
Anda juga dapat membuat fungsi Tahan Lama berdasarkan gambar kontainer. Untuk petunjuk tentang cara membuat image container, lihat [Runtime yang didukung untuk fungsi tahan lama](durable-supported-runtimes.md).
### AWS CDK
AWS CDK memungkinkan Anda menentukan infrastruktur menggunakan bahasa pemrograman. Contoh berikut menunjukkan cara membuat fungsi tahan lama menggunakan TypeScript dari gambar kontainer.
```
import * as cdk from 'aws-cdk-lib';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as iam from 'aws-cdk-lib/aws-iam';
import { Construct } from 'constructs';
export class DurableFunctionStack extends cdk.Stack {
constructor(scope: Construct, id: string, props?: cdk.StackProps) {
super(scope, id, props);
// Create the durable function
const durableFunction = new lambda.DockerImageFunction(this, 'DurableFunction', {
code: lambda.DockerImageCode.fromImageAsset('./lambda', {
platform: cdk.aws_ecr_assets.Platform.LINUX_AMD64,
}),
functionName: 'myDurableFunction',
memorySize: 512,
timeout: cdk.Duration.seconds(30),
durableConfig: { executionTimeout: cdk.Duration.hours(1), retentionPeriod: cdk.Duration.days(30) },
});
// Create version and alias
const version = durableFunction.currentVersion;
const alias = new lambda.Alias(this, 'ProdAlias', {
aliasName: 'prod',
version: version,
});
// Output the alias ARN
new cdk.CfnOutput(this, 'FunctionAliasArn', {
value: alias.functionArn,
description: 'Use this ARN to invoke the durable function',
});
}
}
```
**Untuk menyebarkan tumpukan CDK**
```
cdk deploy
```
### AWS Serverless Application Model
AWS SAM menyederhanakan CloudFormation template untuk aplikasi tanpa server. Template berikut menciptakan fungsi yang tahan lama dengan AWS SAM.
```
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: Lambda durable function with SAM
Resources:
DurableFunction:
Type: AWS::Serverless::Function
Properties:
FunctionName: myDurableFunction
PackageType: Image
ImageUri: ./src
DurableConfig:
ExecutionTimeout: 3600
RetentionPeriodInDays: 7
Policies:
- arn:aws:iam::aws:policy/service-role/AWSLambdaBasicDurableExecutionRolePolicy
AutoPublishAlias: prod
Metadata:
DockerTag: latest
DockerContext: ./src
Dockerfile: Dockerfile
Outputs:
FunctionArn:
Description: Durable function ARN
Value: !GetAtt DurableFunction.Arn
AliasArn:
Description: Function alias ARN (use this for invocations)
Value: !Ref DurableFunction.Alias
```
**Untuk menyebarkan template SAM**
```
sam build
sam deploy --guided
```
## Pola konfigurasi umum
Terlepas dari alat IAc mana yang Anda gunakan, ikuti pola ini untuk fungsi yang tahan lama:
**Aktifkan eksekusi yang tahan lama**
Atur `DurableConfig` properti pada fungsi Anda untuk mengaktifkan eksekusi yang tahan lama. Properti ini hanya tersedia saat membuat fungsi. Anda tidak dapat mengaktifkan eksekusi tahan lama pada fungsi yang ada.
**Berikan izin pos pemeriksaan**
Lampirkan kebijakan `AWSLambdaBasicDurableExecutionRolePolicy` terkelola ke peran eksekusi. Kebijakan ini mencakup persyaratan `lambda:CheckpointDurableExecutions` dan `lambda:GetDurableExecutionState` izin.
**Gunakan yang memenuhi syarat ARNs**
Buat versi atau alias untuk fungsi Anda. Fungsi tahan lama membutuhkan kualifikasi ARNs (dengan versi atau alias) untuk pemanggilan. Gunakan `AutoPublishAlias` dalam AWS SAM atau buat versi eksplisit di CloudFormation, AWS CDK, dan Terraform.
**Package dependensi**
Sertakan SDK eksekusi tahan lama dalam paket penerapan Anda. Untuk Node.js, instal`@aws/durable-execution-sdk-js`. Untuk Python, instal. `aws-durable-execution-sdk-python`
## Langkah selanjutnya
Setelah menerapkan fungsi tahan lama Anda:
+ Uji fungsi Anda menggunakan ARN yang memenuhi syarat (versi atau alias)
+ Pantau kemajuan eksekusi di konsol Lambda di bawah tab Eksekusi tahan lama
+ Lihat operasi pos pemeriksaan dalam peristiwa AWS CloudTrail data
+ Tinjau CloudWatch Log untuk output fungsi dan perilaku pemutaran ulang
Untuk informasi selengkapnya tentang penerapan fungsi Lambda dengan alat IAc, lihat:
+ [CloudFormation AWS::Lambda::Function referensi](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-lambda-function.html)
+ [AWS CDK Dokumentasi modul Lambda](https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_lambda-readme.html)
+ [AWS SAM Panduan Pengembang](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html)
# Fungsi tahan lama atau Step Functions
Kedua fungsi Lambda tahan lama dan AWS Step Functions memungkinkan orkestrasi alur kerja yang andal dengan manajemen status otomatis dan pemulihan kegagalan. Mereka melayani preferensi pengembang yang berbeda dan pola arsitektur. Fungsi tahan lama dioptimalkan untuk pengembangan aplikasi dalam Lambda, sementara Step Functions dibangun untuk orkestrasi alur kerja di seluruh layanan. AWS
## Kapan menggunakan fungsi yang tahan lama
Gunakan fungsi tahan lama saat:
+ Tim Anda lebih menyukai bahasa pemrograman standar dan alat pengembangan yang sudah dikenal
+ Logika aplikasi Anda terutama dalam fungsi Lambda
+ Anda ingin kontrol halus atas status eksekusi dalam kode
+ Anda sedang membangun aplikasi Lambda-sentris dengan kopling ketat antara alur kerja dan logika bisnis
+ Anda ingin mengulangi dengan cepat tanpa beralih antara kode dan desainer visual/JSON
## Kapan menggunakan Step Functions
Gunakan Step Functions saat:
+ Anda memerlukan representasi alur kerja visual untuk visibilitas lintas tim
+ Anda mengatur beberapa AWS layanan dan menginginkan integrasi asli tanpa kode SDK khusus
+ Anda memerlukan infrastruktur tanpa pemeliharaan (tidak ada penambalan, pembaruan runtime)
+ Pemangku kepentingan non-teknis perlu memahami dan memvalidasi logika alur kerja
## Kerangka keputusan
Gunakan pertanyaan berikut untuk menentukan layanan mana yang sesuai dengan kasus penggunaan Anda:
+ **Apa fokus utama Anda?** Pengembangan aplikasi di Lambda → fungsi tahan lama. Orkestrasi alur kerja di seluruh → Step AWS Functions.
+ **Apa model pemrograman pilihan Anda?** Bahasa pemrograman standar → fungsi tahan lama. DSL berbasis grafik atau desainer visual → Step Functions.
+ **Berapa banyak AWS layanan yang terlibat?** Terutama Lambda → fungsi tahan lama. Beberapa AWS layanan → Step Functions.
+ **Alat pengembangan apa yang Anda gunakan?** Pengalaman pengembang Lambda, IDE dengan agen LLM, kerangka kerja pengujian unit khusus bahasa pemrograman,, AWS SAM, AWS CDK Toolkit → fungsi tahan lama. AWS Pembuat alur kerja visual, AWS CDK untuk memodelkan alur kerja → Step Functions.
+ **Siapa yang mengelola infrastruktur?** Ingin fleksibilitas dalam Lambda → fungsi tahan lama. Ingin dikelola sepenuhnya, tanpa pemeliharaan → Step Functions.
## Perbandingan fitur
Tabel berikut membandingkan fitur utama antara Step Functions dan Lambda fungsi tahan lama:
| Fitur | AWS Step Functions | Lambda fungsi tahan lama |
| --- | --- | --- |
| Fokus utama | Orkestrasi alur kerja lintas AWS | Pengembangan aplikasi di Lambda |
| Jenis Layanan | Layanan alur kerja mandiri dan berdedikasi | Berjalan di dalam Lambda |
| Model pemrograman | Berbasis grafik, DSL Bahasa Negara Amazon atau AWS CDK | Bahasa pemrograman standar (JavaScript/TypeScript, Python) |
| Alat pengembangan | Pembangun visual di ekstensi IDE AWS Konsol/Toolkit, AWS CDK | Lambda DX dalam agen IDE dan LLM, kerangka pengujian unit, ekstensi IDE Toolkit AWS SAM AWS |
| Integrasi | 220\$1 AWS layanan, 16k APIs | Ekstensi model pemrograman berbasis peristiwa Lambda (sumber acara) |
| Manajemen | Dikelola sepenuhnya, agnostik runtime, nol pemeliharaan (tidak ada penambalan, pembaruan runtime) | Dikelola dalam lingkungan Lambda |
| Terbaik untuk | Proses bisnis dan otomatisasi TI, pemrosesan data, alur kerja AI | Transaksi terdistribusi, logika aplikasi stateful, orkestrasi fungsi, pemrosesan data, alur kerja AI |
## Arsitektur hibrida
Banyak aplikasi mendapat manfaat dari menggunakan kedua layanan tersebut. Pola umum menggunakan fungsi tahan lama untuk logika tingkat aplikasi dalam Lambda, sementara Step Functions mengoordinasikan alur kerja tingkat tinggi di beberapa layanan di luar fungsi Lambda. AWS
## Pertimbangan migrasi
**Memulai kompleks yang sederhana dan berkembang:** Mulailah dengan fungsi tahan lama untuk alur kerja yang berpusat pada Lambda. Tambahkan Step Functions saat Anda membutuhkan orkestrasi multi-layanan atau desain alur kerja visual.
**Pengguna Step Functions yang ada:** Keep Step Functions untuk alur kerja lintas layanan yang telah ditetapkan. Pertimbangkan fungsi tahan lama untuk logika aplikasi Lambda baru yang membutuhkan keandalan.
## Sumber daya terkait
+ [Lambda fungsi tahan lama](durable-functions.md)
+ [Mengatur fungsi Lambda dengan Step Functions](with-step-functions.md)
+ [Memulai dengan fungsi yang tahan lama](durable-getting-started.md)
# Contoh dan kasus penggunaan
Fungsi Lambda yang tahan lama memungkinkan Anda membangun aplikasi multi-langkah yang toleran terhadap kesalahan menggunakan operasi yang tahan lama seperti langkah dan menunggu. Dengan checkpointing otomatis dan model checkpoint-replay. Di mana eksekusi dimulai ulang dari awal setelah kegagalan tetapi melewatkan pos pemeriksaan yang selesai, fungsi Anda dapat pulih dari kegagalan dan melanjutkan eksekusi tanpa kehilangan kemajuan.
## Proses toleran kesalahan berumur pendek
Gunakan fungsi yang tahan lama untuk membangun operasi andal yang biasanya selesai dalam hitungan menit. Meskipun proses ini lebih pendek dari alur kerja yang berjalan lama, mereka masih mendapat manfaat dari pemeriksaan otomatis dan toleransi kesalahan di seluruh sistem terdistribusi. Fungsi tahan lama membantu memastikan proses multi-langkah Anda berhasil diselesaikan bahkan ketika panggilan layanan individu gagal, tanpa memerlukan penanganan kesalahan yang rumit atau kode manajemen status.
Skenario umum termasuk sistem pemesanan hotel, platform reservasi restoran, permintaan perjalanan berbagi perjalanan, pembelian tiket acara, dan peningkatan langganan SaaS. Skenario ini memiliki karakteristik umum: beberapa panggilan layanan yang harus diselesaikan bersama, kebutuhan untuk mencoba ulang otomatis pada kegagalan sementara, dan persyaratan untuk mempertahankan status konsisten di seluruh sistem terdistribusi.
### Transaksi terdistribusi di seluruh layanan mikro
Mengkoordinasikan pembayaran, inventaris, dan pengiriman di beberapa layanan dengan rollback otomatis pada kegagalan. Setiap operasi layanan dibungkus dalam satu langkah, memastikan transaksi dapat pulih dari titik mana pun jika layanan gagal.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { orderId, amount, items } = event;
// Reserve inventory across multiple warehouses
const inventory = await context.step("reserve-inventory", async () => {
return await inventoryService.reserve(items);
});
// Process payment
const payment = await context.step("process-payment", async () => {
return await paymentService.charge(amount);
});
// Create shipment
const shipment = await context.step("create-shipment", async () => {
return await shippingService.createShipment(orderId, inventory);
});
return { orderId, status: 'completed', shipment };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
amount = event['amount']
items = event['items']
# Reserve inventory across multiple warehouses
inventory = context.step(
lambda _: inventory_service.reserve(items),
name='reserve-inventory'
)
# Process payment
payment = context.step(
lambda _: payment_service.charge(amount),
name='process-payment'
)
# Create shipment
shipment = context.step(
lambda _: shipping_service.create_shipment(order_id, inventory),
name='create-shipment'
)
return {'orderId': order_id, 'status': 'completed', 'shipment': shipment}
```
------
Jika ada langkah yang gagal, fungsi secara otomatis mencoba ulang dari pos pemeriksaan terakhir yang berhasil. Reservasi inventaris tetap ada meskipun pemrosesan pembayaran gagal sementara. Ketika fungsi mencoba lagi, ia melewatkan langkah inventaris yang telah selesai dan langsung melanjutkan ke pemrosesan pembayaran. Ini menghilangkan reservasi duplikat dan memastikan status konsisten di seluruh sistem terdistribusi Anda.
### Pemrosesan pesanan dengan beberapa langkah
Memproses pesanan melalui validasi, otorisasi pembayaran, alokasi inventaris, dan pemenuhan dengan percobaan ulang dan pemulihan otomatis. Setiap langkah diperiksa, memastikan pesanan berlanjut bahkan jika langkah individu gagal dan coba lagi.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { orderId, customerId, items } = event;
// Validate order details
const validation = await context.step("validate-order", async () => {
const customer = await customerService.validate(customerId);
const itemsValid = await inventoryService.validateItems(items);
return { customer, itemsValid };
});
if (!validation.itemsValid) {
return { orderId, status: 'rejected', reason: 'invalid_items' };
}
// Authorize payment
const authorization = await context.step("authorize-payment", async () => {
return await paymentService.authorize(
validation.customer.paymentMethod,
calculateTotal(items)
);
});
// Allocate inventory
const allocation = await context.step("allocate-inventory", async () => {
return await inventoryService.allocate(items);
});
// Fulfill order
const fulfillment = await context.step("fulfill-order", async () => {
return await fulfillmentService.createShipment({
orderId,
items: allocation.allocatedItems,
address: validation.customer.shippingAddress
});
});
return {
orderId,
status: 'completed',
trackingNumber: fulfillment.trackingNumber
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
customer_id = event['customerId']
items = event['items']
# Validate order details
def validate_order(_):
customer = customer_service.validate(customer_id)
items_valid = inventory_service.validate_items(items)
return {'customer': customer, 'itemsValid': items_valid}
validation = context.step(validate_order, name='validate-order')
if not validation['itemsValid']:
return {'orderId': order_id, 'status': 'rejected', 'reason': 'invalid_items'}
# Authorize payment
authorization = context.step(
lambda _: payment_service.authorize(
validation['customer']['paymentMethod'],
calculate_total(items)
),
name='authorize-payment'
)
# Allocate inventory
allocation = context.step(
lambda _: inventory_service.allocate(items),
name='allocate-inventory'
)
# Fulfill order
fulfillment = context.step(
lambda _: fulfillment_service.create_shipment({
'orderId': order_id,
'items': allocation['allocatedItems'],
'address': validation['customer']['shippingAddress']
}),
name='fulfill-order'
)
return {
'orderId': order_id,
'status': 'completed',
'trackingNumber': fulfillment['trackingNumber']
}
```
------
Pola ini memastikan pesanan tidak pernah terjebak dalam keadaan menengah. Jika validasi gagal, pesanan ditolak sebelum otorisasi pembayaran. Jika otorisasi pembayaran gagal, inventaris tidak dialokasikan. Setiap langkah dibangun di atas yang sebelumnya dengan percobaan ulang dan pemulihan otomatis.
**Catatan**
Pemeriksaan bersyarat `if (!validation.itemsValid)` berada di luar langkah dan akan dijalankan kembali selama pemutaran ulang. Ini aman karena deterministik—selalu menghasilkan hasil yang sama dengan objek validasi yang sama.
## Proses yang berjalan lama
Gunakan fungsi tahan lama untuk proses yang berlangsung berjam-jam, berhari-hari, atau berminggu-minggu. Operasi tunggu menangguhkan eksekusi tanpa menimbulkan biaya komputasi, membuat proses yang berjalan lama menjadi hemat biaya. Selama periode tunggu, fungsi Anda berhenti berjalan dan Lambda mendaur ulang lingkungan eksekusi. Ketika tiba waktunya untuk melanjutkan, Lambda memanggil fungsi Anda lagi dan memutar ulang dari pos pemeriksaan terakhir.
Model eksekusi ini membuat fungsi tahan lama ideal untuk proses yang perlu dijeda untuk waktu yang lama, baik menunggu keputusan manusia, respons sistem eksternal, jendela pemrosesan terjadwal, atau penundaan berbasis waktu. Anda hanya membayar untuk waktu komputasi aktif, bukan untuk menunggu.
Skenario umum termasuk proses persetujuan dokumen, pemrosesan batch terjadwal, proses orientasi multi-hari, proses uji coba berlangganan, dan sistem notifikasi tertunda. Skenario ini memiliki karakteristik umum: periode tunggu yang diperpanjang yang diukur dalam jam atau hari, kebutuhan untuk mempertahankan status eksekusi di seluruh penantian tersebut, dan persyaratan yang sensitif terhadap biaya di mana membayar waktu komputasi idle sangat mahal.
### Human-in-the-loop persetujuan
Jeda eksekusi untuk tinjauan dokumen, persetujuan, atau keputusan sambil mempertahankan status eksekusi. Fungsi menunggu callback eksternal tanpa menghabiskan sumber daya, dilanjutkan secara otomatis ketika persetujuan diterima.
Pola ini penting untuk proses yang membutuhkan penilaian manusia atau validasi eksternal. Fungsi ditangguhkan pada titik panggilan balik, tidak menimbulkan biaya komputasi saat menunggu. Ketika seseorang mengirimkan keputusan mereka melalui API, Lambda memanggil fungsi Anda lagi dan memutar ulang dari pos pemeriksaan, melanjutkan dengan hasil persetujuan.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { documentId, reviewers } = event;
// Step 1: Prepare document for review
const prepared = await context.step("prepare-document", async () => {
return await documentService.prepare(documentId);
});
// Step 2: Request approval with callback
const approval = await context.waitForCallback(
"approval-callback",
async (callbackId) => {
await notificationService.sendApprovalRequest({
documentId,
reviewers,
callbackId,
expiresIn: 86400
});
},
{
timeout: { seconds: 86400 }
}
);
// Function resumes here when approval is received
if (approval?.approved) {
const finalized = await context.step("finalize-document", async () => {
return await documentService.finalize(documentId, approval.comments);
});
return {
status: 'approved',
documentId,
finalizedAt: finalized.timestamp
};
}
// Handle rejection
await context.step("archive-rejected", async () => {
await documentService.archive(documentId, approval?.reason);
});
return {
status: 'rejected',
documentId,
reason: approval?.reason
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution, WaitConfig
@durable_execution
def lambda_handler(event, context: DurableContext):
document_id = event['documentId']
reviewers = event['reviewers']
# Step 1: Prepare document for review
prepared = context.step(
lambda _: document_service.prepare(document_id),
name='prepare-document'
)
# Step 2: Request approval with callback
def send_approval_request(callback_id):
notification_service.send_approval_request({
'documentId': document_id,
'reviewers': reviewers,
'callbackId': callback_id,
'expiresIn': 86400
})
approval = context.wait_for_callback(
send_approval_request,
name='approval-callback',
config=WaitConfig(timeout=86400)
)
# Function resumes here when approval is received
if approval and approval.get('approved'):
finalized = context.step(
lambda _: document_service.finalize(document_id, approval.get('comments')),
name='finalize-document'
)
return {
'status': 'approved',
'documentId': document_id,
'finalizedAt': finalized['timestamp']
}
# Handle rejection
context.step(
lambda _: document_service.archive(document_id, approval.get('reason') if approval else None),
name='archive-rejected'
)
return {
'status': 'rejected',
'documentId': document_id,
'reason': approval.get('reason') if approval else None
}
```
------
Ketika callback diterima dan fungsi Anda dilanjutkan, itu akan diputar ulang dari awal. Langkah persiapan-dokumen mengembalikan hasil checkpoint-nya secara instan. waitForCallback Operasi juga kembali secara instan dengan hasil persetujuan yang disimpan alih-alih menunggu lagi. Eksekusi kemudian dilanjutkan ke langkah finalisasi atau arsip.
### Pipa data multi-tahap
Memproses kumpulan data besar melalui fase ekstraksi, transformasi, dan pemuatan dengan pos pemeriksaan antar tahapan. Setiap tahap dapat memakan waktu berjam-jam untuk diselesaikan, dan pos pemeriksaan memungkinkan pipa untuk melanjutkan dari tahap mana pun jika terputus.
Pola ini sangat ideal untuk alur kerja ETL, migrasi data, atau pekerjaan pemrosesan batch di mana Anda perlu memproses data secara bertahap dengan titik pemulihan di antaranya. Jika tahap gagal, pipa dilanjutkan dari tahap selesai terakhir daripada memulai kembali dari awal. Anda juga dapat menggunakan operasi tunggu untuk berhenti sejenak di antara tahapan; menghormati batas tarif, menunggu sistem hilir siap, atau menjadwalkan pemrosesan selama jam-jam sibuk.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { datasetId, batchSize } = event;
// Stage 1: Extract data from source
const extracted = await context.step("extract-data", async () => {
const records = await sourceDatabase.extractRecords(datasetId);
return { recordCount: records.length, records };
});
// Wait 5 minutes to respect source system rate limits
await context.wait({ seconds: 300 });
// Stage 2: Transform data in batches
const transformed = await context.step("transform-data", async () => {
const batches = chunkArray(extracted.records, batchSize);
const results = [];
for (const batch of batches) {
const transformed = await transformService.processBatch(batch);
results.push(transformed);
}
return { batchCount: batches.length, results };
});
// Wait until off-peak hours (e.g., 2 AM)
const now = new Date();
const targetHour = 2;
const msUntilTarget = calculateMsUntilHour(now, targetHour);
await context.wait({ seconds: Math.floor(msUntilTarget / 1000) });
// Stage 3: Load data to destination
const loaded = await context.step("load-data", async () => {
let loadedCount = 0;
for (const result of transformed.results) {
await destinationDatabase.loadBatch(result);
loadedCount += result.length;
}
return { loadedCount };
});
// Stage 4: Verify and finalize
const verified = await context.step("verify-pipeline", async () => {
const verification = await destinationDatabase.verifyRecords(datasetId);
await pipelineService.markComplete(datasetId, verification);
return verification;
});
return {
datasetId,
recordsProcessed: extracted.recordCount,
batchesProcessed: transformed.batchCount,
recordsLoaded: loaded.loadedCount,
verified: verified.success
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
from datetime import datetime
@durable_execution
def lambda_handler(event, context: DurableContext):
dataset_id = event['datasetId']
batch_size = event['batchSize']
# Stage 1: Extract data from source
def extract_data(_):
records = source_database.extract_records(dataset_id)
return {'recordCount': len(records), 'records': records}
extracted = context.step(extract_data, name='extract-data')
# Wait 5 minutes to respect source system rate limits
context.wait(300)
# Stage 2: Transform data in batches
def transform_data(_):
batches = chunk_array(extracted['records'], batch_size)
results = []
for batch in batches:
transformed = transform_service.process_batch(batch)
results.append(transformed)
return {'batchCount': len(batches), 'results': results}
transformed = context.step(transform_data, name='transform-data')
# Wait until off-peak hours (e.g., 2 AM)
now = datetime.now()
target_hour = 2
ms_until_target = calculate_ms_until_hour(now, target_hour)
context.wait(ms_until_target // 1000)
# Stage 3: Load data to destination
def load_data(_):
loaded_count = 0
for result in transformed['results']:
destination_database.load_batch(result)
loaded_count += len(result)
return {'loadedCount': loaded_count}
loaded = context.step(load_data, name='load-data')
# Stage 4: Verify and finalize
def verify_pipeline(_):
verification = destination_database.verify_records(dataset_id)
pipeline_service.mark_complete(dataset_id, verification)
return verification
verified = context.step(verify_pipeline, name='verify-pipeline')
return {
'datasetId': dataset_id,
'recordsProcessed': extracted['recordCount'],
'batchesProcessed': transformed['batchCount'],
'recordsLoaded': loaded['loadedCount'],
'verified': verified['success']
}
```
------
Setiap tahap dibungkus dalam satu langkah, menciptakan pos pemeriksaan yang memungkinkan pipa untuk melanjutkan dari tahap apa pun jika terputus. Penantian 5 menit antara ekstrak dan transformasi menghormati batas laju sistem sumber tanpa mengkonsumsi sumber daya komputasi, sementara menunggu hingga jam 2 pagi menjadwalkan operasi beban yang mahal selama jam-jam di luar sibuk.
**Catatan**
`new Date()`Panggilan dan `calculateMsUntilHour()` fungsi berada di luar langkah dan akan dijalankan kembali selama pemutaran ulang. Untuk operasi berbasis waktu yang harus konsisten di seluruh tayangan ulang, hitung stempel waktu di dalam langkah atau gunakan hanya untuk durasi tunggu (yang ditunjuk periksa).
## Pola lanjutan
Gunakan fungsi tahan lama untuk membangun aplikasi multi-langkah kompleks yang menggabungkan beberapa operasi tahan lama, eksekusi paralel, pemrosesan array, logika bersyarat, dan polling. Pola ini memungkinkan Anda membangun aplikasi canggih yang mengoordinasikan banyak tugas sambil mempertahankan toleransi kesalahan dan pemulihan otomatis.
Pola lanjutan melampaui langkah-langkah berurutan sederhana. Anda dapat menjalankan operasi secara bersamaan dengan`parallel()`, memproses array dengan`map()`, menunggu kondisi eksternal dengan`waitForCondition()`, dan menggabungkan primitif ini untuk membangun aplikasi yang andal. Setiap operasi yang tahan lama membuat pos pemeriksaannya sendiri, sehingga aplikasi Anda dapat pulih dari titik mana pun jika terputus.
### Proses orientasi pengguna
Memandu pengguna melalui pendaftaran, verifikasi email, pengaturan profil, dan konfigurasi awal dengan penanganan coba lagi. Contoh ini menggabungkan langkah-langkah berurutan, callback, dan logika bersyarat untuk membuat proses orientasi yang lengkap.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { userId, email } = event;
// Step 1: Create user account
const user = await context.step("create-account", async () => {
return await userService.createAccount(userId, email);
});
// Step 2: Send verification email
await context.step("send-verification", async () => {
return await emailService.sendVerification(email);
});
// Step 3: Wait for email verification (up to 48 hours)
const verified = await context.waitForCallback(
"email-verification",
async (callbackId) => {
await notificationService.sendVerificationLink({
email,
callbackId,
expiresIn: 172800
});
},
{
timeout: { seconds: 172800 }
}
);
if (!verified) {
await context.step("send-reminder", async () => {
await emailService.sendReminder(email);
});
return {
status: "verification_timeout",
userId,
message: "Email verification not completed within 48 hours"
};
}
// Step 4: Initialize user profile in parallel
const setupResults = await context.parallel("profile-setup", [
async (ctx: DurableContext) => {
return await ctx.step("create-preferences", async () => {
return await preferencesService.createDefaults(userId);
});
},
async (ctx: DurableContext) => {
return await ctx.step("setup-notifications", async () => {
return await notificationService.setupDefaults(userId);
});
},
async (ctx: DurableContext) => {
return await ctx.step("create-welcome-content", async () => {
return await contentService.createWelcome(userId);
});
}
]);
// Step 5: Send welcome email
await context.step("send-welcome", async () => {
const [preferences, notifications, content] = setupResults.getResults();
return await emailService.sendWelcome({
email,
preferences,
notifications,
content
});
});
return {
status: "onboarding_complete",
userId,
completedAt: new Date().toISOString()
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution, WaitConfig
from datetime import datetime
@durable_execution
def lambda_handler(event, context: DurableContext):
user_id = event['userId']
email = event['email']
# Step 1: Create user account
user = context.step(
lambda _: user_service.create_account(user_id, email),
name='create-account'
)
# Step 2: Send verification email
context.step(
lambda _: email_service.send_verification(email),
name='send-verification'
)
# Step 3: Wait for email verification (up to 48 hours)
def send_verification_link(callback_id):
notification_service.send_verification_link({
'email': email,
'callbackId': callback_id,
'expiresIn': 172800
})
verified = context.wait_for_callback(
send_verification_link,
name='email-verification',
config=WaitConfig(timeout=172800)
)
if not verified:
context.step(
lambda _: email_service.send_reminder(email),
name='send-reminder'
)
return {
'status': 'verification_timeout',
'userId': user_id,
'message': 'Email verification not completed within 48 hours'
}
# Step 4: Initialize user profile in parallel
def create_preferences(ctx: DurableContext):
return ctx.step(
lambda _: preferences_service.create_defaults(user_id),
name='create-preferences'
)
def setup_notifications(ctx: DurableContext):
return ctx.step(
lambda _: notification_service.setup_defaults(user_id),
name='setup-notifications'
)
def create_welcome_content(ctx: DurableContext):
return ctx.step(
lambda _: content_service.create_welcome(user_id),
name='create-welcome-content'
)
setup_results = context.parallel(
[create_preferences, setup_notifications, create_welcome_content],
name='profile-setup'
)
# Step 5: Send welcome email
def send_welcome(_):
results = setup_results.get_results()
preferences, notifications, content = results[0], results[1], results[2]
return email_service.send_welcome({
'email': email,
'preferences': preferences,
'notifications': notifications,
'content': content
})
context.step(send_welcome, name='send-welcome')
return {
'status': 'onboarding_complete',
'userId': user_id,
'completedAt': datetime.now().isoformat()
}
```
------
Proses ini menggabungkan langkah-langkah berurutan dengan pos pemeriksaan untuk pembuatan akun dan pengiriman email, kemudian berhenti hingga 48 jam menunggu verifikasi email tanpa menghabiskan sumber daya. Logika bersyarat menangani jalur yang berbeda berdasarkan apakah verifikasi selesai atau habis waktu. Tugas penyiapan profil berjalan secara bersamaan menggunakan operasi paralel untuk mengurangi total waktu eksekusi, dan setiap langkah mencoba ulang secara otomatis pada kegagalan sementara untuk membantu memastikan orientasi selesai dengan andal.
### Pemanggilan berantai di seluruh fungsi
Memanggil fungsi Lambda lainnya dari dalam fungsi tahan lama menggunakan. `context.invoke()` Fungsi pemanggilan ditangguhkan sambil menunggu fungsi yang dipanggil selesai, membuat pos pemeriksaan yang mempertahankan hasilnya. Jika fungsi pemanggilan terputus setelah fungsi yang dipanggil selesai, fungsi tersebut dilanjutkan dengan hasil yang disimpan tanpa memanggil kembali fungsi tersebut.
Gunakan pola ini ketika Anda memiliki fungsi khusus yang menangani domain tertentu (validasi pelanggan, pemrosesan pembayaran, manajemen inventaris) dan perlu mengoordinasikannya dalam alur kerja. Setiap fungsi mempertahankan logikanya sendiri dan dapat dipanggil oleh beberapa fungsi orkestrator, menghindari duplikasi kode.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
// Main orchestrator function
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { orderId, customerId } = event;
// Step 1: Validate customer by invoking customer service function
const customer = await context.invoke(
"validate-customer",
"arn:aws:lambda:us-east-1:123456789012:function:customer-service:1",
{ customerId }
);
if (!customer.isValid) {
return { orderId, status: "rejected", reason: "invalid_customer" };
}
// Step 2: Check inventory by invoking inventory service function
const inventory = await context.invoke(
"check-inventory",
"arn:aws:lambda:us-east-1:123456789012:function:inventory-service:1",
{ orderId, items: event.items }
);
if (!inventory.available) {
return { orderId, status: "rejected", reason: "insufficient_inventory" };
}
// Step 3: Process payment by invoking payment service function
const payment = await context.invoke(
"process-payment",
"arn:aws:lambda:us-east-1:123456789012:function:payment-service:1",
{
customerId,
amount: inventory.totalAmount,
paymentMethod: customer.paymentMethod
}
);
// Step 4: Create shipment by invoking fulfillment service function
const shipment = await context.invoke(
"create-shipment",
"arn:aws:lambda:us-east-1:123456789012:function:fulfillment-service:1",
{
orderId,
items: inventory.allocatedItems,
address: customer.shippingAddress
}
);
return {
orderId,
status: "completed",
trackingNumber: shipment.trackingNumber,
estimatedDelivery: shipment.estimatedDelivery
};
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution
# Main orchestrator function
@durable_execution
def lambda_handler(event, context: DurableContext):
order_id = event['orderId']
customer_id = event['customerId']
# Step 1: Validate customer by invoking customer service function
customer = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:customer-service:1',
{'customerId': customer_id},
name='validate-customer'
)
if not customer['isValid']:
return {'orderId': order_id, 'status': 'rejected', 'reason': 'invalid_customer'}
# Step 2: Check inventory by invoking inventory service function
inventory = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:inventory-service:1',
{'orderId': order_id, 'items': event['items']},
name='check-inventory'
)
if not inventory['available']:
return {'orderId': order_id, 'status': 'rejected', 'reason': 'insufficient_inventory'}
# Step 3: Process payment by invoking payment service function
payment = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:payment-service:1',
{
'customerId': customer_id,
'amount': inventory['totalAmount'],
'paymentMethod': customer['paymentMethod']
},
name='process-payment'
)
# Step 4: Create shipment by invoking fulfillment service function
shipment = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:fulfillment-service:1',
{
'orderId': order_id,
'items': inventory['allocatedItems'],
'address': customer['shippingAddress']
},
name='create-shipment'
)
return {
'orderId': order_id,
'status': 'completed',
'trackingNumber': shipment['trackingNumber'],
'estimatedDelivery': shipment['estimatedDelivery']
}
```
------
Setiap pemanggilan membuat pos pemeriksaan dalam fungsi orkestrator. Jika orkestrator terganggu setelah validasi pelanggan selesai, ia melanjutkan dari pos pemeriksaan itu dengan data pelanggan yang disimpan, melewatkan pemanggilan validasi. Ini mencegah panggilan duplikat ke layanan hilir dan memastikan eksekusi yang konsisten di seluruh interupsi.
Fungsi yang dipanggil dapat berupa fungsi Lambda yang tahan lama atau standar. Jika Anda menjalankan fungsi yang tahan lama, ia dapat memiliki alur kerja multi-langkah sendiri dengan menunggu dan pos pemeriksaan. Orkestrator hanya menunggu eksekusi yang tahan lama selesai, menerima hasil akhir.
**catatan**
Pemanggilan lintas akun tidak didukung. Semua fungsi yang dipanggil harus berada di AWS akun yang sama dengan fungsi pemanggilan.
### Pemrosesan batch dengan pos pemeriksaan
Memproses jutaan catatan dengan pemulihan otomatis dari pos pemeriksaan terakhir yang berhasil setelah kegagalan. Contoh ini menunjukkan bagaimana fungsi yang tahan lama menggabungkan `map()` operasi dengan chunking dan pembatasan laju untuk menangani pemrosesan data skala besar.
------
#### [ TypeScript ]
```
import { DurableContext, withDurableExecution } from "@aws/durable-execution-sdk-js";
interface Batch {
batchIndex: number;
recordIds: string[];
}
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
const { datasetId, batchSize = 1000 } = event;
// Step 1: Get all record IDs to process
const recordIds = await context.step("fetch-record-ids", async () => {
return await dataService.getRecordIds(datasetId);
});
// Step 2: Split into batches
const batches: Batch[] = [];
for (let i = 0; i < recordIds.length; i += batchSize) {
batches.push({
batchIndex: Math.floor(i / batchSize),
recordIds: recordIds.slice(i, i + batchSize)
});
}
// Step 3: Process batches with controlled concurrency
const batchResults = await context.map(
"process-batches",
batches,
async (ctx: DurableContext, batch: Batch, index: number) => {
const processed = await ctx.step(`batch-${batch.batchIndex}`, async () => {
const results = [];
for (const recordId of batch.recordIds) {
const result = await recordService.process(recordId);
results.push(result);
}
return results;
});
const validated = await ctx.step(`validate-${batch.batchIndex}`, async () => {
return await validationService.validateBatch(processed);
});
return {
batchIndex: batch.batchIndex,
recordCount: batch.recordIds.length,
successCount: validated.successCount,
failureCount: validated.failureCount
};
},
{
maxConcurrency: 5
}
);
// Step 4: Aggregate results
const summary = await context.step("aggregate-results", async () => {
const results = batchResults.getResults();
const totalSuccess = results.reduce((sum, r) => sum + r.successCount, 0);
const totalFailure = results.reduce((sum, r) => sum + r.failureCount, 0);
return {
datasetId,
totalRecords: recordIds.length,
batchesProcessed: batches.length,
successCount: totalSuccess,
failureCount: totalFailure,
completedAt: new Date().toISOString()
};
});
return summary;
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import DurableContext, durable_execution, MapConfig
from datetime import datetime
from typing import List, Dict
@durable_execution
def lambda_handler(event, context: DurableContext):
dataset_id = event['datasetId']
batch_size = event.get('batchSize', 1000)
# Step 1: Get all record IDs to process
record_ids = context.step(
lambda _: data_service.get_record_ids(dataset_id),
name='fetch-record-ids'
)
# Step 2: Split into batches
batches = []
for i in range(0, len(record_ids), batch_size):
batches.append({
'batchIndex': i // batch_size,
'recordIds': record_ids[i:i + batch_size]
})
# Step 3: Process batches with controlled concurrency
def process_batch(ctx: DurableContext, batch: Dict, index: int):
batch_index = batch['batchIndex']
def process_records(_):
results = []
for record_id in batch['recordIds']:
result = record_service.process(record_id)
results.append(result)
return results
processed = ctx.step(process_records, name=f'batch-{batch_index}')
validated = ctx.step(
lambda _: validation_service.validate_batch(processed),
name=f'validate-{batch_index}'
)
return {
'batchIndex': batch_index,
'recordCount': len(batch['recordIds']),
'successCount': validated['successCount'],
'failureCount': validated['failureCount']
}
batch_results = context.map(
process_batch,
batches,
name='process-batches',
config=MapConfig(max_concurrency=5)
)
# Step 4: Aggregate results
def aggregate_results(_):
results = batch_results.get_results()
total_success = sum(r['successCount'] for r in results)
total_failure = sum(r['failureCount'] for r in results)
return {
'datasetId': dataset_id,
'totalRecords': len(record_ids),
'batchesProcessed': len(batches),
'successCount': total_success,
'failureCount': total_failure,
'completedAt': datetime.now().isoformat()
}
summary = context.step(aggregate_results, name='aggregate-results')
return summary
```
------
Catatan dibagi menjadi batch yang dapat dikelola untuk menghindari memori yang berlebihan atau layanan hilir, kemudian beberapa batch diproses secara bersamaan dengan mengendalikan paralelisme. `maxConcurrency` Setiap batch memiliki pos pemeriksaannya sendiri, jadi kegagalan hanya mencoba lagi batch yang gagal daripada memproses ulang semua catatan. Pola ini sangat ideal untuk pekerjaan ETL, migrasi data, atau operasi massal di mana pemrosesan dapat memakan waktu berjam-jam.
## Langkah selanjutnya
+ Jelajahi [konsep dasar](durable-basic-concepts.md) untuk memahami DurableContext, langkah, dan menunggu
+ Tinjau [praktik terbaik](durable-best-practices.md) untuk menulis kode deterministik dan mengoptimalkan kinerja
+ Pelajari tentang [menguji fungsi tahan lama](durable-testing.md) secara lokal dan di cloud
+ Bandingkan fungsi tahan lama dengan Step Functions untuk memahami kapan setiap pendekatan paling efektif. Lihat [Fungsi tahan lama atau Step Functions](durable-step-functions.md).
# Keamanan dan izin untuk fungsi Lambda yang tahan lama
Fungsi tahan lama Lambda memerlukan izin IAM khusus untuk mengelola operasi pos pemeriksaan. Ikuti prinsip hak istimewa paling sedikit dengan hanya memberikan izin yang dibutuhkan fungsi Anda.
## Izin peran eksekusi
Peran eksekusi fungsi tahan lama Anda memerlukan izin untuk membuat pos pemeriksaan dan mengambil status eksekusi. Kebijakan berikut menunjukkan izin minimum yang diperlukan:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:CheckpointDurableExecution",
"lambda:GetDurableExecutionState"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name:*"
}
]
}
```
Saat Anda membuat fungsi tahan lama menggunakan konsol, Lambda secara otomatis menambahkan izin ini ke peran eksekusi. Jika Anda membuat fungsi menggunakan AWS CLI or AWS CloudFormation, tambahkan izin ini ke peran eksekusi Anda.
**Prinsip hak istimewa paling sedikit**
Cakupan `Resource` elemen ke fungsi tertentu ARNs alih-alih menggunakan wildcard. Ini membatasi peran eksekusi ke operasi pos pemeriksaan hanya untuk fungsi yang membutuhkannya.
**Contoh: Izin tercakup untuk beberapa fungsi**
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:CheckpointDurableExecution",
"lambda:GetDurableExecutionState"
],
"Resource": [
"arn:aws:lambda:us-east-1:123456789012:function:orderProcessor:*",
"arn:aws:lambda:us-east-1:123456789012:function:paymentHandler:*"
]
}
]
}
```
Atau, Anda dapat menggunakan kebijakan AWS terkelola `AWSLambdaBasicDurableExecutionRolePolicy` yang menyertakan izin eksekusi tahan lama yang diperlukan bersama dengan izin eksekusi Lambda dasar untuk CloudWatch Log Amazon.
## Enkripsi negara
Fungsi tahan lama Lambda secara otomatis mengaktifkan enkripsi saat istirahat menggunakan kunci AWS yang dimiliki tanpa biaya. Setiap eksekusi fungsi mempertahankan status terisolasi yang tidak dapat diakses oleh eksekusi lain. Kunci terkelola pelanggan (CMK) tidak didukung.
Data pos pemeriksaan meliputi:
+ Hasil langkah dan nilai kembalikan
+ Kemajuan eksekusi dan timeline
+ Tunggu informasi status
Semua data dienkripsi dalam perjalanan menggunakan TLS ketika Lambda membaca atau menulis data pos pemeriksaan.
### Enkripsi khusus dengan serializer dan deserializer khusus
Untuk persyaratan keamanan kritis, Anda dapat menerapkan mekanisme enkripsi dan dekripsi Anda sendiri menggunakan serializer kustom dan deserializer () menggunakan SDK yang tahan lama. SerDer Pendekatan ini memberi Anda kontrol penuh atas kunci enkripsi dan algoritma yang digunakan untuk melindungi data pos pemeriksaan.
**penting**
Saat Anda menggunakan enkripsi khusus, Anda kehilangan visibilitas hasil operasi di konsol Lambda dan respons API. Data pos pemeriksaan muncul dienkripsi dalam riwayat eksekusi dan tidak dapat diperiksa tanpa dekripsi.
Peran eksekusi fungsi Anda membutuhkan `kms:Encrypt` dan `kms:Decrypt` izin untuk AWS KMS kunci yang digunakan dalam SerDer implementasi kustom.
## CloudTrail penebangan
Lambda mencatat operasi pos pemeriksaan sebagai peristiwa data di. AWS CloudTrail Anda dapat menggunakan CloudTrail untuk mengaudit saat pos pemeriksaan dibuat, melacak perubahan status eksekusi, dan memantau akses ke data eksekusi yang tahan lama.
Operasi pos pemeriksaan muncul di CloudTrail log dengan nama acara berikut:
+ `CheckpointDurableExecution`- Log ketika langkah selesai dan membuat pos pemeriksaan
+ `GetDurableExecutionState`- Tercatat saat Lambda mengambil status eksekusi selama pemutaran ulang
Untuk mengaktifkan pencatatan peristiwa data untuk fungsi tahan lama, konfigurasikan CloudTrail jejak untuk mencatat peristiwa data Lambda. Untuk informasi selengkapnya, lihat [Mencatat peristiwa data](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) di Panduan CloudTrail Pengguna.
**Contoh: entri CloudTrail log untuk operasi pos pemeriksaan**
```
{
"eventVersion": "1.08",
"eventTime": "2024-11-16T10:30:45Z",
"eventName": "CheckpointDurableExecution",
"eventSource": "lambda.amazonaws.com",
"requestParameters": {
"functionName": "myDurableFunction",
"executionId": "exec-abc123",
"stepId": "step-1"
},
"responseElements": null,
"eventType": "AwsApiCall"
}
```
## Pertimbangan lintas akun
Jika Anda menjalankan fungsi tahan lama di seluruh AWS akun, akun panggilan memerlukan `lambda:InvokeFunction` izin, tetapi operasi pos pemeriksaan selalu menggunakan peran eksekusi di akun fungsi. Akun panggilan tidak dapat mengakses data pos pemeriksaan atau status eksekusi secara langsung.
Isolasi ini memastikan bahwa data pos pemeriksaan tetap aman di dalam akun fungsi, bahkan ketika dipanggil dari akun eksternal.
## Fitur keamanan Lambda yang diwarisi
Fungsi tahan lama mewarisi semua fitur keamanan, tata kelola, dan kepatuhan dari Lambda, termasuk konektivitas VPC, enkripsi variabel lingkungan, antrian surat mati, konkurensi cadangan, fungsi, penandatanganan kode, dan sertifikasi kepatuhan (SOC URLs, PCI DSS, HIPAA, dll.).
Untuk informasi terperinci tentang fitur keamanan Lambda, lihat [Keamanan AWS Lambda di Panduan Pengembang](https://docs.aws.amazon.com/lambda/latest/dg/lambda-security.html) Lambda. Satu-satunya pertimbangan keamanan tambahan untuk fungsi tahan lama adalah izin pos pemeriksaan yang didokumentasikan dalam panduan ini.
# Eksekusi SDK yang tahan lama
SDK eksekusi yang tahan lama adalah fondasi untuk membangun fungsi yang tahan lama. Ini menyediakan primitif yang Anda butuhkan untuk memeriksa kemajuan, menangani percobaan ulang, dan mengelola alur eksekusi. SDK mengabstraksi kompleksitas manajemen pos pemeriksaan dan pemutaran ulang, memungkinkan Anda menulis kode sekuensial yang secara otomatis menjadi toleran terhadap kesalahan.
SDK tersedia untuk JavaScript, TypeScript, Python dan Java (Preview). Untuk dokumentasi dan contoh API lengkap, lihat SDK [JavaScript/TypeScript SDK, Python SDK](https://github.com/aws/aws-durable-execution-sdk-js)[, [dan](https://github.com/aws/aws-durable-execution-sdk-java) Java](https://github.com/aws/aws-durable-execution-sdk-python) SDK aktif. GitHub
## DurableContext
SDK menyediakan fungsi Anda dengan `DurableContext` objek yang mengekspos semua operasi tahan lama. Konteks ini menggantikan konteks Lambda standar dan menyediakan metode untuk membuat pos pemeriksaan, mengelola alur eksekusi, dan berkoordinasi dengan sistem eksternal.
Untuk menggunakan SDK, bungkus handler Lambda Anda dengan pembungkus eksekusi yang tahan lama:
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Your function receives DurableContext instead of Lambda context
// Use context.step(), context.wait(), etc.
return result;
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
@durable_execution
def handler(event: dict, context: DurableContext):
# Your function receives DurableContext
# Use context.step(), context.wait(), etc.
return result
```
------
#### [ Java (Preview) ]
```
import software.amazon.lambda.durable.DurableContext;
import software.amazon.lambda.durable.DurableHandler;
public class Handler extends DurableHandler {
@Override
public String handleRequest(Object input, DurableContext context) {
// Your function receives DurableContext
// Use context.step(), context.wait(), etc.
return result;
}
}
```
------
Pembungkus mencegat pemanggilan fungsi Anda, memuat log pos pemeriksaan yang ada, dan menyediakan yang mengelola pemutaran ulang dan pos pemeriksaan. `DurableContext`
## Apa yang dilakukan SDK
SDK menangani tiga tanggung jawab penting yang memungkinkan eksekusi yang tahan lama:
**Manajemen pos pemeriksaan:** SDK secara otomatis membuat pos pemeriksaan saat fungsi Anda menjalankan operasi yang tahan lama. Setiap pos pemeriksaan mencatat jenis operasi, input, dan hasil. Saat fungsi Anda menyelesaikan langkah, SDK akan tetap berada di pos pemeriksaan sebelum melanjutkan. Ini memastikan fungsi Anda dapat dilanjutkan dari operasi yang selesai jika terputus.
**Koordinasi pemutaran ulang:** Saat fungsi Anda dilanjutkan setelah jeda atau interupsi, SDK akan melakukan pemutaran ulang. Ini menjalankan kode Anda dari awal tetapi melewatkan operasi yang telah selesai, menggunakan hasil pos pemeriksaan yang disimpan alih-alih mengeksekusinya kembali. SDK memastikan pemutaran ulang bersifat deterministik—dengan input dan log pos pemeriksaan yang sama, fungsi Anda menghasilkan hasil yang sama.
**Isolasi status:** SDK mempertahankan status eksekusi secara terpisah dari logika bisnis Anda. Setiap eksekusi tahan lama memiliki log pos pemeriksaan sendiri yang tidak dapat diakses oleh eksekusi lain. SDK mengenkripsi data pos pemeriksaan saat istirahat dan memastikan status tetap konsisten di seluruh pemutaran ulang.
## Cara kerja checkpointing
Saat Anda memanggil operasi yang tahan lama, SDK mengikuti urutan ini:
1. **Periksa pos pemeriksaan yang ada:** SDK memeriksa apakah operasi ini sudah selesai dalam pemanggilan sebelumnya. Jika pos pemeriksaan ada, SDK mengembalikan hasil yang disimpan tanpa mengeksekusi ulang operasi.
1. **Jalankan operasi:** Jika tidak ada pos pemeriksaan, SDK mengeksekusi kode operasi Anda. Untuk langkah-langkah, ini berarti memanggil fungsi Anda. Untuk menunggu, ini berarti penjadwalan dimulainya kembali.
1. **Buat pos pemeriksaan:** Setelah operasi selesai, SDK membuat serial hasilnya dan membuat pos pemeriksaan. Pos pemeriksaan mencakup jenis operasi, nama, input, hasil, dan stempel waktu.
1. **Persistent checkpoint:** SDK memanggil API pos pemeriksaan Lambda untuk mempertahankan pos pemeriksaan. Ini memastikan pos pemeriksaan tahan lama sebelum melanjutkan eksekusi.
1. **Hasil pengembalian:** SDK mengembalikan hasil operasi ke kode Anda, yang berlanjut ke operasi berikutnya.
Urutan ini memastikan bahwa setelah operasi selesai, hasilnya disimpan dengan aman. Jika fungsi Anda terganggu pada titik mana pun, SDK dapat memutar ulang hingga pos pemeriksaan terakhir yang diselesaikan.
## Perilaku memutar ulang
Saat fungsi Anda dilanjutkan setelah jeda atau interupsi, SDK akan melakukan pemutaran ulang:
1. **Muat log pos pemeriksaan:** SDK mengambil log pos pemeriksaan untuk eksekusi ini dari Lambda.
1. **Jalankan dari awal:** SDK memanggil fungsi handler Anda dari awal, bukan dari tempat dijeda.
1. **Lewati operasi tahan lama yang telah selesai:** Saat kode Anda memanggil operasi yang tahan lama, SDK memeriksa masing-masing terhadap log pos pemeriksaan. Untuk operasi tahan lama yang selesai, SDK mengembalikan hasil yang disimpan tanpa mengeksekusi kode operasi.
**catatan**
Jika hasil konteks anak lebih besar dari ukuran pos pemeriksaan maksimum (256 KB), kode konteks dieksekusi lagi selama pemutaran ulang. Ini memungkinkan Anda untuk membuat hasil besar dari operasi tahan lama yang berjalan di dalam konteks, yang akan dicari dari log pos pemeriksaan. Oleh karena itu sangat penting untuk hanya menjalankan kode deterministik dalam konteks itu sendiri. Saat menggunakan konteks anak dengan hasil yang besar, ini adalah praktik terbaik untuk melakukan pekerjaan jangka panjang atau non-deterministik di dalam langkah-langkah dan hanya melakukan tugas jangka pendek yang menggabungkan hasil dalam konteks itu sendiri.
1. **Lanjutkan pada titik interupsi:** Ketika SDK mencapai operasi tanpa pos pemeriksaan, SDK dijalankan secara normal dan membuat pos pemeriksaan baru saat operasi tahan lama selesai.
Mekanisme replay ini mengharuskan kode Anda menjadi deterministik. Dengan input dan log pos pemeriksaan yang sama, fungsi Anda harus membuat urutan panggilan operasi tahan lama yang sama. SDK memberlakukan ini dengan memvalidasi bahwa nama dan jenis operasi cocok dengan log pos pemeriksaan selama pemutaran ulang.
## Tersedia operasi tahan lama
`DurableContext`Menyediakan operasi untuk pola koordinasi yang berbeda. Setiap operasi yang tahan lama membuat pos pemeriksaan secara otomatis, memastikan fungsi Anda dapat dilanjutkan dari titik mana pun.
### Langkah-langkah
Menjalankan logika bisnis dengan checkpointing otomatis dan coba lagi. Gunakan langkah-langkah untuk operasi yang memanggil layanan eksternal, melakukan perhitungan, atau menjalankan logika apa pun yang harus diperiksa. SDK membuat pos pemeriksaan sebelum dan sesudah langkah, menyimpan hasilnya untuk diputar ulang.
------
#### [ TypeScript ]
```
const result = await context.step('process-payment', async () => {
return await paymentService.charge(amount);
});
```
------
#### [ Python ]
```
result = context.step(
lambda _: payment_service.charge(amount),
name='process-payment'
)
```
------
#### [ Java (Preview) ]
```
var result = context.step("process-payment", Payment.class,
() -> paymentService.charge(amount)
);
```
------
Langkah-langkah mendukung strategi coba ulang yang dapat dikonfigurasi, semantik eksekusi (at-most-once atau at-least-once), dan serialisasi kustom.
### Tunggu
Menjeda eksekusi untuk durasi tertentu tanpa menggunakan sumber daya komputasi. SDK membuat pos pemeriksaan, menghentikan pemanggilan fungsi, dan menjadwalkan dimulainya kembali. Ketika menunggu selesai, Lambda memanggil fungsi Anda lagi dan SDK diputar ulang ke titik tunggu sebelum melanjutkan.
------
#### [ TypeScript ]
```
// Wait 1 hour without charges
await context.wait({ seconds: 3600 });
```
------
#### [ Python ]
```
# Wait 1 hour without charges
context.wait(3600)
```
------
#### [ Java (Preview) ]
```
// Wait 1 hour without charges
context.wait(Duration.ofHours(1));
```
------
### Callback
Callback memungkinkan fungsi Anda berhenti sejenak dan menunggu sistem eksternal memberikan masukan. Saat Anda membuat callback, SDK akan menghasilkan ID callback unik dan membuat pos pemeriksaan. Fungsi Anda kemudian ditangguhkan (menghentikan pemanggilan) tanpa menimbulkan biaya komputasi. Sistem eksternal mengirimkan hasil callback menggunakan `SendDurableExecutionCallbackSuccess` atau `SendDurableExecutionCallbackFailure` Lambda APIs. Saat callback dikirimkan, Lambda akan memanggil fungsi Anda lagi, SDK akan diputar ulang ke titik callback, dan fungsi Anda berlanjut dengan hasil callback.
SDK menyediakan dua metode untuk bekerja dengan callback:
**createCallback:** Membuat callback dan mengembalikan janji dan ID callback. Anda mengirim ID callback ke sistem eksternal, yang mengirimkan hasilnya menggunakan API Lambda.
------
#### [ TypeScript ]
```
const [promise, callbackId] = await context.createCallback('approval', {
timeout: { hours: 24 }
});
await sendApprovalRequest(callbackId, requestData);
const approval = await promise;
```
------
#### [ Python ]
```
callback = context.create_callback(
name='approval',
config=CallbackConfig(timeout_seconds=86400)
)
context.step(
lambda _: send_approval_request(callback.callback_id),
name='send_request'
)
approval = callback.result()
```
------
#### [ Java (Preview) ]
```
var config = CallbackConfig.builder(Duration.ofHours(24)).timeout()
var callback = context.createCallback("approval", String.class, config);
context.step("send-request", String.class, () -> {
notificationService.sendApprovalRequest(callback.callbackId(), requestData);
return "request-sent";
});
// Blocks until the callback finishes or times out
String approval = callback.get();
```
------
**waitForCallback:** Menyederhanakan penanganan callback dengan menggabungkan pembuatan callback dan pengiriman dalam satu operasi. SDK membuat callback, mengeksekusi fungsi submitter Anda dengan ID callback, dan menunggu hasilnya.
------
#### [ TypeScript ]
```
const result = await context.waitForCallback(
'external-api',
async (callbackId, ctx) => {
await submitToExternalAPI(callbackId, requestData);
},
{ timeout: { minutes: 30 } }
);
```
------
#### [ Python ]
```
result = context.wait_for_callback(
lambda callback_id: submit_to_external_api(callback_id, request_data),
name='external-api',
config=WaitForCallbackConfig(timeout_seconds=1800)
)
```
------
#### [ Java (Preview) ]
waitForCallback masih dalam pengembangan untuk Jawa.
------
Konfigurasikan batas waktu untuk mencegah fungsi menunggu tanpa batas waktu. Jika waktu panggilan balik habis, SDK akan melempar a `CallbackError` dan fungsi Anda dapat menangani kasus batas waktu. Gunakan batas waktu detak jantung untuk panggilan balik yang berjalan lama untuk mendeteksi kapan sistem eksternal berhenti merespons.
Gunakan callback untuk human-in-the-loop alur kerja, integrasi sistem eksternal, respons webhook, atau skenario apa pun di mana eksekusi harus dijeda untuk input eksternal.
### Eksekusi paralel
Menjalankan beberapa operasi bersamaan dengan kontrol konkurensi opsional. SDK mengelola eksekusi paralel, membuat pos pemeriksaan untuk setiap operasi, dan menangani kegagalan sesuai dengan kebijakan penyelesaian Anda.
------
#### [ TypeScript ]
```
const results = await context.parallel([
async (ctx) => ctx.step('task1', async () => processTask1()),
async (ctx) => ctx.step('task2', async () => processTask2()),
async (ctx) => ctx.step('task3', async () => processTask3())
]);
```
------
#### [ Python ]
```
results = context.parallel(
lambda ctx: ctx.step(lambda _: process_task1(), name='task1'),
lambda ctx: ctx.step(lambda _: process_task2(), name='task2'),
lambda ctx: ctx.step(lambda _: process_task3(), name='task3')
)
```
------
#### [ Java (Preview) ]
Paralel masih dalam pengembangan untuk Java.
------
Gunakan `parallel` untuk menjalankan operasi independen secara bersamaan.
### Peta
Secara bersamaan menjalankan operasi pada setiap item dalam array dengan kontrol konkurensi opsional. SDK mengelola eksekusi bersamaan, membuat pos pemeriksaan untuk setiap operasi, dan menangani kegagalan sesuai dengan kebijakan penyelesaian Anda.
------
#### [ TypeScript ]
```
const results = await context.map(itemArray, async (ctx, item, index) =>
ctx.step('task', async () => processItem(item, index))
);
```
------
#### [ Python ]
```
results = context.map(
item_array,
lambda ctx, item, index: ctx.step(
lambda _: process_item(item, index),
name='task'
)
)
```
------
#### [ Java (Preview) ]
Peta masih dalam pengembangan untuk Jawa.
------
Gunakan `map` untuk memproses array dengan kontrol konkurensi.
### Konteks anak
Menciptakan konteks eksekusi terisolasi untuk operasi pengelompokan. Konteks anak memiliki log pos pemeriksaan sendiri dan dapat berisi beberapa langkah, menunggu, dan operasi lainnya. SDK memperlakukan seluruh konteks anak sebagai satu unit untuk coba lagi dan pemulihan.
Gunakan konteks anak untuk mengatur alur kerja yang kompleks, mengimplementasikan sub-alur kerja, atau mengisolasi operasi yang harus dicoba lagi bersama-sama.
------
#### [ TypeScript ]
```
const result = await context.runInChildContext(
'batch-processing',
async (childCtx) => {
return await processBatch(childCtx, items);
}
);
```
------
#### [ Python ]
```
result = context.run_in_child_context(
lambda child_ctx: process_batch(child_ctx, items),
name='batch-processing'
)
```
------
#### [ Java (Preview) ]
```
var result = context.runInChildContext(
"batch-processing",
String.class,
childCtx -> process_batch(childCtx, items)
);
```
------
Mekanisme replay menuntut agar operasi yang tahan lama terjadi dalam urutan deterministik. Dengan menggunakan beberapa konteks anak, Anda dapat menjalankan beberapa aliran pekerjaan secara bersamaan, dan determinisme berlaku secara terpisah dalam setiap konteks. Ini memungkinkan Anda untuk membangun fungsi kinerja tinggi yang secara efisien memanfaatkan beberapa core CPU.
Misalnya, bayangkan kita memulai dua konteks anak, A dan B. Pada pemanggilan awal, langkah-langkah dalam konteks dijalankan dalam urutan ini, dengan langkah 'A' berjalan bersamaan dengan langkah 'B': A1, B1, B2, A2, A3. Setelah diputar ulang, waktunya jauh lebih cepat karena hasil diambil dari log pos pemeriksaan, dan langkah-langkahnya ditemukan dalam urutan yang berbeda: B1, A1, A2, B2, A3. Karena langkah 'A' ditemui dalam urutan yang benar (A1, A2, A3) dan langkah 'B' ditemui dalam urutan yang benar (B1, B2), kebutuhan akan determinisme dipenuhi dengan benar.
### Penantian bersyarat
Jajak pendapat untuk kondisi dengan pos pemeriksaan otomatis di antara upaya. SDK mengeksekusi fungsi pemeriksaan Anda, membuat pos pemeriksaan dengan hasilnya, menunggu sesuai dengan strategi Anda, dan mengulangi hingga kondisi terpenuhi.
------
#### [ TypeScript ]
```
const result = await context.waitForCondition(
async (state, ctx) => {
const status = await checkJobStatus(state.jobId);
return { ...state, status };
},
{
initialState: { jobId: 'job-123', status: 'pending' },
waitStrategy: (state) =>
state.status === 'completed'
? { shouldContinue: false }
: { shouldContinue: true, delay: { seconds: 30 } }
}
);
```
------
#### [ Python ]
```
result = context.wait_for_condition(
lambda state, ctx: check_job_status(state['jobId']),
config=WaitForConditionConfig(
initial_state={'jobId': 'job-123', 'status': 'pending'},
wait_strategy=lambda state, attempt:
{'should_continue': False} if state['status'] == 'completed'
else {'should_continue': True, 'delay': 30}
)
)
```
------
#### [ Java (Preview) ]
waitForCondition masih dalam pengembangan untuk Jawa.
------
Gunakan `waitForCondition` untuk polling sistem eksternal, menunggu sumber daya siap, atau menerapkan coba lagi dengan backoff.
### Pemanggilan fungsi
Memanggil fungsi Lambda lain dan menunggu hasilnya. SDK membuat pos pemeriksaan, memanggil fungsi target, dan melanjutkan fungsi Anda saat pemanggilan selesai. Hal ini memungkinkan komposisi fungsi dan dekomposisi alur kerja.
------
#### [ TypeScript ]
```
const result = await context.invoke(
'invoke-processor',
'arn:aws:lambda:us-east-1:123456789012:function:processor:1',
{ data: inputData }
);
```
------
#### [ Python ]
```
result = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:processor:1',
{'data': input_data},
name='invoke-processor'
)
```
------
#### [ Java (Preview) ]
```
var result = context.invoke(
"invoke-processor",
"arn:aws:lambda:us-east-1:123456789012:function:processor:1",
inputData,
Result.class,
InvokeConfig.builder().build()
);
```
------
## Bagaimana operasi tahan lama diukur
Setiap operasi tahan lama yang Anda panggil `DurableContext` membuat pos pemeriksaan untuk melacak kemajuan eksekusi dan menyimpan data status. Operasi ini dikenakan biaya berdasarkan penggunaannya, dan pos pemeriksaan mungkin berisi data yang berkontribusi pada biaya penulisan dan penyimpanan data Anda. Data yang disimpan mencakup data peristiwa pemanggilan, muatan yang dikembalikan dari langkah, dan data yang diteruskan saat menyelesaikan panggilan balik. Memahami bagaimana operasi tahan lama diukur membantu Anda memperkirakan biaya eksekusi dan mengoptimalkan alur kerja Anda. Untuk detail tentang harga, lihat halaman [harga Lambda](https://aws.amazon.com/lambda/pricing/).
Ukuran muatan mengacu pada ukuran data serial yang tetap ada operasi yang tahan lama. Data diukur dalam byte dan ukurannya dapat bervariasi tergantung pada serializer yang digunakan oleh operasi. Muatan operasi bisa menjadi hasil itu sendiri untuk penyelesaian yang berhasil, atau objek kesalahan serial jika operasi gagal.
### Operasi dasar
Operasi dasar adalah blok bangunan mendasar untuk fungsi tahan lama:
| Operasi | Waktu pos pemeriksaan | Jumlah operasi | Data bertahan |
| --- | --- | --- | --- |
| Eksekusi | Dimulai | 1 | Ukuran muatan masukan |
| Eksekusi | Selesai (Succeeded/Failed/Stopped) | 0 | Ukuran muatan keluaran |
| Langkah | Retry/Succeeded/Failed | 1 \$1 N mencoba lagi | Ukuran muatan yang dikembalikan dari setiap upaya |
| Tunggu | Dimulai | 1 | N/A |
| WaitForCondition | Setiap upaya jajak pendapat | 1 \$1 N jajak pendapat | Ukuran payload yang dikembalikan dari setiap upaya polling |
| Coba Ulang Tingkat Permintaan | Dimulai | 1 | Muatan untuk objek kesalahan |
### Operasi callback
Operasi callback memungkinkan fungsi Anda berhenti sejenak dan menunggu sistem eksternal memberikan masukan. Operasi ini membuat pos pemeriksaan saat callback dibuat dan saat selesai:
| Operasi | Waktu pos pemeriksaan | Jumlah operasi | Data bertahan |
| --- | --- | --- | --- |
| CreateCallback | Dimulai | 1 | N/A |
| Penyelesaian panggilan balik melalui panggilan API | Selesai | 0 | Payload panggilan balik |
| WaitForCallback | Dimulai | 3 \$1 N mencoba ulang (konteks\$1panggilan balik\$1langkah) | Muatan yang dikembalikan oleh upaya langkah pengirim, ditambah dua salinan payload callback |
### Operasi majemuk
Operasi gabungan menggabungkan beberapa operasi tahan lama untuk menangani pola koordinasi yang kompleks seperti eksekusi paralel, pemrosesan array, dan konteks bersarang:
| Operasi | Waktu pos pemeriksaan | Jumlah operasi | Data bertahan |
| --- | --- | --- | --- |
| Paralel | Dimulai | 1 \$1 N cabang (1 konteks orangtua\$1N konteks anak) | Hingga dua salinan ukuran muatan yang dikembalikan dari setiap cabang, ditambah status masing-masing cabang |
| Peta | Dimulai | 1 \$1 N cabang (1 konteks orangtua\$1N konteks anak) | Hingga dua salinan ukuran payload yang dikembalikan dari setiap iterasi, ditambah status setiap iterasi |
| Penolong janji | Selesai | 1 | Ukuran payload yang dikembalikan dari janji |
| RunInChildContext | Berhasil/Gagal | 1 | Ukuran payload yang dikembalikan dari konteks anak |
Untuk konteks, seperti dari `runInChildContext` atau digunakan secara internal oleh operasi gabungan, hasil yang lebih kecil dari 256 KB diperiksa secara langsung. Hasil yang lebih besar tidak disimpan — sebaliknya, mereka direkonstruksi selama pemutaran ulang dengan memproses ulang operasi konteks.
# Runtime yang didukung untuk fungsi yang tahan lama
Fungsi tahan lama tersedia untuk runtime terkelola yang dipilih dan gambar kontainer OCI untuk fleksibilitas versi runtime tambahan. Anda dapat membuat fungsi tahan lama untuk Node.js dan Python menggunakan runtime terkelola langsung di konsol atau melalui pemrograman. infrastructure-as-code Fungsi tahan lama di Java (Pratinjau) saat ini hanya dapat digunakan melalui gambar kontainer.
## Runtime terkelola Lambda
Runtime terkelola berikut mendukung fungsi tahan lama saat Anda membuat fungsi di konsol Lambda atau menggunakan parameter AWS CLI with`--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'`. [Untuk informasi selengkapnya tentang runtime Lambda, lihat runtime Lambda.](lambda-runtimes.md)
| Bahasa | Waktu Aktif |
| --- | --- |
| Node.js | nodejs22.x |
| Node.js | nodejs24.x |
| Python | python3.13 |
| Python | python3.14 |
**catatan**
Runtime Lambda mencakup SDK eksekusi yang tahan lama untuk pengujian dan pengembangan. Namun, sebaiknya sertakan SDK dalam paket penerapan Anda untuk produksi. Ini memastikan konsistensi versi dan menghindari kemungkinan pembaruan runtime yang mungkin memengaruhi perilaku fungsi Anda.
### Node.js
Instal SDK di proyek Node.js Anda:
```
npm install @aws/durable-execution-sdk-js
```
SDK mendukung JavaScript dan TypeScript. Untuk TypeScript proyek, SDK menyertakan definisi tipe.
### Python
Instal SDK di proyek Python Anda:
```
pip install aws-durable-execution-sdk-python
```
Python SDK menggunakan metode sinkron dan tidak memerlukan. `async/await`
### Java (Pratinjau)
Tambahkan ketergantungan ke`pom.xml`:
```
software.amazon.lambda.durable
aws-durable-execution-sdk-java
VERSION
```
Instal SDK di proyek Java Anda:
```
mvn install
```
Versi pratinjau dari Java SDK tersedia. Operasi waitForCondition waitForCallback,, parallel dan map masih dalam pengembangan.
## Image kontainer
Anda dapat menggunakan fungsi tahan lama dengan gambar kontainer untuk mendukung versi runtime tambahan atau konfigurasi runtime kustom. Gambar kontainer memungkinkan Anda menggunakan versi runtime yang tidak tersedia sebagai runtime terkelola atau menyesuaikan lingkungan runtime Anda.
Untuk membuat fungsi tahan lama menggunakan gambar kontainer:
1. Buat Dockerfile berdasarkan gambar dasar Lambda
1. Instal SDK eksekusi yang tahan lama di container Anda
1. Buat dan dorong gambar kontainer ke Amazon Elastic Container Registry
1. Buat fungsi Lambda dari gambar kontainer dengan eksekusi tahan lama diaktifkan
### Contoh kontainer
Buat Dockerfile:
------
#### [ Python ]
Buat Dockerfile untuk Python 3.11:
```
FROM public.ecr.aws/lambda/python:3.11
# Copy requirements file
COPY requirements.txt ${LAMBDA_TASK_ROOT}/
# Install dependencies including durable SDK
RUN pip install -r requirements.txt
# Copy function code
COPY lambda_function.py ${LAMBDA_TASK_ROOT}/
# Set the handler
CMD [ "lambda_function.handler" ]
```
Buat `requirements.txt` file:
```
aws-durable-execution-sdk-python
```
------
#### [ Java (Preview) ]
Buat Dockerfile untuk Java 25:
```
FROM --platform=linux/amd64 public.ecr.aws/lambda/java:25
# Install Maven
RUN dnf install -y maven
WORKDIR /var/task
# Copy Maven configuration and source code
COPY pom.xml .
COPY src ./src
# Build
RUN mvn clean package -DskipTests
# Move JAR to lib directory
RUN mv target/*.jar lib/
# Set the handler
CMD ["src.path.to.lambdaFunction::handler"]
```
------
Bangun dan dorong gambar:
```
# Build the image
docker build -t my-durable-function .
# Tag for ECR
docker tag my-durable-function:latest 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest
# Push to ECR
docker push 123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest
```
Buat fungsi dengan eksekusi tahan lama diaktifkan:
```
aws lambda create-function \
--function-name myDurableFunction \
--package-type Image \
--code ImageUri=123456789012.dkr.ecr.us-east-1.amazonaws.com/my-durable-function:latest \
--role arn:aws:iam::123456789012:role/lambda-execution-role \
--durable-config '{"ExecutionTimeout": 3600, "RetentionPeriodInDays": 7}'
```
Untuk informasi selengkapnya tentang penggunaan gambar kontainer dengan Lambda, lihat Membuat gambar [kontainer Lambda di](https://docs.aws.amazon.com/lambda/latest/dg/images-create.html) Panduan Pengembang Lambda.
## Pertimbangan runtime
**Manajemen versi SDK:** Sertakan SDK eksekusi tahan lama dalam paket penerapan atau image kontainer Anda. Ini memastikan fungsi Anda menggunakan versi SDK tertentu dan tidak terpengaruh oleh pembaruan runtime. Sematkan versi SDK di `package.json` atau `requirements.txt` untuk mengontrol saat Anda memutakhirkan.
**Pembaruan runtime: AWS memperbarui** runtime terkelola untuk menyertakan patch keamanan dan perbaikan bug. Pembaruan ini mungkin termasuk versi SDK baru. Untuk menghindari perilaku yang tidak terduga, sertakan SDK dalam paket penerapan Anda dan uji secara menyeluruh sebelum menerapkan ke produksi.
**Ukuran gambar kontainer:** Gambar kontainer memiliki ukuran maksimum yang tidak terkompresi 10 GB. SDK eksekusi yang tahan lama menambahkan ukuran minimal pada gambar Anda. Optimalkan penampung Anda dengan menggunakan build multi-tahap dan menghapus dependensi yang tidak perlu.
**Kinerja awal dingin:** Gambar kontainer mungkin memiliki waktu mulai dingin yang lebih lama daripada runtime yang dikelola. SDK eksekusi yang tahan lama memiliki dampak minimal pada kinerja start dingin. Gunakan konkurensi yang disediakan jika latensi start dingin sangat penting untuk aplikasi Anda.
# Memohon fungsi Lambda yang tahan lama
Fungsi Lambda yang tahan lama mendukung metode pemanggilan yang sama dengan fungsi Lambda standar. Anda dapat menjalankan fungsi tahan lama secara sinkron, asinkron, atau melalui pemetaan sumber peristiwa. Proses pemanggilan identik dengan fungsi standar, tetapi fungsi yang tahan lama memberikan kemampuan tambahan untuk eksekusi jangka panjang dan manajemen status otomatis.
## Metode pemanggilan
**Pemanggilan sinkron:** Memanggil fungsi yang tahan lama dan tunggu respons. Pemanggilan sinkron dibatasi oleh Lambda hingga 15 menit (atau kurang, tergantung pada fungsi yang dikonfigurasi dan batas waktu eksekusi). Gunakan pemanggilan sinkron saat Anda membutuhkan hasil segera atau saat mengintegrasikan dengan APIs dan layanan yang mengharapkan respons. Anda dapat menggunakan operasi tunggu untuk perhitungan yang efisien tanpa mengganggu pemanggil—pemanggilan menunggu seluruh eksekusi yang tahan lama selesai. [Untuk eksekusi idempoten dimulai, gunakan parameter nama eksekusi seperti yang dijelaskan dalam Idempotency.](durable-execution-idempotency.md)
```
aws lambda invoke \
--function-name my-durable-function:1 \
--cli-binary-format raw-in-base64-out \
--payload '{"orderId": "12345"}' \
response.json
```
**Pemanggilan asinkron: Antrikan** acara untuk diproses tanpa menunggu respons. Lambda menempatkan acara dalam antrian dan segera kembali. Pemanggilan asinkron mendukung durasi eksekusi hingga 1 tahun. Gunakan pemanggilan asinkron untuk fire-and-forget skenario atau saat pemrosesan dapat terjadi di latar belakang. [Untuk eksekusi idempoten dimulai, gunakan parameter nama eksekusi seperti yang dijelaskan dalam Idempotency.](durable-execution-idempotency.md)
```
aws lambda invoke \
--function-name my-durable-function:1 \
--invocation-type Event \
--cli-binary-format raw-in-base64-out \
--payload '{"orderId": "12345"}' \
response.json
```
**Pemetaan sumber peristiwa: Konfigurasikan** Lambda untuk secara otomatis menjalankan fungsi tahan lama Anda saat rekaman tersedia dari layanan berbasis streaming atau antrian seperti Amazon SQS, Kinesis, atau DynamoDB. Pemetaan sumber peristiwa polling sumber acara dan menjalankan fungsi Anda dengan kumpulan catatan. Untuk detail tentang penggunaan pemetaan sumber peristiwa dengan fungsi tahan lama, termasuk batas durasi eksekusi, lihat [Pemetaan sumber peristiwa](durable-invoking-esm.md) dengan fungsi tahan lama.
[Untuk detail lengkap tentang setiap metode pemanggilan, lihat pemanggilan sinkron dan [pemanggilan asinkron](invocation-sync.md).](invocation-async.md)
**catatan**
Fungsi tahan lama mendukung antrian huruf mati (DLQs) untuk penanganan kesalahan, tetapi tidak mendukung tujuan Lambda. Konfigurasikan DLQ untuk menangkap catatan dari pemanggilan yang gagal.
## ARNs Persyaratan yang memenuhi syarat
Fungsi yang tahan lama membutuhkan pengidentifikasi yang memenuhi syarat untuk pemanggilan. Anda harus menjalankan fungsi tahan lama menggunakan nomor versi, alias, atau. `$LATEST` Anda dapat menggunakan ARN yang memenuhi syarat penuh atau nama fungsi dengan version/alias akhiran. Anda tidak dapat menggunakan pengenal yang tidak memenuhi syarat (tanpa versi atau akhiran alias).
**Doa yang valid:**
```
# Using full ARN with version number
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1
# Using full ARN with alias
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:prod
# Using full ARN with $LATEST
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:$LATEST
# Using function name with version number
my-durable-function:1
# Using function name with alias
my-durable-function:prod
```
**Pemanggilan tidak valid:**
```
# Unqualified ARN (not allowed)
arn:aws:lambda:us-east-1:123456789012:function:my-durable-function
# Unqualified function name (not allowed)
my-durable-function
```
Persyaratan ini memastikan bahwa eksekusi yang tahan lama tetap konsisten sepanjang siklus hidupnya. Ketika eksekusi tahan lama dimulai, itu disematkan ke versi fungsi tertentu. Jika fungsi Anda berhenti dan dilanjutkan beberapa jam atau hari kemudian, Lambda akan memanggil versi yang sama yang memulai eksekusi, memastikan konsistensi kode di seluruh alur kerja.
**Praktik terbaik**
Gunakan versi bernomor atau alias untuk fungsi tahan lama produksi daripada. `$LATEST` Versi bernomor tidak dapat diubah dan mendukung pemutaran ulang deterministik. Secara opsional, alias menyediakan referensi stabil yang dapat Anda perbarui untuk menunjuk ke versi baru tanpa mengubah kode pemanggilan. Saat Anda memperbarui alias, eksekusi baru menggunakan versi baru, sementara eksekusi yang sedang berlangsung berlanjut dengan versi aslinya. Anda dapat menggunakannya `$LATEST` untuk membuat prototipe atau mempersingkat waktu penerapan selama pengembangan, memahami bahwa eksekusi mungkin tidak diputar ulang dengan benar (atau bahkan gagal) jika kode yang mendasarinya berubah selama menjalankan eksekusi.
## Memahami siklus hidup eksekusi
Saat Anda menjalankan fungsi tahan lama, Lambda membuat eksekusi tahan lama yang dapat menjangkau beberapa pemanggilan fungsi:
1. **Pemanggilan awal: Permintaan pemanggilan** Anda membuat eksekusi baru yang tahan lama. Lambda memberikan ID eksekusi unik dan mulai memproses.
1. **Eksekusi dan pos pemeriksaan:** Saat fungsi Anda menjalankan operasi yang tahan lama, SDK membuat pos pemeriksaan yang melacak kemajuan.
1. **Penangguhan (jika diperlukan):** Jika fungsi Anda menggunakan penantian yang tahan lama, seperti `wait` atau`waitForCallback`, atau percobaan ulang langkah otomatis, Lambda menangguhkan eksekusi dan menghentikan pengisian daya untuk waktu komputasi.
1. **Dimulainya kembali:** Ketika tiba waktunya untuk melanjutkan (termasuk setelah mencoba lagi), Lambda memanggil fungsi Anda lagi. SDK memutar ulang log pos pemeriksaan dan melanjutkan dari tempat eksekusi dijeda.
1. **Penyelesaian:** Ketika fungsi Anda mengembalikan hasil akhir atau melempar kesalahan yang tidak tertangani, eksekusi yang tahan lama selesai.
Untuk pemanggilan sinkron, pemanggil menunggu seluruh eksekusi tahan lama selesai, termasuk operasi tunggu apa pun. Jika eksekusi melebihi batas waktu pemanggilan (15 menit atau kurang), waktu pemanggilan habis. Untuk pemanggilan asinkron, Lambda segera kembali dan eksekusi berlanjut secara independen. Gunakan eksekusi tahan lama APIs untuk melacak status eksekusi dan mengambil hasil akhir.
## Memohon dari kode aplikasi
Gunakan AWS SDKs untuk memanggil fungsi tahan lama dari kode aplikasi Anda. Proses pemanggilan identik dengan fungsi standar:
------
#### [ TypeScript ]
```
import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
const client = new LambdaClient({});
// Synchronous invocation
const response = await client.send(new InvokeCommand({
FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
Payload: JSON.stringify({ orderId: '12345' })
}));
const result = JSON.parse(Buffer.from(response.Payload!).toString());
// Asynchronous invocation
await client.send(new InvokeCommand({
FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
InvocationType: 'Event',
Payload: JSON.stringify({ orderId: '12345' })
}));
```
------
#### [ Python ]
```
import boto3
import json
client = boto3.client('lambda')
# Synchronous invocation
response = client.invoke(
FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
Payload=json.dumps({'orderId': '12345'})
)
result = json.loads(response['Payload'].read())
# Asynchronous invocation
client.invoke(
FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
InvocationType='Event',
Payload=json.dumps({'orderId': '12345'})
)
```
------
## Doa berantai
Fungsi yang tahan lama dapat memanggil fungsi tahan lama dan tidak tahan lama lainnya menggunakan `invoke` operasi dari. `DurableContext` Ini menciptakan pemanggilan berantai di mana fungsi pemanggilan menunggu (menangguhkan) agar fungsi yang dipanggil selesai:
------
#### [ TypeScript ]
```
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Invoke another durable function and wait for result
const result = await context.invoke(
'process-order',
'arn:aws:lambda:us-east-1:123456789012:function:order-processor:1',
{ orderId: event.orderId }
);
return { statusCode: 200, body: JSON.stringify(result) };
}
);
```
------
#### [ Python ]
```
@durable_execution
def handler(event, context: DurableContext):
# Invoke another durable function and wait for result
result = context.invoke(
'arn:aws:lambda:us-east-1:123456789012:function:order-processor:1',
{'orderId': event['orderId']},
name='process-order'
)
return {'statusCode': 200, 'body': json.dumps(result)}
```
------
Pemanggilan berantai membuat pos pemeriksaan dalam fungsi pemanggilan. Jika fungsi pemanggilan terputus, ia dilanjutkan dari pos pemeriksaan dengan hasil fungsi yang dipanggil, tanpa memanggil kembali fungsi tersebut.
**catatan**
Pemanggilan berantai lintas akun tidak didukung. Fungsi yang dipanggil harus berada di AWS akun yang sama dengan fungsi pemanggilan.
# Pemetaan sumber acara dengan fungsi tahan lama
Fungsi tahan lama bekerja dengan semua pemetaan sumber acara Lambda. Konfigurasikan pemetaan sumber peristiwa untuk fungsi tahan lama dengan cara yang sama seperti Anda mengonfigurasinya untuk fungsi standar. Pemetaan sumber peristiwa secara otomatis melakukan polling sumber peristiwa seperti Amazon SQS, Kinesis, dan DynamoDB Streams, dan menjalankan fungsi Anda dengan kumpulan catatan.
Pemetaan sumber peristiwa berguna untuk fungsi tahan lama yang memproses aliran atau antrian dengan alur kerja multi-langkah yang kompleks. Misalnya, Anda dapat membuat fungsi tahan lama yang memproses pesan Amazon SQS dengan percobaan ulang, panggilan API eksternal, dan persetujuan manusia.
## Bagaimana pemetaan sumber peristiwa memanggil fungsi yang tahan lama
Pemetaan sumber peristiwa memanggil fungsi tahan lama secara serempak, menunggu eksekusi tahan lama selesai sebelum memproses batch berikutnya atau menandai catatan sebagai diproses. Jika total waktu eksekusi tahan lama melebihi 15 menit, waktu eksekusi habis dan gagal. Pemetaan sumber peristiwa menerima pengecualian batas waktu dan menanganinya sesuai dengan konfigurasi coba ulang.
## Batas eksekusi 15 menit
Ketika fungsi tahan lama dipanggil oleh pemetaan sumber peristiwa, total durasi eksekusi tahan lama tidak boleh melebihi 15 menit. Batas ini berlaku untuk seluruh eksekusi tahan lama dari awal hingga penyelesaian, bukan hanya pemanggilan fungsi individual.
Batas 15 menit ini terpisah dari batas waktu fungsi Lambda (juga maksimum 15 menit). Batas waktu fungsi mengontrol berapa lama setiap pemanggilan individu dapat berjalan, sedangkan batas waktu eksekusi yang tahan lama mengontrol total waktu yang telah berlalu dari awal eksekusi hingga penyelesaian.
**Contoh skenario:**
+ **Berlaku:** Fungsi tahan lama memproses pesan Amazon SQS dengan tiga langkah, masing-masing membutuhkan waktu 2 menit, lalu menunggu 5 menit sebelum menyelesaikan langkah terakhir. Total waktu eksekusi: 11 menit. Ini berfungsi karena totalnya di bawah 15 menit.
+ **Tidak valid:** Fungsi tahan lama memproses pesan Amazon SQS, menyelesaikan pemrosesan awal dalam 2 menit, lalu menunggu 20 menit untuk panggilan balik eksternal sebelum menyelesaikan. Total waktu eksekusi: 22 menit. Ini melebihi batas 15 menit dan akan gagal.
+ **Tidak valid:** Fungsi yang tahan lama memproses catatan Kinesis dengan beberapa operasi tunggu dengan total 30 menit di antara langkah-langkah. Meskipun setiap pemanggilan individu selesai dengan cepat, total waktu eksekusi melebihi 15 menit.
**penting**
Konfigurasikan batas waktu eksekusi tahan lama Anda hingga 15 menit atau kurang saat menggunakan pemetaan sumber peristiwa, jika tidak, pembuatan pemetaan sumber peristiwa akan gagal. Jika alur kerja Anda membutuhkan waktu eksekusi yang lebih lama, gunakan pola fungsi perantara yang dijelaskan di bawah ini.
## Mengkonfigurasi pemetaan sumber acara
Konfigurasikan pemetaan sumber peristiwa untuk fungsi tahan lama menggunakan konsol Lambda,, atau. AWS CLI AWS SDKs Semua properti pemetaan sumber peristiwa standar berlaku untuk fungsi tahan lama:
```
aws lambda create-event-source-mapping \
--function-name arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1 \
--event-source-arn arn:aws:sqs:us-east-1:123456789012:my-queue \
--batch-size 10 \
--maximum-batching-window-in-seconds 5
```
Ingatlah untuk menggunakan ARN yang memenuhi syarat (dengan nomor versi atau alias) saat mengonfigurasi pemetaan sumber peristiwa untuk fungsi yang tahan lama.
## Penanganan kesalahan dengan pemetaan sumber acara
Pemetaan sumber peristiwa menyediakan penanganan kesalahan bawaan yang berfungsi dengan fungsi tahan lama:
+ **Perilaku coba lagi:** Jika pemanggilan awal gagal, pemetaan sumber peristiwa mencoba lagi sesuai dengan konfigurasi coba ulangnya. Konfigurasikan percobaan ulang maksimum dan interval coba lagi berdasarkan kebutuhan Anda.
+ **Antrian huruf mati: Konfigurasikan antrian** huruf mati untuk menangkap catatan yang gagal setelah semua percobaan ulang. Ini mencegah kehilangan pesan dan memungkinkan pemeriksaan manual catatan yang gagal.
+ **Kegagalan batch sebagian:** Untuk Amazon SQS dan Kinesis, gunakan pelaporan kegagalan batch sebagian untuk memproses rekaman satu per satu dan hanya mencoba lagi catatan yang gagal.
+ Membagi dua **kesalahan: Untuk Kinesis dan DynamoDB Streams, aktifkan bisect** pada kesalahan untuk membagi batch yang gagal dan mengisolasi catatan bermasalah.
**catatan**
Fungsi tahan lama mendukung antrian huruf mati (DLQs) untuk penanganan kesalahan, tetapi tidak mendukung tujuan Lambda. Konfigurasikan DLQ untuk menangkap catatan dari pemanggilan yang gagal.
Untuk informasi selengkapnya tentang penanganan kesalahan pemetaan sumber peristiwa, lihat [pemetaan sumber peristiwa](invocation-eventsourcemapping.md).
## Menggunakan fungsi perantara untuk alur kerja yang berjalan lama
Jika alur kerja Anda membutuhkan lebih dari 15 menit untuk diselesaikan, gunakan fungsi Lambda standar perantara antara pemetaan sumber peristiwa dan fungsi tahan lama Anda. Fungsi perantara menerima peristiwa dari pemetaan sumber peristiwa dan memanggil fungsi tahan lama secara asinkron, menghapus batas eksekusi 15 menit.
Pola ini memisahkan model pemanggilan sinkron pemetaan sumber peristiwa dari model eksekusi jangka panjang fungsi tahan lama. Pemetaan sumber peristiwa memanggil fungsi perantara, yang dengan cepat kembali setelah memulai eksekusi yang tahan lama. Fungsi tahan lama kemudian berjalan secara mandiri selama dibutuhkan (hingga 1 tahun).
### Arsitektur
Pola fungsi perantara menggunakan tiga komponen:
1. **Pemetaan sumber peristiwa:** Polling sumber peristiwa (Amazon SQS, Kinesis, DynamoDB Streams) dan memanggil fungsi perantara secara serempak dengan kumpulan catatan.
1. **Fungsi perantara: Fungsi** Lambda standar yang menerima peristiwa dari pemetaan sumber peristiwa, memvalidasi dan mengubah data jika diperlukan, dan memanggil fungsi tahan lama secara asinkron. Fungsi ini selesai dengan cepat (biasanya di bawah 1 detik) dan mengembalikan kontrol ke pemetaan sumber peristiwa.
1. **Fungsi tahan lama:** Memproses acara dengan logika multi-langkah yang kompleks yang dapat berjalan untuk waktu yang lama. Dipanggil secara asinkron, jadi tidak dibatasi oleh batas 15 menit.
### Implementasi
Fungsi perantara menerima seluruh peristiwa dari pemetaan sumber peristiwa dan memanggil fungsi tahan lama secara asinkron. Gunakan parameter nama eksekusi untuk memastikan eksekusi idempoten dimulai, mencegah pemrosesan duplikat jika pemetaan sumber peristiwa mencoba lagi:
------
#### [ TypeScript ]
```
import { LambdaClient, InvokeCommand } from '@aws-sdk/client-lambda';
import { SQSEvent } from 'aws-lambda';
import { createHash } from 'crypto';
const lambda = new LambdaClient({});
export const handler = async (event: SQSEvent) => {
// Invoke durable function asynchronously with execution name
await lambda.send(new InvokeCommand({
FunctionName: 'arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
InvocationType: 'Event',
Payload: JSON.stringify({
executionName: event.Name,
event: event
})
}));
return { statusCode: 200 };
};
```
------
#### [ Python ]
```
import boto3
import json
import hashlib
lambda_client = boto3.client('lambda')
def handler(event, context):
# Invoke durable function asynchronously with execution name
lambda_client.invoke(
FunctionName='arn:aws:lambda:us-east-1:123456789012:function:my-durable-function:1',
InvocationType='Event',
Payload=json.dumps({
'executionName': execution_name,
'event': event["name"]
})
)
return {'statusCode': 200}
```
------
Untuk idempotensi dalam fungsi perantara itu sendiri, gunakan [Powertools AWS Lambda untuk](https://docs.aws.amazon.com//powertools/) mencegah pemanggilan duplikat dari fungsi tahan lama jika pemetaan sumber peristiwa mencoba kembali fungsi perantara.
Fungsi tahan lama menerima muatan dengan nama eksekusi dan memproses semua catatan dengan logika yang berjalan lama:
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (payload: any, context: DurableContext) => {
const sqsEvent = payload.event;
// Process each record with complex, multi-step logic
const results = await context.map(
sqsEvent.Records,
async (ctx, record) => {
const validated = await ctx.step('validate', async () => {
return validateOrder(JSON.parse(record.body));
});
// Wait for external approval (could take hours or days)
const approval = await ctx.waitForCallback(
'approval',
async (callbackId) => {
await requestApproval(callbackId, validated);
},
{ timeout: { hours: 48 } }
);
// Complete processing
return await ctx.step('complete', async () => {
return completeOrder(validated, approval);
});
}
);
return { statusCode: 200, processed: results.getResults().length };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
from aws_durable_execution_sdk_python.config import Duration, WaitForCallbackConfig
from collections.abc import Sequence
import json
def validate_order(order_data: dict) -> dict:
"""Validate order data - always passes."""
return order_data
def request_approval(callback_id: str, validated_order: dict) -> None:
"""Request approval for the order - always passes."""
pass
def complete_order(validated_order: dict, approval_result: str) -> dict:
"""Complete the order processing - always passes."""
return validated_order
@durable_execution
def lambda_handler(payload, context: DurableContext):
sqs_event = payload['event']
def process_record(
ctx: DurableContext,
record: dict,
index: int,
items: Sequence[dict]
) -> dict:
validated = ctx.step(
lambda _: validate_order(json.loads(record['body'])),
name=f'validate-{index}'
)
approval = ctx.wait_for_callback(
submitter=lambda callback_id, wait_ctx: request_approval(callback_id, validated),
name=f'approval-{index}',
config=WaitForCallbackConfig(timeout=Duration.from_seconds(172800))
)
return ctx.step(
lambda _: complete_order(validated, approval),
name=f'complete-{index}'
)
results = context.map(
inputs=sqs_event['Records'],
func=process_record,
name='process-records'
)
return {
'statusCode': 200,
'started': results.started_count,
'completed': results.success_count,
'failed': results.failure_count,
'total': results.total_count
}
```
------
### Pertimbangan utama
Pola ini menghilangkan batas eksekusi 15 menit dengan memisahkan pemetaan sumber peristiwa dari eksekusi tahan lama. Fungsi perantara kembali segera setelah memulai eksekusi tahan lama, memungkinkan pemetaan sumber peristiwa untuk melanjutkan pemrosesan. Fungsi tahan lama kemudian berjalan secara independen selama dibutuhkan.
Fungsi perantara berhasil ketika memanggil fungsi tahan lama, bukan ketika eksekusi yang tahan lama selesai. Jika eksekusi tahan lama gagal nanti, pemetaan sumber peristiwa tidak akan mencoba lagi karena sudah berhasil memproses batch. Terapkan penanganan kesalahan dalam fungsi tahan lama dan konfigurasikan antrian huruf mati untuk eksekusi yang gagal.
Gunakan parameter nama eksekusi untuk memastikan eksekusi idempoten dimulai. Jika pemetaan sumber peristiwa mencoba ulang fungsi perantara, fungsi tahan lama tidak akan memulai eksekusi duplikat karena nama eksekusi sudah ada.
## Sumber acara yang didukung
Fungsi tahan lama mendukung semua sumber acara Lambda yang menggunakan pemetaan sumber peristiwa:
+ Antrian Amazon SQS (standar dan FIFO)
+ Aliran Kinesis
+ DynamoDB Streams
+ Amazon Managed Streaming for Apache Kafka (Amazon MSK)
+ Apache Kafka yang dikelola sendiri
+ Amazon MQ (ActiveMQ dan RabbitMQ)
+ Amazon DocumentDB mengubah aliran
Semua jenis sumber peristiwa tunduk pada batas eksekusi tahan lama 15 menit saat menjalankan fungsi tahan lama.
# Mencoba lagi untuk fungsi tahan lama Lambda
Fungsi tahan lama memberikan kemampuan coba ulang otomatis yang membuat aplikasi Anda tahan terhadap kegagalan sementara. SDK menangani percobaan ulang pada dua tingkat: percobaan ulang langkah untuk kegagalan logika bisnis dan percobaan ulang backend untuk kegagalan infrastruktur.
## Langkah mencoba lagi
Ketika pengecualian yang tidak tertangkap terjadi dalam satu langkah, SDK secara otomatis mencoba ulang langkah berdasarkan strategi coba lagi yang dikonfigurasi. Langkah percobaan ulang adalah operasi checkpoint yang memungkinkan SDK untuk menangguhkan eksekusi dan melanjutkan nanti tanpa kehilangan kemajuan.
### Langkah coba lagi perilaku
Tabel berikut menjelaskan cara SDK menangani pengecualian dalam langkah-langkah:
| Skenario | Apa yang terjadi | Dampak pengukuran |
| --- | --- | --- |
| Pengecualian sejalan dengan upaya coba lagi yang tersisa | SDK membuat pos pemeriksaan untuk coba lagi dan menangguhkan fungsi. Pada pemanggilan berikutnya, langkah mencoba lagi dengan penundaan backoff yang dikonfigurasi. | 1 operasi\$1ukuran muatan kesalahan |
| Pengecualian dalam langkah tanpa upaya coba lagi yang tersisa | Langkah gagal dan melempar pengecualian. Jika kode handler Anda tidak menangkap pengecualian ini, seluruh eksekusi gagal. | 1 operasi\$1ukuran muatan kesalahan |
Ketika sebuah langkah perlu dicoba lagi, SDK memeriksa status coba lagi dan keluar dari pemanggilan Lambda jika tidak ada pekerjaan lain yang berjalan. Hal ini memungkinkan SDK untuk menerapkan penundaan backoff tanpa menghabiskan sumber daya komputasi. Fungsi dilanjutkan secara otomatis setelah periode backoff.
### Mengkonfigurasi strategi coba lagi langkah
Konfigurasikan strategi coba lagi untuk mengontrol cara langkah-langkah menangani kegagalan. Anda dapat menentukan upaya maksimum, interval backoff, dan kondisi untuk mencoba kembali.
**Backoff eksponensial dengan upaya maksimal:**
------
#### [ TypeScript ]
```
const result = await context.step('call-api', async () => {
const response = await fetch('https://api.example.com/data');
if (!response.ok) throw new Error(`API error: ${response.status}`);
return await response.json();
}, {
retryStrategy: (error, attemptCount) => {
if (attemptCount >= 5) {
return { shouldRetry: false };
}
// Exponential backoff: 2s, 4s, 8s, 16s, 32s (capped at 300s)
const delay = Math.min(2 * Math.pow(2, attemptCount - 1), 300);
return { shouldRetry: true, delay: { seconds: delay } };
}
});
```
------
#### [ Python ]
```
def retry_strategy(error, attempt_count):
if attempt_count >= 5:
return {'should_retry': False}
# Exponential backoff: 2s, 4s, 8s, 16s, 32s (capped at 300s)
delay = min(2 * (2 ** (attempt_count - 1)), 300)
return {'should_retry': True, 'delay': delay}
result = context.step(
lambda _: call_external_api(),
name='call-api',
config=StepConfig(retry_strategy=retry_strategy)
)
```
------
**Backoff interval tetap:**
------
#### [ TypeScript ]
```
const orders = await context.step('query-orders', async () => {
return await queryDatabase(event.userId);
}, {
retryStrategy: (error, attemptCount) => {
if (attemptCount >= 3) {
return { shouldRetry: false };
}
return { shouldRetry: true, delay: { seconds: 5 } };
}
});
```
------
#### [ Python ]
```
def retry_strategy(error, attempt_count):
if attempt_count >= 3:
return {'should_retry': False}
return {'should_retry': True, 'delay': 5}
orders = context.step(
lambda _: query_database(event['userId']),
name='query-orders',
config=StepConfig(retry_strategy=retry_strategy)
)
```
------
**Coba lagi bersyarat (coba lagi hanya kesalahan tertentu):**
------
#### [ TypeScript ]
```
const result = await context.step('call-rate-limited-api', async () => {
const response = await fetch('https://api.example.com/data');
if (response.status === 429) throw new Error('RATE_LIMIT');
if (response.status === 504) throw new Error('TIMEOUT');
if (!response.ok) throw new Error(`API_ERROR_${response.status}`);
return await response.json();
}, {
retryStrategy: (error, attemptCount) => {
// Only retry rate limits and timeouts
const isRetryable = error.message === 'RATE_LIMIT' || error.message === 'TIMEOUT';
if (!isRetryable || attemptCount >= 3) {
return { shouldRetry: false };
}
// Exponential backoff: 1s, 2s, 4s (capped at 30s)
const delay = Math.min(Math.pow(2, attemptCount - 1), 30);
return { shouldRetry: true, delay: { seconds: delay } };
}
});
```
------
#### [ Python ]
```
def retry_strategy(error, attempt_count):
# Only retry rate limits and timeouts
is_retryable = str(error) in ['RATE_LIMIT', 'TIMEOUT']
if not is_retryable or attempt_count >= 3:
return {'should_retry': False}
# Exponential backoff: 1s, 2s, 4s (capped at 30s)
delay = min(2 ** (attempt_count - 1), 30)
return {'should_retry': True, 'delay': delay}
result = context.step(
lambda _: call_rate_limited_api(),
name='call-rate-limited-api',
config=StepConfig(retry_strategy=retry_strategy)
)
```
------
**Nonaktifkan percobaan ulang:**
------
#### [ TypeScript ]
```
const isDuplicate = await context.step('check-duplicate', async () => {
return await checkIfOrderExists(event.orderId);
}, {
retryStrategy: () => ({ shouldRetry: false })
});
```
------
#### [ Python ]
```
is_duplicate = context.step(
lambda _: check_if_order_exists(event['orderId']),
name='check-duplicate',
config=StepConfig(
retry_strategy=lambda error, attempt: {'should_retry': False}
)
)
```
------
Ketika strategi coba lagi kembali`shouldRetry: false`, langkah gagal segera tanpa mencoba lagi. Gunakan ini untuk operasi yang tidak boleh dicoba lagi, seperti pemeriksaan idempotensi atau operasi dengan efek samping yang tidak dapat diulang dengan aman.
## Pengecualian di luar langkah
Ketika pengecualian yang tidak tertangkap terjadi dalam kode handler Anda tetapi di luar langkah apa pun, SDK menandai eksekusi sebagai gagal. Ini memastikan kesalahan dalam logika aplikasi Anda ditangkap dan dilaporkan dengan benar.
| Skenario | Apa yang terjadi | Dampak pengukuran |
| --- | --- | --- |
| Pengecualian dalam kode handler di luar langkah apa pun | SDK menandai eksekusi sebagai GAGAL dan mengembalikan kesalahan. Pengecualian tidak dicoba ulang secara otomatis. | Kesalahan ukuran payload |
Untuk mengaktifkan percobaan ulang otomatis untuk kode rawan kesalahan, bungkus dalam satu langkah dengan strategi coba lagi. Langkah-langkah memberikan percobaan ulang otomatis dengan backoff yang dapat dikonfigurasi, sementara kode di luar langkah segera gagal.
## Backend mencoba lagi
Percobaan ulang backend terjadi ketika Lambda mengalami kegagalan infrastruktur, kesalahan runtime, atau saat SDK tidak dapat berkomunikasi dengan layanan eksekusi tahan lama. Lambda secara otomatis mencoba kembali kegagalan ini untuk membantu fungsi tahan lama Anda dapat pulih dari masalah infrastruktur sementara.
### Skenario coba lagi backend
Lambda secara otomatis mencoba ulang fungsi Anda ketika menemukan skenario berikut:
+ **Kesalahan layanan internal** - Ketika Lambda atau layanan eksekusi tahan lama mengembalikan kesalahan 5xx, menunjukkan masalah layanan sementara.
+ **Throttling** - Ketika fungsi Anda dibatasi karena batas konkurensi atau kuota layanan.
+ **Timeout** - Ketika SDK tidak dapat mencapai layanan eksekusi tahan lama dalam periode batas waktu.
+ **Kegagalan inisialisasi kotak pasir - Ketika** Lambda tidak dapat menginisialisasi lingkungan eksekusi.
+ **Kesalahan runtime** - Ketika runtime Lambda menemukan kesalahan di luar kode fungsi Anda, out-of-memory seperti kesalahan atau proses crash.
+ **Kesalahan token pos pemeriksaan tidak valid - Ketika token** pos pemeriksaan tidak lagi valid, biasanya karena perubahan status sisi layanan.
Tabel berikut menjelaskan cara SDK menangani skenario ini:
| Skenario | Apa yang terjadi | Dampak pengukuran |
| --- | --- | --- |
| Kesalahan runtime di luar handler tahan lama (OOM, batas waktu, crash) | Lambda secara otomatis mencoba ulang pemanggilan. SDK diputar ulang dari pos pemeriksaan terakhir, melewatkan langkah-langkah yang telah selesai. | Kesalahan ukuran payload\$11 operasi per coba lagi |
| Kesalahan layanan (5xx) atau batas waktu saat menelepon/CheckpointDurableExecutionGetDurableExecutionState APIs | Lambda secara otomatis mencoba ulang pemanggilan. SDK diputar ulang dari pos pemeriksaan terakhir. | Kesalahan ukuran payload\$11 operasi per coba lagi |
| Throttling (429) atau token pos pemeriksaan tidak valid saat memanggil/CheckpointDurableExecutionGetDurableExecutionState APIs | Lambda secara otomatis mencoba ulang pemanggilan dengan backoff eksponensial. SDK diputar ulang dari pos pemeriksaan terakhir. | Kesalahan ukuran payload\$11 operasi per coba lagi |
| Kesalahan klien (4xx, kecuali 429 dan token tidak valid) ketika/CheckpointDurableExecutionGetDurableExecutionState APIs | SDK menandai eksekusi sebagai GAGAL. Tidak ada percobaan ulang otomatis yang terjadi karena kesalahan menunjukkan masalah permanen. | Kesalahan ukuran payload |
Backend mencoba menggunakan backoff eksponensial dan melanjutkan sampai fungsi berhasil atau batas waktu eksekusi tercapai. Selama pemutaran ulang, SDK melewati pos pemeriksaan yang telah selesai dan melanjutkan eksekusi dari operasi terakhir yang berhasil, memastikan fungsi Anda tidak menjalankan kembali pekerjaan yang telah selesai.
## Coba lagi praktik terbaik
Ikuti praktik terbaik ini saat mengonfigurasi strategi coba lagi:
+ **Konfigurasikan strategi coba ulang eksplisit** - Jangan mengandalkan perilaku coba ulang default dalam produksi. Konfigurasikan strategi coba ulang eksplisit dengan upaya maksimal dan interval backoff yang sesuai untuk kasus penggunaan Anda.
+ **Gunakan percobaan ulang bersyarat** - Terapkan `shouldRetry` logika untuk mencoba lagi hanya kesalahan sementara (batas tingkat, batas waktu) dan gagal cepat pada kesalahan permanen (kegagalan validasi, tidak ditemukan).
+ **Tetapkan upaya maksimal yang sesuai** - Keseimbangan antara ketahanan dan waktu eksekusi. Terlalu banyak percobaan ulang dapat menunda deteksi kegagalan, sementara terlalu sedikit dapat menyebabkan kegagalan yang tidak perlu.
+ **Gunakan backoff eksponensial - Backoff** eksponensial mengurangi beban pada layanan hilir dan meningkatkan kemungkinan pemulihan dari kegagalan sementara.
+ **Bungkus kode rawan kesalahan dalam langkah-langkah - Kode di** luar langkah tidak dapat dicoba ulang secara otomatis. Bungkus panggilan API eksternal, kueri database, dan operasi rawan kesalahan lainnya dalam langkah-langkah dengan strategi coba lagi.
+ **Pantau metrik coba lagi** - Lacak operasi percobaan ulang langkah dan kegagalan eksekusi di Amazon CloudWatch untuk mengidentifikasi pola dan mengoptimalkan strategi coba lagi.
# Idempotensi
Fungsi tahan lama menyediakan idempotensi bawaan untuk eksekusi dimulai melalui nama eksekusi. Saat Anda memberikan nama eksekusi, Lambda menggunakannya untuk mencegah eksekusi duplikat dan mengaktifkan percobaan ulang permintaan pemanggilan yang aman. Langkah-langkah memiliki semantik at-least-once eksekusi secara default—selama pemutaran ulang, SDK mengembalikan hasil pemeriksaan tanpa mengeksekusi ulang langkah yang telah diselesaikan, tetapi logika bisnis Anda harus idempoten untuk menangani percobaan ulang potensial sebelum selesai.
**catatan**
Pemetaan sumber acara Lambda (ESM) tidak mendukung idempotensi saat peluncuran. Oleh karena itu, setiap pemanggilan (termasuk percobaan ulang) memulai eksekusi baru yang tahan lama. Untuk memastikan eksekusi idempoten dengan pemetaan sumber peristiwa, terapkan logika idempotensi dalam kode fungsi Anda seperti dengan [Powertools for AWS Lambda](https://docs.aws.amazon.com//powertools/) atau gunakan fungsi Lambda biasa sebagai proxy (dispatcher) untuk memanggil fungsi tahan lama dengan kunci idempotensi (parameter nama eksekusi).
## Nama eksekusi
Anda dapat memberikan nama eksekusi saat menjalankan fungsi tahan lama. Nama eksekusi bertindak sebagai kunci idempotensi, memungkinkan Anda untuk mencoba kembali permintaan pemanggilan dengan aman tanpa membuat eksekusi duplikat. Jika Anda tidak memberikan nama, Lambda akan menghasilkan ID eksekusi unik secara otomatis.
Nama eksekusi harus unik dalam akun dan wilayah Anda. Saat Anda memanggil fungsi dengan nama eksekusi yang sudah ada, perilaku Lambda bergantung pada status eksekusi yang ada dan apakah payload cocok.
## Perilaku idempotensi
Tabel berikut menjelaskan cara Lambda menangani permintaan pemanggilan berdasarkan apakah Anda memberikan nama eksekusi, status eksekusi yang ada, dan apakah payload cocok:
| Skenario | Nama yang disediakan? | Status eksekusi yang ada | Muatan identik? | Perilaku |
| --- | --- | --- | --- | --- |
| 1 | Tidak | N/A | N/A | Eksekusi baru dimulai: Lambda menghasilkan ID eksekusi unik dan memulai eksekusi baru |
| 2 | Ya | Tidak pernah ada atau retensi kedaluwarsa | N/A | Eksekusi baru dimulai: Lambda memulai eksekusi baru dengan nama yang disediakan |
| 3 | Ya | Berjalan | Ya | Idempoten start: Lambda mengembalikan informasi eksekusi yang ada tanpa memulai duplikat. Untuk pemanggilan sinkron, ini bertindak sebagai penyambungan kembali ke eksekusi yang sedang berjalan |
| 4 | Ya | Berjalan | Tidak | Kesalahan: Lambda mengembalikan DurableExecutionAlreadyExists kesalahan karena eksekusi dengan nama ini sudah berjalan dengan muatan yang berbeda |
| 5 | Ya | Ditutup (berhasil, gagal, berhenti, atau habis waktu) | Ya | Idempoten start: Lambda mengembalikan informasi eksekusi yang ada tanpa memulai eksekusi baru. Hasil eksekusi tertutup dikembalikan |
| 6 | Ya | Ditutup (berhasil, gagal, berhenti, atau habis waktu) | Tidak | Kesalahan: Lambda mengembalikan DurableExecutionAlreadyExists kesalahan karena eksekusi dengan nama ini sudah selesai dengan muatan yang berbeda |
**Catatan**
Skenario 3 dan 5 menunjukkan perilaku idempoten di mana Lambda menangani permintaan pemanggilan duplikat dengan aman dengan mengembalikan informasi eksekusi yang ada alih-alih membuat duplikat.
## Langkah idempotensi
Langkah-langkah memiliki semantik at-least-once eksekusi secara default. Saat fungsi Anda diputar ulang setelah menunggu, panggilan balik, atau kegagalan, SDK akan memeriksa setiap langkah terhadap log pos pemeriksaan. Untuk langkah-langkah yang sudah selesai, SDK mengembalikan hasil pemeriksaan tanpa mengeksekusi ulang logika langkah. Namun, jika sebuah langkah gagal atau fungsi terputus sebelum langkah selesai, langkah tersebut dapat dijalankan beberapa kali.
Logika bisnis Anda yang dibungkus dalam langkah-langkah harus idempoten untuk menangani percobaan ulang potensial. Gunakan kunci idempotensi untuk memastikan operasi seperti pembayaran atau penulisan database dijalankan hanya sekali, bahkan jika langkah tersebut dicoba lagi.
**Contoh: Menggunakan kunci idempotensi dalam langkah-langkah**
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
import { randomUUID } from 'crypto';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Generate idempotency key once
const idempotencyKey = await context.step('generate-key', async () => {
return randomUUID();
});
// Use idempotency key in payment API to prevent duplicate charges
const payment = await context.step('process-payment', async () => {
return paymentAPI.charge({
amount: event.amount,
idempotencyKey: idempotencyKey
});
});
return { statusCode: 200, payment };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid
@durable_execution
def handler(event, context: DurableContext):
# Generate idempotency key once
idempotency_key = context.step(
lambda _: str(uuid.uuid4()),
name='generate-key'
)
# Use idempotency key in payment API to prevent duplicate charges
payment = context.step(
lambda _: payment_api.charge(
amount=event['amount'],
idempotency_key=idempotency_key
),
name='process-payment'
)
return {'statusCode': 200, 'payment': payment}
```
------
Anda dapat mengonfigurasi langkah-langkah untuk menggunakan semantik at-most-once eksekusi dengan menyetel mode eksekusi ke. `AT_MOST_ONCE_PER_RETRY` Ini memastikan langkah dijalankan paling banyak sekali per percobaan ulang, tetapi mungkin tidak mengeksekusi sama sekali jika fungsi terganggu sebelum langkah selesai.
SDK memberlakukan pemutaran ulang deterministik dengan memvalidasi bahwa nama langkah dan urutan cocok dengan log pos pemeriksaan selama pemutaran ulang. Jika kode Anda mencoba mengeksekusi langkah-langkah dalam urutan yang berbeda atau dengan nama yang berbeda, SDK akan menampilkan file. `NonDeterministicExecutionError`
**Cara kerja replay dengan langkah-langkah yang telah selesai:**
1. Pemanggilan pertama: Fungsi mengeksekusi langkah A, membuat pos pemeriksaan, lalu menunggu
1. Pemanggilan kedua (setelah menunggu): Fungsi memutar ulang dari awal, langkah A mengembalikan hasil yang diperiksa secara instan tanpa mengeksekusi ulang, lalu melanjutkan ke langkah B
1. Pemanggilan ketiga (setelah menunggu lagi): Fungsi memutar ulang dari awal, langkah A dan B mengembalikan hasil pemeriksaan secara instan, lalu melanjutkan ke langkah C
Mekanisme pemutaran ulang ini memastikan bahwa langkah-langkah yang telah diselesaikan tidak dijalankan kembali, tetapi logika bisnis Anda harus tetap idempoten untuk menangani percobaan ulang sebelum selesai.
# Menguji fungsi Lambda yang tahan lama
AWS menyediakan pengujian khusus SDKs untuk fungsi tahan lama yang memungkinkan Anda menjalankan dan memeriksa eksekusi baik secara lokal maupun di cloud. Instal SDK pengujian untuk bahasa Anda:
------
#### [ TypeScript ]
```
npm install --save-dev @aws/aws-durable-execution-sdk-js-testing
```
Untuk dokumentasi dan contoh lengkap, lihat [SDK TypeScript pengujian](https://github.com/aws/aws-durable-execution-sdk-js/tree/development/packages/aws-durable-execution-sdk-js-testing) aktif. GitHub
------
#### [ Python ]
```
pip install aws-durable-execution-sdk-python-testing
```
Untuk dokumentasi dan contoh lengkap, lihat [SDK pengujian Python](https://github.com/aws/aws-durable-execution-sdk-python-testing). GitHub
------
SDK pengujian menyediakan dua mode pengujian: pengujian lokal untuk pengujian unit cepat, dan pengujian cloud untuk pengujian integrasi terhadap fungsi yang diterapkan.
## Pengujian lokal
Pengujian lokal menjalankan fungsi tahan lama Anda di lingkungan pengembangan Anda tanpa memerlukan sumber daya yang digunakan. Pelari uji menjalankan kode fungsi Anda secara langsung dan menangkap semua operasi untuk diperiksa.
Gunakan pengujian lokal untuk pengujian unit, pengembangan berbasis tes, dan CI/CD jaringan pipa. Pengujian dijalankan secara lokal tanpa latensi jaringan atau biaya tambahan.
**Contoh tes:**
------
#### [ TypeScript ]
```
import { withDurableExecution } from '@aws/aws-durable-execution-sdk-js';
import { DurableFunctionTestRunner } from '@aws/aws-durable-execution-sdk-js-testing';
const handler = withDurableExecution(async (event, context) => {
const result = await context.step('calculate', async () => {
return event.a + event.b;
});
return result;
});
test('addition works correctly', async () => {
const runner = new DurableFunctionTestRunner({ handler });
const result = await runner.run({ a: 5, b: 3 });
expect(result.status).toBe('SUCCEEDED');
expect(result.result).toBe(8);
const step = result.getStep('calculate');
expect(step.result).toBe(8);
});
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
from aws_durable_execution_sdk_python_testing import DurableFunctionTestRunner
from aws_durable_execution_sdk_python.execution import InvocationStatus
@durable_execution
def handler(event: dict, context: DurableContext) -> int:
result = context.step(lambda _: event["a"] + event["b"], name="calculate")
return result
def test_addition():
runner = DurableFunctionTestRunner(handler=handler)
with runner:
result = runner.run(input={"a": 5, "b": 3}, timeout=10)
assert result.status is InvocationStatus.SUCCEEDED
assert result.result == 8
step = result.get_step("calculate")
assert step.result == 8
```
------
Runner pengujian menangkap status eksekusi termasuk hasil akhir, hasil langkah individual, operasi tunggu, panggilan balik, dan kesalahan apa pun. Anda dapat memeriksa operasi berdasarkan nama atau iterasi melalui semua operasi untuk memverifikasi perilaku eksekusi.
### Toko eksekusi
SDK pengujian menggunakan penyimpanan eksekusi untuk mempertahankan data eksekusi pengujian. Secara default, pengujian menggunakan penyimpanan dalam memori yang cepat dan tidak memerlukan pembersihan. Untuk men-debug atau menganalisis riwayat eksekusi, Anda dapat menggunakan penyimpanan sistem file yang menyimpan eksekusi sebagai file JSON.
**Penyimpanan dalam memori (default):**
Penyimpanan dalam memori menyimpan data eksekusi dalam memori selama pengujian dijalankan. Data hilang saat pengujian selesai, sehingga ideal untuk pengujian unit standar dan CI/CD saluran pipa di mana Anda tidak perlu memeriksa eksekusi setelah pengujian selesai.
**Toko sistem file:**
Penyimpanan sistem file mempertahankan data eksekusi ke disk sebagai file JSON. Setiap eksekusi disimpan dalam file terpisah, sehingga mudah untuk memeriksa riwayat eksekusi setelah tes selesai. Gunakan penyimpanan sistem file saat men-debug kegagalan pengujian yang kompleks atau menganalisis pola eksekusi dari waktu ke waktu.
Konfigurasikan toko menggunakan variabel lingkungan:
```
# Use filesystem store
export AWS_DEX_STORE_TYPE=filesystem
export AWS_DEX_STORE_PATH=./test-executions
# Run tests
pytest tests/
```
File eksekusi disimpan dengan nama yang disanitasi dan berisi status eksekusi lengkap termasuk operasi, pos pemeriksaan, dan hasil. Penyimpanan sistem file secara otomatis membuat direktori penyimpanan jika tidak ada.
## Pengujian cloud
Pengujian cloud memanggil fungsi tahan lama yang diterapkan AWS dan mengambil riwayat eksekusi mereka menggunakan Lambda API. Gunakan pengujian cloud untuk memverifikasi perilaku di lingkungan seperti produksi dengan AWS layanan dan konfigurasi nyata.
Pengujian cloud memerlukan fungsi dan AWS kredensil yang diterapkan dengan izin untuk memanggil fungsi dan membaca riwayat eksekusi:
```
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"lambda:InvokeFunction",
"lambda:GetDurableExecution",
"lambda:GetDurableExecutionHistory"
],
"Resource": "arn:aws:lambda:region:account-id:function:function-name"
}
]
}
```
**Contoh tes cloud:**
------
#### [ TypeScript ]
```
import { DurableFunctionCloudTestRunner } from '@aws/aws-durable-execution-sdk-js-testing';
test('deployed function processes orders', async () => {
const runner = new DurableFunctionCloudTestRunner({
functionName: 'order-processor',
region: 'us-east-1'
});
const result = await runner.run({ orderId: 'order-123' });
expect(result.status).toBe('SUCCEEDED');
expect(result.result.status).toBe('completed');
});
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python_testing import (
DurableFunctionCloudTestRunner,
DurableFunctionCloudTestRunnerConfig
)
def test_deployed_function():
config = DurableFunctionCloudTestRunnerConfig(
function_name="order-processor",
region="us-east-1"
)
runner = DurableFunctionCloudTestRunner(config=config)
result = runner.run(input={"orderId": "order-123"})
assert result.status is InvocationStatus.SUCCEEDED
assert result.result["status"] == "completed"
```
------
Pengujian cloud memanggil fungsi yang diterapkan yang sebenarnya dan mengambil riwayat eksekusi dari. AWS Ini memungkinkan Anda memverifikasi integrasi dengan AWS layanan lain, memvalidasi karakteristik kinerja, dan menguji dengan data dan konfigurasi seperti produksi.
## Apa yang harus diuji
Uji fungsi tahan lama dengan memverifikasi hasil eksekusi, perilaku operasi, dan penanganan kesalahan. Fokus pada kebenaran logika bisnis daripada detail implementasi.
**Verifikasi hasil eksekusi:** Periksa apakah fungsi mengembalikan nilai yang diharapkan untuk input yang diberikan. Uji eksekusi yang berhasil dan kasus kesalahan untuk memastikan fungsi menangani input yang tidak valid dengan tepat.
**Periksa eksekusi operasi:** Verifikasi bahwa langkah, menunggu, dan panggilan balik dijalankan seperti yang diharapkan. Periksa hasil langkah untuk memastikan operasi perantara menghasilkan nilai yang benar. Validasi bahwa operasi tunggu dikonfigurasi dengan batas waktu yang sesuai dan callback dibuat dengan pengaturan yang benar.
**Penanganan kesalahan pengujian:** Verifikasi fungsi gagal dengan benar dengan pesan kesalahan deskriptif saat diberikan input yang tidak valid. Uji perilaku coba lagi dengan mensimulasikan kegagalan sementara dan mengonfirmasi operasi coba lagi dengan tepat. Periksa apakah kegagalan permanen tidak memicu percobaan ulang yang tidak perlu.
**Validasi alur kerja:** Untuk alur kerja multi-langkah, verifikasi operasi yang dijalankan dalam urutan yang benar. Uji percabangan bersyarat untuk memastikan jalur eksekusi yang berbeda bekerja dengan benar. Validasi operasi paralel dijalankan secara bersamaan dan menghasilkan hasil yang diharapkan.
Repositori dokumentasi SDK berisi contoh ekstensif pola pengujian termasuk alur kerja multi-langkah, skenario kesalahan, penanganan batas waktu, dan pola polling.
## Strategi pengujian
Gunakan pengujian lokal untuk pengujian unit selama pengembangan dan di CI/CD jaringan pipa. Pengujian lokal berjalan cepat, tidak memerlukan AWS kredensil, dan memberikan umpan balik langsung tentang perubahan kode. Tulis tes lokal untuk memverifikasi logika bisnis, penanganan kesalahan, dan perilaku operasi.
Gunakan pengujian cloud untuk pengujian integrasi sebelum menerapkan ke produksi. Pengujian cloud memverifikasi perilaku dengan AWS layanan dan konfigurasi nyata, memvalidasi karakteristik kinerja, dan menguji end-to-end alur kerja. Jalankan pengujian cloud di lingkungan pementasan untuk menangkap masalah integrasi sebelum mencapai produksi.
Mengolok-olok dependensi eksternal dalam pengujian lokal untuk mengisolasi logika fungsi dan menjaga pengujian tetap cepat. Gunakan pengujian cloud untuk memverifikasi integrasi aktual dengan layanan eksternal seperti database APIs, dan AWS layanan lainnya.
Tulis tes terfokus yang memverifikasi satu perilaku tertentu. Gunakan nama tes deskriptif yang menjelaskan apa yang sedang diuji. Kelompokkan tes terkait bersama-sama dan gunakan perlengkapan uji untuk kode pengaturan umum. Jaga agar tes tetap sederhana dan hindari logika pengujian kompleks yang sulit dipahami.
## Kegagalan debugging
Ketika tes gagal, periksa hasil eksekusi untuk memahami apa yang salah. Periksa status eksekusi untuk melihat apakah fungsi berhasil, gagal, atau habis waktu. Baca pesan kesalahan untuk memahami penyebab kegagalan.
Periksa hasil operasi individu untuk menemukan di mana perilaku menyimpang dari harapan. Periksa hasil langkah untuk melihat nilai apa yang dihasilkan. Verifikasi urutan operasi untuk mengonfirmasi operasi yang dijalankan dalam urutan yang diharapkan. Hitung operasi untuk memastikan jumlah langkah, menunggu, dan panggilan balik yang tepat dibuat.
Masalah umum termasuk kode non-deterministik yang menghasilkan hasil yang berbeda pada pemutaran ulang, status bersama melalui variabel global yang rusak selama pemutaran ulang, dan operasi yang hilang karena kesalahan logika bersyarat. Gunakan debugger standar dan logging untuk melangkah melalui kode fungsi dan melacak alur eksekusi.
Untuk pengujian cloud, periksa riwayat eksekusi di CloudWatch Log untuk melihat log operasi terperinci. Gunakan tracing untuk melacak alur eksekusi di seluruh layanan dan mengidentifikasi kemacetan.
# Memantau fungsi tahan lama
Anda dapat memantau fungsi tahan lama Anda menggunakan CloudWatch metrik, CloudWatch Log, dan penelusuran. Karena fungsi tahan lama dapat berjalan untuk waktu yang lama dan mencakup beberapa pemanggilan fungsi, pemantauannya memerlukan pemahaman pola eksekusi uniknya, termasuk pos pemeriksaan, transisi status, dan perilaku pemutaran ulang.
## CloudWatch metrik
Lambda secara otomatis menerbitkan metrik tanpa CloudWatch biaya tambahan. Fungsi tahan lama menyediakan metrik tambahan di luar metrik Lambda standar untuk membantu Anda memantau alur kerja yang berjalan lama, manajemen status, dan pemanfaatan sumber daya.
### Metrik eksekusi yang tahan lama
Lambda memancarkan metrik berikut untuk eksekusi yang tahan lama:
| Metrik | Deskripsi |
| --- | --- |
| ApproximateRunningDurableExecutions | Jumlah eksekusi tahan lama dalam status RUNNING |
| ApproximateRunningDurableExecutionsUtilization | Persentase kuota eksekusi tahan lama maksimum akun Anda yang sedang digunakan |
| DurableExecutionDuration | Waktu jam dinding berlalu dalam milidetik sehingga eksekusi yang tahan lama tetap dalam status RUNNING |
| DurableExecutionStarted | Jumlah eksekusi tahan lama yang dimulai |
| DurableExecutionStopped | Jumlah eksekusi tahan lama yang berhenti menggunakan API StopDurableExecution |
| DurableExecutionSucceeded | Jumlah eksekusi tahan lama yang berhasil diselesaikan |
| DurableExecutionFailed | Jumlah eksekusi tahan lama yang diselesaikan dengan kegagalan |
| DurableExecutionTimedOut | Jumlah eksekusi tahan lama yang melebihi batas waktu eksekusi yang dikonfigurasi |
| DurableExecutionOperations | Jumlah kumulatif operasi yang dilakukan dalam eksekusi yang tahan lama (maks: 3.000) |
| DurableExecutionStorageWrittenBytes | Jumlah kumulatif data dalam byte dipertahankan oleh eksekusi yang tahan lama (maks: 100 MB) |
### CloudWatch metrik
Lambda memancarkan metrik pemanggilan standar, kinerja, dan konkurensi untuk fungsi yang tahan lama. Karena eksekusi yang tahan lama dapat menjangkau beberapa pemanggilan fungsi saat berlangsung melalui pos pemeriksaan dan pemutaran ulang, metrik ini berperilaku berbeda dari fungsi standar:
+ **Pemanggilan:** Menghitung setiap pemanggilan fungsi, termasuk pemutaran ulang. Eksekusi tunggal yang tahan lama dapat menghasilkan beberapa titik data pemanggilan.
+ **Durasi:** Mengukur setiap pemanggilan fungsi secara terpisah. Gunakan `DurableExecutionDuration` untuk total waktu yang diambil oleh eksekusi tunggal yang tahan lama.
+ **Kesalahan:** Melacak kegagalan pemanggilan fungsi. Gunakan `DurableExecutionFailed` untuk kegagalan tingkat eksekusi.
Untuk daftar lengkap metrik Lambda standar, lihat [Jenis metrik untuk](https://docs.aws.amazon.com//lambda/latest/dg/monitoring-metrics-types.html) fungsi Lambda.
### Membuat CloudWatch alarm
Buat CloudWatch alarm untuk memberi tahu Anda saat metrik melebihi ambang batas. Alarm umum meliputi:
+ `ApproximateRunningDurableExecutionsUtilization`melebihi 80% dari kuota Anda
+ `DurableExecutionFailed`meningkat di atas ambang batas
+ `DurableExecutionTimedOut`menunjukkan eksekusi habis waktu
+ `DurableExecutionStorageWrittenBytes`mendekati batas penyimpanan
Untuk informasi selengkapnya, [lihat Menggunakan CloudWatch alarm](https://docs.aws.amazon.com//AmazonCloudWatch/latest/monitoring/AlarmThatSendsEmail.html). .
## EventBridge acara
Lambda menerbitkan peristiwa perubahan status eksekusi tahan lama ke. EventBridge Anda dapat menggunakan peristiwa ini untuk memicu alur kerja, mengirim pemberitahuan, atau melacak perubahan siklus hidup eksekusi di seluruh fungsi tahan lama Anda.
### Peristiwa perubahan status eksekusi yang tahan lama
Lambda memancarkan peristiwa ke EventBridge setiap kali eksekusi tahan lama mengubah status. Peristiwa ini memiliki karakteristik sebagai berikut:
+ **Sumber:** `aws.lambda`
+ **Jenis detail:** `Durable Execution Status Change`
Peristiwa perubahan status dipublikasikan untuk status eksekusi berikut:
+ `RUNNING`- Eksekusi dimulai
+ `SUCCEEDED`- Eksekusi berhasil diselesaikan
+ `STOPPED`- Eksekusi berhenti menggunakan StopDurableExecution API
+ `FAILED`- Eksekusi gagal dengan kesalahan
+ `TIMED_OUT`- Eksekusi melebihi batas waktu yang dikonfigurasi
Contoh berikut menunjukkan peristiwa perubahan status eksekusi tahan lama:
```
{
"version": "0",
"id": "d019b03c-a8a3-9d58-85de-241e96206538",
"detail-type": "Durable Execution Status Change",
"source": "aws.lambda",
"account": "123456789012",
"time": "2025-11-20T13:08:22Z",
"region": "us-east-1",
"resources": [],
"detail": {
"durableExecutionArn": "arn:aws:lambda:us-east-1:123456789012:function:my-function:$LATEST/durable-execution/090c4189-b18b-4296-9d0c-cfd01dc3a122/9f7d84c9-ea3d-3ffc-b3e5-5ec51c34ffc9",
"durableExecutionName": "order-123",
"functionArn": "arn:aws:lambda:us-east-1:123456789012:function:my-function:2",
"status": "RUNNING",
"startTimestamp": "2025-11-20T13:08:22.345Z"
}
}
```
Untuk status terminal (`SUCCEEDED``STOPPED`,`FAILED`,,`TIMED_OUT`), acara menyertakan `endTimestamp` bidang yang menunjukkan kapan eksekusi selesai.
### Membuat EventBridge aturan
Buat aturan untuk merutekan peristiwa perubahan status eksekusi tahan lama ke target seperti Amazon Simple Notification Service, Amazon Simple Queue Service, atau fungsi Lambda lainnya.
Contoh berikut membuat aturan yang cocok dengan semua perubahan status eksekusi tahan lama:
```
{
"source": ["aws.lambda"],
"detail-type": ["Durable Execution Status Change"]
}
```
Contoh berikut membuat aturan yang hanya cocok dengan eksekusi yang gagal:
```
{
"source": ["aws.lambda"],
"detail-type": ["Durable Execution Status Change"],
"detail": {
"status": ["FAILED"]
}
}
```
Contoh berikut membuat aturan yang cocok dengan perubahan status untuk fungsi tertentu:
```
{
"source": ["aws.lambda"],
"detail-type": ["Durable Execution Status Change"],
"detail": {
"functionArn": [{
"prefix": "arn:aws:lambda:us-east-1:123456789012:function:my-function"
}]
}
}
```
Untuk informasi selengkapnya tentang membuat aturan, lihat [ EventBridge tutorial Amazon](https://docs.aws.amazon.com/eventbridge/latest/userguide/eb-tutorial.html) di Panduan EventBridge Pengguna.
## AWS X-Ray menelusuri
Anda dapat mengaktifkan penelusuran X-Ray pada fungsi tahan lama Anda. Lambda meneruskan header jejak X-Ray ke eksekusi yang tahan lama, memungkinkan Anda melacak permintaan di seluruh alur kerja Anda.
Untuk mengaktifkan X-Ray; melacak menggunakan konsol Lambda, pilih fungsi Anda, lalu pilih Alat Konfigurasi, Pemantauan dan operasi, dan aktifkan Penelusuran Aktif di bawah X-Ray.
Untuk mengaktifkan penelusuran X-Ray AWS CLI menggunakan:
```
aws lambda update-function-configuration \
--function-name my-durable-function \
--tracing-config Mode=Active
```
Untuk mengaktifkan AWS X-Ray penelusuran menggunakan AWS SAM:
```
Resources:
MyDurableFunction:
Type: AWS::Serverless::Function
Properties:
Tracing: Active
DurableConfig:
ExecutionTimeout: 3600
```
Untuk informasi selengkapnya tentang [X-Ray, lihat Panduan AWS X-Ray Pengembang.](https://docs.aws.amazon.com//xray/latest/devguide/aws-xray.html)
# Praktik terbaik untuk fungsi tahan lama Lambda
Fungsi tahan lama menggunakan model eksekusi berbasis replay yang membutuhkan pola berbeda dari fungsi Lambda tradisional. Ikuti praktik terbaik ini untuk membangun alur kerja yang andal dan hemat biaya.
## Tulis kode deterministik
Selama pemutaran ulang, fungsi Anda berjalan dari awal dan harus mengikuti jalur eksekusi yang sama dengan proses aslinya. Kode di luar operasi tahan lama harus deterministik, menghasilkan hasil yang sama dengan input yang sama.
**Bungkus operasi non-deterministik dalam langkah-langkah:**
+ Pembuatan angka acak dan UUIDs
+ Waktu atau stempel waktu saat ini
+ Panggilan API eksternal dan kueri database
+ Operasi sistem file
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
import { randomUUID } from 'crypto';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Generate transaction ID inside a step
const transactionId = await context.step('generate-transaction-id', async () => {
return randomUUID();
});
// Use the same ID throughout execution, even during replay
const payment = await context.step('process-payment', async () => {
return processPayment(event.amount, transactionId);
});
return { statusCode: 200, transactionId, payment };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid
@durable_execution
def handler(event, context: DurableContext):
# Generate transaction ID inside a step
transaction_id = context.step(
lambda _: str(uuid.uuid4()),
name='generate-transaction-id'
)
# Use the same ID throughout execution, even during replay
payment = context.step(
lambda _: process_payment(event['amount'], transaction_id),
name='process-payment'
)
return {'statusCode': 200, 'transactionId': transaction_id, 'payment': payment}
```
------
**Penting**
Jangan gunakan variabel global atau penutupan untuk berbagi status antar langkah. Lewati data melalui nilai pengembalian. Status global rusak selama pemutaran ulang karena langkah-langkah mengembalikan hasil yang di-cache tetapi variabel global diatur ulang.
**Hindari mutasi penutupan:** Variabel yang ditangkap dalam penutupan dapat kehilangan mutasi selama pemutaran ulang. Langkah-langkah mengembalikan hasil cache, tetapi pembaruan variabel di luar langkah tidak diputar ulang.
------
#### [ TypeScript ]
```
// ❌ WRONG: Mutations lost on replay
export const handler = withDurableExecution(async (event, context) => {
let total = 0;
for (const item of items) {
await context.step(async () => {
total += item.price; // ⚠️ Mutation lost on replay!
return saveItem(item);
});
}
return { total }; // Inconsistent value!
});
// ✅ CORRECT: Accumulate with return values
export const handler = withDurableExecution(async (event, context) => {
let total = 0;
for (const item of items) {
total = await context.step(async () => {
const newTotal = total + item.price;
await saveItem(item);
return newTotal; // Return updated value
});
}
return { total }; // Consistent!
});
// ✅ EVEN BETTER: Use map for parallel processing
export const handler = withDurableExecution(async (event, context) => {
const results = await context.map(
items,
async (ctx, item) => {
await ctx.step(async () => saveItem(item));
return item.price;
}
);
const total = results.getResults().reduce((sum, price) => sum + price, 0);
return { total };
});
```
------
#### [ Python ]
```
# ❌ WRONG: Mutations lost on replay
@durable_execution
def handler(event, context: DurableContext):
total = 0
for item in items:
context.step(
lambda _: save_item_and_mutate(item, total), # ⚠️ Mutation lost on replay!
name=f'save-item-{item["id"]}'
)
return {'total': total} # Inconsistent value!
# ✅ CORRECT: Accumulate with return values
@durable_execution
def handler(event, context: DurableContext):
total = 0
for item in items:
total = context.step(
lambda _: save_item_and_return_total(item, total),
name=f'save-item-{item["id"]}'
)
return {'total': total} # Consistent!
# ✅ EVEN BETTER: Use map for parallel processing
@durable_execution
def handler(event, context: DurableContext):
def process_item(ctx, item):
ctx.step(lambda _: save_item(item))
return item['price']
results = context.map(items, process_item)
total = sum(results.get_results())
return {'total': total}
```
------
## Desain untuk idempotensi
Operasi dapat dijalankan beberapa kali karena mencoba ulang atau memutar ulang. Operasi non-idempoten menyebabkan efek samping duplikat seperti menagih pelanggan dua kali atau mengirim beberapa email.
**Gunakan token idempotensi:** Hasilkan token di dalam langkah-langkah dan sertakan dengan panggilan API eksternal untuk mencegah operasi duplikat.
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Generate idempotency token once
const idempotencyToken = await context.step('generate-idempotency-token', async () => {
return crypto.randomUUID();
});
// Use token to prevent duplicate charges
const charge = await context.step('charge-payment', async () => {
return paymentService.charge({
amount: event.amount,
cardToken: event.cardToken,
idempotencyKey: idempotencyToken
});
});
return { statusCode: 200, charge };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
import uuid
@durable_execution
def handler(event, context: DurableContext):
# Generate idempotency token once
idempotency_token = context.step(
lambda _: str(uuid.uuid4()),
name='generate-idempotency-token'
)
# Use token to prevent duplicate charges
def charge_payment(_):
return payment_service.charge(
amount=event['amount'],
card_token=event['cardToken'],
idempotency_key=idempotency_token
)
charge = context.step(charge_payment, name='charge-payment')
return {'statusCode': 200, 'charge': charge}
```
------
**Gunakan at-most-once semantik:** Untuk operasi kritis yang tidak boleh diduplikasi (transaksi keuangan, pengurangan inventaris), konfigurasikan mode eksekusi. at-most-once
------
#### [ TypeScript ]
```
// Critical operation that must not duplicate
await context.step('deduct-inventory', async () => {
return inventoryService.deduct(event.productId, event.quantity);
}, {
executionMode: 'AT_MOST_ONCE_PER_RETRY'
});
```
------
#### [ Python ]
```
# Critical operation that must not duplicate
context.step(
lambda _: inventory_service.deduct(event['productId'], event['quantity']),
name='deduct-inventory',
config=StepConfig(execution_mode='AT_MOST_ONCE_PER_RETRY')
)
```
------
**Idempotensi basis data:** Gunakan check-before-write pola, pembaruan bersyarat, atau operasi upsert untuk mencegah duplikat catatan.
## Kelola negara secara efisien
Setiap pos pemeriksaan menyimpan status ke penyimpanan persisten. Objek status besar meningkatkan biaya, pos pemeriksaan lambat, dan kinerja dampak. Simpan hanya data koordinasi alur kerja yang penting.
**Pertahankan status minimal:**
+ Simpan IDs dan referensi, bukan objek penuh
+ Ambil data terperinci dalam langkah-langkah sesuai kebutuhan
+ Gunakan Amazon S3 atau DynamoDB untuk data besar, teruskan referensi dalam status
+ Hindari melewatkan muatan besar di antara langkah-langkah
------
#### [ TypeScript ]
```
import { withDurableExecution, DurableContext } from '@aws/durable-execution-sdk-js';
export const handler = withDurableExecution(
async (event: any, context: DurableContext) => {
// Store only the order ID, not the full order object
const orderId = event.orderId;
// Fetch data within each step as needed
await context.step('validate-order', async () => {
const order = await orderService.getOrder(orderId);
return validateOrder(order);
});
await context.step('process-payment', async () => {
const order = await orderService.getOrder(orderId);
return processPayment(order);
});
return { statusCode: 200, orderId };
}
);
```
------
#### [ Python ]
```
from aws_durable_execution_sdk_python import durable_execution, DurableContext
@durable_execution
def handler(event, context: DurableContext):
# Store only the order ID, not the full order object
order_id = event['orderId']
# Fetch data within each step as needed
context.step(
lambda _: validate_order(order_service.get_order(order_id)),
name='validate-order'
)
context.step(
lambda _: process_payment(order_service.get_order(order_id)),
name='process-payment'
)
return {'statusCode': 200, 'orderId': order_id}
```
------
## Rancang langkah-langkah efektif
Langkah-langkah adalah unit dasar kerja dalam fungsi yang tahan lama. Langkah-langkah yang dirancang dengan baik membuat alur kerja lebih mudah dipahami, di-debug, dan dipelihara.
**Prinsip desain langkah:**
+ **Gunakan nama deskriptif** - Nama seperti `validate-order` alih-alih `step1` membuat log dan kesalahan lebih mudah dipahami
+ **Pertahankan nama statis** - Jangan gunakan nama dinamis dengan cap waktu atau nilai acak. Nama langkah harus deterministik untuk diputar ulang
+ **Granularitas keseimbangan** - Pecahkan operasi kompleks menjadi langkah-langkah yang terfokus, tetapi hindari langkah-langkah kecil yang berlebihan yang meningkatkan overhead pos pemeriksaan
+ **Operasi terkait kelompok** - Operasi yang harus berhasil atau gagal bersama termasuk dalam langkah yang sama
## Gunakan operasi tunggu secara efisien
Tunggu operasi menangguhkan eksekusi tanpa menghabiskan sumber daya atau menimbulkan biaya. Gunakan mereka alih-alih menjaga Lambda tetap berjalan.
Penantian **berbasis waktu:** Gunakan `context.wait()` untuk penundaan, bukan atau. `setTimeout` `sleep`
**Callback eksternal:** Gunakan `context.waitForCallback()` saat menunggu sistem eksternal. Selalu atur batas waktu untuk mencegah penantian yang tidak terbatas.
**Polling:** Gunakan `context.waitForCondition()` dengan backoff eksponensial untuk melakukan polling layanan eksternal tanpa membebani mereka.
------
#### [ TypeScript ]
```
// Wait 24 hours without cost
await context.wait({ seconds: 86400 });
// Wait for external callback with timeout
const result = await context.waitForCallback(
'external-job',
async (callbackId) => {
await externalService.submitJob({
data: event.data,
webhookUrl: `https://api.example.com/callbacks/${callbackId}`
});
},
{ timeout: { seconds: 3600 } }
);
```
------
#### [ Python ]
```
# Wait 24 hours without cost
context.wait(86400)
# Wait for external callback with timeout
result = context.wait_for_callback(
lambda callback_id: external_service.submit_job(
data=event['data'],
webhook_url=f'https://api.example.com/callbacks/{callback_id}'
),
name='external-job',
config=WaitForCallbackConfig(timeout_seconds=3600)
)
```
------
## Pertimbangan tambahan
**Penanganan kesalahan:** Coba lagi kegagalan sementara seperti batas waktu jaringan dan batas tarif. Jangan mencoba lagi kegagalan permanen seperti kesalahan input atau otentikasi yang tidak valid. Konfigurasikan strategi coba lagi dengan upaya maksimal dan tingkat backoff yang sesuai. Untuk contoh rinci, lihat [Penanganan kesalahan dan percobaan ulang](durable-execution-sdk-retries.md).
**Kinerja:** Minimalkan ukuran pos pemeriksaan dengan menyimpan referensi alih-alih muatan penuh. Gunakan `context.parallel()` dan `context.map()` untuk menjalankan operasi independen secara bersamaan. Operasi terkait batch untuk mengurangi overhead pos pemeriksaan.
**Versioning: Memanggil** fungsi dengan nomor versi atau alias untuk menyematkan eksekusi ke versi kode tertentu. Pastikan versi kode baru dapat menangani status dari versi yang lebih lama. Jangan mengganti nama langkah atau mengubah perilaku mereka dengan cara yang merusak pemutaran ulang.
**Serialisasi:** Gunakan tipe yang kompatibel dengan JSON untuk input dan hasil operasi. Konversikan tanggal ke string ISO dan objek kustom menjadi objek biasa sebelum meneruskannya ke operasi yang tahan lama.
**Pemantauan:** Aktifkan pencatatan terstruktur dengan nama eksekusi IDs dan langkah. Siapkan CloudWatch alarm untuk tingkat kesalahan dan durasi eksekusi. Gunakan penelusuran untuk mengidentifikasi kemacetan. Untuk panduan terperinci, lihat [Monitoring dan debugging](durable-monitoring.md).
**Pengujian:** Uji jalur bahagia, penanganan kesalahan, dan perilaku pemutaran ulang. Uji skenario batas waktu untuk panggilan balik dan menunggu. Gunakan pengujian lokal untuk mengurangi waktu iterasi. Untuk panduan terperinci, lihat [Menguji fungsi tahan lama](durable-testing.md).
**Kesalahan umum yang harus dihindari:** Jangan membuat `context.step()` panggilan sarang, gunakan konteks anak sebagai gantinya. Bungkus operasi non-deterministik dalam langkah-langkah. Selalu atur batas waktu untuk callback. Seimbangkan granularitas langkah dengan overhead pos pemeriksaan. Simpan referensi alih-alih objek besar dalam keadaan.
## Sumber daya tambahan
+ [Dokumentasi Python SDK](https://github.com/aws/aws-durable-execution-sdk-python/tree/main/docs) - Referensi API lengkap, pola pengujian, dan contoh lanjutan
+ [TypeScript Dokumentasi SDK](https://github.com/aws/aws-durable-execution-sdk-js/tree/main/docs) - Referensi API lengkap, pola pengujian, dan contoh lanjutan