Serverless Go Applications

Consider running a restaurant kitchen. Instead of hiring full-time chefs who sit around when there are no customers, you hire freelance chefs who appear instantly when orders come in, cook the food, and disappear when done. You only pay for the actual cooking time! This is exactly how serverless computing works - your code appears on demand, executes, and you only pay for the exact execution time.

Serverless computing allows you to run code without managing servers. This article covers deploying Go applications as serverless functions on AWS Lambda, Knative, and other platforms with production-ready patterns.

Introduction to Serverless

Serverless computing provides automatic scaling, pay-per-use pricing, and zero server management. It represents the highest level of abstraction in cloud-native computing - you write code, the platform handles everything else.

💡 Key Takeaway: Serverless isn't actually "no servers" - it's "no server management." The cloud provider handles all infrastructure, patching, scaling, and availability. You focus purely on business logic.

Why Serverless in Cloud-Native

Traditional Cloud-Native:

You manage: Container images, deployments, replicas, resource limits, autoscaling policies
Platform manages: Hardware, networking, orchestration

Serverless:

You manage: Just your code
Platform manages: Everything else - scaling, availability, infrastructure, runtime

When Serverless Makes Sense:

• Event-driven workloads: Respond to S3 uploads, database changes, API requests
• Variable load: Traffic spikes from 0 to 1000 requests/sec unpredictably
• Cost optimization: Workloads that run infrequently
• Fast iteration: Ship features without infrastructure complexity

Real-World Example: A photo processing service that generates thumbnails when users upload images. With serverless, you pay nothing when no photos are being uploaded, but can instantly handle thousands of concurrent uploads during peak hours.

Cloud-Native Serverless Benefits:

• Automatic scaling from zero: Scale down to zero during idle periods, scale up to handle millions of requests
• Built-in fault tolerance: Platform automatically retries, handles failures, distributes across AZs
• Focus on business logic: No Dockerfiles, Kubernetes manifests, or infrastructure code needed
• Regional availability: Deploy globally with a single command

⚠️ Important: While serverless scales automatically, you still need to design for concurrency. Shared resources like databases must handle concurrent access from multiple function instances.

Serverless Benefits

Cost Efficiency:

• Pay only for execution time
• No idle server costs - $0 when not running
• Automatic scaling - no over-provisioning needed
• Example: API that runs 1 hour/day costs ~$0.20/month vs ~$30/month for smallest container

Operational Simplicity:

• No server management - no SSH, no patching, no capacity planning
• Automatic patching - runtime updates handled by platform
• Built-in high availability - runs across multiple AZs automatically
• No Dockerfiles or Kubernetes manifests to maintain

Rapid Development:

• Focus on business logic - write pure Go functions
• Fast deployment - seconds from code to production
• Easy integration - native integrations with cloud services
• Instant rollback - deploy new versions instantly, rollback just as fast

Go for Serverless

Think of Go as a high-performance race car for serverless functions. While other languages are like family sedans that take time to warm up, Go starts instantly and runs efficiently at high speeds.

 1// Why Go is ideal for serverless
 2
 3/*
 4Advantages:
 51. Fast cold starts
 62. Small binary size
 73. Low memory footprint
 84. Built-in concurrency
 95. Native compilation
106. Strong typing
11
12Challenges:
131. Larger binaries than interpreted languages
142. No dynamic loading
153. Must compile for Linux AMD64/ARM64
16*/

Real-World Performance: A Go Lambda function processing images typically completes in 200-500ms with 128MB memory, while a Python equivalent might need 512MB and take 1-2 seconds for the same task.

Serverless Platforms

Choosing a serverless platform is like choosing a delivery service for your packages. Each has different strengths, coverage areas, and pricing models.

 1// Platform comparison
 2
 3/*
 4AWS Lambda:
 5- Most mature
 6- Broad service integration
 7- Multiple runtime options
 8- Complex pricing
 9
10Google Cloud Functions:
11- Simple interface
12- Good for GCP integration
13- Limited runtime options
14
15Azure Functions:
16- Microsoft ecosystem
17- Good Windows support
18- Hybrid cloud scenarios
19
20Knative:
21- Kubernetes-native
22- Portable across clouds
23- More control
24- Self-hosted option
25
26OpenFaaS:
27- Self-hosted
28- Docker-based
29- Kubernetes/Docker Swarm
30- Full control
31*/

When to use AWS Lambda vs Knative:

• AWS Lambda: Best for AWS-centric workloads, rapid prototyping, and when you want zero infrastructure management
• Knative: Best for multi-cloud strategies, custom runtime requirements, and when you need more control over the execution environment

AWS Lambda with Go

AWS Lambda is the most popular serverless platform, and Go's performance characteristics make it an excellent match for Lambda's execution model.

Basic Lambda Function

