Serverless Architecture #

// ✓ Expensive initialization outside the handler — runs once during cold start
// On warm starts, the initialization is already done

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

// Global variables initialized once during cold start
// ✓ Database connections are reused across warm invocations
var (
	db     *sql.DB
	config *AppConfig
)

// init() or package-level init — runs when the container is initialized
func init() {
	var err error

	// Load config
	config = loadConfig()

	// Open the database connection — expensive, but only once
	db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
	if err != nil {
		panic("database connection failed: " + err.Error())
	}

	// ✓ Set the connection pool for reuse on warm starts
	db.SetMaxOpenConns(5)    // serverless: do not keep too many connections
	db.SetMaxIdleConns(2)
}

// Handler is the function entry point — invoked on every request
func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	// ✓ db and config are ready — no need to reinitialize
	userID := req.PathParameters["id"]
	if userID == "" {
		return badRequest("user ID is required"), 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 not found"), nil
	}
	if err != nil {
		return serverError("failed to fetch user data"), 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 for 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("invalid request body"), nil
	}

	// Validation
	if body.CustomerID == "" {
		return badRequest("customer_id is required"), nil
	}
	if len(body.Items) == 0 {
		return badRequest("items must not be empty"), nil
	}

	// Process the order
	orderID, total, err := createOrder(ctx, body)
	if err != nil {
		if errors.Is(err, ErrCustomerNotFound) {
			return notFound("customer not found"), nil
		}
		return serverError("failed to create 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 for 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 is invoked with a batch of messages from 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, "failed to process message",
				"message_id", msg.MessageId,
				"error", err,
			)
			// ✓ Report as a failure — SQS will retry this message
			failures = append(failures, events.SQSBatchItemFailure{
				ItemIdentifier: msg.MessageId,
			})
		}
	}

	// ✓ Partial batch failure — only failed messages are retried
	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 {
		// ✗ Invalid message — do not retry, send to the DLQ
		slog.Warn("invalid SQS message, skipping", "message_id", msg.MessageId)
		return nil // return nil so it is not retried
	}

	slog.InfoContext(ctx, "processing payment",
		"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, "starting cleanup of 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 finished", "deleted_count", rows)
	return nil
}

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

// Example: upload a file + store metadata (stateless, all in external stores)
func HandleFileUpload(ctx context.Context, req events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
	// Decode the file from the request body (base64)
	fileData, err := base64.StdEncoding.DecodeString(req.Body)
	if err != nil {
		return badRequest("invalid file"), nil
	}

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

	// Store metadata to 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("failed to save metadata"), nil
	}

	// Send an event for asynchronous processing (resize, virus scan, etc.)
	if err := sendToSQS(ctx, ProcessFileTask{FileID: fileName}); err != nil {
		slog.Warn("failed to send to 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 directly depending on the 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 inside a handler tightly coupled to 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
}

// ✓ CORRECT: Separate business logic from the platform adapter
// The adapter is easy to swap without touching business logic

// core/user_service.go — pure business logic, no AWS dependencies
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 must not be empty")
	}
	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 here
}

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

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

var svc *core.UserService // initialized in init()

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

// ✗ Storing state in variables modified between invocations
var requestCount int // ✗ this variable may be shared between invocations
                    // or reset at cold start — not reliable

func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (...) {
	requestCount++ // ✗ this state is inconsistent between invocations
}

// ✓ State that must persist goes into an external store
func Handler(ctx context.Context, req events.APIGatewayProxyRequest) (...) {
	// ✓ update the counter in DynamoDB or Redis — consistent and scalable
	incrementRequestCount(ctx, "my-api")
}

// ✗ Database connections recreated on every invocation
func Handler(ctx context.Context, ...) (...) {
	db, _ := sql.Open("postgres", os.Getenv("DATABASE_URL")) // ✗ expensive!
	defer db.Close()
	// ...
}

// ✓ Database connections initialized once at the package level
var db *sql.DB
func init() {
	db, _ = sql.Open("postgres", os.Getenv("DATABASE_URL")) // ✓ once
}

// ✗ Functions that are too large — doing too many things
func HandleEverything(ctx context.Context, req events.APIGatewayProxyRequest) (...) {
	// ✗ handle all endpoints in one function
	switch req.Path {
	case "/users":
		handleUsers(ctx, req)
	case "/orders":
		handleOrders(ctx, req)
	case "/payments":
		handlePayments(ctx, req)
	}
}

// ✓ One function = one responsibility
// get_user/main.go only handles GET /users/{id}
// create_order/main.go only handles POST /orders

// ✗ Long-running processes in Lambda
func Handler(ctx context.Context, ...) (...) {
	// ✗ a process needing 20 minutes — will time out in Lambda (max 15 minutes)
	processLargeDataset(ctx) // loop over millions of records
}

// ✓ Split into small jobs via SQS
func Handler(ctx context.Context, ...) (...) {
	// ✓ send each batch to SQS for parallel processing
	batches := splitDatasetIntoBatches(dataset, 1000)
	for _, batch := range batches {
		sendToSQS(ctx, ProcessBatchTask{Records: batch})
	}
}