Serverless #

// Go: cold-start mitigation — initialize AWS clients ONCE at package scope
// Anti-pattern: creating clients inside the handler (runs on every invocation)
package main

import (
    "context"
    "encoding/json"
    "fmt"
    "os"
    "sync"

    "github.com/aws/aws-sdk-go-v2/aws"
    "github.com/aws/aws-sdk-go-v2/service/dynamodb"
    "github.com/aws/aws-sdk-go-v2/service/s3"
)

// ✗ Anti-pattern: expensive initialization inside the handler
func handlerBad(ctx context.Context, event map[string]any) error {
    dbClient := dynamodb.NewFromConfig(cfg) // overhead on every call
    s3Client := s3.NewFromConfig(cfg)
    config := loadConfigFromS3(ctx, s3Client) // a network call every time!
    _ = dbClient
    // ... process the event ...
    return nil
}

// ✓ Correct: clients initialized ONCE at package scope (global scope)
// Executed once at cold start, reused across warm invocations
var (
    cfg      aws.Config
    dbClient *dynamodb.Client
    s3Client *s3.Client
    config   *AppConfig // lazy load
)

func init() {
    cfg = loadAWSConfig()
    dbClient = dynamodb.NewFromConfig(cfg)
    s3Client = s3.NewFromConfig(cfg)
}

var configOnce sync.Once

func getConfig(ctx context.Context) *AppConfig {
    configOnce.Do(func() {
        out, err := s3Client.GetObject(ctx, &s3.GetObjectInput{
            Bucket: aws.String("config"), Key: aws.String("app.json"),
        })
        if err != nil {
            return
        }
        defer out.Body.Close()
        config = &AppConfig{}
        _ = json.NewDecoder(out.Body).Decode(config)
    })
    return config
}

func handler(ctx context.Context, event map[string]any) error {
    // Handler runs on every invocation, but dbClient/s3Client already exist
    cfg := getConfig(ctx) // only loads the first time per container
    // ... process the event using the existing clients ...
    return processEvent(ctx, event, cfg, dbClient)
}

func loadAWSConfig() aws.Config      { return aws.Config{} }
func loadConfigFromS3(ctx context.Context, c *s3.Client) string { return "" }
func processEvent(ctx context.Context, e map[string]any, c *AppConfig, d *dynamodb.Client) error { return nil }
type AppConfig struct{ URL string }

// Other cold start mitigation techniques:

// 1. Reduce the deployment package size
// Smaller packages → faster downloads → shorter cold starts
// requirements.txt: only include what's truly needed
// Use Lambda Layers for rarely-changing dependencies

// 2. Provisioned Concurrency (AWS Lambda)
// Pre-warm N containers before requests arrive
// Pay extra but cold starts are eliminated for predictable traffic
// aws lambda put-provisioned-concurrency-config \
//     --function-name my-function \
//     --qualifier LIVE \
//     --provisioned-concurrent-executions 5

// 3. Scheduled pings for keep-alive (cheap workaround)
// CloudWatch Events every 5 minutes → invoke the Lambda
// → Containers stay warm
// But this doesn't scale for functions needing many concurrent instances

// 4. Choose runtimes with faster cold starts
// Cold start ranking (fastest first):
// Go/Rust > Node.js ≈ Python > C# > Java
// For latency-sensitive functions, avoid Java without GraalVM native images

// Go: stateless by design — all state lives in external storage
// Anti-pattern: storing state in container memory

// ✗ Anti-pattern: storing state in container memory
// This state is inconsistent across invocations!
var requestCounter = 0 // container A: 5, container B: 3, container C: 0

func handlerBad(ctx context.Context, event map[string]any) {
    requestCounter++
    // requestCounter differs in every container
    // Can't be relied on for anything
}