Let's start with a simple "Hello World" Lambda function. This is the serverless equivalent of a traditional web API endpoint - it receives a request, processes it, and returns a response.

 1// main.go
 2package main
 3
 4import (
 5    "context"
 6    "fmt"
 7
 8    "github.com/aws/aws-lambda-go/lambda"
 9)
10
11type Request struct {
12    Name string `json:"name"`
13}
14
15type Response struct {
16    Message string `json:"message"`
17}
18
19func handler(ctx context.Context, req Request) {
20    message := fmt.Sprintf("Hello, %s!", req.Name)
21    return Response{Message: message}, nil
22}
23
24func main() {
25    lambda.Start(handler)
26}

Building and Deploying:

 1# Build for Linux
 2GOOS=linux GOARCH=amd64 go build -o bootstrap main.go
 3
 4# Create deployment package
 5zip function.zip bootstrap
 6
 7# Deploy with AWS CLI
 8aws lambda create-function \
 9    --function-name hello-go \
10    --runtime provided.al2 \
11    --handler bootstrap \
12    --zip-file fileb://function.zip \
13    --role arn:aws:iam::ACCOUNT_ID:role/lambda-role

💡 Key Takeaway: The bootstrap filename is required for Go Lambda functions using the provided.al2 runtime. AWS looks for this executable to run when your function is invoked.

Lambda with Dependencies

Real-world Lambda functions almost always need to interact with other AWS services. Here's where Go's concurrency and performance really shine compared to interpreted languages.

 1package main
 2
 3import (
 4    "context"
 5    "encoding/json"
 6
 7    "github.com/aws/aws-lambda-go/lambda"
 8    "github.com/aws/aws-sdk-go/aws"
 9    "github.com/aws/aws-sdk-go/aws/session"
10    "github.com/aws/aws-sdk-go/service/dynamodb"
11)
12
13type User struct {
14    ID    string `json:"id"`
15    Name  string `json:"name"`
16    Email string `json:"email"`
17}
18
19var (
20    sess *session.Session
21    db   *dynamodb.DynamoDB
22)
23
24func init() {
25    // Initialize AWS session once
26    sess = session.Must(session.NewSession())
27    db = dynamodb.New(sess)
28}
29
30func handler(ctx context.Context, event map[string]interface{}) {
31    userID := event["userId"].(string)
32
33    // Query DynamoDB
34    result, err := db.GetItemWithContext(ctx, &dynamodb.GetItemInput{
35        TableName: aws.String("Users"),
36        Key: map[string]*dynamodb.AttributeValue{
37            "ID": {
38                S: aws.String(userID),
39            },
40        },
41    })
42    if err != nil {
43        return User{}, err
44    }
45
46    // Parse result
47    var user User
48    err = dynamodbattribute.UnmarshalMap(result.Item, &user)
49    return user, err
50}
51
52func main() {
53    lambda.Start(handler)
54}

⚠️ Important: Always initialize external clients in the init() function or as global variables. This connection reuse across invocations is crucial for performance - initializing clients on every request would make your function much slower and more expensive.

Error Handling

 1package main
 2
 3import (
 4    "context"
 5    "errors"
 6    "fmt"
 7
 8    "github.com/aws/aws-lambda-go/lambda"
 9)
10
11type CustomError struct {
12    Code    string `json:"code"`
13    Message string `json:"message"`
14}
15
16func Error() string {
17    return fmt.Sprintf("%s: %s", e.Code, e.Message)
18}
19
20func handler(ctx context.Context, event map[string]interface{}) {
21    // Validate input
22    email, ok := event["email"].(string)
23    if !ok || email == "" {
24        return nil, &CustomError{
25            Code:    "INVALID_INPUT",
26            Message: "email is required",
27        }
28    }
29
30    // Business logic
31    if err := processEmail(email); err != nil {
32        // Return different error types
33        if errors.Is(err, ErrNotFound) {
34            return nil, &CustomError{
35                Code:    "NOT_FOUND",
36                Message: "user not found",
37            }
38        }
39        return nil, &CustomError{
40            Code:    "INTERNAL_ERROR",
41            Message: err.Error(),
42        }
43    }
44
45    return map[string]string{"status": "success"}, nil
46}
47
48func main() {
49    lambda.Start(handler)
50}

Environment Variables and Configuration

 1package main
 2
 3import (
 4    "context"
 5    "os"
 6
 7    "github.com/aws/aws-lambda-go/lambda"
 8)
 9
10type Config struct {
11    DatabaseURL string
12    APIKey      string
13    Environment string
14}
15
16func loadConfig() *Config {
17    return &Config{
18        DatabaseURL: os.Getenv("DATABASE_URL"),
19        APIKey:      os.Getenv("API_KEY"),
20        Environment: os.Getenv("ENVIRONMENT"),
21    }
22}
23
24var config *Config
25
26func init() {
27    config = loadConfig()
28}
29
30func handler(ctx context.Context, event map[string]interface{}) {
31    // Use configuration
32    if config.Environment == "production" {
33        // Production logic
34    }
35
36    return map[string]string{"env": config.Environment}, nil
37}
38
39func main() {
40    lambda.Start(handler)
41}

