AWS Lambda Function Development

Lambda Handler in Different Languages

Python:

# Basic Lambda function in Python
def lambda_handler(event, context):
    # Log the event object for debugging
    print('Event:', event)
    print('Context:', context)
    
    # Process the event
    response = {
        'statusCode': 200,
        'body': {
            'message': 'Hello from Lambda!',
            'input': event
        }
    }
    
    return response
        

Java:

// Basic Lambda function in Java
package example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.LambdaLogger;
import java.util.HashMap;
import java.util.Map;

public class Handler implements RequestHandler<Map<String, Object>, Map<String, Object>> {
    @Override
    public Map<String, Object> handleRequest(Map<String, Object> event, Context context) {
        LambdaLogger logger = context.getLogger();
        logger.log("Event: " + event);
        
        Map<String, Object> body = new HashMap<>();
        body.put("message", "Hello from Lambda!");
        body.put("input", event);
        
        Map<String, Object> response = new HashMap<>();
        response.put("statusCode", 200);
        response.put("body", body);
        
        return response;
    }
}
        

Execution Context Reuse

// Global variables defined outside the handler are initialized once
// and can be reused across invocations in the same execution context
const AWS = require('aws-sdk');
const dynamoDB = new AWS.DynamoDB.DocumentClient();
let connectionPool;

// Expensive initialization should be done outside the handler
connectionPool = initializeConnectionPool();

exports.handler = async (event, context) => {
  console.log('Remaining time:', context.getRemainingTimeInMillis());
  console.log('Function name:', context.functionName);
  console.log('AWS request ID:', context.awsRequestId);
  
  // Use the connection pool from the global scope
  const result = await connectionPool.query('SELECT * FROM users');
  
  return {
    statusCode: 200,
    body: JSON.stringify(result)
  };
};

function initializeConnectionPool() {
  console.log('Initializing connection pool - this happens only during cold start');
  // Expensive initialization logic here
  return {
    query: async (sql) => {
      console.log(`Executing query: ${sql}`);
      return { items: [] }; // Simulated response
    }
  };
}
        

Memory vs Performance and Cost

API Gateway Integration

// Lambda function for API Gateway
exports.handler = async (event) => {
  console.log('Event:', JSON.stringify(event, null, 2));
  
  // Extract path parameters
  const pathParameters = event.pathParameters || {};
  const id = pathParameters.id;
  
  // Extract query string parameters
  const queryStringParameters = event.queryStringParameters || {};
  const filter = queryStringParameters.filter;
  
  // Extract HTTP method
  const httpMethod = event.httpMethod;
  
  // Extract body for POST/PUT requests
  let body = {};
  if (event.body) {
    try {
      body = JSON.parse(event.body);
    } catch (error) {
      return {
        statusCode: 400,
        body: JSON.stringify({ message: 'Invalid request body' })
      };
    }
  }
  
  // Process based on HTTP method
  let response;
  switch (httpMethod) {
    case 'GET':
      if (id) {
        response = await getItem(id);
      } else {
        response = await listItems(filter);
      }
      break;
    case 'POST':
      response = await createItem(body);
      break;
    case 'PUT':
      response = await updateItem(id, body);
      break;
    case 'DELETE':
      response = await deleteItem(id);
      break;
    default:
      return {
        statusCode: 405,
        body: JSON.stringify({ message: 'Method not allowed' })
      };
  }
  
  return {
    statusCode: response.statusCode,
    headers: {
      'Content-Type': 'application/json',
      'Access-Control-Allow-Origin': '*' // CORS support
    },
    body: JSON.stringify(response.body)
  };
};

async function getItem(id) {
  // Implementation to fetch an item
  return { statusCode: 200, body: { id, name: 'Example Item' } };
}

// Other CRUD function implementations
        

S3 Event Processing

// Lambda function for processing S3 events
exports.handler = async (event) => {
  console.log('Event:', JSON.stringify(event, null, 2));
  
  // Extract S3 event information
  const s3Event = event.Records[0].s3;
  const bucket = s3Event.bucket.name;
  const key = decodeURIComponent(s3Event.object.key.replace(/\+/g, ' '));
  const size = s3Event.object.size;
  
  console.log(`Processing new file: ${key} (${size} bytes) in bucket: ${bucket}`);
  
  try {
    // Process the file
    if (key.endsWith('.jpg') || key.endsWith('.png')) {
      await processImage(bucket, key);
    } else if (key.endsWith('.csv')) {
      await processCSV(bucket, key);
    } else if (key.endsWith('.pdf')) {
      await processPDF(bucket, key);
    } else {
      console.log(`Unsupported file type: ${key}`);
    }
    
    console.log(`Successfully processed: ${key}`);
    return { status: 'success', key };
  } catch (error) {
    console.error(`Error processing ${key}:`, error);
    throw error; // For asynchronous invocation, this triggers retry
  }
};

async function processImage(bucket, key) {
  // Implementation for image processing
  console.log(`Processing image: ${key}`);
  // Example: resize image, extract metadata, etc.
}

// Other file processing implementations
        

DynamoDB Stream Processing

