Serverless Architecture #

// ✓ Inisialisasi mahal di luar handler — dijalankan sekali saat cold start
// Saat warm start, init sudah selesai

package main

import (
	"context"
	"database/sql"
	"encoding/json"
	"os"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
	_ "github.com/lib/pq"
)

// Variabel global diinisialisasi sekali saat cold start
// ✓ Koneksi database di-reuse antar warm invocations
var (
	db     *sql.DB
	config *AppConfig
)

// init() atau init di level package — berjalan saat container di-init
func init() {
	var err error

	// Load config
	config = loadConfig()

	// Buka koneksi database — mahal, tapi hanya sekali
	db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
	if err != nil {
		panic("gagal koneksi database: " + err.Error())
	}

	// ✓ Set connection pool untuk reuse di warm start
	db.SetMaxOpenConns(5)    // serverless: jangan terlalu banyak koneksi
	db.SetMaxIdleConns(2)
}

// Handler adalah entry point fungsi — diinvokasi setiap request
func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	// ✓ db dan config sudah siap — tidak perlu init ulang
	userID := req.PathParameters["id"]
	if userID == "" {
		return badRequest("user ID wajib diisi"), nil
	}

	var user struct {
		ID       string `json:"id"`
		FullName string `json:"full_name"`
		Email    string `json:"email"`
	}

	err := db.QueryRowContext(ctx,
		`SELECT id, full_name, email FROM users WHERE id = $1`, userID,
	).Scan(&user.ID, &user.FullName, &user.Email)

	if err == sql.ErrNoRows {
		return notFound("user tidak ditemukan"), nil
	}
	if err != nil {
		return serverError("gagal ambil data user"), nil
	}

	body, _ := json.Marshal(user)
	return events.APIGatewayProxyResponse{
		StatusCode: 200,
		Headers:    map[string]string{"Content-Type": "application/json"},
		Body:       string(body),
	}, nil
}

func main() {
	lambda.Start(Handler)
}

func badRequest(msg string) events.APIGatewayProxyResponse {
	return events.APIGatewayProxyResponse{
		StatusCode: 400,
		Body:       `{"error":"` + msg + `"}`,
	}
}

func notFound(msg string) events.APIGatewayProxyResponse {
	return events.APIGatewayProxyResponse{
		StatusCode: 404,
		Body:       `{"error":"` + msg + `"}`,
	}
}

func serverError(msg string) events.APIGatewayProxyResponse {
	return events.APIGatewayProxyResponse{
		StatusCode: 500,
		Body:       `{"error":"` + msg + `"}`,
	}
}

// functions/create_order/main.go — function handler untuk POST /orders
package main

import (
	"context"
	"encoding/json"
	"errors"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

type CreateOrderRequest struct {
	CustomerID string      `json:"customer_id"`
	Items      []OrderItem `json:"items"`
}

type OrderItem struct {
	ProductID  string `json:"product_id"`
	Quantity   int    `json:"quantity"`
	PriceCents int64  `json:"price_cents"`
}

type CreateOrderResponse struct {
	OrderID    string `json:"order_id"`
	TotalCents int64  `json:"total_cents"`
}

func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	var body CreateOrderRequest
	if err := json.Unmarshal([]byte(req.Body), &body); err != nil {
		return badRequest("request body tidak valid"), nil
	}

	// Validasi
	if body.CustomerID == "" {
		return badRequest("customer_id wajib diisi"), nil
	}
	if len(body.Items) == 0 {
		return badRequest("items tidak boleh kosong"), nil
	}

	// Proses order
	orderID, total, err := createOrder(ctx, body)
	if err != nil {
		if errors.Is(err, ErrCustomerNotFound) {
			return notFound("customer tidak ditemukan"), nil
		}
		return serverError("gagal membuat order"), nil
	}

	respBody, _ := json.Marshal(CreateOrderResponse{
		OrderID:    orderID,
		TotalCents: total,
	})

	return events.APIGatewayProxyResponse{
		StatusCode: 201,
		Headers:    map[string]string{"Content-Type": "application/json"},
		Body:       string(respBody),
	}, nil
}

func main() {
	lambda.Start(Handler)
}

// functions/process_payment/main.go — function handler untuk SQS messages
package main

import (
	"context"
	"encoding/json"
	"fmt"
	"log/slog"

	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-lambda-go/lambda"
)

type PaymentTask struct {
	OrderID    string `json:"order_id"`
	AmountCents int64 `json:"amount_cents"`
	Method     string `json:"method"`
}