Lambda Triggers and Events

AWS Lambda supports various event sources.

API Gateway Integration

 1package main
 2
 3import (
 4    "context"
 5    "encoding/json"
 6    "net/http"
 7
 8    "github.com/aws/aws-lambda-go/events"
 9    "github.com/aws/aws-lambda-go/lambda"
10)
11
12type RequestBody struct {
13    Name  string `json:"name"`
14    Email string `json:"email"`
15}
16
17func handler(ctx context.Context, request events.APIGatewayProxyRequest) {
18    // Parse request body
19    var body RequestBody
20    if err := json.Unmarshal([]byte(request.Body), &body); err != nil {
21        return events.APIGatewayProxyResponse{
22            StatusCode: http.StatusBadRequest,
23            Body:       `{"error": "invalid request body"}`,
24        }, nil
25    }
26
27    // Access path parameters
28    userID := request.PathParameters["id"]
29
30    // Access query parameters
31    filter := request.QueryStringParameters["filter"]
32
33    // Access headers
34    authToken := request.Headers["Authorization"]
35
36    // Business logic
37    result := map[string]interface{}{
38        "userId": userID,
39        "filter": filter,
40        "hasAuth": authToken != "",
41        "body": body,
42    }
43
44    responseBody, _ := json.Marshal(result)
45
46    return events.APIGatewayProxyResponse{
47        StatusCode: http.StatusOK,
48        Headers: map[string]string{
49            "Content-Type": "application/json",
50        },
51        Body: string(responseBody),
52    }, nil
53}
54
55func main() {
56    lambda.Start(handler)
57}

S3 Event Handler

 1package main
 2
 3import (
 4    "context"
 5    "fmt"
 6
 7    "github.com/aws/aws-lambda-go/events"
 8    "github.com/aws/aws-lambda-go/lambda"
 9    "github.com/aws/aws-sdk-go/aws"
10    "github.com/aws/aws-sdk-go/aws/session"
11    "github.com/aws/aws-sdk-go/service/s3"
12)
13
14var s3Client *s3.S3
15
16func init() {
17    sess := session.Must(session.NewSession())
18    s3Client = s3.New(sess)
19}
20
21func handler(ctx context.Context, s3Event events.S3Event) error {
22    for _, record := range s3Event.Records {
23        bucket := record.S3.Bucket.Name
24        key := record.S3.Object.Key
25
26        fmt.Printf("Processing file: s3://%s/%s\n", bucket, key)
27
28        // Get object
29        result, err := s3Client.GetObjectWithContext(ctx, &s3.GetObjectInput{
30            Bucket: aws.String(bucket),
31            Key:    aws.String(key),
32        })
33        if err != nil {
34            return err
35        }
36        defer result.Body.Close()
37
38        // Process file
39        if err := processFile(result.Body); err != nil {
40            return err
41        }
42
43        fmt.Printf("Successfully processed: %s\n", key)
44    }
45
46    return nil
47}
48
49func main() {
50    lambda.Start(handler)
51}

DynamoDB Streams

 1package main
 2
 3import (
 4    "context"
 5    "fmt"
 6
 7    "github.com/aws/aws-lambda-go/events"
 8    "github.com/aws/aws-lambda-go/lambda"
 9)
10
11func handler(ctx context.Context, event events.DynamoDBEvent) error {
12    for _, record := range event.Records {
13        fmt.Printf("Event: %s\n", record.EventName)
14
15        switch record.EventName {
16        case "INSERT":
17            handleInsert(record.Change.NewImage)
18        case "MODIFY":
19            handleModify(record.Change.OldImage, record.Change.NewImage)
20        case "REMOVE":
21            handleRemove(record.Change.OldImage)
22        }
23    }
24
25    return nil
26}
27
28func handleInsert(newImage map[string]events.DynamoDBAttributeValue) {
29    // Process new record
30    userID := newImage["ID"].String()
31    fmt.Printf("New user: %s\n", userID)
32}
33
34func handleModify(oldImage, newImage map[string]events.DynamoDBAttributeValue) {
35    // Process update
36    fmt.Println("User updated")
37}
38
39func handleRemove(oldImage map[string]events.DynamoDBAttributeValue) {
40    // Process deletion
41    fmt.Println("User deleted")
42}
43
44func main() {
45    lambda.Start(handler)
46}