// Lambda function for processing DynamoDB streams
exports.handler = async (event) => {
  console.log('Event:', JSON.stringify(event, null, 2));
  
  // Process each record in the batch
  for (const record of event.Records) {
    // Get the DynamoDB stream event type
    const eventType = record.eventName; // INSERT, MODIFY, REMOVE
    
    // Get the new and old images (if available)
    const newImage = record.dynamodb.NewImage 
      ? AWS.DynamoDB.Converter.unmarshall(record.dynamodb.NewImage) 
      : null;
      
    const oldImage = record.dynamodb.OldImage 
      ? AWS.DynamoDB.Converter.unmarshall(record.dynamodb.OldImage) 
      : null;
    
    console.log(`Processing ${eventType} event:`, { oldImage, newImage });
    
    switch (eventType) {
      case 'INSERT':
        await handleInsert(newImage);
        break;
      case 'MODIFY':
        await handleUpdate(oldImage, newImage);
        break;
      case 'REMOVE':
        await handleDelete(oldImage);
        break;
    }
  }
  
  console.log(`Successfully processed ${event.Records.length} records`);
  return { status: 'success', count: event.Records.length };
};

async function handleInsert(item) {
  // Handle item creation
  console.log(`New item created: ${item.id}`);
  // Example: update search index, send notification, etc.
}

async function handleUpdate(oldItem, newItem) {
  // Handle item update
  console.log(`Item updated: ${newItem.id}`);
  // Example: track changes, update aggregates, etc.
}

async function handleDelete(item) {
  // Handle item deletion
  console.log(`Item deleted: ${item.id}`);
  // Example: clean up related resources, archive data, etc.
}
        

Environment Variables Best Practices

• Use for configuration: Connection strings, feature flags, API endpoints
• Environment separation: Development, testing, production settings
• Don't store secrets: Use AWS Secrets Manager or Parameter Store for sensitive values
• Define defaults: Always provide fallback values for optional settings
• Keep size small: Environment variables contribute to cold start time

IAM Best Practices for Lambda

• Principle of least privilege: Grant only the permissions needed
• Use resource-level permissions: Restrict access to specific resources
• Separate roles per function: Don't reuse roles across functions
• Use conditions: Further restrict access based on context
• Audit regularly: Review and remove unused permissions

VPC Considerations

• Cold start impact: VPC-connected functions have longer cold starts
• Internet access: Requires NAT Gateway for outbound internet access
• Security groups: Control inbound/outbound traffic
• ENI limits: Be aware of Elastic Network Interface limits in your account
• Only use when needed: Only configure VPC access if you need to access private resources

Managing Dependencies

Node.js Layers Example:

# Create a layer for common dependencies
mkdir nodejs
cd nodejs
npm init -y
npm install aws-sdk axios lodash moment

# Create layer ZIP
cd ..
zip -r layer.zip nodejs

# Create Lambda layer
aws lambda publish-layer-version \
  --layer-name common-dependencies \
  --description "Common Node.js dependencies" \
  --zip-file fileb://layer.zip \
  --compatible-runtimes nodejs14.x

# Note the LayerVersionArn from the response

# Update function to use the layer
aws lambda update-function-configuration \
  --function-name my-function \
  --layers arn:aws:lambda:us-east-1:123456789012:layer:common-dependencies:1
        

Deploy with SAM CLI

# Build the application
sam build

# Deploy the application
sam deploy --guided

# Follow the interactive prompts to configure deployment options
        

Deploy with Serverless Framework

# Install Serverless Framework
npm install -g serverless

# Create a new service
serverless create --template aws-nodejs --path my-service

# Install dependencies
cd my-service
npm install

# Deploy the service
serverless deploy
        

Connection Reuse Example

const AWS = require('aws-sdk');
const mysql = require('mysql2/promise');

// Configure AWS SDK outside the handler
AWS.config.update({ region: 'us-east-1' });

// Initialize clients outside the handler
const s3 = new AWS.S3();
const dynamoDB = new AWS.DynamoDB.DocumentClient();

// Database connection pool - initialized once per container
let connectionPool;

async function getConnectionPool() {
  if (connectionPool) {
    return connectionPool;
  }
  
  // Initialize connection pool
  connectionPool = await mysql.createPool({
    host: process.env.DB_HOST,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    database: process.env.DB_NAME,
    waitForConnections: true,
    connectionLimit: 10,
    queueLimit: 0
  });
  
  return connectionPool;
}

exports.handler = async (event) => {
  // Get database connection from the pool
  const pool = await getConnectionPool();
  
  try {
    // Use the connection pool
    const [rows] = await pool.query('SELECT * FROM users WHERE id = ?', [event.userId]);
    
    // Use the S3 client
    const imageData = await s3.getObject({
      Bucket: 'my-bucket',
      Key: `users/${event.userId}/profile.jpg`
    }).promise();
    
    // Use the DynamoDB client
    const userPrefs = await dynamoDB.get({
      TableName: 'UserPreferences',
      Key: { userId: event.userId }
    }).promise();
    
    return {
      statusCode: 200,
      body: JSON.stringify({
        user: rows[0],
        preferences: userPrefs.Item,
        imageUrl: `https://my-bucket.s3.amazonaws.com/users/${event.userId}/profile.jpg`
      })
    };
  } catch (error) {
    console.error('Error:', error);
    return {
      statusCode: 500,
      body: JSON.stringify({ message: 'Internal server error' })
    };
  }
};
        

