AWS Lambda Deep Dive

1// ✅ INIT PHASE — runs ONCE per execution environment lifecycle
2const { DynamoDBClient } = require('@aws-sdk/client-dynamodb');
3const { DynamoDBDocumentClient, GetCommand } = require('@aws-sdk/lib-dynamodb');
4
5// Initialize expensive resources here — reused across warm invocations
6const ddbClient = new DynamoDBClient({ region: process.env.AWS_REGION });
7const docClient = DynamoDBDocumentClient.from(ddbClient);
8const CONFIG = JSON.parse(process.env.APP_CONFIG ?? '{}');
9
10// ✅ INVOKE PHASE — runs on EVERY invocation
11exports.handler = async (event) => {
12  // ddbClient and CONFIG are already initialized — zero overhead on warm starts
13  const result = await docClient.send(new GetCommand({
14    TableName: 'Users',
15    Key: { userId: event.pathParameters.userId },
16  }));
17  return { statusCode: 200, body: JSON.stringify(result.Item) };
18};

1// ⚠️ Module-scope state persists between warm invocations on the same environment
2let requestCount = 0;
3
4exports.handler = async (event) => {
5  requestCount += 1;
6  console.log(`Warm invocation #${requestCount} on this environment`);
7  // Never rely on this for business logic — any invocation may hit a fresh environment
8};

1exports.handler = async function(event, context) {
2  console.log('Event:', JSON.stringify(event));
3  console.log('Request ID:', context.awsRequestId);
4  console.log('Remaining time (ms):', context.getRemainingTimeInMillis());
5  console.log('Memory limit (MB):', context.memoryLimitInMB);
6
7  return {
8    statusCode: 200,
9    body: JSON.stringify({ message: 'Hello from Lambda!' }),
10  };
11};

1import json
2
3def handler(event, context):
4    print(f"Request ID: {context.aws_request_id}")
5    print(f"Remaining time: {context.get_remaining_time_in_millis()}ms")
6    print(f"Memory limit: {context.memory_limit_in_mb}MB")
7
8    return {
9        'statusCode': 200,
10        'body': json.dumps({'message': 'Hello from Lambda!'})
11    }

1{
2  "httpMethod": "POST",
3  "path": "/orders",
4  "queryStringParameters": { "source": "web" },
5  "headers": { "Authorization": "Bearer eyJhbGci..." },
6  "body": "{\"product\": \"widget\", \"qty\": 3}",
7  "requestContext": { "requestId": "abc-123", "stage": "prod" }
8}

1// Lambda response format for API Gateway proxy integration
2exports.handler = async (event) => {
3  const body = JSON.parse(event.body ?? '{}');
4  return {
5    statusCode: 201,
6    headers: { 'Content-Type': 'application/json' },
7    body: JSON.stringify({ orderId: 'ORD-' + Date.now(), ...body }),
8  };
9};

1{
2  "Records": [{
3    "eventSource": "aws:s3",
4    "eventName": "ObjectCreated:Put",
5    "s3": {
6      "bucket": { "name": "my-uploads-bucket" },
7      "object": { "key": "uploads/photo.jpg", "size": 2097152 }
8    }
9  }]
10}

1{
2  "Records": [{
3    "messageId": "19dd0b57-1234-4f67-8a7b-ce3b2d0c5d2f",
4    "body": "{\"orderId\": \"ORD-001\", \"amount\": 49.99}",
5    "attributes": { "ApproximateReceiveCount": "1" },
6    "eventSource": "aws:sqs"
7  }]
8}

1exports.handler = async (event) => {
2  const batchItemFailures = [];
3
4  for (const record of event.Records) {
5    try {
6      await processOrder(JSON.parse(record.body));
7    } catch (err) {
8      console.error(`Failed: ${record.messageId}`, err.message);
9      batchItemFailures.push({ itemIdentifier: record.messageId });
10    }
11  }
12
13  return { batchItemFailures };
14  // Requires FunctionResponseTypes: ['ReportBatchItemFailures'] on the event source mapping
15};

1# Enable Provisioned Concurrency on the "prod" alias
2aws lambda put-provisioned-concurrency-config \
3  --function-name MyFunction \
4  --qualifier prod \
5  --provisioned-concurrent-executions 100

