Arsitektur Serverless Berbasis AWS Lambda & EventBridge untuk Skala Ekstrem

1. Konteks Industri & Analisis Akar Masalah

Dalam lanskap pengembangan sistem terdistribusi modern, arsitektur berbasis mikroservis monolitik yang berjalan di atas virtual machine (EC2) tradisional atau container cluster (Kubernetes/ECS) kerap menghadapi tantangan struktural yang pelik ketika dihadapkan pada lonjakan trafik ekstrem. Masalah utama yang sering muncul adalah pemborosan sumber daya idle, latensi yang tidak konsisten akibat cold start infrastruktur, serta kompleksitas manajemen kapasitas (autoscaling group) yang reaktif alih-alih proaktif.

Sebelum penerapan arsitektur Serverless berbasis AWS Lambda dan EventBridge, sistem web tradisional mengandalkan server web persisten (seperti Nginx/Apache yang dikawinkan dengan PHP-FPM, Node.js, atau Go binary) di belakang Application Load Balancer (ALB). Pendekatan ini memaksa organisasi untuk melakukan over-provisioning demi mengantisipasi trafik puncak, yang berdampak langsung pada pembengkakan biaya infrastruktur operasional. Ketika beban melonjak hingga 100.000 request per detik (RPS), bottleneck sering kali berpindah ke lapisan koneksi database relasional, antrean worker asynchronous yang menggunakan Supervisor, serta manajemen memori pada instance penampung.

Setelah migrasi ke arsitektur Event-Driven Serverless, paradigma berubah total. Komputasi hanya terjadi saat ada event nyata yang masuk, menghilangkan biaya saat idle (pay-per-execution), dan penskalaan terjadi secara instan dari nol hingga ribuan eksekusi paralel tanpa intervensi manual. Amazon EventBridge bertindak sebagai router event sentral yang mendistribusikan payload secara asinkron ke AWS Lambda, sementara DynamoDB menyediakan penyimpanan NoSQL dengan skalabilitas linier dan latensi sub-milidetik.

[!IMPORTANT] Arsitektur serverless bukanlah peluru perak. Kegagalan dalam merancang pola event routing dan manajemen concurrency Lambda dapat mengakibatkan throttling, peningkatan biaya secara tak terduga, dan cascade failure pada sistem hilir.

2. Konsep Inti & Deep Dive Arsitektur

Arsitektur Event-Driven (EDA) memisahkan produsen event (event producers) dari konsumen event (event consumers) menggunakan perantara asinkron. Dalam ekosistem AWS, Amazon EventBridge menggunakan event bus berbasis skema JSON yang memproses event dari sumber kustom, AWS services, atau SaaS pihak ketiga.

+------------------+
|  Client / Web UI |
+--------+---------+
         |
         v
+------------------+
|   API Gateway    |
+--------+---------+
         |
         v
+------------------+       PutEvents       +------------------+
|  Lambda (Ingest) +---------------------->| EventBridge Bus  |
+------------------+                       +--------+---------+
                                                    |
                        +---------------------------+---------------------------+
                        |                                                       |
                        v                                                       v
             +--------------------+                                  +--------------------+
             | Lambda (Worker A)  |                                  | Lambda (Worker B)  |
             +---------+----------+                                  +---------+----------+
                       |                                                          |
                       v                                                          v
             +--------------------+                                  +--------------------+
             |    DynamoDB (Tabel)|                                  |  S3 / Webhook / SQS|
             +--------------------+                                  +--------------------+

Alur eksekusi di balik layar:

1. Klien mengirimkan HTTP Request ke Amazon API Gateway.
2. API Gateway memicu fungsi Lambda Ingestor yang melakukan validasi payload awal.
3. Lambda Ingestor mempublikasikan event ke EventBridge Event Bus menggunakan PutEvents.
4. EventBridge mencocokkan event dengan Event Patterns yang telah didefinisikan.
5. Berdasarkan pola yang cocok, EventBridge merutekan event secara paralel ke satu atau lebih target AWS Lambda.
6. Fungsi Lambda pemroses (Workers) mengeksekusi logika bisnis dan membaca/menulis state ke DynamoDB.

3. Perbandingan Komparatif / Analisis Pendekatan

4. Prasyarat Sistem & Persiapan Lingkungan

Sebelum mengimplementasikan arsitektur ini, pastikan Anda telah menyiapkan lingkungan pengembangan lokal dan akun AWS dengan hak akses yang memadai (AdministratorAccess atau IAM Policies terkontrol untuk Lambda, EventBridge, dan DynamoDB).

Tooling yang dibutuhkan:

• Node.js (v18.x atau v20.x)
• AWS CLI (v2.x terkini)
• AWS Serverless Application Model (SAM CLI) atau Terraform
• cURL dan jq untuk pengujian API

Verifikasi instalasi AWS CLI:

aws --version
aws sts get-caller-identity

Pastikan variabel environment AWS terkonfigurasi dengan benar di terminal Anda:

export AWS_DEFAULT_REGION="us-east-1"
export AWS_ACCOUNT_ID="123456789012"

5. Panduan Implementasi Langkah demi Langkah

Kita akan membangun sistem pemrosesan pesanan (Order Processing System) menggunakan AWS SAM (Serverless Application Model). Buat direktori proyek baru dan inisialisasi file konfigurasi.

Struktur File Proyek

• template.yaml (Definisi Infrastruktur sebagai Kode)
• src/ingestor/index.js (Lambda penerima event)
• src/processor/index.js (Lambda pemroses pesanan)
• package.json (Dependensi Node.js)

1. template.yaml

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Description: >-
  Arsitektur Serverless Berbasis AWS Lambda & EventBridge untuk Skala Ekstrem

Globals:
  Function:
    Timeout: 30
    MemorySize: 256
    Runtime: nodejs20.x
    Architectures:
      - arm64

Resources:
  OrderEventBus:
    Type: AWS::Events::EventBus
    Properties:
      Name: CustomOrderEventBus

  OrderTable:
    Type: AWS::DynamoDB::Table
    Properties:
      TableName: OrdersTable
      BillingMode: PAY_PER_REQUEST
      AttributeDefinitions:
        - AttributeName: OrderId
          AttributeType: S
      KeySchema:
        - AttributeName: OrderId
          KeyType: HASH

  IngestFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: src/ingestor/
      Handler: index.handler
      Policies:
        - EventBridgePutEventsPolicy:
            EventBusName: !Ref OrderEventBus
      Environment:
        Variables:
          EVENT_BUS_NAME: !Ref OrderEventBus
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /orders
            Method: post

  ProcessOrderFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: src/processor/
      Handler: index.handler
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref OrderTable
      Events:
        EventBridgeRuleEvent:
          Type: EventBridge
          Properties:
            EventBusName: !Ref OrderEventBus
            Pattern:
              source:
                - "com.ecommerce.orders"
              detail-type:
                - "OrderPlaced"

Outputs:
  ApiUrl:
    Description: "API Gateway endpoint URL"
    Value: !Sub "https://${ServerlessRestApi}.execute-api.${AWS::Region}.amazonaws.com/Prod/orders/"

2. src/ingestor/index.js

const { EventBridgeClient, PutEventsCommand } = require("@aws-sdk/client-eventbridge");
const client = new EventBridgeClient({});

exports.handler = async (event) => {
    try {
        const body = JSON.parse(event.body);
        
        if (!body.orderId || !body.items) {
            return {
                statusCode: 400,
                body: JSON.stringify({ error: "Invalid payload. orderId and items are required.\