Agent skill

aws-lambda-functions

Build optimized serverless functions with Lambda

View SKILL.md on GitHub Repository
Stars 163
Forks 31

Install this agent skill to your Project

npx add-skill https://github.com/majiayu000/claude-skill-registry/tree/main/skills/development/aws-lambda-functions-pluginagentmarketpla-custom-plugin-aws

SKILL.md

AWS Lambda Functions Skill

Develop high-performance serverless functions with best practices.

Quick Reference

Attribute Value
AWS Service Lambda
Complexity Medium
Est. Time 5-15 min
Prerequisites IAM Role, (Optional) VPC

Parameters

Required

Parameter Type Description Validation
function_name string Function name ^[a-zA-Z0-9-_]{1,64}$
runtime string Runtime environment python3.12, nodejs20.x, etc.
handler string Handler function module.function
role_arn string Execution role ARN Valid IAM role ARN

Optional

Parameter Type Default Description
memory_mb int 128 Memory allocation (128-10240)
timeout int 3 Timeout seconds (1-900)
architecture string x86_64 x86_64 or arm64
environment object {} Environment variables
vpc_config object null VPC configuration

Execution Flow

1. Package code and dependencies
2. Create/update function
3. Configure triggers
4. Set concurrency limits
5. Test invocation
6. Monitor cold starts

Implementation

Create Function

bash
# Create deployment package
zip -r function.zip . -x "*.git*"

# Create function
aws lambda create-function \
  --function-name my-function \
  --runtime python3.12 \
  --architectures arm64 \
  --handler main.handler \
  --role arn:aws:iam::123456789012:role/lambda-role \
  --zip-file fileb://function.zip \
  --memory-size 1024 \
  --timeout 30 \
  --environment "Variables={LOG_LEVEL=INFO}" \
  --tracing-config Mode=Active

Handler Template (Python)

python
import json
import logging

logger = logging.getLogger()
logger.setLevel(logging.INFO)

def handler(event, context):
    """
    Lambda handler function.

    Args:
        event: Trigger event data
        context: Runtime context (request_id, memory_limit, etc.)

    Returns:
        Response object or value
    """
    try:
        logger.info(f"Event: {json.dumps(event)}")

        # Business logic here
        result = process_event(event)

        return {
            "statusCode": 200,
            "body": json.dumps(result)
        }
    except Exception as e:
        logger.error(f"Error: {str(e)}")
        return {
            "statusCode": 500,
            "body": json.dumps({"error": str(e)})
        }

Handler Template (Node.js)

javascript
export const handler = async (event, context) => {
    console.log('Event:', JSON.stringify(event));

    try {
        const result = await processEvent(event);

        return {
            statusCode: 200,
            body: JSON.stringify(result)
        };
    } catch (error) {
        console.error('Error:', error);
        return {
            statusCode: 500,
            body: JSON.stringify({ error: error.message })
        };
    }
};

Memory/CPU Optimization

Memory vCPU Network Use Case
128 MB 0.08 Low Simple transforms
512 MB 0.33 Low Basic API handlers
1024 MB 0.58 Medium Standard workloads
1769 MB 1.0 Medium CPU-bound tasks
3008 MB 2.0 High Parallel processing
10240 MB 6.0 Very High Data processing

Cold Start Mitigation

  1. Use arm64: ~34% better price-performance
  2. Minimize package: Only required dependencies
  3. Use Layers: Shared dependencies
  4. Provisioned Concurrency: Pre-warmed functions
  5. SnapStart (Java): Cached initialization
  6. Avoid VPC: Unless necessary (+1s cold start)

Troubleshooting

Common Issues

Symptom Cause Solution
Timeout Long execution Increase timeout, optimize code
OOM (signal: killed) Memory exceeded Increase memory
Import error Missing dependency Check package includes deps
Permission denied IAM role Update execution role

Debug Checklist

  • Handler path correct (file.function)?
  • All dependencies packaged?
  • Execution role has permissions?
  • Environment variables set?
  • Memory sufficient for workload?
  • Timeout appropriate?
  • VPC has NAT for internet?

CloudWatch Log Patterns

Task timed out after X.XX seconds → Increase timeout
Runtime exited with error: signal: killed → Increase memory
Unable to import module → Check handler path/dependencies
ECONNREFUSED → Check VPC/security group

Test Template

python
def test_lambda_handler():
    # Arrange
    event = {"key": "value"}
    context = MockContext()

    # Act
    response = handler(event, context)

    # Assert
    assert response["statusCode"] == 200
    body = json.loads(response["body"])
    assert "result" in body

Observability

X-Ray Tracing

python
from aws_xray_sdk.core import xray_recorder

@xray_recorder.capture('process_data')
def process_data(data):
    # Traced function
    pass

Structured Logging

json
{
  "level": "INFO",
  "message": "Processing request",
  "request_id": "abc-123",
  "function_name": "my-function",
  "cold_start": true
}

Assets

  • assets/lambda-template.py - Python handler template

References

Didn't find tool you were looking for?

Be as detailed as possible for better results