Membangun Serverless REST API dengan AWS API Gateway dan Lambda

Memahami Peran API Gateway dan Lambda dalam REST API Serverless

Sebelum era serverless, membangun REST API berarti kita harus menyediakan server sendiri — memilih instance EC2, mengatur kapasitas, dan menyiapkan strategi scaling. Pendekatan ini membawa tantangan tersendiri: provisioning yang lambat, biaya idle untuk resource yang tidak terpakai, dan beban operasional untuk menjaga server tetap hidup.

Serverless architecture mengubah paradigma ini secara fundamental. Kita tidak lagi memikirkan server; kita hanya fokus pada kode dan konfigurasi layanan yang menghubungkannya.

API Gateway bertindak sebagai managed entry point untuk semua request HTTP yang masuk. Layanan ini menangani routing dari endpoint URL ke function yang sesuai, throttling untuk melindungi backend dari lonjakan traffic, serta authentication melalui API Keys atau Amazon Cognito. Ketika sebuah request masuk, API Gateway memvalidasi format, memeriksa authorization, dan meneruskannya ke target.

AWS Lambda adalah compute layer yang mengeksekusi kode secara event-driven. Function Lambda hanya berjalan ketika dipanggil dan scale secara otomatis dari nol hingga ribuan eksekusi paralel. Model pricing-nya berbasis per-execution dan duration — kita hanya membayar ketika kode benar-benar berjalan.

Alur request pada arsitektur ini sangat sederhana: klien mengirim HTTP request ke endpoint API Gateway, API Gateway memetakan request tersebut ke function Lambda tertentu berdasarkan resource path dan HTTP method, function Lambda memproses logika bisnis dan mengembalikan response, lalu API Gateway meneruskan response kembali ke klien. Tidak ada server yang perlu kita restart, tidak ada kapasitas yang perlu kita perkirakan.

