Aws Serverless

# AWS Serverless

Patterns

Lambda Handler Pattern

Proper Lambda function structure with error handling

**When to use**: ['Any Lambda function implementation', 'API handlers, event processors, scheduled tasks']

// Node.js Lambda Handler

// handler.js

// Initialize outside handler (reused across invocations)

const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');

const { DynamoDBDocumentClient, GetCommand } = require('@aws-sdk/lib-dynamodb');

const client = new DynamoDBClient({});

const docClient = DynamoDBDocumentClient.from(client);

// Handler function

exports.handler = async (event, context) => {

// Optional: Don't wait for event loop to clear (Node.js)

context.callbackWaitsForEmptyEventLoop = false;

try {

// Parse input based on event source

const body = typeof event.body === 'string'

? JSON.parse(event.body)

: event.body;

// Business logic

const result = await processRequest(body);

// Return API Gateway compatible response

return {

statusCode: 200,

headers: {

'Content-Type': 'application/json',

'Access-Control-Allow-Origin': '*'

},

body: JSON.stringify(result)

};

} catch (error) {

console.error('Error:', JSON.stringify({

error: error.message,

stack: error.stack,

requestId: context.awsRequestId

}));

return {

statusCode: error.statusCode || 500,

headers: { 'Content-Type': 'application/json' },

body: JSON.stringify({

error: error.message || 'Internal server error'

})

};

}

};

async function processRequest(data) {

// Your business logic here

const result = await docClient.send(new GetCommand({

TableName: process.env.TABLE_NAME,

Key: { id: data.id }

}));

return result.Item;

}

# Python Lambda Handler

# handler.py

import json

import os

import logging

import boto3

from botocore.exceptions import ClientError

# Initialize outside handler (reused across invocations)

logger = logging.getLogger()

logger.setLevel(logging.INFO)

dynamodb = boto3.resource('dynamodb')

table = dynamodb.Table(os.environ['TABLE_NAME'])

def handler(event, context):

try:

# Parse i

### API Gateway Integration Pattern

REST API and HTTP API integration with Lambda

**When to use**: ['Building REST APIs backed by Lambda', 'Need HTTP endpoints for functions']

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

Globals:
  Function:
    Runtime: nodejs20.x
    Timeout: 30
    MemorySize: 256
    Environment:
      Variables:
        TABLE_NAME: !Ref ItemsTable

Resources:
  # HTTP API (recommended for simple use cases)
  HttpApi:
    Type: AWS::Serverless::HttpApi
    Properties:
      StageName: prod
      CorsConfiguration:
        AllowOrigins:
          - "*"
        AllowMethods:
          - GET
          - POST
          - DELETE
        AllowHeaders:
          - "*"

  # Lambda Functions
  GetItemFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/get.handler
      Events:
        GetItem:
          Type: HttpApi
          Properties:
            ApiId: !Ref HttpApi
            Path: /items/{id}
            Method: GET
      Policies:
        - DynamoDBReadPolicy:
            TableName: !Ref ItemsTable

  CreateItemFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: src/handlers/create.handler
      Events:
        CreateItem:
          Type: HttpApi
          Properties:
            ApiId: !Ref HttpApi
            Path: /items
            Method: POST
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref ItemsTable

  # DynamoDB Table
  ItemsTable:
    Type: AWS::DynamoDB::Table
    Properties:
      AttributeDefinitions:
        - AttributeName: id
          AttributeType: S
      KeySchema:
        - AttributeName: id
          KeyType: HASH
      Billing