AWS Lambda Function Development

This skill guides you through creating, deploying, and managing AWS Lambda serverless functions based on AWS documentation best practices.

What This Skill Does

Helps you build AWS Lambda functions from scratch, covering:

Function creation and configuration

Event-driven handler implementation

Runtime selection (Node.js, Python, and others)

CloudWatch Logs integration

IAM execution roles

Testing and invocation patterns

Deployment and cleanup workflows

Instructions

1. Verify AWS Prerequisites

Before creating Lambda functions:

Confirm AWS account is configured with appropriate credentials

Verify IAM permissions for Lambda, CloudWatch Logs, and relevant AWS services

Check that AWS CLI or SDK is properly configured if deploying programmatically

For console-based work, ensure user has access to Lambda console at `https://console.aws.amazon.com/lambda/`

2. Create Lambda Function Structure

When creating a new Lambda function:

**For Node.js (ESM):**

```javascript

export const handler = async (event, context) => {

// Extract parameters from event object

const param1 = event.param1;

const param2 = event.param2;

// Business logic

const result = processData(param1, param2);

// Logging for CloudWatch

console.log(`Processed result: ${result}`);

console.log('CloudWatch log group:', context.logGroupName);

// Return JSON response

return JSON.stringify({

statusCode: 200,

body: result

});

};

function processData(param1, param2) {

// Your logic here

return param1 + param2;

}

```

**For Python:**

```python

import json

import logging

logger = logging.getLogger()

logger.setLevel(logging.INFO)

def lambda_handler(event, context):

# Extract parameters from event dictionary

param1 = event['param1']

param2 = event['param2']

# Business logic

result = process_data(param1, param2)

# Logging for CloudWatch

print(f"Processed result: {result}")

logger.info(f"CloudWatch log group: {context.log_group_name}")

# Return JSON response

return json.dumps({

'statusCode': 200,

'body': result

})

def process_data(param1, param2):

# Your logic here

return param1 + param2

```

3. Configure Function Settings

Set up essential Lambda configuration:

**Function name**: Use descriptive, kebab-case naming (e.g., `process-user-data`)

**Runtime**: Select appropriate runtime version (Node.js 24, Python 3.14, etc.)

**Architecture**: Choose x86_64 or arm64 (Graviton2)

**Execution role**: Create or attach IAM role with required permissions

- Minimum: `AWSLambdaBasicExecutionRole` for CloudWatch Logs

- Add additional policies for AWS service integrations (S3, DynamoDB, etc.)

**Memory**: Start with 256 MB, adjust based on performance testing

**Timeout**: Default 3 seconds, increase for longer-running functions (max 15 minutes)

4. Understand Event and Context Objects

**Event Object:**

JSON document containing input data for your function

Structure varies based on invocation source (API Gateway, S3, EventBridge, etc.)

For manual testing, create custom JSON test events in console

Access properties directly: `event.propertyName` (Node.js) or `event['propertyName']` (Python)

**Context Object:**

Automatically passed by Lambda runtime

Contains invocation metadata:

- `context.logGroupName` / `context.log_group_name`: CloudWatch Logs group

- `context.requestId` / `context.aws_request_id`: Unique invocation ID

- `context.functionName` / `context.function_name`: Function name

- `context.getRemainingTimeInMillis()` / `context.get_remaining_time_in_millis()`: Time left before timeout

5. Implement Logging Best Practices

**For Node.js:**

Use `console.log()`, `console.error()`, `console.warn()` for basic logging

Logs automatically captured by CloudWatch

Consider structured logging for production:

```javascript

console.log(JSON.stringify({

level: 'INFO',

message: 'Processing started',

requestId: context.requestId,

data: { userId: event.userId }

}));

```

**For Python:**

Use `logging` module (recommended) or `print()` statements

Configure logger level: `logger.setLevel(logging.INFO)`

Log with context:

```python

logger.info('Processing started', extra={

'requestId': context.aws_request_id,

'userId': event['userId']

})

```