Gambar: Arsitektur API Gateway sebagai "front door" untuk aplikasi serverless yang terintegrasi dengan Lambda dan backend services — Sumber: [AWS Documentation](https://docs.aws.amazon.com/apigateway/latest/developerguide/welcome.html)

Mendefinisikan Infrastruktur API Gateway dan Lambda dengan AWS CDK

Mendefinisikan resource AWS secara manual melalui konsol memang cepat untuk eksperimen awal, tetapi untuk lingkungan yang reprodusibel dan version-controlled, kita membutuhkan Infrastructure as Code. AWS CDK (Cloud Development Kit) memungkinkan kita mendefinisikan resource cloud menggunakan bahasa pemrograman seperti TypeScript atau Python.

Berikut adalah contoh stack CDK yang mendefinisikan REST API dengan endpoint /items, function Lambda untuk menangani request, serta tabel DynamoDB sebagai persistent storage:

import * as cdk from 'aws-cdk-lib';
import * as apigateway from 'aws-cdk-lib/aws-apigateway';
import * as lambda from 'aws-cdk-lib/aws-lambda';
import * as dynamodb from 'aws-cdk-lib/aws-dynamodb';

export class ServerlessApiStack extends cdk.Stack {
  constructor(scope: cdk.App, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const table = new dynamodb.Table(this, 'ItemsTable', {
      partitionKey: { name: 'id', type: dynamodb.AttributeType.STRING },
      billingMode: dynamodb.BillingMode.PAY_PER_REQUEST,
    });

    const handler = new lambda.Function(this, 'ItemHandler', {
      runtime: lambda.Runtime.PYTHON_3_12,
      handler: 'index.lambda_handler',
      code: lambda.Code.fromAsset('lambda'),
      environment: { TABLE_NAME: table.tableName },
    });

    table.grantReadWriteData(handler);

    const api = new apigateway.RestApi(this, 'ItemsApi', {
      restApiName: 'Items Service',
    });

    const itemsResource = api.root.addResource('items');
    itemsResource.addMethod('GET', new apigateway.LambdaIntegration(handler));
    itemsResource.addMethod('POST', new apigateway.LambdaIntegration(handler));

    const itemResource = itemsResource.addResource('{id}');
    itemResource.addMethod('GET', new apigateway.LambdaIntegration(handler));
    itemResource.addMethod('DELETE', new apigateway.LambdaIntegration(handler));
  }
}

Kode di atas mendefinisikan tabel DynamoDB dengan pay-per-request billing — ideal untuk beban kerja serverless yang tidak menentu. Function Lambda dikonfigurasi dengan runtime Python dan diberikan akses read/write ke tabel melalui method grantReadWriteData. Resource API Gateway dipetakan ke method HTTP yang sesuai: GET /items untuk mengambil semua item, POST /items untuk membuat item baru, GET /items/{id} untuk mengambil satu item, dan DELETE /items/{id} untuk menghapus item.

Untuk mendeploy stack ini, jalankan perintah cdk synth untuk menghasilkan template CloudFormation, cdk bootstrap untuk menyiapkan environment, dan cdk deploy untuk menerapkan resource ke akun AWS.

Menulis Lambda Handler untuk Operasi CRUD dengan DynamoDB

Setelah infrastruktur siap, kita perlu menulis function Lambda yang akan menangani logika CRUD. Function ini menerima event dari API Gateway yang berisi informasi HTTP method, path parameters, dan request body.

import json
import boto3
import os

dynamodb = boto3.resource('dynamodb')
table = dynamodb.Table(os.environ['TABLE_NAME'])

def lambda_handler(event, context):
    http_method = event['httpMethod']
    path_params = event.get('pathParameters') or {}

    if http_method == 'GET' and path_params.get('id'):
        return get_item(path_params['id'])
    elif http_method == 'GET':
        return list_items()
    elif http_method == 'POST':
        return create_item(json.loads(event['body']))
    elif http_method == 'DELETE' and path_params.get('id'):
        return delete_item(path_params['id'])

    return respond(400, {'error': 'Unsupported method'})

def get_item(item_id):
    response = table.get_item(Key={'id': item_id})
    item = response.get('Item')
    if not item:
        return respond(404, {'error': 'Item not found'})
    return respond(200, item)

def list_items():
    response = table.scan()
    return respond(200, {'items': response.get('Items', [])})

def create_item(data):
    table.put_item(Item=data)
    return respond(201, data)

def delete_item(item_id):
    table.delete_item(Key={'id': item_id})
    return respond(200, {'message': 'Item deleted'})

def respond(status_code, body):
    return {
        'statusCode': status_code,
        'headers': {
            'Content-Type': 'application/json',
            'Access-Control-Allow-Origin': '*'
        },
        'body': json.dumps(body)
    }

Function lambda_handler menjadi entry point yang menerima dua parameter: event dan context. Objek event berisi semua informasi request dari API Gateway — kita membaca httpMethod, pathParameters, dan body untuk menentukan operasi yang harus dijalankan. Library boto3 sudah tersedia di runtime Lambda, sehingga tidak perlu install tambahan.

Setiap operasi CRUD dikemas dalam function terpisah untuk menjaga readability. Function get_item menggunakan method get_item DynamoDB yang mengembalikan item berdasarkan primary key — jika tidak ditemukan, kita kembalikan status 404. Function list_items menggunakan scan untuk mengambil semua data (cocok untuk dataset kecil). Function create_item menggunakan put_item yang akan membuat item baru atau menimpa item yang sudah ada dengan key yang sama. Function delete_item menggunakan delete_item untuk menghapus data.

Response dikembalikan dalam format standar yang terdiri dari statusCode, headers (termasuk CORS header), dan body dalam format JSON.

Deployment Stages, Testing Endpoint, dan Menangani CORS

Setelah kode siap, API Gateway menyediakan konsep deployment stages untuk memisahkan environment. Kita dapat membuat stage dev, staging, dan production, masing-masing dengan URL endpoint yang berbeda. Fitur ini memungkinkan kita menguji perubahan di environment terisolasi sebelum mempromosikannya ke production.

Untuk menguji endpoint, kita bisa menggunakan curl atau Postman. Berikut contoh pengujian dengan curl:

# Membuat item baru
curl -X POST https://your-api-id.execute-api.region.amazonaws.com/dev/items \
  -H "Content-Type: application/json" \
  -d '{"id": "001", "name": "Serverless Book", "price": 10}'

# Mengambil semua item
curl https://your-api-id.execute-api.region.amazonaws.com/dev/items

# Mengambil satu item
curl https://your-api-id.execute-api.region.amazonaws.com/dev/items/001

# Menghapus item
curl -X DELETE https://your-api-id.execute-api.region.amazonaws.com/dev/items/001

CORS (Cross-Origin Resource Sharing) menjadi perhatian penting ketika API kita diakses dari aplikasi frontend yang berbeda domain. API Gateway membutuhkan konfigurasi khusus: kita perlu menambahkan method OPTIONS yang mengembalikan header Access-Control-Allow-Origin, Access-Control-Allow-Methods, dan Access-Control-Allow-Headers. Dalam CDK, kita dapat mengaktifkan CORS melalui properti defaultCorsPreflightOptions pada definisi REST API.

Untuk debugging, CloudWatch Logs mencatat setiap invocation Lambda secara detail — termasuk log dari statement print() atau logging library, durasi eksekusi, dan memory yang digunakan. Pastikan IAM role Lambda memiliki permission logs:CreateLogGroup, logs:CreateLogStream, dan logs:PutLogEvents.

Best Practices Keamanan, Monitoring, dan Optimasi Biaya

Membangun API serverless tidak berhenti pada deployment. Kita perlu menerapkan praktik keamanan, monitoring, dan optimasi biaya untuk memastikan sistem berjalan andal dan efisien.

IAM Least Privilege adalah prinsip keamanan paling penting. Function Lambda sebaiknya hanya memiliki akses ke resource yang spesifik — misalnya, hanya ke tabel DynamoDB tertentu, bukan ke semua tabel. Dalam CDK, method grantReadWriteData sudah menerapkan prinsip ini secara otomatis dengan menghasilkan policy yang terbatas pada satu tabel.

API Keys dan Usage Plans melindungi API dari akses tidak sah dan penyalahgunaan. API Gateway mendukung rate limiting hingga level request per detik, serta quota bulanan untuk setiap API key. Fitur ini sangat berguna untuk API publik yang memiliki banyak konsumen.

CloudWatch Metrics memberikan visibilitas penuh terhadap performa API: jumlah invocations, error count, latency rata-rata, dan throttle count. Kita bisa mengatur CloudWatch Alarm untuk menerima notifikasi ketika error rate melebihi threshold tertentu.

Cold start adalah jeda inisialisasi yang terjadi ketika Lambda menjalankan function yang sudah lama tidak dipanggil. Cold start pada Lambda mirip seperti menghidupkan mesin mobil — ada jeda inisialisasi runtime sebelum dapat mengeksekusi function. Untuk aplikasi latency-sensitive, kita dapat menggunakan Provisioned Concurrency yang menjaga sejumlah lingkungan eksekusi tetap hangat, meskipun ada biaya tambahan.

Optimasi biaya serverless bergantung pada dua faktor utama: duration dan memory allocation. Meningkatkan memory Lambda sering kali mempercepat eksekusi secara linear, sehingga total biaya per-invocation bisa tetap sama atau bahkan lebih rendah. API Gateway sendiri dikenakan biaya per-juta request, dengan tier gratis 1 juta request per bulan untuk tahun pertama.

Serverless REST API dengan AWS API Gateway dan Lambda memberikan fleksibilitas dan skalabilitas yang sulit ditandingi arsitektur tradisional. Kita bisa membangun dan mendeploy API production-grade tanpa mengelola infrastruktur server sama sekali.

Tertarik menguasai deployment serverless production-grade dengan studi kasus nyata? Bergabunglah dengan program Cloud & DevOps di Rumah Coding — kami membahas arsitektur cloud end-to-end, dari infrastruktur hingga monitoring, dengan proyek langsung yang siap portofolio.