Building microservice applications can be a real headache without the right tools. Enter Micronaut CLI, a handy command-line interface that can rapidly scaffold and build robust microservices for your projects. If you’ve been living under a rock and haven’t given Micronaut CLI a try, this article is here to guide you through getting your microservice applications up and running in no time.

Installing the Micronaut CLI

First things first, let’s get the Micronaut CLI installed. For most Unix-based systems, SDKMAN is your best bet for managing multiple software development kits. The installation is a breeze:

sdk install micronaut

Check that it’s installed by running:

mn --version

You should see the version info pop up, and boom, you’re ready for the next step.

Creating a New Micronaut Application

Once you’ve got the CLI all set up, the real magic begins. Creating a new Micronaut application is as simple as running a single command. This will scaffold the basic structure, including configuration files and build scripts. Let’s say you want to create an app called my-micronaut-app:

mn create-app my-micronaut-app

Just like that, a directory named my-micronaut-app is generated for you, packed with the essentials to get started. Want to add some extra features right off the bat, like HTTP client support or GraalVM native image capabilities? No problem:

mn create-app my-micronaut-app --features http-client,graal-native-image

Understanding Your New Project

Now, inside your newly created app, the CLI throws in several key files and directories. Here’s a quick look:

• build.gradle: The brain of your build process, containing dependencies and configurations.
• src/main/java: Where your main code lives.
• src/main/resources: Home to your configuration files like application.yml.
• Application.java: The starting point of your app, setting up your Micronaut server.

Adding Features and Dependencies

Micronaut makes it super easy to add new features to your application. If you forgot to add something like HTTP client support during the setup, you can tweak your build.gradle file later, or just use the CLI command to create a new app with the needed features:

mn create-app my-micronaut-app --features http-client

Or manually add it later:

dependencies {
    implementation "io.micronaut:micronaut-http-client"
}

Creating Controllers and Endpoints

Handling incoming requests? You’ll need some controllers. Micronaut simplifies controller creation with a handy CLI command. To create something like a GreetingController, just run:

mn create-controller GreetingController

Here’s what your basic GreetingController might look like:

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.PathVariable;

@Controller("/greet")
public class GreetingController {

    @Get("/{name}")
    public String greet(@PathVariable String name) {
        return "Hello, " + name + "!";
    }
}

Using Declarative HTTP Clients

Micronaut also supports declarative HTTP clients. These handy tools let you define interfaces that represent your HTTP endpoints. The framework does the heavy lifting by generating the implementation for you. For a greeting service client, you might write something like:

import io.micronaut.http.annotation.Client;
import io.micronaut.http.annotation.Get;
import reactor.core.publisher.Mono;

@Client("/hello")
public interface HelloClient {

    @Get
    Mono<String> hello();
}

Inject this client into your controllers or other components to make HTTP requests seamlessly.

Configuring Your Application

When it comes to configuration, Micronaut uses an application.yml file. You can set server ports, database connections, and tons more in this file. Say you want your server to run on port 8081:

micronaut:
  server:
    port: 8081

Micronaut smartly maps environment variables to configuration properties, making environment-specific configs a breeze.

Testing Your Application

No serious coding effort is complete without testing, right? Micronaut has your back, making it easy to write both unit tests and integration tests. Here’s a quick example of how you might test that GreetingController:

import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

@MicronautTest
public class GreetingControllerTest {

    @Test
    void testHelloWorldResponse(HelloClient client) {
        assertEquals("Hello, World!", client.hello().block());
    }
}

Creating CLI Applications with Picocli

Micronaut and Picocli make a killer combo for building command-line interface (CLI) applications. Let’s say you want a CLI app to check the weather. First, generate the application skeleton with Picocli support:

mn create-cli-app my-cli-app --features http-client

Then, define your commands using Picocli:

import io.micronaut.configuration.picocli.PicocliRunner;
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Option;

@Command(name = "weather-cli", mixinStandardHelpOptions = true, version = "1.0",
        description = "A weather CLI application")
public class WeatherCli implements Runnable {

    @Option(names = {"-c", "--city"}, description = "City name")
    private String city;

    @Option(names = {"-n", "--country"}, description = "Country name")

    private String country;
    
    public static void main(String[] args) {
        PicocliRunner.run(WeatherCli.class, args);
    }

    @Override
    public void run() {
        // Logic to fetch and display weather data
    }
}

Compiling to Native Binaries with GraalVM

Now, let’s talk advanced features. One cool feature of Micronaut is its ability to compile applications to native binaries using GraalVM. This can really speed up your app’s startup and shrink its memory footprint. To enable native image support, add the graal-native-image feature when creating your app:

mn create-app my-micronaut-app --features graal-native-image

Don’t forget to tweak your build script to include required dependencies and plugins for native image compilation.

Conclusion

The Micronaut CLI isn’t just another tool in your development toolkit. It’s a game-changer, making it easier and faster to scaffold, build, and manage microservice applications. From adding HTTP client support and declarative HTTP clients to tweaking configurations and writing tests, Micronaut has you covered. Whether you’re creating RESTful APIs, CLI applications, or serverless functions, this CLI tool offers everything you need to kickstart your next big project.

So, go ahead and dive into the world of Micronaut CLI, and watch as it transforms your coding experience from tedious to seamless in no time.