Lambda Durable Functions: Hướng dẫn toàn diện cho AWS Developer

// Lambda thông thường - CÓ VẤN ĐỀ!
export const handler = async (event) => {
  // Bước 1: Kiểm tra đơn hàng (2 giây)
  const order = await validateOrder(event.orderId);

  // Bước 2: Trừ tiền khách hàng (3 giây)
  const payment = await chargePayment(order.amount);

  // Bước 3: Giảm tồn kho (2 giây)
  await reduceInventory(order.items);

  // Bước 4: Gửi email xác nhận (1 giây)
  await sendConfirmationEmail(order.email);

  // Bước 5: Đợi shipper xác nhận (có thể 2-3 ngày!)
  await waitForShipperConfirmation(order.id);  // ❌ QUÁ THỜI GIAN CHO PHÉP!

  return { status: 'completed' };
};

// Lambda Durable - GIẢI QUYẾT TẤT CẢ!
import { withDurableExecution, DurableContext } from '@aws-lambda-powertools/durable';

export const handler = withDurableExecution(async (ctx: DurableContext, event) => {
  // Bước 1: Kiểm tra - được LƯU TRẠNG THÁI sau khi xong
  const order = await ctx.step('validate', () => validateOrder(event.orderId));

  // Bước 2: Trừ tiền - được LƯU TRẠNG THÁI sau khi xong
  const payment = await ctx.step('charge', () => chargePayment(order.amount));

  // Bước 3: Giảm tồn kho - được LƯU TRẠNG THÁI sau khi xong
  await ctx.step('reduce-inventory', () => reduceInventory(order.items));

  // Bước 4: Gửi email - được LƯU TRẠNG THÁI sau khi xong
  await ctx.step('send-email', () => sendConfirmationEmail(order.email));

  // Bước 5: Đợi shipper - CÓ THỂ ĐỢI HÀNG NGÀY!
  await ctx.waitForCallback('shipper-confirm', {
    callbackId: order.id,
    timeout: '7d'  // Đợi tối đa 7 ngày
  });

  return { status: 'completed' };
});

export const handler = withDurableExecution(async (ctx, event) => {
  console.log('Handler bắt đầu chạy');  // In ra MỖI LẦN chạy lại

  // Lần 1: Thực thi và lưu kết quả
  // Lần 2+: Bỏ qua và trả về kết quả đã lưu
  const step1Result = await ctx.step('step-1', async () => {
    console.log('Step 1 đang thực thi');  // CHỈ in lần đầu
    return 'result-from-step-1';
  });

  console.log(`Step 1 result: ${step1Result}`);  // In MỖI LẦN, nhưng kết quả giống nhau

  // Tương tự cho các step khác...
});

Handler bắt đầu chạy
Step 1 đang thực thi
Step 1 result: result-from-step-1

Handler bắt đầu chạy
Step 1 result: result-from-step-1

// Cú pháp cơ bản
const result = await ctx.step('tên-step-duy-nhất', async () => {
  // Code xử lý ở đây
  return 'kết quả';
});

// Ví dụ thực tế
const user = await ctx.step('get-user', async () => {
  const response = await fetch(`https://api.example.com/users/${userId}`);
  return response.json();
});

// Chờ 24 giờ rồi gửi email nhắc nhở
await ctx.step('create-order', () => createOrder(event));

await ctx.wait('wait-24h', { duration: '24h' });  // Lambda "ngủ" 24 giờ

await ctx.step('send-reminder', () => sendReminderEmail(event.email));

// Chờ quản lý phê duyệt
const approval = await ctx.waitForCallback('manager-approval', {
  callbackId: `request-${requestId}`,
  timeout: '7d'
});

if (approval.status === 'approved') {
  await ctx.step('process', () => processRequest(requestId));
} else {
  await ctx.step('reject', () => rejectRequest(requestId));
}

# Quản lý click nút Phê duyệt → gọi API này
aws lambda invoke-durable-callback \
  --function-name MyFunction \
  --callback-id "request-12345" \
  --payload '{"status": "approved", "approver": "manager@company.com"}'

