Introduction

The serverless revolution continues to reshape how we build and deploy applications, and AWS Lambda remains at its forefront. For Java developers, the runtime version we choose is critical—it dictates the language features we can use, the performance we can expect, and the security patches we benefit from.

The long-term support (LTS) release of Java 21 is a monumental step forward for the ecosystem, packed with features that make Java more concise, expressive, and performant. With the general availability of the Amazon Linux 2023-based Java 21 runtime for AWS Lambda, we can now leverage these modern Java capabilities in our serverless functions. Let's dive into what this new runtime offers and how you can start using it.

Article: Embracing the Future: Building with the AWS Lambda Java 21 Runtime

The wait is over. AWS has officially launched the java21 runtime for Lambda, built on the new Amazon Linux 2023 execution environment. This is a significant upgrade, moving the baseline from the now-aged Java 17 (and earlier) to the latest LTS release, Java 21. This new runtime isn't just a version bump; it's a gateway to a more modern and efficient Java development experience in the cloud.

Why Upgrade to the Java 21 Runtime?

Java 21 is a feature-rich release, and many of its enhancements are perfectly suited for the short-lived, event-driven nature of Lambda functions.

1. Virtual Threads (Project Loom): This is the headline feature. Virtual threads dramatically simplify writing high-throughput concurrent applications without the complexity of traditional thread-pool management. For Lambda functions that need to make multiple external calls (e.g., to databases, HTTP APIs), virtual threads allow you to write blocking-style code that is actually non-blocking under the hood, leading to better resource utilization and potentially lower execution costs.
2. String Templates (Preview): Say goodbye to cumbersome string concatenation. String templates make it easy to embed expressions directly within strings, improving readability and safety by automatically escaping where necessary. This is a boon for constructing dynamic SQL queries, JSON objects, or log messages.
3. Record Patterns & Pattern Matching for switch: These features allow for more declarative and robust data processing. You can deconstruct record objects and complex data structures with elegant, concise syntax, making your data-handling logic in Lambda functions cleaner and less error-prone.
4. Sequenced Collections: New, unified interfaces for dealing with collections that have a defined encounter order. This simplifies common tasks like getting the first or last element, making your collection manipulation code more intuitive.
5. Performance and Security: As with any new LTS release, Java 21 includes underlying performance improvements from the JVM (e.g., generational ZGC) and critical security updates. The new runtime on AL2023 also benefits from a more secure and modern base operating system.

How to Migrate Your Lambda Functions to Java 21

Migrating is straightforward. Here’s a step-by-step guide.

Step 1: Update Your Build Configuration

First, ensure your project is configured to use Java 21. In your pom.xml (Maven) or build.gradle (Gradle), set the source and target compatibility.

Maven Example (pom.xml):

<properties>
<maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

Step 2: Choose Your Deployment Method

You can deploy your function using the AWS Management Console, AWS CLI, or infrastructure-as-code tools like AWS SAM or CDK.

• AWS Console: When creating or updating your function, simply select Java 21 in the "Runtime" dropdown.
• AWS SAM Template (template.yaml): Update the Runtime property for your function resource.
  yaml MyJavaFunction: Type: AWS::Serverless::Function Properties: CodeUri: target/my-lambda-function.jar Handler: com.example.MyLambdaHandler::handleRequest Runtime: java21 MemorySize: 512 Timeout: 30

Step 3: Update Your Handler Code (Optional but Recommended)

Your existing handlers will likely work without changes. However, to truly leverage Java 21, consider refactoring. Here’s a simple example demonstrating a virtual thread.

Traditional Approach:

public class SimpleHandler implements RequestHandler<Map<String,String>, String> {
@Override
public String handleRequest(Map<String,String> event, Context context) {
// This blocks the platform thread
return fetchDataFromExternalService(event.get("id"));
}
private String fetchDataFromExternalService(String id) {
// Simulate a blocking I/O call (e.g., HTTP request)
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return "Data for " + id;
}
}

Modernized with Virtual Threads (for high-concurrency scenarios):