1// ❌ ANTI-PATTERN: Import entire AWS SDK v2 (loads all ~700 service clients)
2const AWS = require('aws-sdk');
3
4// ✅ BEST PRACTICE: AWS SDK v3 — modular, import only what you need
5const { S3Client, GetObjectCommand } = require('@aws-sdk/client-s3');
6const s3 = new S3Client({}); // Initialized ONCE in module scope
7
8// ❌ ANTI-PATTERN: Require heavy module inside handler (runs every invocation)
9exports.handler = async (event) => {
10  const sharp = require('sharp');
11  return await sharp(event.imageData).resize(800, 600).toBuffer();
12};
13
14// ✅ BEST PRACTICE: Lazy-load and cache heavy modules in module scope
15let sharp;
16exports.handler = async (event) => {
17  if (!sharp) sharp = require('sharp'); // Load once, cached for warm invocations
18  return await sharp(event.imageData).resize(800, 600).toBuffer();
19};

1{
2  "Effect": "Allow",
3  "Action": [
4    "ec2:CreateNetworkInterface",
5    "ec2:DescribeNetworkInterfaces",
6    "ec2:DescribeSubnets",
7    "ec2:DeleteNetworkInterface",
8    "ec2:AssignPrivateIpAddresses",
9    "ec2:UnassignPrivateIpAddresses"
10  ],
11  "Resource": "*"
12}

1# Build a Node.js dependency layer
2mkdir -p layer/nodejs && cd layer/nodejs
3npm install lodash axios
4cd ../.. && zip -r deps-layer.zip layer/
5
6# Publish the layer
7aws lambda publish-layer-version \
8  --layer-name common-nodejs-deps \
9  --description "Shared Node.js dependencies" \
10  --zip-file fileb://deps-layer.zip \
11  --compatible-runtimes nodejs18.x nodejs20.x
12
13# Attach the layer to a function
14aws lambda update-function-configuration \
15  --function-name MyFunction \
16  --layers arn:aws:lambda:us-east-1:123456789:layer:common-nodejs-deps:1

1from aws_lambda_powertools import Logger, Tracer, Metrics
2from aws_lambda_powertools.metrics import MetricUnit
3
4logger = Logger()
5tracer = Tracer()
6metrics = Metrics(namespace="MyApp")
7
8@logger.inject_lambda_context
9@tracer.capture_lambda_handler
10@metrics.log_metrics
11def handler(event, context):
12    metrics.add_metric(name="OrderProcessed", unit=MetricUnit.Count, value=1)
13    logger.info("Processing order", order_id=event["orderId"])
14    return {"statusCode": 200}

1aws lambda put-function-event-invoke-config \
2  --function-name MyFunction \
3  --destination-config '{
4    "OnSuccess": { "Destination": "arn:aws:events:us-east-1:123:event-bus/my-bus" },
5    "OnFailure":  { "Destination": "arn:aws:sqs:us-east-1:123:my-dlq" }
6  }'

1# Publish a version from $LATEST
2aws lambda publish-version \
3  --function-name MyFunction \
4  --description "v2.3.1 — improved error handling"
5
6# Versioned ARN:  arn:aws:lambda:us-east-1:123:function:MyFunction:7
7# $LATEST ARN:    arn:aws:lambda:us-east-1:123:function:MyFunction:$LATEST

1# Create "prod" alias pointing to version 6
2aws lambda create-alias \
3  --function-name MyFunction --name prod --function-version 6
4
5# Canary: send 10% of traffic to v7, 90% stays on v6
6aws lambda update-alias \
7  --function-name MyFunction --name prod \
8  --function-version 6 \
9  --routing-config AdditionalVersionWeights={"7"=0.1}
10
11# After validation: promote v7 to 100% of traffic
12aws lambda update-alias \
13  --function-name MyFunction --name prod \
14  --function-version 7 \
15  --routing-config AdditionalVersionWeights={}

1# Use the official AWS Lambda base image
2FROM public.ecr.aws/lambda/nodejs:20
3
4# Install production dependencies
5COPY package.json package-lock.json ${LAMBDA_TASK_ROOT}/
6RUN npm ci --omit=dev
7
8# Copy function code
9COPY index.mjs ${LAMBDA_TASK_ROOT}/
10
11# Set the handler (filename.exportedFunction)
12CMD ["index.handler"]

1# Authenticate Docker to Amazon ECR
2aws ecr get-login-password --region us-east-1 \
3  | docker login --username AWS --password-stdin 123456789.dkr.ecr.us-east-1.amazonaws.com
4
5# Build, tag, and push the image
6docker build -t my-lambda:latest .
7docker tag my-lambda:latest 123456789.dkr.ecr.us-east-1.amazonaws.com/my-lambda:latest
8docker push 123456789.dkr.ecr.us-east-1.amazonaws.com/my-lambda:latest