aws-lambda-java-integration

仓库: giuseppe-trisciuoglio/developer-kit
安装量: 163
排名: #5296

安装

npx skills add https://github.com/giuseppe-trisciuoglio/developer-kit --skill aws-lambda-java-integration
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:
Micronaut Framework
- Full-featured framework with AOT compilation, dependency injection, and cold start < 1s
Raw Java
- Minimal overhead approach with cold start < 500ms
Both approaches support API Gateway and ALB integration with production-ready configurations.
When to Use
Use this skill when:
Creating new Lambda functions in Java
Migrating existing Java applications to Lambda
Optimizing cold start performance for Java Lambda
Choosing between framework-based and minimal Java approaches
Configuring API Gateway or ALB integration
Setting up deployment 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
2. Project Structure
my-lambda-function/
├── build.gradle (or pom.xml)
├── src/
│ └── main/
│ ├── java/
│ │ └── com/example/
│ │ └── Handler.java
│ └── resources/
│ └── application.yml (Micronaut only)
└── serverless.yml (or template.yaml)
3. Implementation Examples
Micronaut Handler
@FunctionBean
(
"my-function"
)
public
class
MyFunction
implements
Function
<
APIGatewayProxyRequestEvent
,
APIGatewayProxyResponseEvent
>
{
private
final
MyService
service
;
public
MyFunction
(
MyService
service
)
{
this
.
service
=
service
;
}
@Override
public
APIGatewayProxyResponseEvent
apply
(
APIGatewayProxyRequestEvent
request
)
{
// Process request
return
new
APIGatewayProxyResponseEvent
(
)
.
withStatusCode
(
200
)
.
withBody
(
"{\"message\": \"Success\"}"
)
;
}
}
Raw Java Handler
public
class
MyHandler
implements
RequestHandler
<
APIGatewayProxyRequestEvent
,
APIGatewayProxyResponseEvent
>
{
// Singleton pattern for warm invocations
private
static
final
MyService
service
=
new
MyService
(
)
;
@Override
public
APIGatewayProxyResponseEvent
handleRequest
(
APIGatewayProxyRequestEvent
request
,
Context
context
)
{
return
new
APIGatewayProxyResponseEvent
(
)
.
withStatusCode
(
200
)
.
withBody
(
"{\"message\": \"Success\"}"
)
;
}
}
Core Concepts
Cold Start Optimization
Cold start time depends on initialization code. Key strategies:
Lazy Initialization
- Defer heavy setup from constructor
Singleton Pattern
- Cache initialized services as static fields
Minimal Dependencies
- Reduce JAR size by excluding unused libraries
AOT Compilation
- Micronaut's ahead-of-time compilation eliminates reflection
Connection Management
// GOOD: Initialize once, reuse across invocations
private
static
final
DynamoDbClient
dynamoDb
=
DynamoDbClient
.
builder
(
)
.
region
(
Region
.
US_EAST_1
)
.
build
(
)
;
// AVOID: Creating clients in handler method
public
APIGatewayProxyResponseEvent
handleRequest
(
.
.
.
)
{
DynamoDbClient
client
=
DynamoDbClient
.
create
(
)
;
// Slow on every invocation
}
Error Handling
@Override
public
APIGatewayProxyResponseEvent
handleRequest
(
APIGatewayProxyRequestEvent
request
,
Context
context
)
{
try
{
// Business logic
return
successResponse
(
result
)
;
}
catch
(
ValidationException
e
)
{
return
errorResponse
(
400
,
e
.
getMessage
(
)
)
;
}
catch
(
Exception
e
)
{
context
.
getLogger
(
)
.
log
(
"Error: "
+
e
.
getMessage
(
)
)
;
return
errorResponse
(
500
,
"Internal error"
)
;
}
}
Best Practices
Memory and Timeout Configuration
Memory
Start with 512MB, adjust based on profiling
Timeout
Set based on cold start + expected processing time
Micronaut: 10-30 seconds for cold start buffer
Raw Java: 5-10 seconds typically sufficient
Packaging
Use Gradle Shadow Plugin or Maven Shade Plugin
Exclude unnecessary dependencies
Target Java 17 or 21 for best performance
Monitoring
Enable X-Ray tracing for performance analysis
Log initialization time separately from processing time
Use CloudWatch Insights to track cold vs warm starts
Deployment Options
Serverless Framework
service
:
my
-
java
-
lambda
provider
:
name
:
aws
runtime
:
java21
memorySize
:
512
timeout
:
10
package
:
artifact
:
build/libs/function.jar
functions
:
api
:
handler
:
com.example.Handler
events
:
-
http
:
path
:
/
{
proxy+
}
method
:
ANY
AWS SAM
AWSTemplateFormatVersion
:
'2010-09-09'
Transform
:
AWS
:
:
Serverless
-
2016-10-31
Resources
:
MyFunction
:
Type
:
AWS
:
:
Serverless
:
:
Function
Properties
:
CodeUri
:
build/libs/function.jar
Handler
:
com.example.Handler
Runtime
:
java21
MemorySize
:
512
Timeout
:
10
Events
:
ApiEvent
:
Type
:
Api
Properties
:
Path
:
/
{
proxy+
}
Method
:
ANY
Constraints and Warnings
Lambda Limits
Deployment package
250MB unzipped maximum
Memory
128MB to 10GB
Timeout
15 minutes maximum
Concurrent executions
1000 default (adjustable)
Java-Specific Considerations
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 Initialization in handler - Causes repeated work on warm invocations Oversized JARs - Include only required dependencies Insufficient memory - Java needs more memory than Node.js/Python No timeout handling - Always set appropriate timeouts References For detailed guidance on specific topics: Micronaut Lambda - Complete Micronaut setup, AOT configuration, DI optimization Raw Java Lambda - Minimal handler patterns, singleton caching, JAR packaging Serverless Deployment - Serverless Framework, SAM, CI/CD pipelines, provisioned concurrency Testing Lambda - JUnit 5, SAM Local, integration testing, performance measurement Examples Example 1: Create a Micronaut Lambda Function Input: Create a Java Lambda function using Micronaut to handle user REST API Process: Configure Gradle project with Micronaut plugin Create Handler class extending MicronautRequestHandler Implement methods for GET/POST/PUT/DELETE Configure application.yml with AOT optimizations Set up packaging with Shadow plugin Output: Complete project structure Handler with dependency injection serverless.yml deployment configuration Example 2: Optimize Cold Start for Raw Java Input: My Java Lambda has 3 second cold start, how do I optimize it? Process: Analyze initialization code Move AWS client creation to static fields Reduce dependencies in build.gradle Configure optimized JVM options Consider provisioned concurrency Output: Refactored code with singleton pattern Minimized JAR Cold start < 500ms Example 3: Deploy with GitHub Actions Input: Configure CI/CD for Java Lambda with SAM Process: Create GitHub Actions workflow Configure Gradle build with Shadow Set up SAM build and deploy Add test stage before deployment 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
← 返回排行榜