SQS Message Processing

 1package main
 2
 3import (
 4    "context"
 5    "encoding/json"
 6    "fmt"
 7
 8    "github.com/aws/aws-lambda-go/events"
 9    "github.com/aws/aws-lambda-go/lambda"
10)
11
12type Message struct {
13    Type string                 `json:"type"`
14    Data map[string]interface{} `json:"data"`
15}
16
17func handler(ctx context.Context, sqsEvent events.SQSEvent) error {
18    for _, record := range sqsEvent.Records {
19        // Parse message
20        var msg Message
21        if err := json.Unmarshal([]byte(record.Body), &msg); err != nil {
22            fmt.Printf("Failed to parse message: %v\n", err)
23            continue
24        }
25
26        // Process based on type
27        if err := processMessage(msg); err != nil {
28            // Return error to retry
29            return err
30        }
31    }
32
33    return nil
34}
35
36func processMessage(msg Message) error {
37    switch msg.Type {
38    case "user_created":
39        return handleUserCreated(msg.Data)
40    case "user_updated":
41        return handleUserUpdated(msg.Data)
42    default:
43        fmt.Printf("Unknown message type: %s\n", msg.Type)
44    }
45    return nil
46}
47
48func main() {
49    lambda.Start(handler)
50}

EventBridge Scheduled Events

 1package main
 2
 3import (
 4    "context"
 5    "fmt"
 6    "time"
 7
 8    "github.com/aws/aws-lambda-go/events"
 9    "github.com/aws/aws-lambda-go/lambda"
10)
11
12func handler(ctx context.Context, event events.CloudWatchEvent) error {
13    fmt.Printf("Scheduled execution at: %s\n", time.Now())
14
15    // Perform scheduled task
16    if err := performCleanup(); err != nil {
17        return err
18    }
19
20    if err := generateReports(); err != nil {
21        return err
22    }
23
24    return nil
25}
26
27func performCleanup() error {
28    // Cleanup logic
29    fmt.Println("Performing cleanup...")
30    return nil
31}
32
33func generateReports() error {
34    // Report generation
35    fmt.Println("Generating reports...")
36    return nil
37}
38
39func main() {
40    lambda.Start(handler)
41}

Cold Start Optimization

Cold starts are like waiting for a delivery truck to warm up its engine before making a delivery. The first request after idle time takes longer while AWS prepares your function. With Go, this "warm-up" time is minimal, but we can optimize it even further.

Minimizing Binary Size

Smaller binaries download faster and use less memory, reducing cold start time and cost.

 1# Optimize build
 2CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build \
 3    -ldflags="-s -w" \
 4    -trimpath \
 5    -o bootstrap main.go
 6
 7# Further compress with UPX
 8upx --best --lzma bootstrap
 9
10# Result: 30-50% size reduction

Real-World Impact: A 15MB binary vs 30MB can reduce cold start time by ~200ms and monthly costs by $5-10 for high-traffic functions.

💡 Key Takeaway: Use CGO_ENABLED=0 to disable CGO and create a static binary. This eliminates C library dependencies and ensures portability across Lambda environments.

Global Variable Initialization

Think of global variables like pre-loading your delivery truck with all the tools you'll need before starting deliveries. This avoids wasting time loading tools for each delivery.

 1package main
 2
 3import (
 4    "context"
 5
 6    "github.com/aws/aws-lambda-go/lambda"
 7    "github.com/aws/aws-sdk-go/aws/session"
 8    "github.com/aws/aws-sdk-go/service/dynamodb"
 9)
10
11var (
12    // Initialize once, reuse across invocations
13    sess *session.Session
14    db   *dynamodb.DynamoDB
15)
16
17func init() {
18    // This runs once per cold start
19    sess = session.Must(session.NewSession())
20    db = dynamodb.New(sess)
21}
22
23func handler(ctx context.Context, event map[string]interface{}) error {
24    // Reuse initialized clients
25    // No cold start penalty on warm invocations
26    result, err := db.GetItem(&dynamodb.GetItemInput{
27        // ...
28    })
29    return err
30}
31
32func main() {
33    lambda.Start(handler)
34}

⚠️ Important: Don't initialize everything in init(). Only initialize what you know will be used in most invocations. For rarely-used clients, consider lazy initialization to keep cold starts fast.

Connection Pooling

 1package main
 2
 3import (
 4    "context"
 5    "database/sql"
 6
 7    "github.com/aws/aws-lambda-go/lambda"
 8    _ "github.com/lib/pq"
 9)
10
11var db *sql.DB
12
13func init() {
14    var err error
15    db, err = sql.Open("postgres", os.Getenv("DATABASE_URL"))
16    if err != nil {
17        panic(err)
18    }
19
20    // Configure connection pool for Lambda
21    db.SetMaxOpenConns(5)  // Low for serverless
22    db.SetMaxIdleConns(2)
23    db.SetConnMaxLifetime(5 * time.Minute)
24}
25
26func handler(ctx context.Context, event map[string]interface{}) error {
27    // Use pooled connection
28    rows, err := db.QueryContext(ctx, "SELECT * FROM users")
29    defer rows.Close()
30    return err
31}
32
33func main() {
34    lambda.Start(handler)
35}

Provisioned Concurrency

Provisioned Concurrency is like keeping a fleet of delivery trucks always running and ready, instead of starting them only when orders arrive. No waiting, but higher fuel costs.

 1// CloudFormation template
 2Resources:
 3  MyFunction:
 4    Type: AWS::Lambda::Function
 5    Properties:
 6      FunctionName: my-function
 7      Runtime: provided.al2
 8      Handler: bootstrap
 9      Code:
