Building Micronaut Microservices Using MicrostarterCLI

Building Micronaut Microservices Using MicrostarterCLI: Microservices architecture has gained widespread popularity for its scalability, flexibility, and ease of management. Micronaut is a modern, JVM-based framework that simplifies the development of microservices and serverless applications. Coupled with MicrostarterCLI, a rapid development tool, you can expedite the creation of reusable, standard code, configurations, and patterns essential for your application. This article will guide you through the process of bootstrapping a Micronaut microservices application using MicrostarterCLI, covering the architecture, setup, and implementation in detail.

Contents

Understanding MicrostarterCLI Prerequisites Setting Up the Development Environment Installing JDK Installing Micronaut CLI Installing MicrostarterCLI Creating a Micronaut Microservices Project Step 1: Initialize the Project Step 2: Project Structure Creating Microservices Components Service Discovery with Netflix Eureka Configuring Eureka Server Configuring Eureka Clients Creating REST Endpoints Creating a Controller Creating a Service Configuration Management with Config Client Configuring Spring Cloud Config Server Configuring Config Client Implementing Circuit Breaker with Resilience4j Adding Circuit Breaker to a Service Implementing Load Balancing with Ribbon Adding Ribbon Dependency Configuring Ribbon Testing the Microservices Writing Unit Tests Writing Integration Tests Deploying the Microservices Dockerizing the Application Deploying to Kubernetes Conclusion

Understanding MicrostarterCLI

MicrostarterCLI is a command-line interface designed to streamline the development of Micronaut applications. It helps in generating boilerplate code and configurations, reducing the initial setup time and allowing developers to focus on writing business logic. With MicrostarterCLI, you can quickly scaffold projects, generate controllers, services, and other components necessary for a microservices application.

Prerequisites

Before we begin, ensure you have the following installed on your system:

Java Development Kit (JDK) 11 or higher
Micronaut CLI
MicrostarterCLI
An Integrated Development Environment (IDE) such as IntelliJ IDEA or Visual Studio Code

Setting Up the Development Environment

Installing JDK

Download and install the latest version of JDK from the Oracle website or use a package manager like Homebrew (for macOS) or Chocolatey (for Windows).

shCopy code# For macOS
brew install openjdk@11

# For Windows
choco install openjdk11

Installing Micronaut CLI

Micronaut CLI is essential for creating and managing Micronaut projects. Install it using SDKMAN:

shCopy codecurl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install micronaut

Installing MicrostarterCLI

To install MicrostarterCLI, download it from the official GitHub repository and follow the installation instructions.

Creating a Micronaut Microservices Project

Step 1: Initialize the Project

Use MicrostarterCLI to bootstrap a new Micronaut project:

shCopy codemicrostartercli create-app com.example.micronaut.microservices --features=netflix-eureka,discovery-client,config-client --build=gradle

This command creates a new Micronaut application with the specified features and Gradle as the build tool.

Step 2: Project Structure

After generating the project, you’ll notice the following directory structure:

cssCopy codemicronaut-microservices/
├── build.gradle
├── src
│   ├── main
│   │   ├── java
│   │   │   └── com
│   │   │       └── example
│   │   │           └── micronaut
│   │   │               └── microservices
│   │   ├── resources
│   │   │   └── application.yml
├── settings.gradle

Creating Microservices Components

Service Discovery with Netflix Eureka

Service discovery is a fundamental aspect of microservices architecture. Netflix Eureka is a service registry that enables dynamic registration and discovery of microservices.

Configuring Eureka Server

First, create a new module for the Eureka server:

shCopy codemicrostartercli create-app com.example.micronaut.eurekaserver --features=eureka-server --build=gradle

In the application.yml file of the Eureka server, configure the Eureka server properties:

yamlCopy codeeureka:
  client:
    registerWithEureka: false
    fetchRegistry: false
  instance:
    hostname: localhost
server:
  port: 8761

Configuring Eureka Clients

In the application.yml file of your microservices, configure the Eureka client properties:

yamlCopy codeeureka:
  client:
    serviceUrl:
      defaultZone: http://localhost:8761/eureka/

Creating REST Endpoints

Let’s create a simple microservice with a REST endpoint.

Creating a Controller

Use MicrostarterCLI to generate a controller:

shCopy codemicrostartercli create-controller com.example.micronaut.microservices.HelloController

This command generates a HelloController class in the specified package. Modify the class to include a simple endpoint:

javaCopy codepackage com.example.micronaut.microservices;

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

@Controller("/hello")
public class HelloController {

    @Get("/")
    public String index() {
        return "Hello, Micronaut!";
    }
}

Creating a Service

Generate a service class to handle business logic:

shCopy codemicrostartercli create-service com.example.micronaut.microservices.HelloService

Modify the generated HelloService class:

javaCopy codepackage com.example.micronaut.microservices;

import jakarta.inject.Singleton;

@Singleton
public class HelloService {

    public String getGreeting() {
        return "Hello, Micronaut!";
    }
}

Update the HelloController to use the HelloService:

javaCopy codepackage com.example.micronaut.microservices;

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import jakarta.inject.Inject;