Idempotent Operation Example

// Example of an idempotent handler for order processing
exports.handler = async (event) => {
  for (const record of event.Records) {
    try {
      // Parse the SQS message
      const message = JSON.parse(record.body);
      const orderId = message.orderId;
      
      // Check if this order has already been processed
      const orderStatus = await checkOrderStatus(orderId);
      
      if (orderStatus === 'PROCESSED' || orderStatus === 'PROCESSING') {
        console.log(`Order ${orderId} already processed or processing, skipping`);
        continue;
      }
      
      // Mark order as processing
      await updateOrderStatus(orderId, 'PROCESSING');
      
      // Process the order
      await processOrder(orderId, message.orderDetails);
      
      // Mark order as processed
      await updateOrderStatus(orderId, 'PROCESSED');
      
      console.log(`Successfully processed order ${orderId}`);
    } catch (error) {
      console.error('Error processing record:', error);
      // Let the Lambda retry the message
      throw error;
    }
  }
  
  return { status: 'success' };
};

async function checkOrderStatus(orderId) {
  // Implementation to check order status in database
}

async function updateOrderStatus(orderId, status) {
  // Implementation to update order status in database
}

async function processOrder(orderId, orderDetails) {
  // Implementation to process the order
}
        

Structured Logging Example

// Helper function for structured logging
function log(level, message, data = {}) {
  const logEntry = {
    level,
    message,
    timestamp: new Date().toISOString(),
    ...data
  };
  
  console.log(JSON.stringify(logEntry));
}

exports.handler = async (event, context) => {
  // Generate a correlation ID or use one from the event
  const correlationId = event.headers?.['x-correlation-id'] || context.awsRequestId;
  
  // Log with context
  log('info', 'Function invoked', {
    correlationId,
    functionName: context.functionName,
    functionVersion: context.functionVersion,
    eventSource: event.requestContext?.eventSource || 'direct'
  });
  
  try {
    // Process business logic
    const result = await processRequest(event, correlationId);
    
    // Log success
    log('info', 'Request processed successfully', {
      correlationId,
      executionTime: Date.now() - context.invokeStartTime,
      responseSize: JSON.stringify(result).length
    });
    
    return {
      statusCode: 200,
      body: JSON.stringify(result)
    };
  } catch (error) {
    // Log error with details
    log('error', 'Error processing request', {
      correlationId,
      errorMessage: error.message,
      errorName: error.name,
      errorStack: error.stack,
      errorCode: error.code
    });
    
    return {
      statusCode: error.statusCode || 500,
      body: JSON.stringify({
        message: error.message,
        reference: correlationId
      })
    };
  }
};

async function processRequest(event, correlationId) {
  // Business logic implementation
  log('debug', 'Processing request', {
    correlationId,
    step: 'started'
  });
  
  // Processing steps...
  
  log('debug', 'Request processed', {
    correlationId,
    step: 'completed'
  });
  
  return { result: 'success' };
}
        

Sample Code Structure

// Project structure
notes-api/
├── serverless.yml         # Infrastructure definition
├── package.json           # Dependencies
├── src/
│   ├── handlers/
│   │   ├── createNote.js  # Create note handler
│   │   ├── getNote.js     # Get note handler
│   │   ├── listNotes.js   # List notes handler
│   │   ├── updateNote.js  # Update note handler
│   │   └── deleteNote.js  # Delete note handler
│   ├── lib/
│   │   ├── dynamodb.js    # DynamoDB client
│   │   ├── response.js    # Response formatting
│   │   └── validator.js   # Input validation
│   └── models/
│       └── Note.js        # Note data model
└── tests/
    └── ...                # Unit tests
        

Example createNote.js:

const { v4: uuidv4 } = require('uuid');
const dynamodb = require('../lib/dynamodb');
const { formatResponse, formatError } = require('../lib/response');
const { validateNote } = require('../lib/validator');

const TABLE_NAME = process.env.NOTES_TABLE;

exports.handler = async (event) => {
  try {
    // Parse request body
    const body = JSON.parse(event.body);
    
    // Validate input
    const { valid, errors } = validateNote(body);
    if (!valid) {
      return formatError(400, 'Invalid input', errors);
    }
    
    // Create note item
    const note = {
      id: uuidv4(),
      userId: body.userId,
      title: body.title,
      content: body.content,
      category: body.category || 'general',
      important: body.important || false,
      completed: false,
      createdAt: new Date().toISOString(),
      updatedAt: new Date().toISOString()
    };
    
    // Save to DynamoDB
    await dynamodb.put({
      TableName: TABLE_NAME,
      Item: note
    }).promise();
    
    return formatResponse(201, note);
  } catch (error) {
    console.error('Error creating note:', error);
    return formatError(500, 'Could not create note');
  }
};