10        S3Bucket: my-bucket
11        S3Key: function.zip
12
13  MyFunctionAlias:
14    Type: AWS::Lambda::Alias
15    Properties:
16      FunctionName: !Ref MyFunction
17      FunctionVersion: $LATEST
18      Name: live
19      ProvisionedConcurrencyConfig:
20        ProvisionedConcurrentExecutions: 5  # Always warm
21
22/*
23Provisioned Concurrency:
24- Keeps instances warm
25- No cold starts
26- Costs more
27- Use for latency-sensitive APIs
28*/

Real-World Example: An e-commerce checkout API used provisioned concurrency with 10 instances to handle payment processing. This eliminated cold starts during peak shopping seasons, reducing checkout latency from 800ms to 200ms, but increased monthly costs by ~$200.

When to use Provisioned Concurrency:

• APIs with strict latency requirements
• Functions with unpredictable traffic spikes
• Critical business functions where performance outweighs cost
• Functions with high initialization overhead

When to avoid:

• Background jobs and batch processing
• Functions with consistent, predictable traffic
• Cost-sensitive applications
• Development and testing environments

Lazy Initialization

 1package main
 2
 3import (
 4    "context"
 5    "sync"
 6
 7    "github.com/aws/aws-lambda-go/lambda"
 8    "github.com/aws/aws-sdk-go/aws/session"
 9    "github.com/aws/aws-sdk-go/service/s3"
10)
11
12var (
13    s3Client *s3.S3
14    once     sync.Once
15)
16
17func getS3Client() *s3.S3 {
18    once.Do(func() {
19        sess := session.Must(session.NewSession())
20        s3Client = s3.New(sess)
21    })
22    return s3Client
23}
24
25func handler(ctx context.Context, event map[string]interface{}) error {
26    // Initialize only when needed
27    // Reduces cold start if not all code paths need S3
28    client := getS3Client()
29
30    _, err := client.ListBuckets(&s3.ListBucketsInput{})
31    return err
32}
33
34func main() {
35    lambda.Start(handler)
36}

Knative Functions

Knative is a Kubernetes-based serverless platform.

Knative Function

 1// main.go
 2package main
 3
 4import (
 5    "fmt"
 6    "net/http"
 7)
 8
 9func handler(w http.ResponseWriter, r *http.Request) {
10    name := r.URL.Query().Get("name")
11    if name == "" {
12        name = "World"
13    }
14
15    fmt.Fprintf(w, "Hello, %s!\n", name)
16}
17
18func main() {
19    http.HandleFunc("/", handler)
20    http.ListenAndServe(":8080", nil)
21}

Deployment:

 1# service.yaml
 2apiVersion: serving.knative.dev/v1
 3kind: Service
 4metadata:
 5  name: hello-go
 6spec:
 7  template:
 8    metadata:
 9      annotations:
10        autoscaling.knative.dev/minScale: "0"
11        autoscaling.knative.dev/maxScale: "10"
12    spec:
13      containers:
14      - image: myregistry/hello-go:latest
15        ports:
16        - containerPort: 8080
17        env:
18        - name: TARGET
19          value: "Go"

1# Deploy to Knative
2kubectl apply -f service.yaml
3
4# Get URL
5kubectl get ksvc hello-go

Knative with CloudEvents

 1package main
 2
 3import (
 4    "context"
 5    "fmt"
 6    "log"
 7    "net/http"
 8
 9    cloudevents "github.com/cloudevents/sdk-go/v2"
10)
11
12type UserCreated struct {
13    UserID string `json:"userId"`
14    Email  string `json:"email"`
15}
16
17func receiver(ctx context.Context, event cloudevents.Event) error {
18    fmt.Printf("Received event: %s\n", event.Type())
19
20    var data UserCreated
21    if err := event.DataAs(&data); err != nil {
22        return err
23    }
24
25    fmt.Printf("User created: %s\n", data.UserID, data.Email)
26
27    // Process event
28    return processUser(data)
29}
30
31func main() {
32    c, err := cloudevents.NewClientHTTP()
33    if err != nil {
34        log.Fatal(err)
35    }
36
37    if err := c.StartReceiver(context.Background(), receiver); err != nil {
38        log.Fatal(err)
39    }
40}

Knative Autoscaling

 1apiVersion: serving.knative.dev/v1
 2kind: Service
 3metadata:
 4  name: autoscale-go
 5spec:
 6  template:
 7    metadata:
 8      annotations:
 9        # Scale to zero after 30s
