Serverless computing has taken the tech world by storm, and Micronaut is leading the charge when it comes to building efficient, lightweight serverless functions. If you’re looking to dive into the world of serverless with Micronaut, you’ve come to the right place. Let’s explore how to create powerful serverless applications using Micronaut for AWS Lambda and other platforms.

First things first, let’s set up our development environment. Make sure you have Java 8 or higher installed, along with Gradle or Maven for dependency management. We’ll be using Gradle in our examples, but feel free to adapt to Maven if that’s your preference.

To get started, we’ll create a new Micronaut project using the Micronaut CLI. Open your terminal and run:

mn create-function-app com.example.demo

This command creates a new Micronaut function project with the package name “com.example.demo”. Navigate into the project directory and open it in your favorite IDE.

Now, let’s take a look at the project structure. You’ll notice a build.gradle file (or pom.xml if you’re using Maven) that defines our project dependencies. The most important dependency for our serverless function is:

implementation("io.micronaut.aws:micronaut-function-aws")

This dependency enables Micronaut’s AWS Lambda integration. If you’re targeting a different serverless platform, you’ll need to use the appropriate dependency.

Next, let’s create our first serverless function. In the src/main/java/com/example/demo directory, create a new file called HelloFunction.java:

package com.example.demo;

import io.micronaut.function.FunctionBean;
import java.util.function.Function;

@FunctionBean("hello")
public class HelloFunction implements Function<String, String> {

    @Override
    public String apply(String name) {
        return "Hello, " + name + "!";
    }
}

This simple function takes a name as input and returns a greeting. The @FunctionBean annotation tells Micronaut that this is a serverless function, and “hello” is the name we’re giving it.

Now, let’s add some configuration to our application.yml file in the src/main/resources directory:

micronaut:
  function:
    name: hello

This configuration tells Micronaut which function to use as the entry point for our serverless application.

To test our function locally, we can use the Micronaut CLI. Run the following command:

./gradlew run

This will start a local server, and you can test your function by sending a POST request to http://localhost:8080/hello with a JSON payload like {"name": "World"}.

Now that we have a working function, let’s deploy it to AWS Lambda. First, we need to add the AWS Lambda handler to our project. Create a new file called FunctionRequestHandler.java in the same directory as your HelloFunction.java:

package com.example.demo;

import com.amazonaws.services.lambda.runtime.Context;
import com.amazonaws.services.lambda.runtime.RequestHandler;
import io.micronaut.function.aws.MicronautRequestHandler;
import java.io.IOException;

public class FunctionRequestHandler extends MicronautRequestHandler<String, String> implements RequestHandler<String, String> {

    @Override
    public String execute(String input) {
        return new HelloFunction().apply(input);
    }

    @Override
    public String handleRequest(String input, Context context) {
        return execute(input);
    }
}

This class extends MicronautRequestHandler and implements RequestHandler, which allows it to handle AWS Lambda requests. The execute method calls our HelloFunction, and handleRequest is the entry point for AWS Lambda.

To deploy our function to AWS Lambda, we first need to build a deployable JAR file. Run the following command:

./gradlew shadowJar

This creates a fat JAR containing all our dependencies in the build/libs directory. Now, we can use the AWS CLI or the AWS Management Console to create a new Lambda function and upload our JAR file.

If you’re using the AWS CLI, you can create and deploy your function with these commands:

aws lambda create-function --function-name micronaut-hello \
    --handler com.example.demo.FunctionRequestHandler \
    --runtime java11 \
    --role arn:aws:iam::YOUR_ACCOUNT_ID:role/lambda_basic_execution \
    --zip-file fileb://build/libs/demo-0.1-all.jar

aws lambda update-function-code --function-name micronaut-hello \
    --zip-file fileb://build/libs/demo-0.1-all.jar

Remember to replace YOUR_ACCOUNT_ID with your actual AWS account ID and make sure you have the necessary IAM permissions to create and update Lambda functions.

Now that our function is deployed, we can test it using the AWS CLI:

aws lambda invoke --function-name micronaut-hello \
    --payload '{"name": "Micronaut"}' \
    output.txt

This should return a success message, and the output.txt file will contain the response from our function.

But wait, there’s more! Micronaut isn’t just limited to simple functions. Let’s explore some more advanced features that make Micronaut an excellent choice for serverless development.

One of Micronaut’s strengths is its powerful dependency injection system. Let’s modify our function to use a service class:

package com.example.demo;

import io.micronaut.function.FunctionBean;
import jakarta.inject.Inject;
import java.util.function.Function;

@FunctionBean("hello")
public class HelloFunction implements Function<String, String> {

    @Inject
    private GreetingService greetingService;

    @Override
    public String apply(String name) {
        return greetingService.greet(name);
    }
}

