aws-sdk-java-v2-lambda

SKILL.md

AWS SDK for Java 2.x - AWS Lambda

Overview

AWS Lambda is a compute service that runs code without managing servers. Use this skill to implement AWS Lambda operations using AWS SDK for Java 2.x in applications and services.

When to Use

Invoking Lambda functions from Java applications

Deploying and updating Lambda functions via SDK

Managing function configurations and layers

Integrating Lambda with Spring Boot applications

Quick Reference

Operation
SDK Method
Use Case

Invoke
invoke()
Synchronous/async function invocation

List Functions
listFunctions()
Get all Lambda functions

Get Config
getFunction()
Retrieve function configuration

Create Function
createFunction()
Create new Lambda function

Update Code
updateFunctionCode()
Deploy new function code

Update Config
updateFunctionConfiguration()
Modify settings (timeout, memory, env vars)

Delete Function
deleteFunction()
Remove Lambda function

Instructions

1. Add Dependencies

Include Lambda SDK dependency in pom.xml:

<dependency>
    <groupId>software.amazon.awssdk</groupId>
    <artifactId>lambda</artifactId>
</dependency>

See client-setup.md for complete setup.

2. Create Client

Instantiate LambdaClient with proper configuration:

LambdaClient lambdaClient = LambdaClient.builder()
    .region(Region.US_EAST_1)
    .build();

For async operations, use LambdaAsyncClient.

3. Invoke Lambda Function

Synchronous invocation:

InvokeRequest request = InvokeRequest.builder()
    .functionName("my-function")
    .payload(SdkBytes.fromUtf8String(payload))
    .build();

InvokeResponse response = lambdaClient.invoke(request);

return response.payload().asUtf8String();

See invocation-patterns.md for patterns.

4. Handle Responses

Parse response payloads and check for errors:

if (response.functionError() != null) {
    throw new LambdaInvocationException("Lambda error: " + response.functionError());
}

String result = response.payload().asUtf8String();

5. Manage Functions

Create, update, or delete Lambda functions:

// Create
CreateFunctionRequest createRequest = CreateFunctionRequest.builder()
    .functionName("my-function")
    .runtime(Runtime.JAVA17)
    .role(roleArn)
    .code(code)
    .build();

lambdaClient.createFunction(createRequest);

// Verify function is active before proceeding
GetFunctionRequest getRequest = GetFunctionRequest.builder()
    .functionName("my-function")
    .build();
GetFunctionResponse getResponse = lambdaClient.getFunction(getRequest);
if (!"Active".equals(getResponse.configuration().state())) {
    throw new IllegalStateException("Function not active: " + getResponse.configuration().stateReason());
}

// Update code
UpdateFunctionCodeRequest updateCodeRequest = UpdateFunctionCodeRequest.builder()
    .functionName("my-function")
    .zipFile(SdkBytes.fromByteArray(zipBytes))
    .build();

lambdaClient.updateFunctionCode(updateCodeRequest);

// Wait for deployment to complete
Waiter<GetFunctionConfigurationRequest> waiter = lambdaClient.waiter();
waiter.waitUntilFunctionUpdatedActive(GetFunctionConfigurationRequest.builder()
    .functionName("my-function")
    .build());

See function-management.md for complete patterns.

6. Configure Environment

Set environment variables and concurrency limits:

Environment env = Environment.builder()
    .variables(Map.of(
        "DB_URL", "jdbc:postgresql://db",
        "LOG_LEVEL", "INFO"
    ))
    .build();

UpdateFunctionConfigurationRequest configRequest = UpdateFunctionConfigurationRequest.builder()
    .functionName("my-function")
    .environment(env)
    .timeout(60)
    .memorySize(512)
    .build();

lambdaClient.updateFunctionConfiguration(configRequest);

7. Integrate with Spring Boot

Configure Lambda beans and services:

@Configuration
public class LambdaConfiguration {
    @Bean
    public LambdaClient lambdaClient() {
        return LambdaClient.builder()
            .region(Region.US_EAST_1)
            .build();
    }
}

@Service
public class LambdaInvokerService {
    public <T, R> R invoke(String functionName, T request, Class<R> responseType) {
        // Implementation
    }
}

See spring-boot-integration.md for complete integration.

8. Test Locally

Use mocks or LocalStack for development testing.

See testing.md for testing patterns.

Examples

Basic Invocation

public String invokeFunction(LambdaClient client, String functionName, String payload) {
    InvokeRequest request = InvokeRequest.builder()
        .functionName(functionName)
        .payload(SdkBytes.fromUtf8String(payload))
        .build();

    InvokeResponse response = client.invoke(request);

    if (response.functionError() != null) {
        throw new RuntimeException("Lambda error: " + response.functionError());
    }

    return response.payload().asUtf8String();
}

Async Invocation

public void invokeAsync(LambdaClient client, String functionName, Map<String, Object> event) {
    String jsonPayload = new ObjectMapper().writeValueAsString(event);

    InvokeRequest request = InvokeRequest.builder()
        .functionName(functionName)
        .invocationType(InvocationType.EVENT)
        .payload(SdkBytes.fromUtf8String(jsonPayload))
        .build();

    client.invoke(request);
}

Spring Boot Service

@Service
public class LambdaService {
    private final LambdaClient lambdaClient;

    public UserResponse processUser(UserRequest request) {
        String payload = objectMapper.writeValueAsString(request);

        InvokeResponse response = lambdaClient.invoke(
            InvokeRequest.builder()
                .functionName("user-processor")
                .payload(SdkBytes.fromUtf8String(payload))
                .build()
        );

        return objectMapper.readValue(
            response.payload().asUtf8String(),
            UserResponse.class
        );
    }
}

See examples.md for more examples.

Best Practices

Reuse clients: Create LambdaClient/LambdaAsyncClient once; they are thread-safe

Use async client: For fire-and-forget invocations, use LambdaAsyncClient with CompletableFuture

Verify deployments: Always wait for function state to be Active after create/update operations

Limit payload size: Keep request/response payloads under 256KB for async, 6MB for sync invocations

Configure timeouts: Set client read timeout slightly higher than Lambda function timeout

Use latest runtime: Specify Runtime.JAVA17 or newer for improved cold start performance

Constraints and Warnings

Payload Limit: 6MB (sync), 256KB (async invocation)

Timeout: Max 900 seconds (15 minutes) per invocation

Cold Starts: JVM-based functions have longer cold starts; use GraalVM Native Image for improvement

Deployment Size: Function code + layers must not exceed 50MB (zipped) or 250MB (unzipped)

Concurrency: Default 1000 per region; use reserved concurrency to guarantee capacity

Cost: Monitor with CloudWatch metrics; set billing alerts to prevent runaway costs

References

client-setup.md — Client configuration and setup

invocation-patterns.md — Synchronous and async invocation patterns

function-management.md — Create, update, delete functions

spring-boot-integration.md — Spring Boot configuration and services

testing.md — Unit and integration testing patterns

examples.md — Complete code examples and integration patterns

official-documentation.md — AWS Lambda concepts and API reference

Related Skills

aws-sdk-java-v2-core — Core AWS SDK patterns and client configuration

spring-boot-dependency-injection — Spring dependency injection best practices

unit-test-service-layer — Service testing patterns with Mockito

spring-boot-actuator — Production monitoring and health checks

External Resources

Lambda Examples on GitHub

Lambda API Reference

AWS Lambda Developer Guide