// ✓ Correct: all state in external storage
// For accurate counters (DynamoDB atomic ADD)
func incrementRequestCounter(ctx context.Context, functionName string) (int64, error) {
    out, err := dbClient.UpdateItem(ctx, &dynamodb.UpdateItemInput{
        TableName: aws.String("counters"),
        Key:       map[string]types.AttributeValue{"name": &types.AttributeValueMemberS{Value: functionName}},
        UpdateExpression:          aws.String("ADD #count :one"),
        ExpressionAttributeNames:  map[string]string{"#count": "count"},
        ExpressionAttributeValues: map[string]types.AttributeValue{":one": &types.AttributeValueMemberN{Value: "1"}},
        ReturnValues:              types.ReturnValueUpdatedNew,
    })
    if err != nil {
        return 0, err
    }
    return out.Attributes["count"].(*types.AttributeValueMemberN).Value, nil
}

// For sessions/cache (Redis)
var redisClient = redis.NewClient(&redis.Options{
    Addr: os.Getenv("REDIS_HOST") + ":6379",
})

func handler(ctx context.Context, event map[string]any) {
    // State always from external storage
    counter, _ := incrementRequestCounter(ctx, "my-function")
    session, _ := redisClient.Get(ctx, "session:"+event["session_id"].(string)).Result()
    _ = counter
    _ = session
    // ... process ...
}

// Go: example Lambda functions handling various triggers

// 1. HTTP requests via API Gateway
func apiHandler(ctx context.Context, event map[string]any) (map[string]any, error) {
    // Handler for HTTP requests.
    path := event["path"].(string)
    method := event["httpMethod"].(string)
    body := map[string]any{}
    if raw, ok := event["body"].(string); ok && raw != "" {
        _ = json.Unmarshal([]byte(raw), &body)
    }

    if method == "POST" && path == "/orders" {
        return createOrder(ctx, body)
    }

    return map[string]any{
        "statusCode": 404,
        "body":       `{"error": "Not found"}`,
    }, nil
}

// 2. S3 events — when files are uploaded
func s3EventHandler(ctx context.Context, event map[string]any) {
    // Process newly uploaded files.
    for _, rec := range event["Records"].([]any) {
        r := rec.(map[string]any)
        bucket := r["s3"].(map[string]any)["bucket"].(map[string]any)["name"].(string)
        key := r["s3"].(map[string]any)["object"].(map[string]any)["key"].(string)

        // Process the file: resize images, parse CSVs, scan viruses, etc.
        processUploadedFile(ctx, bucket, key)
    }
}

// 3. SQS queues — process messages from queues
func sqsHandler(ctx context.Context, event map[string]any) (map[string]any, error) {
    // Process messages from an SQS queue.
    failed := []map[string]string{}

    for _, rec := range event["Records"].([]any) {
        r := rec.(map[string]any)
        messageID := r["messageId"].(string)
        var body map[string]any
        _ = json.Unmarshal([]byte(r["body"].(string)), &body)

        if err := processMessage(ctx, body); err != nil {
            // Mark as failed — will return to the queue or go to the DLQ
            failed = append(failed, map[string]string{"itemIdentifier": messageID})
        }
    }

    // Return batch item failures — only the failed ones get retried
    return map[string]any{"batchItemFailures": failed}, nil
}

// 4. CloudWatch Events (scheduled)
func scheduledHandler(ctx context.Context, event map[string]any) (map[string]any, error) {
    // Runs every day at 08:00.
    sendDailyReport(ctx)
    cleanupExpiredSessions(ctx)
    return map[string]any{"status": "completed"}, nil
}

// 5. DynamoDB Streams — react to database changes
func dynamodbStreamHandler(ctx context.Context, event map[string]any) {
    // Triggered when new or changed records appear in DynamoDB.
    for _, rec := range event["Records"].([]any) {
        r := rec.(map[string]any)
        if r["eventName"] == "INSERT" {
            newItem := r["dynamodb"].(map[string]any)["NewImage"].(map[string]any)
            userID := newItem["user_id"].(map[string]any)["S"].(string)
            sendWelcomeEmail(ctx, userID)
        }
    }
}

// Go: best practices for Lambda observability
// Structured logging — easier to parse in CloudWatch Logs Insights
package main

import (
    "encoding/json"
    "log"
    "time"
)

func logEvent(eventType string, fields map[string]any) {
    // Log structured events for observability.
    entry := map[string]any{"event_type": eventType, "timestamp": time.Now().Unix()}
    for k, v := range fields {
        entry[k] = v
    }
    log.Println(string(mustJSON(entry)))
}

