repository·main·Indexed 43 days ago
https://github.com/aws-powertools/powertools-lambda-javaA developer toolkit for implementing serverless best practices in AWS Lambda environments using Java and Kotlin. It provides modules for structured logging, AWS X-Ray tracing, and custom CloudWatch metrics, along with utilities for batch processing (SQS, Kinesis, DynamoDB Streams) and CloudFormation Custom Resources.
This repository contains example implementations demonstrating the core Powertools for AWS Lambda (Java) modules:
Examples are provided for both Java and Kotlin implementations.
The Powertools Kafka utility simplifies working with Kafka messages in AWS Lambda by providing:
ConsumerRecords interface for handling event records.The examples/ directory contains independent projects demonstrating various Powertools modules. You can copy any subdirectory to use it as a starting point for your own project.
Available example modules:
The utility provides the following capabilities:
The Idempotency utility converts Lambda functions into idempotent operations, making them safe to retry. An idempotent operation ensures that calling the function multiple times with the same input parameters does not cause additional side effects and returns the same result.
To achieve this, the utility generates an Idempotency key, which is a hash representation of either the entire event or a specific configured subset of the event. The invocation results are then JSON serialized and stored in a persistence storage layer. If a subsequent invocation arrives with the same key within a defined time window, the utility prevents the handler from executing again and instead returns the stored result.
When combining @LargeMessage and @Idempotent, the @Idempotent annotation takes precedence. This means the Idempotency module will use the initial raw message (containing the S3 pointer) as the basis for the idempotency key, rather than the large unwrapped blob. This is the recommended behavior to ensure consistency.
Important for Functional API: If using the functional API, you must call LargeMessages.processLargeMessage() inside the @Idempotent method to ensure the idempotency check is performed on the S3 pointer before the large payload is fetched.
// Recommended pattern for Annotation
@Idempotent
@LargeMessage
private String processRawMessage(@IdempotencyKey SQSEvent.SQSMessage sqsMessage, Context context) {
// do something with the message
}
// Recommended pattern for Functional API
@Idempotent
private String processRawMessage(@IdempotencyKey SQSEvent.SQSMessage sqsMessage, Context context) {
return LargeMessages.processLargeMessage(sqsMessage, this::handleProcessedMessage);
}Powertools for AWS Lambda (Java) allows you to automatically deserialize Kafka Lambda events into strongly typed ConsumerRecords<K, V> objects. This eliminates manual deserialization logic by using the @Deserialization annotation combined with a specific DeserializationType.
Supported formats include:
To prevent duplicate processing caused by Lambda retries or failed batches, use the Powertools Idempotency utility. The @Idempotent annotation ensures that a specific operation is only executed once for a given input by tracking the result in a persistence store (like DynamoDB).
Idempotency utility with a PersistenceStore (e.g., DynamoDBPersistenceStore) in your handler constructor.@Idempotent.The utility uses the JSON representation of the input object to identify unique messages.
public class IdempotentKafkaHandler implements RequestHandler<ConsumerRecords<String, Payment>, String> {
public IdempotentKafkaHandler() {
Idempotency.config()
.withPersistenceStore(
DynamoDBPersistenceStore.builder()
.withTableName("IdempotencyTable")
.build())
.configure();
}
@Override
@Logging
@Deserialization(type = DeserializationType.KAFKA_JSON)
public String handleRequest(ConsumerRecords<String, Payment> records, Context context) {
for (ConsumerRecord<String, Payment> record : records) {
Payment payment = record.value();
processPayment(payment);
}
return "OK";
}
@Idempotent
private void processPayment(Payment payment) {
// Business logic here
PaymentService.process(payment.getPaymentId(), payment.getCustomerId(), payment.getAmount());
}
}A bug is defined as producing incorrect or unexpected results at runtime that differ from intended behavior.
Key Criteria:
Triage Actions:
bug label with bug-upstream and ask the author if they want to raise it upstream or if the maintainers should.The Large Messages utility is designed to handle SQS and SNS messages that exceed the 1MB payload limit. When using the Amazon SQS/SNS Java Extended Client Libraries, large payloads are offloaded to Amazon S3, and the message body is replaced with a pointer to the S3 object.
The utility's lifecycle for a large message:
This utility is compatible with versions 1.1.0+ and 2.0.0+ of the SQS/SNS extended client libraries.
The CloudFormation module in Powertools for AWS Lambda (Java) allows Lambda functions to act as Custom Resources within a CloudFormation stack. This enables the Lambda to respond to lifecycle events such as CREATE, UPDATE, and DELETE.
In the provided example, the Lambda function manages an S3 bucket lifecycle based on these events:
For detailed API usage, refer to the official documentation.
Metadata is cached automatically after the first call to LambdaMetadataClient.get(). Subsequent calls return the same cached instance without making additional HTTP requests. This is safe because metadata like the Availability Zone does not change during a sandbox's lifetime.
When using AWS Lambda SnapStart, the function may be restored in a different Availability Zone. The utility integrates with CRaC to automatically invalidate the cache upon restore.
Best Practice: If using eager loading (module-level initialization) with SnapStart, ensure LambdaMetadataClient is referenced during class initialization so the CRaC hook registers before the snapshot is taken.