Building Serverless Applications with AWS Lambda

Serverless architecture lets you focus on code without managing infrastructure. AWS Lambda is leading this revolution.

Why Go Serverless?

Serverless computing offers compelling advantages:

• No server management - AWS handles everything
• Automatic scaling - From zero to millions of requests
• Pay per use - Only pay for compute time consumed
• Built-in high availability - Multi-AZ redundancy

Getting Started with Lambda

Prerequisites

1. AWS Account
2. AWS CLI configured
3. Node.js 18+ installed

Your First Lambda Function

Create a simple handler:

export const handler = async (event) => {
  console.log('Event:', JSON.stringify(event, null, 2));
  
  const response = {
    statusCode: 200,
    body: JSON.stringify({
      message: 'Hello from Lambda!',
      input: event,
    }),
  };
  
  return response;
};

Deploying with AWS SAM

AWS SAM simplifies serverless deployment:

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

Resources:
  HelloWorldFunction:
    Type: AWS::Serverless::Function
    Properties:
      CodeUri: hello-world/
      Handler: app.handler
      Runtime: nodejs18.x
      Events:
        HelloWorld:
          Type: Api
          Properties:
            Path: /hello
            Method: get

Deploy with:

sam build
sam deploy --guided

API Gateway Integration

Create RESTful APIs with API Gateway:

// CRUD operations handler
export const handler = async (event) => {
  const { httpMethod, path, body } = event;
  
  switch (httpMethod) {
    case 'GET':
      return handleGet(path);
    case 'POST':
      return handlePost(JSON.parse(body));
    case 'PUT':
      return handlePut(path, JSON.parse(body));
    case 'DELETE':
      return handleDelete(path);
    default:
      return { statusCode: 405, body: 'Method Not Allowed' };
  }
};

Database Integration

Connect to DynamoDB for persistence:

import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
import { DynamoDBDocumentClient, PutCommand } from "@aws-sdk/lib-dynamodb";

const client = new DynamoDBClient({});
const ddbDocClient = DynamoDBDocumentClient.from(client);

export const handler = async (event) => {
  const item = JSON.parse(event.body);
  
  const command = new PutCommand({
    TableName: process.env.TABLE_NAME,
    Item: {
      id: Date.now().toString(),
      ...item,
      createdAt: new Date().toISOString(),
    },
  });
  
  await ddbDocClient.send(command);
  
  return {
    statusCode: 201,
    body: JSON.stringify({ message: 'Item created successfully' }),
  };
};

Environment Variables

Manage configuration with environment variables:

Environment:
  Variables:
    TABLE_NAME: !Ref ItemsTable
    REGION: !Ref AWS::Region
    API_KEY: !Ref ApiKey

Error Handling

Implement robust error handling:

export const handler = async (event) => {
  try {
    // Your logic here
    const result = await processRequest(event);
    
    return {
      statusCode: 200,
      body: JSON.stringify(result),
    };
  } catch (error) {
    console.error('Error:', error);
    
    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({
        message: error.message || 'Internal server error',
      }),
    };
  }
};

Monitoring with CloudWatch

Lambda automatically logs to CloudWatch:

// Structured logging
const log = (level, message, data = {}) => {
  console.log(JSON.stringify({
    timestamp: new Date().toISOString(),
    level,
    message,
    ...data,
  }));
};

export const handler = async (event) => {
  log('INFO', 'Request received', { eventId: event.requestId });
  
  // Process request
  
  log('INFO', 'Request completed', { duration: Date.now() - start });
};

Performance Optimization

1. Cold Start Mitigation

• Use provisioned concurrency for critical functions
• Minimize package size
• Use Lambda layers for dependencies

2. Memory Configuration

// Memory directly correlates with CPU
// More memory = faster execution
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      MemorySize: 1024  # 1GB
      Timeout: 30

3. Connection Pooling

// Reuse connections across invocations
let dbConnection;

export const handler = async (event) => {
  if (!dbConnection) {
    dbConnection = await createConnection();
  }
  
  // Use connection
};

Cost Optimization Tips

1. Right-size memory allocation - Test different configurations
2. Use ARM architecture - 20% cost savings with Graviton2
3. Implement caching - Reduce unnecessary computations
4. Set appropriate timeouts - Avoid runaway functions

Security Best Practices

IAM Roles

Policies:
  - Version: '2012-10-17'
    Statement:
      - Effect: Allow
        Action:
          - dynamodb:GetItem
          - dynamodb:PutItem
        Resource: !GetAtt ItemsTable.Arn

Secrets Management

import { SecretsManagerClient, GetSecretValueCommand } from "@aws-sdk/client-secrets-manager";

const client = new SecretsManagerClient({});

const getSecret = async (secretName) => {
  const command = new GetSecretValueCommand({ SecretId: secretName });
  const response = await client.send(command);
  return JSON.parse(response.SecretString);
};

Testing Strategies

Unit Tests

// handler.test.js
import { handler } from './handler.js';

describe('Lambda Handler', () => {
  test('returns successful response', async () => {
    const event = { httpMethod: 'GET', path: '/test' };
    const response = await handler(event);
    
    expect(response.statusCode).toBe(200);
    expect(JSON.parse(response.body)).toHaveProperty('message');
  });
});

Local Testing

# Test locally with SAM
sam local start-api

Conclusion

AWS Lambda enables building scalable applications without infrastructure overhead. Start small, iterate quickly, and scale infinitely.

Next Steps

• Explore Step Functions for orchestration
• Implement CI/CD with AWS CodePipeline
• Learn about Lambda@Edge for CDN computing
• Try AWS Amplify for full-stack serverless

The serverless revolution is here. Join it!