And here’s our GreetingService:

package com.example.demo;

import jakarta.inject.Singleton;

@Singleton
public class GreetingService {

    public String greet(String name) {
        return "Hello, " + name + "! Welcome to Micronaut serverless.";
    }
}

Micronaut’s dependency injection is incredibly fast and doesn’t rely on reflection, making it perfect for serverless environments where cold start times are crucial.

Another powerful feature of Micronaut is its built-in support for cloud services. Let’s say we want to store our greetings in a DynamoDB table. We can easily integrate with AWS services using Micronaut’s AWS SDK integration.

First, add the following dependency to your build.gradle:

implementation("io.micronaut.aws:micronaut-aws-sdk-v2")

Now, let’s create a DynamoDB client bean:

package com.example.demo;

import io.micronaut.context.annotation.Factory;
import jakarta.inject.Singleton;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;

@Factory
public class DynamoDBFactory {

    @Singleton
    public DynamoDbClient dynamoDbClient() {
        return DynamoDbClient.create();
    }
}

And update our GreetingService to use DynamoDB:

package com.example.demo;

import jakarta.inject.Singleton;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
import software.amazon.awssdk.services.dynamodb.model.GetItemRequest;
import software.amazon.awssdk.services.dynamodb.model.GetItemResponse;

import java.util.HashMap;
import java.util.Map;

@Singleton
public class GreetingService {

    private final DynamoDbClient dynamoDbClient;

    public GreetingService(DynamoDbClient dynamoDbClient) {
        this.dynamoDbClient = dynamoDbClient;
    }

    public String greet(String name) {
        Map<String, AttributeValue> key = new HashMap<>();
        key.put("name", AttributeValue.builder().s(name).build());

        GetItemRequest request = GetItemRequest.builder()
                .tableName("Greetings")
                .key(key)
                .build();

        GetItemResponse response = dynamoDbClient.getItem(request);

        if (response.hasItem()) {
            return response.item().get("greeting").s();
        } else {
            return "Hello, " + name + "! Welcome to Micronaut serverless.";
        }
    }
}

This service now checks a DynamoDB table for a custom greeting before falling back to the default message.

Micronaut also excels at creating RESTful APIs for serverless environments. Let’s modify our function to handle HTTP requests:

package com.example.demo;

import io.micronaut.function.aws.MicronautRequestHandler;
import io.micronaut.http.HttpRequest;
import io.micronaut.http.HttpResponse;
import io.micronaut.http.annotation.Body;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Post;

@Controller("/hello")
public class HelloController extends MicronautRequestHandler<HttpRequest<?>, HttpResponse<?>> {

    private final GreetingService greetingService;

    public HelloController(GreetingService greetingService) {
        this.greetingService = greetingService;
    }

    @Post
    public HttpResponse<String> hello(@Body NameRequest nameRequest) {
        String greeting = greetingService.greet(nameRequest.getName());
        return HttpResponse.ok(greeting);
    }

    @Override
    public HttpResponse<?> execute(HttpRequest<?> input) {
        return handleRequest(input, null);
    }
}

And our NameRequest class:

package com.example.demo;

public class NameRequest {
    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

Now our function can handle proper HTTP requests and responses, making it easy to integrate with API Gateway or other HTTP-based serverless platforms.

One of the challenges with serverless functions is managing configuration across different environments. Micronaut makes this easy with its powerful configuration system. Let’s add some environment-specific configuration:

micronaut:
  function:
    name: hello
  server:
    port: 8080

dynamodb:
  table-name: Greetings

---
micronaut:
  environments: dev
dynamodb:
  table-name: DevGreetings

---
micronaut:
  environments: prod
dynamodb:
  table-name: ProdGreetings

Now we can use @Value or constructor injection to get the table name in our GreetingService:

@Singleton
public class GreetingService {

    private final DynamoDbClient dynamoDbClient;
    private final String tableName;

    public GreetingService(DynamoDbClient dynamoDbClient, @Value("${dynamodb.table-name}") String tableName) {
        this.dynamoDbClient = dynamoDbClient;
        this.tableName = tableName;
    }

    // ... rest of the class
}

This allows us to easily switch between different environments without changing our code.

Micronaut’s support for serverless doesn’t stop at AWS Lambda. It also works great with other serverless platforms like Google Cloud Functions and Azure Functions. The core concepts remain the same, but you’ll need to use platform-specific adapters.

For example, to deploy to Google Cloud Functions, you’d use the micronaut-gcp-function dependency and extend GoogleCloudFunction:

import io.micronaut.gcp.function.GoogleCloudFunction;

public class HelloCloudFunction extends GoogleCloudFunction {
    @Override
    public Object invoke(Object input) {
        return new HelloFunction().apply((String) input);
    }