6. Test Function in Console

Create and run test events:

1. Navigate to "Test" tab in Lambda console

2. Create new test event with JSON payload matching your function's expected input

3. Example test event:

```json

{

"param1": 10,

"param2": 5

}

```

4. Click "Test" to invoke function

5. Review execution results, logs, and duration

6. Check CloudWatch Logs for detailed log output (link provided in test results)

7. Deploy Function Code

**Via Console:**

Edit code directly in built-in code editor

Click "Deploy" button to save changes

Best for interpreted languages (Node.js, Python)

**Via CLI/SDK (for compiled languages or CI/CD):**

```bash

Package code

zip function.zip index.js

Update function code

aws lambda update-function-code \

--function-name myLambdaFunction \

--zip-file fileb://function.zip

```

8. Monitor and Debug

Access function metrics and logs:

**CloudWatch Logs**: View invocation logs at `/aws/lambda/{function-name}`

**Metrics**: Monitor invocations, duration, errors, throttles in CloudWatch

**X-Ray**: Enable active tracing for distributed tracing (optional)

**Error handling**: Implement try-catch blocks and return appropriate error responses

9. Clean Up Resources

When deleting a function:

1. Navigate to Lambda console

2. Select function to delete

3. Choose "Actions" → "Delete function"

4. Confirm deletion

5. Manually delete associated resources:

- CloudWatch Log groups (if not auto-deleted)

- IAM execution roles (if custom-created)

- EventBridge rules or other triggers

Usage Examples

**Example 1: Simple Data Processing Function**

```javascript

// Calculate area from dimensions

export const handler = async (event) => {

const { length, width } = event;

const area = length * width;

return {

statusCode: 200,

body: JSON.stringify({ area })

};

```

**Example 2: S3 Event Handler**

```python

def lambda_handler(event, context):

# Process S3 upload event

bucket = event['Records'][0]['s3']['bucket']['name']

key = event['Records'][0]['s3']['object']['key']

logger.info(f"Processing {key} from {bucket}")

# Your S3 processing logic here

return {'statusCode': 200}

```

**Example 3: API Gateway Integration**

```javascript

export const handler = async (event) => {

// Parse API Gateway request

const body = JSON.parse(event.body);

const userId = event.pathParameters.userId;

// Process request

const result = await processUserData(userId, body);

// Return API Gateway-compatible response

return {

statusCode: 200,

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

body: JSON.stringify(result)

};

```

Important Notes

**Handler naming**: Default handlers are `index.handler` (Node.js) or `lambda_function.lambda_handler` (Python). Changing handler function names requires updating configuration.

**Cold starts**: First invocation may take longer as Lambda initializes execution environment. Keep initialization code outside handler for reuse.

**Timeouts**: Default 3-second timeout. Increase for long-running operations (max 900 seconds).

**Concurrency**: Lambda automatically scales. Monitor throttling if hitting account concurrency limits.

**Security**: Follow principle of least privilege for IAM execution roles. Never hardcode credentials.

**Environment variables**: Use for configuration (accessible via `process.env` in Node.js, `os.environ` in Python).

**Layers**: Use Lambda Layers for shared libraries and dependencies across functions.

Next Steps

Set up function triggers (API Gateway, S3, EventBridge, etc.)

Implement error handling and dead-letter queues

Configure reserved concurrency for production workloads

Set up CI/CD pipelines with AWS SAM or Serverless Framework

Explore Lambda@Edge for CloudFront integration

Review AWS Lambda pricing and optimize function performance

AWS Lambda Function Development

AWS Lambda Function Development

What This Skill Does

Instructions

1. Verify AWS Prerequisites

2. Create Lambda Function Structure

3. Configure Function Settings

4. Understand Event and Context Objects

5. Implement Logging Best Practices

6. Test Function in Console

7. Deploy Function Code

Package code

Update function code

8. Monitor and Debug

9. Clean Up Resources

Usage Examples

Important Notes

Next Steps

Reviews (0)