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

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 dan 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

DurableContextadalah 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 menggunakanasync/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 arraymap(), untuk operasi bersarangrunInChildContext(), dan untuk polling. waitForCondition() Lihat Contoh 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.

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.

DurableConfigObjek mendefinisikan konfigurasi untuk fungsi tahan lama:

{
  "ExecutionTimeout": Integer,
  "RetentionPeriodInDays": Integer
}

Batas waktu eksekusi

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:

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).

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_OUT).

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.