// Handler dipanggil dengan batch pesan dari SQS
func Handler(ctx context.Context, event events.SQSEvent) (events.SQSEventResponse, error) {
	var failures []events.SQSBatchItemFailure

	for _, msg := range event.Records {
		if err := processMessage(ctx, msg); err != nil {
			slog.ErrorContext(ctx, "gagal proses pesan",
				"message_id", msg.MessageId,
				"error", err,
			)
			// ✓ Laporkan sebagai failure — SQS akan retry message ini
			failures = append(failures, events.SQSBatchItemFailure{
				ItemIdentifier: msg.MessageId,
			})
		}
	}

	// ✓ Partial batch failure — hanya message yang gagal yang di-retry
	return events.SQSEventResponse{BatchItemFailures: failures}, nil
}

func processMessage(ctx context.Context, msg events.SQSMessage) error {
	var task PaymentTask
	if err := json.Unmarshal([]byte(msg.Body), &task); err != nil {
		// ✗ Pesan tidak valid — jangan retry, kirim ke DLQ
		slog.Warn("pesan SQS tidak valid, skip", "message_id", msg.MessageId)
		return nil // return nil agar tidak di-retry
	}

	slog.InfoContext(ctx, "memproses pembayaran",
		"order_id", task.OrderID,
		"amount_cents", task.AmountCents,
	)

	return processPayment(ctx, task)
}

func main() {
	lambda.Start(Handler)
}

// functions/cleanup_expired_sessions/main.go — CloudWatch Events trigger
package main

import (
	"context"
	"database/sql"
	"log/slog"
	"time"

	"github.com/aws/aws-lambda-go/lambda"
)

var db *sql.DB

func init() {
	// Init DB connection
}

type ScheduledEvent struct {
	Source     string `json:"source"`
	DetailType string `json:"detail-type"`
}

func Handler(ctx context.Context, event ScheduledEvent) error {
	slog.InfoContext(ctx, "memulai cleanup expired sessions")

	cutoff := time.Now().Add(-24 * time.Hour)
	result, err := db.ExecContext(ctx,
		`DELETE FROM sessions WHERE expires_at < $1`, cutoff,
	)
	if err != nil {
		return err
	}

	rows, _ := result.RowsAffected()
	slog.InfoContext(ctx, "cleanup selesai", "deleted_count", rows)
	return nil
}

func main() {
	lambda.Start(Handler)
}

// Contoh: upload file + simpan metadata (stateless, semua di external store)
func HandleFileUpload(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	// Decode file dari request body (base64)
	fileData, err := base64.StdEncoding.DecodeString(req.Body)
	if err != nil {
		return badRequest("file tidak valid"), nil
	}

	// Simpan ke S3 — external storage
	fileName := generateFileName()
	if err := uploadToS3(ctx, fileName, fileData); err != nil {
		return serverError("gagal upload file"), nil
	}

	// Simpan metadata ke DynamoDB — external state
	metadata := FileMetadata{
		FileID:    fileName,
		UserID:    req.RequestContext.Authorizer["userId"].(string),
		Size:      len(fileData),
		CreatedAt: time.Now().Unix(),
	}
	if err := saveMetadata(ctx, metadata); err != nil {
		return serverError("gagal simpan metadata"), nil
	}

	// Kirim event untuk processing asinkron (resize, virus scan, dll)
	if err := sendToSQS(ctx, ProcessFileTask{FileID: fileName}); err != nil {
		slog.Warn("gagal kirim ke SQS", "file_id", fileName)
	}

	body, _ := json.Marshal(map[string]string{"file_id": fileName})
	return events.APIGatewayProxyResponse{StatusCode: 201, Body: string(body)}, nil
}

// ✗ ANTI-PATTERN: business logic langsung bergantung ke AWS SDK
package main

import (
	"github.com/aws/aws-lambda-go/events"
	"github.com/aws/aws-sdk-go-v2/service/dynamodb"
)

func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	// ✗ Business logic di dalam handler yang tightly coupled ke AWS
	client := dynamodb.NewFromConfig(awsConfig)
	item, err := client.GetItem(ctx, &dynamodb.GetItemInput{
		TableName: aws.String("users"),
		Key: map[string]types.AttributeValue{
			"id": &types.AttributeValueMemberS{Value: req.PathParameters["id"]},
		},
	})
	// ... process item
}

// ✓ BENAR: Pisahkan business logic dari adapter platform
// Adapter mudah diganti tanpa menyentuh business logic

// core/user_service.go — business logic murni, tidak ada AWS dependency
package core

type UserRepository interface {
	GetByID(ctx context.Context, id string) (*User, error)
}

type UserService struct {
	repo UserRepository
}

func (s *UserService) GetUser(ctx context.Context, id string) (*User, error) {
	if id == "" {
		return nil, errors.New("ID tidak boleh kosong")
	}
	return s.repo.GetByID(ctx, id)
}