10        autoscaling.knative.dev/scale-to-zero-pod-retention-period: "30s"
11        # Target 100 concurrent requests per pod
12        autoscaling.knative.dev/target: "100"
13        # Minimum instances
14        autoscaling.knative.dev/minScale: "1"
15        # Maximum instances
16        autoscaling.knative.dev/maxScale: "100"
17        # Scale down gradually
18        autoscaling.knative.dev/scale-down-delay: "15m"
19    spec:
20      containers:
21      - image: myregistry/autoscale-go:latest
22        resources:
23          limits:
24            cpu: "1000m"
25            memory: "256Mi"
26          requests:
27            cpu: "100m"
28            memory: "64Mi"

OpenFaaS Deployment

OpenFaaS is a self-hosted serverless framework.

OpenFaaS Function

 1// handler.go
 2package function
 3
 4import (
 5    "encoding/json"
 6    "fmt"
 7)
 8
 9type Request struct {
10    Name string `json:"name"`
11}
12
13type Response struct {
14    Message string `json:"message"`
15}
16
17func Handle(req []byte) {
18    var request Request
19    if err := json.Unmarshal(req, &request); err != nil {
20        return nil, err
21    }
22
23    response := Response{
24        Message: fmt.Sprintf("Hello, %s!", request.Name),
25    }
26
27    return json.Marshal(response)
28}

Function Configuration:

 1# stack.yml
 2provider:
 3  name: openfaas
 4  gateway: http://localhost:8080
 5
 6functions:
 7  hello-go:
 8    lang: go
 9    handler: ./hello-go
10    image: myregistry/hello-go:latest
11    environment:
12      write_debug: true
13    limits:
14      memory: "128Mi"
15      cpu: "0.5"
16    requests:
17      memory: "64Mi"
18      cpu: "0.1"
19    labels:
20      com.openfaas.scale.min: "1"
21      com.openfaas.scale.max: "10"

Deployment:

 1# Build
 2faas-cli build -f stack.yml
 3
 4# Push to registry
 5faas-cli push -f stack.yml
 6
 7# Deploy
 8faas-cli deploy -f stack.yml
 9
10# Invoke
11echo '{"name":"OpenFaaS"}' | faas-cli invoke hello-go

OpenFaaS with Secrets

 1package function
 2
 3import (
 4    "io/ioutil"
 5)
 6
 7func Handle(req []byte) {
 8    // Read secret from mounted file
 9    apiKey, err := ioutil.ReadFile("/var/openfaas/secrets/api-key")
10    if err != nil {
11        return nil, err
12    }
13
14    // Use secret
15    // ...
16
17    return []byte("success"), nil
18}

Azure and Google Cloud Functions

Azure Functions

 1package main
 2
 3import (
 4    "encoding/json"
 5    "fmt"
 6    "net/http"
 7)
 8
 9type Request struct {
10    Name string `json:"name"`
11}
12
13type Response struct {
14    Message string `json:"message"`
15}
16
17func handler(w http.ResponseWriter, r *http.Request) {
18    var req Request
19    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
20        http.Error(w, err.Error(), http.StatusBadRequest)
21        return
22    }
23
24    resp := Response{
25        Message: fmt.Sprintf("Hello, %s!", req.Name),
26    }
27
28    w.Header().Set("Content-Type", "application/json")
29    json.NewEncoder(w).Encode(resp)
30}
31
32func main() {
33    http.HandleFunc("/api/hello", handler)
34    http.ListenAndServe(":8080", nil)
35}

Google Cloud Functions

 1package hello
 2
 3import (
 4    "encoding/json"
 5    "fmt"
 6    "net/http"
 7)
 8
 9type Request struct {
10    Name string `json:"name"`
11}
12
13// HelloHTTP is an HTTP Cloud Function
14func HelloHTTP(w http.ResponseWriter, r *http.Request) {
15    var req Request
16    if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
17        http.Error(w, "Invalid request", http.StatusBadRequest)
18        return
19    }
20
21    fmt.Fprintf(w, "Hello, %s!", req.Name)
22}

Deployment:

1gcloud functions deploy hello-go \
2    --runtime go121 \
3    --trigger-http \
4    --allow-unauthenticated \
5    --entry-point HelloHTTP

Production Patterns

Function Composition

Function composition is like an assembly line where each worker performs a specific task and passes the result to the next worker. This creates modular, reusable serverless workflows.

 1package main
 2
 3import (
 4    "context"
 5    "encoding/json"
 6
 7    "github.com/aws/aws-lambda-go/lambda"
 8    "github.com/aws/aws-sdk-go/aws"
 9    "github.com/aws/aws-sdk-go/aws/session"
10    "github.com/aws/aws-sdk-go/service/lambda as awslambda"
11)
12
13var lambdaClient *awslambda.Lambda
14
15func init() {
16    sess := session.Must(session.NewSession())
17    lambdaClient = awslambda.New(sess)
18}
19
20func handler(ctx context.Context, event map[string]interface{}) {
21    // Step 1: Validate
22    validatePayload, _ := json.Marshal(event)
23    validateResp, err := lambdaClient.InvokeWithContext(ctx, &awslambda.InvokeInput{
24        FunctionName: aws.String("validate-function"),
25        Payload:      validatePayload,
26    })
27    if err != nil {
28        return nil, err
29    }
30
31    // Step 2: Process
32    processResp, err := lambdaClient.InvokeWithContext(ctx, &awslambda.InvokeInput{
33        FunctionName: aws.String("process-function"),
34        Payload:      validateResp.Payload,
35    })
36    if err != nil {
37        return nil, err
38    }
39
40    // Step 3: Store
41    storeResp, err := lambdaClient.InvokeWithContext(ctx, &awslambda.InvokeInput{
42        FunctionName: aws.String("store-function"),
43        Payload:      processResp.Payload,
44    })
45    if err != nil {
46        return nil, err
47    }
48
49    var result interface{}
50    json.Unmarshal(storeResp.Payload, &result)
51
52    return result, nil
53}
54
55func main() {
56    lambda.Start(handler)
57}