// Kiểm tra định kỳ đến khi thanh toán được xác nhận
await ctx.waitForCondition('payment-confirmed', async () => {
  const status = await checkPaymentStatus(paymentId);
  return status === 'SUCCESS';  // true → dừng chờ
}, {
  interval: '30s',   // Kiểm tra mỗi 30 giây
  timeout: '2h'      // Hết hạn sau 2 giờ
});

// Chạy 3 lệnh gọi API cùng lúc thay vì tuần tự
const [inventory, pricing, shipping] = await ctx.parallel([
  ctx.step('check-inventory', () => checkInventory(productId)),
  ctx.step('get-pricing', () => getPricing(productId)),
  ctx.step('calculate-shipping', () => calculateShipping(address))
]);

// Tổng thời gian = thời gian của lệnh lâu nhất (thay vì tổng 3 lệnh)

Đặt Tour Đà Nẵng 3N2Đ:
1. Đặt vé máy bay VN Airlines: 5,000,000 VNĐ
2. Đặt khách sạn Hilton: 3,000,000 VNĐ
3. Đặt xe đưa đón sân bay: 500,000 VNĐ
```saga-pattern-tour-booking.drawio

**Vấn đề**: Nếu bước 3 (đặt xe) lỗi, bạn cần:
- Hủy vé máy bay (bước 1) → hoàn tiền
- Hủy khách sạn (bước 2) → hoàn tiền

Đây gọi là **compensation** (bù đắp/hoàn tác).

### 5.2 Saga Pattern với Lambda Durable

```typescript
export const handler = withDurableExecution(async (ctx: DurableContext, event) => {
  const { customerId, tourId, flightDate, hotelDate } = event;

  // Bước 1: Đặt vé máy bay
  // Nếu các bước sau lỗi → gọi cancelFlight để hoàn vé
  const flight = await ctx.step('book-flight',
    async () => {
      const booking = await flightAPI.book({
        customerId,
        date: flightDate,
        route: 'SGN-DAD'
      });
      return booking;
    },
    {
      compensation: async () => {
        await flightAPI.cancel(flight.bookingId);
        console.log('Đã hoàn vé máy bay');
      }
    }
  );

  // Bước 2: Đặt khách sạn
  // Nếu các bước sau lỗi → gọi cancelHotel để hủy phòng
  const hotel = await ctx.step('book-hotel',
    async () => {
      const booking = await hotelAPI.book({
        customerId,
        date: hotelDate,
        hotel: 'Hilton Da Nang'
      });
      return booking;
    },
    {
      compensation: async () => {
        await hotelAPI.cancel(hotel.bookingId);
        console.log('Đã hủy đặt phòng khách sạn');
      }
    }
  );

  // Bước 3: Đặt xe đưa đón
  // Nếu lỗi ở đây → TỰ ĐỘNG gọi compensation của bước 2, rồi bước 1
  const car = await ctx.step('book-car', async () => {
    const booking = await carAPI.book({
      customerId,
      pickupTime: flightDate,
      location: 'Da Nang Airport'
    });
    return booking;
  });

  // Nếu tất cả thành công
  return {
    status: 'success',
    bookings: { flight, hotel, car }
  };
});

Step Functions (Điều phối cấp cao)
    │
    ├── Lambda Durable (Logic nghiệp vụ phức tạp)
    │       └── Xử lý đơn hàng với Saga pattern
    │
    ├── Lambda đơn giản (Tác vụ nhanh)
    │       └── Gửi thông báo
    │
    └── Tích hợp AWS trực tiếp
            └── Ghi vào DynamoDB

mkdir hello-durable && cd hello-durable
npm init -y
npm install @aws-lambda-powertools/durable typescript @types/node

import { withDurableExecution, DurableContext } from '@aws-lambda-powertools/durable';

interface OrderEvent {
  orderId: string;
  customerEmail: string;
  amount: number;
}