// adapter/dynamo/user_repo.go — AWS-specific adapter
package dynamo

type DynamoUserRepo struct {
	client *dynamodb.Client
	table  string
}

func (r *DynamoUserRepo) GetByID(ctx context.Context, id string) (*core.User, error) {
	// AWS DynamoDB specific code di sini
}

// handler/lambda/user_handler.go — AWS Lambda adapter tipis
package lambda_handler

import (
	"github.com/aws/aws-lambda-go/events"
)

var svc *core.UserService // diinisialisasi di init()

func GetUserHandler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	id := req.PathParameters["id"]
	user, err := svc.GetUser(ctx, id) // ✓ panggil business logic
	// ... format response
}

# template.yaml — AWS SAM template
AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31

Globals:
  Function:
    Runtime: provided.al2023   # Go on AWS Lambda ARM
    Architectures: [arm64]
    Timeout: 30
    MemorySize: 256
    Environment:
      Variables:
        DATABASE_URL: !Sub '{{resolve:ssm:/myapp/${Env}/database_url}}'
    Tracing: Active            # ✓ X-Ray tracing otomatis

Resources:
  # GET /users/{id}
  GetUserFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/get_user/
      Handler: bootstrap
      Events:
        GetUser:
          Type: Api
          Properties:
            Path: /users/{id}
            Method: GET

  # POST /orders
  CreateOrderFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/create_order/
      Handler: bootstrap
      Events:
        CreateOrder:
          Type: Api
          Properties:
            Path: /orders
            Method: POST

  # SQS Consumer
  ProcessPaymentFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/process_payment/
      Handler: bootstrap
      Events:
        SQSQueue:
          Type: SQS
          Properties:
            Queue: !GetAtt PaymentQueue.Arn
            BatchSize: 10
            FunctionResponseTypes:
              - ReportBatchItemFailures  # ✓ partial batch failure

  PaymentQueue:
    Type: AWS::SQS::Queue
    Properties:
      VisibilityTimeout: 90
      RedrivePolicy:
        deadLetterTargetArn: !GetAtt PaymentDLQ.Arn
        maxReceiveCount: 3

  PaymentDLQ:
    Type: AWS::SQS::Queue

  # Scheduled cleanup setiap hari jam 2 pagi
  CleanupFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: functions/cleanup_sessions/
      Handler: bootstrap
      Events:
        DailyCleanup:
          Type: Schedule
          Properties:
            Schedule: cron(0 2 * * ? *)

// ✗ Menyimpan state di variabel yang dimodifikasi antar invokasi
var requestCount int // ✗ variabel ini mungkin di-share antar invocation
                    // atau di-reset saat cold start — tidak reliable

func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (...) {
	requestCount++ // ✗ state ini tidak konsisten antar invocations
}

// ✓ State yang perlu persisten harus disimpan ke external store
func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (...) {
	// ✓ update counter di DynamoDB atau Redis — konsisten dan scalable
	incrementRequestCount(ctx, "my-api")
}

// ✗ Koneksi database dibuat ulang setiap invokasi
func Handler(ctx context.Context, ...) (...) {
	db, _ := sql.Open("postgres", os.Getenv("DATABASE_URL")) // ✗ mahal!
	defer db.Close()
	// ...
}

// ✓ Koneksi database di-init sekali di package level
var db *sql.DB
func init() {
	db, _ = sql.Open("postgres", os.Getenv("DATABASE_URL")) // ✓ sekali
}

// ✗ Fungsi yang terlalu besar — melakukan terlalu banyak hal
func HandleEverything(ctx context.Context, req events.APIGatewayProxyRequest) (...) {
	// ✗ handle semua endpoint dalam satu function
	switch req.Path {
	case "/users":
		handleUsers(ctx, req)
	case "/orders":
		handleOrders(ctx, req)
	case "/payments":
		handlePayments(ctx, req)
	}
}

// ✓ Satu fungsi = satu tanggung jawab
// get_user/main.go hanya handle GET /users/{id}
// create_order/main.go hanya handle POST /orders

// ✗ Long-running process di Lambda
func Handler(ctx context.Context, ...) (...) {
	// ✗ proses yang butuh 20 menit — akan timeout di Lambda (max 15 menit)
	processLargeDataset(ctx) // loop jutaan record
}

// ✓ Pecah ke job kecil via SQS
func Handler(ctx context.Context, ...) (...) {
	// ✓ kirim setiap batch ke SQS untuk diproses secara paralel
	batches := splitDatasetIntoBatches(dataset, 1000)
	for _, batch := range batches {
		sendToSQS(ctx, ProcessBatchTask{Records: batch})
	}
}