// tracedHandler — wrapper (the Go equivalent of a decorator) for tracing and error handling
func tracedHandler(handler func(event, context any) (any, error)) func(event, context any) (any, error) {
    return func(event, context any) (any, error) {
        startTime := time.Now()

        // Log invocation metadata
        logEvent("invocation_start", map[string]any{
            "function_name":     context.(map[string]any)["function_name"],
            "request_id":        context.(map[string]any)["request_id"],
            "remaining_time_ms": context.(map[string]any)["remaining_time_ms"],
            "memory_limit_mb":   context.(map[string]any)["memory_limit_mb"],
        })

        result, err := handler(event, context)

        durationMs := time.Since(startTime).Milliseconds()
        if err != nil {
            logEvent("invocation_error", map[string]any{
                "error_type":    fmt.Sprintf("%T", err),
                "error_message": err.Error(),
                "duration_ms":   durationMs,
                "request_id":    context.(map[string]any)["request_id"],
            })
            return nil, err // re-raise so Lambda knows this was an error
        }

        logEvent("invocation_success", map[string]any{
            "duration_ms": durationMs,
            "request_id":  context.(map[string]any)["request_id"],
        })
        return result, nil
    }
}

var handler = tracedHandler(func(event, context any) (any, error) {
    // The main handler function
    return nil, nil
})

// Go: AWS X-Ray for distributed tracing
import (
    "context"

    "github.com/aws/aws-xray-sdk-go/xray"
)

func init() {
    // Patch all AWS SDK calls for auto-tracing
    xray.Configure(xray.Config{})
}

// processOrder — this function appears as a subsegment in X-Ray traces
func processOrder(ctx context.Context, orderData map[string]any) (map[string]any, error) {
    ctx, seg := xray.BeginSubsegment(ctx, "process_order")
    defer seg.Close(nil)
    seg.AddAnnotation("order.id", orderData["id"])
    seg.AddAnnotation("order.total", orderData["total"])

    ctx, sub := xray.BeginSubsegment(ctx, "validate_order")
    err := validateOrder(ctx, orderData)
    sub.Close(err)
    if err != nil {
        return nil, err
    }

    ctx, sub2 := xray.BeginSubsegment(ctx, "save_to_database")
    order, err := saveOrder(ctx, orderData)
    sub2.AddMetadata("saved_order", order)
    sub2.Close(err)

    return order, err
}

// Go: anti-patterns
// ✗ Anti-pattern 1: expensive initialization inside the handler
func handlerBad(ctx context.Context, event map[string]any) {
    db := connectDatabase(ctx) // a new connection every invocation!
    config := loadFromS3(ctx)  // a network call every invocation!
}

// ✓ Solution: global scope for reusable initialization
var (
    db     = connectDatabase(nil) // once per container
    config = loadFromS3(nil)      // once per container
)

func handler(ctx context.Context, event map[string]any) {
    // reused from the global scope
    process(ctx, event, db, config)
}

// ✗ Anti-pattern 2: storing state in /tmp and relying on its persistence
func handlerTmp(ctx context.Context, event map[string]any) {
    os.WriteFile("/tmp/data.json", data, 0644)
    // The next invocation may use a different container — the file doesn't exist!
}

// ✓ Solution: use S3 or databases for persistent state

// ✗ Anti-pattern 3: timeouts too short without retry logic
// Default Lambda timeout: 3 seconds
// If the downstream service is slow → timeout before finishing
// ✓ Solution: set realistic timeouts + implement retries in SQS

// ✗ Anti-pattern 4: no Dead Letter Queues
// Failed messages → lost forever
// ✓ Solution: always configure DLQs for SQS consumers and async invocations

// ✗ Anti-pattern 5: concurrency not limited for downstream protection
// Lambdas scaling to thousands of concurrent executions → flooding databases or third-party APIs
// ✓ Solution: set reservedConcurrency or use SQS for natural throttling

// ✗ Anti-pattern 6: functions doing too much (monolithic Lambdas)
// One function handling everything: auth + business logic + data access + notifications
// ✓ Solution: single responsibility per function, composition via events/messages