AWS Lambda: The Ultimate Serverless Function Cheatsheet

Introduction: What is AWS Lambda and Why It Matters

AWS Lambda is a serverless compute service that runs your code in response to events and automatically manages the underlying compute resources. With Lambda, you can run code without provisioning or managing servers, paying only for the compute time you consume.

Key Benefits:

• Zero Server Management: No servers to provision, patch, or maintain
• Continuous Scaling: Automatically scales with workload demands
• Cost Efficiency: Pay only for compute time used (to the nearest millisecond)
• Event-Driven: Executes code in response to various AWS service events
• Flexible Integration: Works with virtually any application or backend service
• Multiple Languages: Supports Node.js, Python, Java, Go, .NET, Ruby and custom runtimes

Core Lambda Concepts

Lambda Function Components

Lambda Execution Model

Lambda Limits and Quotas

Creating and Managing Lambda Functions

Step-by-Step: Creating a Basic Lambda Function

1. Navigate to the Lambda console

   • Sign in to AWS Management Console
   • Go to Lambda service

2. Create a new function

   • Click “Create function”
   • Choose “Author from scratch”, “Use a blueprint”, or “Container image”

3. Configure basic settings

   • Enter function name
   • Select runtime (e.g., Python 3.9, Node.js 16.x)
   • Choose or create an execution role

4. Write or upload function code

   • Use inline editor for simple functions
   • Upload a ZIP file for more complex functions

5. Configure function settings

   • Set memory allocation (128 MB – 10,240 MB)
   • Set timeout value (up to 15 minutes)
   • Configure environment variables

6. Set up triggers (optional)

   • Select event sources to trigger the function

7. Configure destinations (optional)

   • Define where to send results of asynchronous invocations

8. Save and test the function

   • Create a test event
   • Invoke the function to verify it works correctly

Lambda Function Handler Structures by Language

Sample Function Code by Language

Node.js (JavaScript)

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

Python

import json

def lambda_handler(event, context):
    print('Event: ', json.dumps(event))
    return {
        'statusCode': 200,
        'body': json.dumps('Hello from Lambda!')
    }

Java

package com.example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;

public class LambdaHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        context.getLogger().log("Input: " + input);
        
        APIGatewayProxyResponseEvent response = new APIGatewayProxyResponseEvent();
        response.setStatusCode(200);
        response.setBody("Hello from Lambda!");
        return response;
    }
}

Go

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "github.com/aws/aws-lambda-go/events"
    "github.com/aws/aws-lambda-go/lambda"
)

func handler(ctx context.Context, request events.APIGatewayProxyRequest) (events.APIGatewayProxyResponse, error) {
    fmt.Printf("Request: %+v\n", request)
    
    return events.APIGatewayProxyResponse{
        StatusCode: 200,
        Body:       "Hello from Lambda!",
    }, nil
}

func main() {
    lambda.Start(handler)
}

Lambda Integrations and Event Sources

Common Lambda Triggers

Event Source Mapping Types

Integration Configuration Examples

API Gateway Trigger

{
  "Type": "Api",
  "Properties": {
    "Path": "/items",
    "Method": "GET",
    "RestApiId": { "Ref": "MyApi" }
  }
}

S3 Event Trigger

{
  "Type": "S3",
  "Properties": {
    "Bucket": { "Ref": "MyBucket" },
    "Events": "s3:ObjectCreated:*",
    "Filter": {
      "S3Key": {
        "Rules": [
          { "Name": "prefix", "Value": "uploads/" },
          { "Name": "suffix", "Value": ".jpg" }
        ]
      }
    }
  }
}

EventBridge (CloudWatch Events) Schedule

{
  "Type": "Schedule",
  "Properties": {
    "Schedule": "rate(1 hour)",
    "Input": { "key": "value" }
  }
}

Lambda Deployment Strategies

Deployment Package Types

Deployment Tools and Methods

AWS Serverless Application Model (SAM) Example

