aws-lambda-java-integration
Provides AWS Lambda integration patterns for Java with cold start optimization. Use when deploying Java functions to AWS Lambda, choosing between Micronaut and Raw Java approaches, optimizing cold starts below 1 second, configuring API Gateway or ALB integration, or implementing serverless Java appl
By giuseppe-trisciuoglio · 2,719 installs
npx skills add giuseppe-trisciuoglio/developer-kit --skill aws-lambda-java-integration
Source repository · Upstream listing
AWS Lambda Java Integration
Patterns for creating high performance AWS Lambda functions in Java with optimized cold starts.
Overview
This skill provides complete patterns for AWS Lambda Java development, covering two main approaches:
1. Micronaut Framework Full featured framework with AOT compilation, dependency injection, and cold start < 1s
2. Raw Java Minimal overhead approach with cold start < 500ms
Both approaches support API Gateway and ALB integration with production ready configurations.
When to Use
Deploying Java functions to AWS Lambda
Optimizing cold starts below 1 second
Choosing between Micronaut and Raw Java approaches
Configuring API Gateway or ALB integration
Setting up CI/CD pipelines for Java Lambda
Instructions
1. Choose Your Approach
Approach Cold Start Best For Complexity
Micronaut < 1s Complex apps, DI needed, enterprise Medium
Raw Java < 500ms Simple handlers, minimal overhead Low
Validate : Confirm the approach fits your use case before proceeding.
2. Project Structure
Validate : Verify project structure matches the template.
3. Implementation Examples
Micronaut Handler
Raw Java Handler
Validate : Run sam local invoke to verify handler works before deployment.
Core Patterns
Connection Management
Error Handling
Best Practices
Configuration
Memory : Start with 512MB, adjust based on profiling
Timeout : Micronaut 10 30s, Raw Java 5 10s
Runtime : Java 17 or 21 for best performance
Packaging
Use Gradle Shadow Plugin or Maven Shade Plugin
Exclude unnecessary dependencies
Monitoring
Enable X Ray tracing for performance analysis
Use CloudWatch Insights to track cold vs warm starts
Deployment Options
Serverless Framework
Validate : Run serverless deploy with stage dev first.
AWS SAM
Validate : Run sam validate before deploying.
Constraints and Warnings
Java Specific Constraints
Reflection : Minimize use; prefer AOT compilation (Micronaut)
Classpath scanning : Slows cold start; use explicit configuration
Large frameworks : Spring Boot adds significant cold start overhead
Common Pitfalls
1. Initialization in handler Causes repeated work on warm invocations
2. Oversized JARs Include only required dependencies
3. Insufficient memory Java needs more memory than Node.js/Python
4. No timeout handling Always set appropriate timeouts
References
For detailed guidance on specific topics:
[Micronaut Lambda](references/micronaut lambda.md) Complete Micronaut setup, AOT configuration, DI optimization
[Raw Java Lambda](references/raw java lambda.md) Minimal handler patterns, singleton caching, JAR packaging
[Serverless Deployment](references/serverless deployment.md) Serverless Framework, SAM, CI/CD pipelines, provisioned concurrency
[Testing Lambda](references/testing lambda.md) JUnit 5, SAM Local, integration testing, performance measurement
Examples
Example 1: Create a Micronaut Lambda Function
Input:
Process:
1. Configure Gradle project with Micronaut plugin
2. Create Handler class extending MicronautRequestHandler
3. Implement methods for GET/POST/PUT/DELETE
4. Configure application.yml with AOT optimizations
5. Set up packaging with Shadow plugin
6. Validate : Test locally with SAM CLI before deploying
Output:
Complete project structure
Handler with dependency injection
serverless.yml deployment configuration
Example 2: Optimize Cold Start for Raw Java
Input:
Process:
1. Analyze initialization code
2. Move AWS client creation to static fields
3. Reduce dependencies in build.gradle
4. Configure optimized JVM options
5. Consider provisioned concurrency
6. Validate : Measure cold start with CloudWatch metrics after changes
Output:
Refactored code with singleton pattern
Minimized JAR
Cold start < 500ms
Example 3: Deploy with GitHub Actions
Input:
Process:
1. Create GitHub Actions workflow
2. Configure Gradle build with Shadow
3. Set up SAM build and deploy
4. Add test stage before deployment
5. Configure environment protection for prod
Output:
Complete .github/workflows/deploy.yml
Multi stage pipeline (dev/staging/prod)
Integrated test automation
Version
Version: 1.0.0