Serverless Java Quarkus App with AWS Lambda in 5 Steps

Image taken from Google

As serverless computing continues to grow in popularity, Java developers are seeking efficient ways to build lightweight, high-performance applications without the need for managing infrastructure. Traditionally, Java applications have faced challenges in serverless environments due to cold start latency and resource consumption. However, with the advent of Quarkus, these limitations are being addressed, making Java a viable option for serverless architectures.

In this article, we’ll explore how Quarkus integrates seamlessly with AWS Lambda to enable low-latency, serverless applications in Java. We’ll cover the basics of Quarkus, its benefits for serverless deployments, and provide a step-by-step guide to deploying a Quarkus-based application on AWS Lambda.

Why Use Quarkus with AWS Lambda?

AWS Lambda is a serverless compute service that runs your code in response to events and automatically manages the underlying compute resources. By combining AWS Lambda with Quarkus, you can build scalable, responsive, and cost-effective serverless applications in Java.

Benefits of Using Quarkus with AWS Lambda:

1. Low Latency: Quarkus reduces cold start times, which is a common issue with Java-based Lambda functions.
2. Cost Efficiency: The reduced memory footprint and faster execution times of Quarkus-based applications can help lower AWS Lambda costs.
3. Cloud-Native Capabilities: Quarkus provides extensive support for cloud-native development, including integration with AWS services like S3, DynamoDB, and SNS.
4. Developer Productivity: Quarkus offers features like hot reload and a simple configuration model, streamlining the development process.

Step-by-Step Guide: Deploying a Quarkus Application on AWS Lambda

Let’s walk through how to create a simple Quarkus application and deploy it to AWS Lambda.

Step 1: Setting Up the Quarkus Project

First, we’ll create a new Quarkus project using the Quarkus Maven plugin:

mvn io.quarkus:quarkus-maven-plugin:create \
    -DprojectGroupId=com.example \
    -DprojectArtifactId=quarkus-lambda \
    -DclassName="com.example.LambdaHandler" \
    -Dpath="/hello"

This command creates a new Quarkus project with a simple REST endpoint.

Step 2: Adding AWS Lambda Extensions

Next, add the Quarkus AWS Lambda extensions to your pom.xml:

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-amazon-lambda</artifactId>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-amazon-lambda-http</artifactId>
</dependency>

These extensions enable Quarkus to handle AWS Lambda events and HTTP requests.

Step 3: Creating the Lambda Handler

Modify the LambdaHandler class to handle AWS Lambda requests:

package com.example;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyRequestEvent;
import com.amazonaws.services.lambda.runtime.events.APIGatewayProxyResponseEvent;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;

@Path("/hello")
public class LambdaHandler implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {

    @GET
    public Response hello() {
        return Response.ok("Hello from Quarkus with AWS Lambda!").build();
    }

    @Override
    public APIGatewayProxyResponseEvent handleRequest(APIGatewayProxyRequestEvent input, Context context) {
        return new APIGatewayProxyResponseEvent()
                .withStatusCode(200)
                .withBody("Hello from AWS Lambda!");
    }
}

This class handles API Gateway requests and returns a simple greeting message.

Step 4: Packaging the Application for AWS Lambda

To deploy the application to AWS Lambda, we need to create a “fat JAR” (Uber JAR) that includes all dependencies. Use the following Maven command:

mvn clean package -Pnative -Dnative-image.docker-build=true

This command creates a native executable suitable for deployment on AWS Lambda.

Step 5: Creating and Deploying the Lambda Function

1. Create a Lambda Function: Go to the AWS Management Console, navigate to AWS Lambda, and create a new function.
2. Upload the Deployment Package:

• For a native image, upload the native executable directly.
• For a JVM-based deployment, upload the target/quarkus-lambda-1.0.0-SNAPSHOT-runner.jar as the deployment package.

3. Configure the Handler:

• Set the handler to io.quarkus.amazon.lambda.runtime.QuarkusStreamHandler for JVM-based deployment.
• For native deployment, the handler is automatically configured.

4. Test the Lambda Function: Invoke the function from the AWS Lambda console to ensure everything is working correctly.

Step 6: Setting Up API Gateway (Optional)

If you want to expose the Lambda function as a REST API, create an API Gateway, link it to your Lambda function, and deploy the API. This will allow you to access your Quarkus application over HTTP.

Conclusion

Using Quarkus with AWS Lambda enables Java developers to leverage the benefits of serverless computing while maintaining the familiar Java ecosystem. The combination of Quarkus’ low memory footprint and fast startup times with the scalability and cost-efficiency of AWS Lambda makes it an excellent choice for building serverless Java applications.

Whether you’re creating simple APIs, complex microservices, or integrating with other AWS services, Quarkus provides the tools and performance needed to build modern serverless applications. With Quarkus, Java developers can confidently enter the serverless space without compromising on performance or developer productivity.

Let me know your thoughts and feel free to ask if you have any questions!