AWSTemplateFormatVersion: '2010-09-09'
Transform: AWS::Serverless-2016-10-31
Resources:
  MyFunction:
    Type: AWS::Serverless::Function
    Properties:
      Handler: index.handler
      Runtime: nodejs14.x
      CodeUri: ./src/
      MemorySize: 256
      Timeout: 10
      Environment:
        Variables:
          TABLE_NAME: !Ref MyTable
      Policies:
        - DynamoDBCrudPolicy:
            TableName: !Ref MyTable
      Events:
        ApiEvent:
          Type: Api
          Properties:
            Path: /hello
            Method: get

  MyTable:
    Type: AWS::Serverless::SimpleTable
    Properties:
      PrimaryKey:
        Name: id
        Type: String

Lambda Performance and Optimization

Optimizing Cold Starts

Memory and Performance Tuning

Performance Testing and Monitoring

Common Challenges and Solutions

Error Handling and Retries

Network and VPC Integration

Security Challenges

Lambda CLI Quick Reference

Function Management

# Create a function
aws lambda create-function \
  --function-name my-function \
  --runtime python3.9 \
  --zip-file fileb://function.zip \
  --handler lambda_function.lambda_handler \
  --role arn:aws:iam::123456789012:role/lambda-role

# Update function code
aws lambda update-function-code \
  --function-name my-function \
  --zip-file fileb://function.zip

# Update function configuration
aws lambda update-function-configuration \
  --function-name my-function \
  --timeout 30 \
  --memory-size 512 \
  --environment "Variables={KEY=VALUE}"

# List functions
aws lambda list-functions

# Get function details
aws lambda get-function --function-name my-function

# Delete function
aws lambda delete-function --function-name my-function

Invocation and Testing

# Invoke function synchronously
aws lambda invoke \
  --function-name my-function \
  --payload '{"key": "value"}' \
  output.txt

# Invoke function asynchronously
aws lambda invoke \
  --function-name my-function \
  --payload '{"key": "value"}' \
  --invocation-type Event \
  output.txt

# Get function logs
aws logs get-log-events \
  --log-group-name /aws/lambda/my-function \
  --log-stream-name 2023/05/14/[$LATEST]1234567890

Permissions and Triggers

# Add permission for S3 to invoke function
aws lambda add-permission \
  --function-name my-function \
  --statement-id s3-trigger \
  --action lambda:InvokeFunction \
  --principal s3.amazonaws.com \
  --source-arn arn:aws:s3:::my-bucket

# Create event source mapping (for poll-based services)
aws lambda create-event-source-mapping \
  --function-name my-function \
  --event-source-arn arn:aws:sqs:us-east-1:123456789012:my-queue \
  --batch-size 10

# List event source mappings
aws lambda list-event-source-mappings \
  --function-name my-function

Layers and Versions

# Publish a layer
aws lambda publish-layer-version \
  --layer-name my-layer \
  --zip-file fileb://layer.zip \
  --compatible-runtimes python3.8 python3.9

# Add layer to function
aws lambda update-function-configuration \
  --function-name my-function \
  --layers arn:aws:lambda:us-east-1:123456789012:layer:my-layer:1

# Publish a version
aws lambda publish-version \
  --function-name my-function \
  --description "Production version"

# Create an alias
aws lambda create-alias \
  --function-name my-function \
  --name production \
  --function-version 1

Advanced Lambda Patterns

Lambda Concurrency Types

Canary Deployments with Aliases

1. Create function versions

   • Publish a version representing stable code
   • Update function code and publish new version

2. Configure alias with routing

   aws lambda create-alias \
     --function-name my-function \
     --name production \
     --function-version 1 \
     --routing-config '{"AdditionalVersionWeights": {"2": 0.1}}'
   

3. Gradually update weights

   • Increase traffic to new version over time
   • Monitor the performance and errors
   • Complete the deployment by setting alias to new version

Lambda State Machine Patterns

AWS Step Functions Integration Example