export const handler = withDurableExecution(async (
  ctx: DurableContext,
  event: OrderEvent
) => {
  console.log(`Đang xử lý đơn hàng: ${event.orderId}`);

  // Bước 1: Kiểm tra đơn hàng
  const isValid = await ctx.step('validate-order', async () => {
    console.log('Đang kiểm tra đơn hàng...');
    // Giả lập kiểm tra
    await sleep(1000);
    return event.amount > 0;
  });

  if (!isValid) {
    return { status: 'failed', reason: 'Số tiền không hợp lệ' };
  }

  // Bước 2: Xử lý thanh toán
  const paymentId = await ctx.step('process-payment', async () => {
    console.log('Đang xử lý thanh toán...');
    await sleep(2000);
    return `PAY-${Date.now()}`;
  });

  // Bước 3: Gửi xác nhận
  await ctx.step('send-confirmation', async () => {
    console.log(`Đang gửi email đến ${event.customerEmail}`);
    await sleep(500);
  });

  return {
    status: 'completed',
    orderId: event.orderId,
    paymentId: paymentId
  };
});

const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Resources:
  HelloDurableFunction:
    Type: AWS::Serverless::Function
    Properties:
      FunctionName: hello-durable
      Handler: dist/index.handler
      Runtime: nodejs22.x
      Timeout: 900
      MemorySize: 256
      DurableExecution:
        Enabled: true
      Policies:
        - Statement:
            - Effect: Allow
              Action:
                - lambda:CheckpointDurableExecution
                - lambda:GetDurableExecutionState
              Resource: !Sub 'arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:function:hello-durable'

# Build
npm run build

# Triển khai
sam deploy --guided

# Kiểm tra
aws lambda invoke \
  --function-name hello-durable \
  --payload '{"orderId":"ORD-001","customerEmail":"test@example.com","amount":100}' \
  response.json

cat response.json

// ❌ SAI - UUID nằm NGOÀI step
const orderId = crypto.randomUUID();  // Dòng này chạy MỖI LẦN replay!
await ctx.step('create-order', () => createOrder(orderId));
await ctx.step('send-email', () => sendEmail(orderId));  // orderId có thể KHÁC!

Lần chạy 1:
─────────────────────────────────────────────────────────
orderId = crypto.randomUUID()     → "abc-123"
create-order với "abc-123"        → ✅ Thành công, lưu checkpoint
send-email với "abc-123"          → ❌ LỖI! (mất mạng)

Lần chạy 2 (Replay):
─────────────────────────────────────────────────────────
orderId = crypto.randomUUID()     → "xyz-789" (KHÁC vì random lại!)
create-order với "xyz-789"        → ⏩ Bỏ qua (đã có checkpoint)
                                     NHƯNG checkpoint lưu cho "abc-123"!
send-email với "xyz-789"          → ✅ Gửi email cho order SAI!

KẾT QUẢ: Order "abc-123" được tạo nhưng email gửi cho "xyz-789" (không tồn tại)

// ✅ ĐÚNG - Bọc trong step để lưu kết quả
const orderId = await ctx.step('generate-id', () => crypto.randomUUID());
// Lần 1: thực thi → "abc-123" (LƯU vào checkpoint)
// Lần 2: bỏ qua → trả về "abc-123" từ checkpoint (GIỐNG lần 1!)

await ctx.step('create-order', () => createOrder(orderId));  // Luôn dùng "abc-123"
await ctx.step('send-email', () => sendEmail(orderId));      // Luôn dùng "abc-123"

// ❌ SAI - Thay đổi biến `total` bên ngoài step
let total = 0;  // Khai báo bên ngoài

for (const item of items) {  // items = [{id: 1, price: 100}, {id: 2, price: 200}]
  await ctx.step(`process-${item.id}`, async () => {
    total += item.price;  // Thay đổi biến bên ngoài → KHÔNG được lưu!
  });
}

console.log(total);  // Mong đợi: 300, nhưng kết quả có thể SAI!