@Controller("/hello")
public class HelloController {

    @Inject
    HelloService helloService;

    @Get("/")
    public String index() {
        return helloService.getGreeting();
    }
}

Configuration Management with Config Client

Centralized configuration management is crucial for microservices to ensure consistency and ease of maintenance. Micronaut provides a config client that integrates with various configuration servers, such as Spring Cloud Config.

Configuring Spring Cloud Config Server

Create a new module for the config server:

shCopy codemicrostartercli create-app com.example.micronaut.configserver --features=config-server --build=gradle

Configure the application.yml file of the config server:

yamlCopy codeserver:
  port: 8888
spring:
  cloud:
    config:
      server:
        git:
          uri: https://github.com/your-repo/config-repo

Configuring Config Client

In the application.yml file of your microservices, configure the config client properties:

yamlCopy codemicronaut:
  config-client:
    enabled: true
  application:
    name: microservice1

spring:
  cloud:
    config:
      uri: http://localhost:8888

Implementing Circuit Breaker with Resilience4j

Circuit breakers are essential for creating resilient microservices. Micronaut integrates with Resilience4j to provide circuit breaker functionality.

Adding Circuit Breaker to a Service

First, add the necessary dependencies to your build.gradle file:

gradleCopy codedependencies {
    implementation("io.github.resilience4j:resilience4j-micronaut")
}

Annotate the service method with @CircuitBreaker:

javaCopy codepackage com.example.micronaut.microservices;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import jakarta.inject.Singleton;

@Singleton
public class HelloService {

    @CircuitBreaker(name = "helloService", fallbackMethod = "fallbackGreeting")
    public String getGreeting() {
        // Simulate a delay or error
        if (new Random().nextInt(10) < 7) {
            throw new RuntimeException("Service failed");
        }
        return "Hello, Micronaut!";
    }

    public String fallbackGreeting(Throwable throwable) {
        return "Hello, from the fallback method!";
    }
}

Implementing Load Balancing with Ribbon

Load balancing distributes incoming requests across multiple instances of a microservice, improving availability and performance. Micronaut integrates with Netflix Ribbon for client-side load balancing.

Adding Ribbon Dependency

Add the Ribbon dependency to your build.gradle file:

gradleCopy codedependencies {
    implementation("io.micronaut.configuration:micronaut-ribbon")
}

Configuring Ribbon

In the application.yml file, configure the Ribbon client:

yamlCopy coderibbon:
  eureka:
    enabled: true

microservice1:
  ribbon:
    listOfServers: localhost:8081,localhost:8082

Testing the Microservices

Testing is an integral part of microservices development. Micronaut provides a comprehensive testing framework that supports unit and integration testing.

Writing Unit Tests

Create a test class for HelloService:

javaCopy codepackage com.example.micronaut.microservices;

import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

@MicronautTest
public class HelloServiceTest {

    @Inject
    HelloService helloService;

    @Test
    void testGetGreeting() {
        String greeting = helloService.getGreeting();
        assertEquals("Hello, Micronaut!", greeting);
    }
}

Writing Integration Tests

Create an integration test for HelloController:

javaCopy codepackage com.example.micronaut.microservices;

import io.micronaut.http.client.HttpClient;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.assertEquals;

@MicronautTest
public class HelloControllerTest {

    @Inject
    @Client("/")
    HttpClient client;

    @Test
    void testHelloEndpoint() {
        String response = client.toBlocking().retrieve("/hello");
        assertEquals("Hello, Micronaut!", response);
    }
}

Deploying the Microservices

Deploying microservices can be done using various methods, including containerization with Docker, Kubernetes orchestration, and cloud services. Here, we’ll focus on containerizing the application using Docker.

Dockerizing the Application

Create a Dockerfile in the root directory of your project:

dockerfileCopy codeFROM openjdk:11-jre-slim
VOLUME /tmp
COPY build/libs/micronaut-microservices-*.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

Build the Docker image:

shCopy codedocker build -t micronaut-microservices .

Run the Docker container:

shCopy codedocker run -p 8080:8080 micronaut-microservices

Deploying to Kubernetes

Create a Kubernetes deployment file deployment.yaml:

yamlCopy codeapiVersion: apps/v1
kind: Deployment
metadata:
  name: micronaut-microservices
spec:
  replicas: 3
  selector:
    matchLabels:
      app: micronaut-microservices
  template:
    metadata:
      labels:
        app: micronaut-microservices
    spec:
      containers:
      - name: micronaut-microservices
        image: micronaut-microservices:latest
        ports:
        - containerPort: 8080

Apply the deployment to your Kubernetes cluster:

shCopy codekubectl apply -f deployment.yaml

Conclusion

Building Micronaut microservices using MicrostarterCLI simplifies and accelerates the development process. By leveraging the capabilities of Micronaut and MicrostarterCLI, you can create scalable, resilient, and maintainable microservices architectures. This article covered the essential steps, including project setup, service discovery, REST endpoint creation, configuration management, circuit breaker implementation, load balancing, testing, and deployment. With these tools and techniques, you are well-equipped to build and deploy robust Micronaut microservices. Keep reading on Groundsurf.