{
  "Comment": "A simple order processing workflow",
  "StartAt": "ProcessOrder",
  "States": {
    "ProcessOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:process-order",
      "Next": "CheckInventory"
    },
    "CheckInventory": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:check-inventory",
      "Next": "InventoryChoice"
    },
    "InventoryChoice": {
      "Type": "Choice",
      "Choices": [
        {
          "Variable": "$.inventoryExists",
          "BooleanEquals": true,
          "Next": "ProcessPayment"
        }
      ],
      "Default": "NotifyOutOfStock"
    },
    "ProcessPayment": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:process-payment",
      "Next": "ShipOrder"
    },
    "ShipOrder": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:ship-order",
      "End": true
    },
    "NotifyOutOfStock": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:us-east-1:123456789012:function:notify-out-of-stock",
      "End": true
    }
  }
}

Lambda Monitoring and Troubleshooting

CloudWatch Metrics to Monitor

Troubleshooting Common Lambda Issues

Interpreting Lambda Logs

START RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 Version: $LATEST
2020-06-22T15:05:07.409Z 6bc28136-xmpl-4365-b021-0ce6b2e64ab0 INFO  ENVIRONMENT VARIABLES:
{
    "AWS_LAMBDA_FUNCTION_VERSION": "$LATEST",
    "AWS_LAMBDA_LOG_GROUP_NAME": "/aws/lambda/my-function",
    "AWS_LAMBDA_LOG_STREAM_NAME": "2020/06/22/[$LATEST]fc11c7c43833457e9136f9b3cabd85ad",
    ...
}
REPORT RequestId: 6bc28136-xmpl-4365-b021-0ce6b2e64ab0
Duration: 1055.52 ms
Billed Duration: 1056 ms
Memory Size: 128 MB
Max Memory Used: 67 MB
Init Duration: 430.47 ms

Key Log Components:

• START line: Beginning of invocation with RequestId
• INFO/ERROR lines: Custom log output from your function
• REPORT line: Performance metrics including:
  • Duration: Actual execution time
  • Billed Duration: Rounded up to nearest millisecond
  • Memory Size: Configured memory
  • Max Memory Used: Actual memory consumption
  • Init Duration: Time spent initializing (cold start)

Best Practices for Lambda Functions

Performance Best Practices

• Initialize SDK clients and database connections outside handler function
• Use global/static variables to cache state between invocations
• Minimize deployment package size by removing unnecessary dependencies
• Set function memory based on performance needs
• Use appropriate asynchronous patterns for long-running tasks
• Implement retries with exponential backoff for transient failures
• Use Provisioned Concurrency for latency-sensitive applications

Security Best Practices

• Follow least privilege principle when configuring IAM roles
• Never store credentials in function code or environment variables
• Use AWS Secrets Manager or Parameter Store for sensitive data
• Validate all input data before processing
• Implement function timeout appropriate to task
• Enable AWS X-Ray for request tracing
• Encrypt environment variables with KMS
• Regularly update dependencies and runtime versions

Cost Optimization Best Practices

• Set appropriate memory settings to minimize duration
• Use Lambda Power Tuning to find optimal memory configuration
• Combine similar functions to reduce number of invocations
• Implement request batching when possible
• Use websockets for real-time applications instead of polling
• Choose efficient trigger patterns (filtering at the source)
• Consider container-based alternatives for long-running processes

Development and Testing Best Practices

• Use AWS SAM CLI for local testing
• Implement unit and integration tests
• Use layers for shared dependencies
• Implement CI/CD pipelines for automated deployment
• Version functions and use aliases for deployment stages
• Use environment variables for stage-specific configuration
• Implement structured logging with contextual information

Resources for Further Learning

Official AWS Resources

• AWS Lambda Documentation
• AWS Lambda Developer Guide
• AWS Serverless Application Model (SAM)
• AWS Lambda Sample Applications
• AWS Lambda Power Tuning
• AWS Serverless Workshops

Community Resources

• Serverless Framework
• AWS Lambda Powertools
• CDK Patterns
• Serverless Land
• Jeremy Daly’s Newsletter

Books and Courses

• “Serverless Applications with Node.js” by Slobodan Stojanović
• “AWS Lambda in Action” by Danilo Poccia
• A Cloud Guru’s AWS Lambda courses