Lần chạy 1:
─────────────────────────────────────────────────────────
total = 0                          (khởi tạo)
process-1: total += 100 → total = 100   ✅ checkpoint
process-2: total += 200 → total = 300   ❌ LỖI! (mất mạng)

Lần chạy 2 (Replay):
─────────────────────────────────────────────────────────
total = 0                          (khởi tạo LẠI từ đầu!)
process-1: ⏩ Bỏ qua (có checkpoint)
           NHƯNG total vẫn = 0 (vì mutation không được lưu!)
process-2: total += 200 → total = 200   ✅ checkpoint

KẾT QUẢ: total = 200 (SAI! đáng lẽ phải là 300)

// ✅ ĐÚNG - Trả về kết quả từ step thay vì thay đổi biến ngoài
const prices = [];

for (const item of items) {
  const price = await ctx.step(`process-${item.id}`, async () => {
    return item.price;  // RETURN → được lưu vào checkpoint!
  });
  prices.push(price);  // prices được xây dựng từ kết quả đã lưu
}

const total = prices.reduce((a, b) => a + b, 0);
console.log(total);  // Luôn đúng: 300

Lần chạy 2 (Replay):
─────────────────────────────────────────────────────────
prices = []
process-1: ⏩ Bỏ qua → return 100 từ checkpoint → prices = [100]
process-2: ⏩ Thực thi → return 200 → prices = [100, 200]
total = 100 + 200 = 300  ✅ ĐÚNG!

TÌNH HUỐNG: Bạn deploy code mới GIỮA LÚC execution đang chạy

Ngày 1 - 9:00 AM: Execution bắt đầu với Code v1
─────────────────────────────────────────────────────────
Code v1:
  step('validate', () => validateOrder(order))     ✅ checkpoint
  step('charge', () => chargePayment(amount))      ❌ LỖI!

Ngày 1 - 10:00 AM: Bạn deploy Code v2 (thay đổi logic)
─────────────────────────────────────────────────────────
Code v2:
  step('validate', () => validateOrderV2(order))   // Logic KHÁC!
  step('check-fraud', () => checkFraud(order))     // Step MỚI!
  step('charge', () => chargePaymentV2(amount))    // Logic KHÁC!

Ngày 1 - 10:05 AM: Lambda Durable tự động Replay
─────────────────────────────────────────────────────────

Replay chạy Code v2 (phiên bản MỚI NHẤT):
  step('validate'): ⏩ Bỏ qua, trả về checkpoint
                    NHƯNG checkpoint lưu kết quả của validateOrder()
                    còn code mới là validateOrderV2() → KHÔNG KHỚP!
  step('check-fraud'): 🤯 Step này KHÔNG CÓ checkpoint!
                       Vì code v1 không có step này!
  step('charge'): Logic chargePaymentV2() khác chargePayment()!

KẾT QUẢ: Execution bị lỗi hoặc cho kết quả sai!

❌ arn:aws:lambda:us-east-1:123456789:function:MyFunction
✅ arn:aws:lambda:us-east-1:123456789:function:MyFunction:7
                                                         ↑
                                                    Version 7 (Code v1)

Replay vẫn chạy Code v1 (version 7):
  step('validate'): ⏩ Bỏ qua, trả về checkpoint    ✅ Khớp!
  step('charge'): Chạy chargePayment() giống lần đầu ✅ Đúng logic!

KẾT QUẢ: Execution hoàn thành đúng như mong đợi!

✅ arn:aws:lambda:us-east-1:123456789:function:MyFunction:$LATEST
   → Dùng phiên bản mới nhất TẠI THỜI ĐIỂM bắt đầu execution

✅ arn:aws:lambda:us-east-1:123456789:function:MyFunction:7
   → Dùng chính xác phiên bản số 7

✅ arn:aws:lambda:us-east-1:123456789:function:MyFunction:prod
   → Dùng alias "prod" (alias trỏ đến một version cụ thể)

Chi phí = (Số thao tác / 1,000,000) × $8 + Chi phí tính toán Lambda