Common Pitfalls in Function Composition:

• Chained failures: If one function fails, the entire chain fails
• Payload size limits: Lambda responses have 6MB limits
• Cold start accumulation: Each function in the chain can have cold starts
• Error handling complexity: Need to handle failures at each step

Alternative: Consider using AWS Step Functions for complex workflows. They provide built-in error handling, retries, and visual workflow monitoring.

Retry and Error Handling

 1package main
 2
 3import (
 4    "context"
 5    "errors"
 6    "time"
 7
 8    "github.com/aws/aws-lambda-go/lambda"
 9)
10
11type RetriableError struct {
12    error
13}
14
15func Error() string {
16    return e.error.Error()
17}
18
19func handler(ctx context.Context, event map[string]interface{}) error {
20    err := processEvent(event)
21
22    if err != nil {
23        // Determine if error is retriable
24        if isRetriable(err) {
25            // Return error - Lambda will retry
26            return &RetriableError{err}
27        }
28
29        // Non-retriable error - send to DLQ
30        return err
31    }
32
33    return nil
34}
35
36func processEvent(event map[string]interface{}) error {
37    // Implement exponential backoff for external calls
38    maxRetries := 3
39    baseDelay := 100 * time.Millisecond
40
41    for attempt := 0; attempt < maxRetries; attempt++ {
42        err := callExternalAPI()
43        if err == nil {
44            return nil
45        }
46
47        if !isRetriable(err) {
48            return err
49        }
50
51        delay := baseDelay * time.Duration(1<<uint(attempt))
52        time.Sleep(delay)
53    }
54
55    return errors.New("max retries exceeded")
56}
57
58func isRetriable(err error) bool {
59    // Check if error is transient
60    // Network errors, rate limits, etc.
61    return true
62}
63
64func main() {
65    lambda.Start(handler)
66}

Observability

 1package main
 2
 3import (
 4    "context"
 5    "log"
 6
 7    "github.com/aws/aws-lambda-go/lambda"
 8    "github.com/aws/aws-lambda-go/lambdacontext"
 9    "github.com/aws/aws-xray-sdk-go/xray"
10)
11
12func handler(ctx context.Context, event map[string]interface{}) error {
13    // Get Lambda context
14    lc, _ := lambdacontext.FromContext(ctx)
15
16    log.Printf("Request ID: %s", lc.AwsRequestID)
17    log.Printf("Function ARN: %s", lc.InvokedFunctionArn)
18    log.Printf("Memory Limit: %d MB", lc.MemoryLimitInMB)
19
20    // X-Ray tracing
21    ctx, seg := xray.BeginSubsegment(ctx, "business-logic")
22    defer seg.Close(nil)
23
24    // Add metadata
25    seg.AddMetadata("event", event)
26
27    // Process
28    if err := processEvent(ctx, event); err != nil {
29        seg.AddError(err)
30        return err
31    }
32
33    return nil
34}
35
36func processEvent(ctx context.Context, event map[string]interface{}) error {
37    // Traced database call
38    err := xray.Capture(ctx, "database-query", func(ctx context.Context) error {
39        return queryDatabase(ctx)
40    })
41
42    return err
43}
44
45func main() {
46    lambda.Start(handler)
47}

Further Reading

• AWS Lambda Go
• Knative Documentation
• OpenFaaS Workshop
• Serverless Framework
• SAM

Practice Exercises

Exercise 1: Build a Serverless API

Objective: Create a complete CRUD API using Lambda, API Gateway, and DynamoDB.

Requirements:

1. Create/Read/Update/Delete endpoints
2. Input validation
3. Error handling
4. DynamoDB integration
5. CloudFormation/SAM template

  1// handlers/user.go
  2package handlers
  3
  4import (
  5    "context"
  6    "encoding/json"
  7    "net/http"
  8
  9    "github.com/aws/aws-lambda-go/events"
 10    "github.com/aws/aws-sdk-go/aws"
 11    "github.com/aws/aws-sdk-go/service/dynamodb"
 12    "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
 13    "github.com/google/uuid"
 14)
 15
 16type User struct {
 17    ID    string `json:"id" dynamodbav:"id"`
 18    Name  string `json:"name" dynamodbav:"name"`
 19    Email string `json:"email" dynamodbav:"email"`
 20}
 21
 22type UserHandler struct {
 23    db        *dynamodb.DynamoDB
 24    tableName string
 25}
 26
 27func NewUserHandler(db *dynamodb.DynamoDB, tableName string) *UserHandler {
 28    return &UserHandler{
 29        db:        db,
 30        tableName: tableName,
 31    }
 32}
 33
 34func Create(ctx context.Context, req events.APIGatewayProxyRequest) {
 35    var user User
 36    if err := json.Unmarshal([]byte(req.Body), &user); err != nil {
 37        return response(http.StatusBadRequest, map[string]string{"error": "invalid request"}), nil
 38    }
 39
 40    // Validate
 41    if user.Name == "" || user.Email == "" {
 42        return response(http.StatusBadRequest, map[string]string{"error": "name and email required"}), nil
 43    }
 44
 45    user.ID = uuid.New().String()
 46
 47    // Save to DynamoDB
 48    item, _ := dynamodbattribute.MarshalMap(user)
 49    _, err := h.db.PutItemWithContext(ctx, &dynamodb.PutItemInput{
 50        TableName: aws.String(h.tableName),
 51        Item:      item,
 52    })
 53    if err != nil {
 54        return response(http.StatusInternalServerError, map[string]string{"error": "failed to create user"}), nil
 55    }
 56
 57    return response(http.StatusCreated, user), nil
 58}
 59
 60func Get(ctx context.Context, req events.APIGatewayProxyRequest) {
 61    id := req.PathParameters["id"]
 62
 63    result, err := h.db.GetItemWithContext(ctx, &dynamodb.GetItemInput{
 64        TableName: aws.String(h.tableName),
 65        Key: map[string]*dynamodb.AttributeValue{
 66            "id": {S: aws.String(id)},
 67        },
 68    })
 69    if err != nil {
 70        return response(http.StatusInternalServerError, map[string]string{"error": "failed to get user"}), nil
 71    }
 72
 73    if result.Item == nil {
 74        return response(http.StatusNotFound, map[string]string{"error": "user not found"}), nil
 75    }
 76
 77    var user User
 78    dynamodbattribute.UnmarshalMap(result.Item, &user)
 79
 80    return response(http.StatusOK, user), nil
 81}
 82
 83func Update(ctx context.Context, req events.APIGatewayProxyRequest) {
 84    id := req.PathParameters["id"]
 85
 86    var updates map[string]string
 87    json.Unmarshal([]byte(req.Body), &updates)
 88
 89    // Build update expression
 90    updateExpr := "SET "
 91    exprAttrValues := make(map[string]*dynamodb.AttributeValue)
 92
 93    if name, ok := updates["name"]; ok {
 94        updateExpr += "#n = :name, "
 95        exprAttrValues[":name"] = &dynamodb.AttributeValue{S: aws.String(name)}
 96    }
 97
 98    if email, ok := updates["email"]; ok {
 99        updateExpr += "email = :email"
100        exprAttrValues[":email"] = &dynamodb.AttributeValue{S: aws.String(email)}
101    }
102
103    _, err := h.db.UpdateItemWithContext(ctx, &dynamodb.UpdateItemInput{
104        TableName: aws.String(h.tableName),
105        Key: map[string]*dynamodb.AttributeValue{
106            "id": {S: aws.String(id)},
107        },
108        UpdateExpression:          aws.String(updateExpr),
109        ExpressionAttributeValues: exprAttrValues,
110        ExpressionAttributeNames: map[string]*string{
111            "#n": aws.String("name"),
112        },
113    })
114    if err != nil {
115        return response(http.StatusInternalServerError, map[string]string{"error": "failed to update user"}), nil
116    }
117
118    return response(http.StatusOK, map[string]string{"status": "updated"}), nil
119}
120
121func Delete(ctx context.Context, req events.APIGatewayProxyRequest) {
122    id := req.PathParameters["id"]
123
124    _, err := h.db.DeleteItemWithContext(ctx, &dynamodb.DeleteItemInput{
125        TableName: aws.String(h.tableName),
126        Key: map[string]*dynamodb.AttributeValue{
127            "id": {S: aws.String(id)},
128        },
129    })
130    if err != nil {
131        return response(http.StatusInternalServerError, map[string]string{"error": "failed to delete user"}), nil
132    }
133
134    return response(http.StatusNoContent, nil), nil
135}
136
137func response(statusCode int, body interface{}) events.APIGatewayProxyResponse {
138    bodyBytes, _ := json.Marshal(body)
139
140    return events.APIGatewayProxyResponse{
141        StatusCode: statusCode,
142        Headers: map[string]string{
143            "Content-Type": "application/json",
144        },
145        Body: string(bodyBytes),
146    }
147}