import java.util.concurrent.Executors;
public class ConcurrentHandler implements RequestHandler<Map<String,String>, String> {
// Using a custom executor service for virtual threads
private static final ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor();
@Override
public String handleRequest(Map<String,String> event, Context context) {
// Offload the blocking task to a virtual thread
Future<String> future = executor.submit(() -> fetchDataFromExternalService(event.get("id")));
try {
return future.get(); // Wait for the result
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private String fetchDataFromExternalService(String id) {
// This now blocks a virtual thread, freeing the platform thread.
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
return "Data for " + id;
}
}

Key Considerations

• Libraries and Dependencies: Ensure all your third-party libraries are compatible with Java 21. Most modern libraries already are, but it's crucial to test.
• Cold Starts: The Java 21 runtime on AL2023 is optimized, but always monitor your function's cold start performance, especially if you are using a large framework like Spring. Favor lightweight dependency injection (like Dagger or Micronaut) over monolithic frameworks.
• Preview Features: If you use preview features like String Templates, you must explicitly enable them in your build and deployment configuration using the --enable-preview flag.

Conclusion

The AWS Lambda Java 21 runtime is a compelling reason to modernize your serverless Java applications. By upgrading, you gain access to groundbreaking features like virtual threads, which can lead to more efficient and scalable functions, alongside a host of language improvements that boost developer productivity and code quality.

Don't get left behind on older runtimes. Start experimenting with Java 21 in your non-critical functions today, plan your migration path for production workloads, and experience the future of serverless Java.

Call to Action: What's the first feature you're excited to try? Virtual threads, or perhaps the new switch expressions? Share your thoughts and experiments with the community

Pyroscope Profiling in Java
Explains how to use Pyroscope for continuous profiling in Java applications, helping developers analyze CPU and memory usage patterns to improve performance and identify bottlenecks.
https://macronepal.com/blog/pyroscope-profiling-in-java/

OpenTelemetry Metrics in Java: Comprehensive Guide
Provides a complete guide to collecting and exporting metrics in Java using OpenTelemetry, including counters, histograms, gauges, and integration with monitoring tools. (MACRO NEPAL)
https://macronepal.com/blog/opentelemetry-metrics-in-java-comprehensive-guide/

OTLP Exporter in Java: Complete Guide for OpenTelemetry
Explains how to configure OTLP exporters in Java to send telemetry data such as traces, metrics, and logs to monitoring systems using HTTP or gRPC protocols. (MACRO NEPAL)
https://macronepal.com/blog/otlp-exporter-in-java-complete-guide-for-opentelemetry/

Thanos Integration in Java: Global View of Metrics
Explains how to integrate Thanos with Java monitoring systems to create a scalable global metrics view across multiple Prometheus instances.

https://macronepal.com/blog/thanos-integration-in-java-global-view-of-metrics

Time Series with InfluxDB in Java: Complete Guide (Version 2)
Explains how to manage time-series data using InfluxDB in Java applications, including storing, querying, and analyzing metrics data.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide-2

Time Series with InfluxDB in Java: Complete Guide
Provides an overview of integrating InfluxDB with Java for time-series data handling, including monitoring applications and managing performance metrics.

https://macronepal.com/blog/time-series-with-influxdb-in-java-complete-guide

Implementing Prometheus Remote Write in Java (Version 2)
Explains how to configure Java applications to send metrics data to Prometheus-compatible systems using the remote write feature for scalable monitoring.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide-2

Implementing Prometheus Remote Write in Java: Complete Guide
Provides instructions for sending metrics from Java services to Prometheus servers, enabling centralized monitoring and real-time analytics.

https://macronepal.com/blog/implementing-prometheus-remote-write-in-java-a-complete-guide

Building a TileServer GL in Java: Vector and Raster Tile Server
Explains how to build a TileServer GL in Java for serving vector and raster map tiles, useful for geographic visualization and mapping applications.

https://macronepal.com/blog/building-a-tileserver-gl-in-java-vector-and-raster-tile-server

Indoor Mapping in Java
Explains how to create indoor mapping systems in Java, including navigation inside buildings, spatial data handling, and visualization techniques.