Groovy / Maven

Kubernetes service discovery and distributed configuration

How to use Kubernetes service discovery and distributed configuration in a Micronaut application

Nemanja Mikic

On this guide

In this section

Getting Started

In this guide, we will create three microservices, build containerized versions, and deploy them with Kubernetes. We will use Kubernetes service discovery and distributed configuration to wire up our microservices.

Kubernetes is a portable, extensible, open source platform for managing containerized workloads and services, that facilitates both declarative configuration and automation. It has a large, rapidly growing ecosystem. Kubernetes services, support, and tools are widely available.

You will discover how the Micronaut framework eases Kubernetes integration.

What you will need

To complete this guide, you will need the following:

Some time on your hands
A decent text editor or IDE (e.g. IntelliJ IDEA)
JDK 17 or greater installed with JAVA_HOME configured appropriately
Docker.
Local Kubernetes cluster. We will use Minikube in this guide.

Solution

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Download and unzip the source

Writing the Apps

Let’s describe the microservices you will build through the guide.

users - This microservice contains customers data that can place orders on items, also a new customer can be created. Microservice requires Basic authentication to access it.
orders - This microservice contains all orders that customers have created as well as available items that customers can order. Also this microservice enables the creation of new orders. Microservice requires Basic authentication to access it.
api - This microservice acts as a gateway to the orders and users services. It combines results from both services and checks data when customers create a new order.

Initially we will hard-code the URLs of the orders and users services in the api service. Additionally, we will hard-code credentials (username and password) into every microservice configuration that are required for Basic authentication.

In the second part of this guide, we will use a Kubernetes discovery service and Kubernetes configuration maps to dynamically resolve the URLs of the orders and users microservices and get authentication credentials. The microservices call the Kubernetes API to register when they start up and then resolve placeholders inside the microservices' configurations.

Users Microservice

Create the users microservice using the Micronaut Command Line Interface or with Micronaut Launch.

mn create-app          \
    --features=discovery-kubernetes,management,security,kubernetes,serialization-jackson,validation \
    --build=maven             \
    --lang=groovy               \
    --jdk=21              \
    example.micronaut.users

Note	If you don’t specify the `--build` argument, Gradle with the Kotlin DSL is used as the build tool. If you don’t specify the `--lang` argument, Java is used as the language. If you don’t specify the `--test` argument, JUnit is used for Java and Kotlin, and Spock is used for Groovy.

If you use Micronaut Launch, select Micronaut Application as application type and add the yaml, discovery-kubernetes, management, security, serialization-jackson, kubernetes and graalvm features.

The previous command creates a directory named users containing Micronaut application with a package named example.micronaut.

Note	If you have an existing Micronaut application and want to add the functionality described here, you can view the dependency and configuration changes from the specified features, and apply those changes to your application.

Diff

Create a package named controllers and create a UsersController class to handle incoming HTTP requests for the users microservice:

users/groovy/src/main/groovy/example/micronaut/controllers/UsersController.groovy

package example.micronaut.controllers

import example.micronaut.models.User
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.exceptions.HttpStatusException
import io.micronaut.security.annotation.Secured
import io.micronaut.security.rules.SecurityRule

import jakarta.validation.Valid
import jakarta.validation.constraints.NotNull

@Controller("/users") // 
@Secured(SecurityRule.IS_AUTHENTICATED) // 
class UsersController {

    List<User> persons = []

    @Post // 
    User add(@Body @Valid User user) {
        def existingUser = findByUsername(user.username)

        if (existingUser.isPresent()) {
            throw new HttpStatusException(HttpStatus.CONFLICT, "User with provided username already exists");
        }

        def newUser = new User(persons.size() + 1, user.firstName, user.lastName, user.username)
        persons.add(newUser)
        newUser
    }

    @Get("/{id}") // 
    User findById(int id) {
        persons.stream()
                .filter(it -> it.id == id)
                .findFirst().orElse(null)
    }

    @Get // 
    List<User> getUsers() {
        persons
    }

    Optional<User> findByUsername(@NotNull String username) {
        persons.stream()
                .filter(it -> it.username == username)
                .findFirst()
    }
}

1	The class is defined as a controller with the @Controller annotation mapped to the path `/users`.
2	Annotate with `io.micronaut.security.Secured` to configure secured access. The `isAuthenticated()` expression will allow access only to authenticated users.
3	The @Post annotation maps the `add` method to an HTTP POST request on `/users`.
4	The @Get annotation maps the `findById` method to an HTTP GET request on `/users/{id}`.
5	The @Get annotation maps the `getUsers` method to an HTTP GET request on `/users`.

Create a package named models where we will put our data beans.

The UsersController class uses a User object to represent customer. Create the User class

users/groovy/src/main/groovy/example/micronaut/models/User.groovy

package example.micronaut.models

import com.fasterxml.jackson.annotation.JsonProperty
import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import io.micronaut.core.annotation.Creator
import io.micronaut.core.annotation.Nullable
import io.micronaut.serde.annotation.Serdeable

import jakarta.validation.constraints.NotBlank

@CompileStatic
@EqualsAndHashCode
@Serdeable // 
class User {

    @Nullable
    Integer id // 

    @NotBlank @JsonProperty("first_name")
    String firstName

    @NotBlank @JsonProperty("last_name")
    String lastName

    @NotBlank
    String username

    @Creator
    User(Integer id,
         @NotBlank @JsonProperty("first_name") String firstName,
         @NotBlank @JsonProperty("last_name") String lastName,
         @NotBlank String username
    ) {
        this.id = id
        this.firstName = firstName
        this.lastName = lastName
        this.username = username
    }
}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.
2	ID will be generated by application.

Create a package named auth where you will check basic authentication credentials.

The Credentials class will load and store credentials (username and password) from a configuration file.

users/groovy/src/main/groovy/example/micronaut/auth/Credentials.groovy

package example.micronaut.auth

import io.micronaut.context.annotation.ConfigurationProperties

@ConfigurationProperties("authentication-credentials") // 
class Credentials {
    String username
    String password
}

1	The `@ConfigurationProperties` annotation takes the configuration prefix.

The CredentialsChecker class, as the name suggests, will check if the provided credentials inside the HTTP request’s Authorization header are the same as those that are stored inside the Credentials class that we created above.

users/groovy/src/main/groovy/example/micronaut/auth/CredentialsChecker.groovy

package example.micronaut.auth

import io.micronaut.core.annotation.NonNull
import io.micronaut.core.annotation.Nullable
import io.micronaut.http.HttpRequest
import io.micronaut.security.authentication.AuthenticationFailureReason
import io.micronaut.security.authentication.AuthenticationRequest
import io.micronaut.security.authentication.AuthenticationResponse
import io.micronaut.security.authentication.provider.HttpRequestAuthenticationProvider
import jakarta.inject.Singleton

@Singleton // 
class CredentialsChecker<B> implements HttpRequestAuthenticationProvider<B> { // 

    private final Credentials credentials

    CredentialsChecker(Credentials credentials) {
        this.credentials = credentials
    }

    AuthenticationResponse authenticate(
            @Nullable HttpRequest<B> httpRequest,
            @NonNull AuthenticationRequest<String, String> authenticationRequest
    ) {
        return (authenticationRequest.getIdentity() == credentials.username && authenticationRequest.getSecret() == credentials.password)
                ? AuthenticationResponse.success(authenticationRequest.getIdentity())
                : AuthenticationResponse.failure(AuthenticationFailureReason.CREDENTIALS_DO_NOT_MATCH)
    }
}

1	Use `jakarta.inject.Singleton` to designate a class as a singleton.

Write tests to verify application logic

Create the UsersClient, a declarative Micronaut HTTP Client for testing:

users/groovy/src/test/groovy/example/micronaut/UsersClient.groovy

package example.micronaut

import example.micronaut.models.User
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Header
import io.micronaut.http.annotation.Post
import io.micronaut.http.client.annotation.Client

@Client("/") // 
interface UsersClient {
    @Get("/users/{id}")
    User getById(@Header String authorization, int id)

    @Post("/users")
    User createUser(@Header String authorization, @Body User user)

    @Get("/users")
    List<User> getUsers(@Header String authorization)
}

1	Use `@Client` to use declarative HTTP Clients. You can annotate interfaces or abstract classes. You can use the `id` member to provide a service identifier or specify the URL directly as the annotation’s value.

HealthTest checks that there is /health endpoint that is required for service discovery.

users/groovy/src/test/groovy/example/micronaut/HealthSpec.groovy

package example.micronaut

import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpStatus
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest // 
class HealthSpec extends Specification {

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

    void 'health endpoint exposed'() {
        when:
        def status = client.toBlocking().retrieve(HttpRequest.GET("/health"), HttpStatus.class)

        then:
        status == HttpStatus.OK
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.
2	Inject the `HttpClient` bean and point it to the embedded server.

UsersControllerTest tests endpoints inside the UserController.

users/groovy/src/test/groovy/example/micronaut/UsersControllerSpec.groovy

package example.micronaut

import example.micronaut.auth.Credentials
import example.micronaut.models.User
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

import static io.micronaut.http.HttpStatus.CONFLICT
import static io.micronaut.http.HttpStatus.UNAUTHORIZED

@MicronautTest // 
class UsersControllerSpec extends Specification {

    @Inject
    UsersClient usersClient

    @Inject
    Credentials credentials

    void "unauthorized"() {

        when:
        usersClient.getUsers("")

        then:
        HttpClientResponseException e = thrown()
        e.response.status == UNAUTHORIZED
        e.message.contains("Unauthorized")
    }

    void "get user that doesn't exist"() {
        String authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())

        when:
        User retriedUser = usersClient.getById(authHeader, 100)

        then:
        retriedUser == null
    }

    void "multiple user interaction"() {
        String authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())

        String firstName = "firstName"
        String lastName = "lastName"
        String username = "username"

        User user = new User(0 ,firstName, lastName, username)

        when:
        User createdUser = usersClient.createUser(authHeader, user)

        then:
        createdUser.firstName == firstName
        createdUser.lastName == lastName
        createdUser.username == username
        createdUser.id != 0

        when:
        User retriedUser = usersClient.getById(authHeader, createdUser.id)

        then:
        retriedUser.firstName == firstName
        retriedUser.lastName == lastName
        retriedUser.username == username
        retriedUser.id != 0

        when:
        List<User> users = usersClient.getUsers(authHeader)

        then:
        users != null
        users.stream().map(x->x.username).anyMatch(name -> name == username)
    }

    void "create same user twice"() {
        String authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())

        String firstName = "SameUserFirstName"
        String lastName = "SameUserLastName"
        String username = "SameUserUsername"

        User user = new User(0 ,firstName, lastName, username)

        when:
        User createdUser = usersClient.createUser(authHeader, user)

        then:
        createdUser.firstName == firstName
        createdUser.firstName == firstName
        createdUser.lastName == lastName
        createdUser.username == username
        createdUser.id != 0

        when:
        usersClient.createUser(authHeader, user)

        then:
        HttpClientResponseException e = thrown()
        e.response.status == CONFLICT
        e.response.getBody(String.class).orElse("").contains("User with provided username already exists")
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.

Edit application.properties

users/src/main/resources/application.properties

micronaut.application.name=users
authentication-credentials.username=${username} 
authentication-credentials.password=${password}

1	Placeholder for username that will be populated by Kubernetes.
2	Placeholder for password that will be populated by Kubernetes.

Edit the bootstrap.properties file in the resources directory to enable distributed configuration. Change the default contents to the following:

users/src/main/resources/bootstrap.properties

micronaut.application.name=users
micronaut.config-client.enabled=true 
kubernetes.client.secrets.enabled=true 
kubernetes.client.secrets.use-api=true

1	Set `micronaut.config-client.enabled: true` to read and resolve configuration from distributed sources.
2	Set `kubernetes.client.secrets.enabled: true` to enable Kubernetes secrets as distributed source.
3	Set `kubernetes.client.secrets.use-api: true` to use the Kubernetes API to fetch the configuration.

Create src/main/resources/application-dev.properties. The Micronaut framework applies this configuration file only for the dev environment.

users/src/main/resources/application-dev.properties

micronaut.server.port=8081 
authentication-credentials.username=test_username 
authentication-credentials.password=test_password

1	Configure the application to listen on port 8081.
2	Hardcoded username for the development environment.
3	Hardcoded password for the development environment.

Create a file named bootstrap-dev.properties to disable distributed configuration in the dev environment:

users/src/main/resources/bootstrap-dev.properties

kubernetes.client.secrets.enabled=false

1	Disable the Kubernetes secrets client.

Create a file named application-test.properties for use in the test environment:

users/src/test/resources/application-test.properties

authentication-credentials.username=test_username 
authentication-credentials.password=test_password

1	Hardcoded username for the test environment.
2	Hardcoded password for the test environment.

Run the unit test:

users

./mvnw test

Running the application

Run the users microservice:

users

 MICRONAUT_ENVIRONMENTS=dev ./mvnw mn:run

14:28:34.034 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 499ms. Server Running: http://localhost:8081

Orders Microservice

Create the orders microservice using the Micronaut Command Line Interface or with Micronaut Launch.

mn create-app        \
  --features=discovery-kubernetes,management,security,kubernetes,serialization-jackson,validation \
  --build=maven              \
  --lang=groovy                \
  --jdk=21               \
example.micronaut.orders

Note	If you don’t specify the `--build` argument, Gradle with the Kotlin DSL is used as the build tool. If you don’t specify the `--lang` argument, Java is used as the language. If you don’t specify the `--test` argument, JUnit is used for Java and Kotlin, and Spock is used for Groovy.

The previous command creates a directory named orders containing a Micronaut application with a package named example.micronaut.

Note	If you have an existing Micronaut application and want to add the functionality described here, you can view the dependency and configuration changes from the specified features, and apply those changes to your application.

Diff

Create a package named controllers and create the OrdersController and ItemsController classes to handle incoming HTTP requests to the orders microservice:

orders/groovy/src/main/groovy/example/micronaut/controllers/OrdersController.groovy

package example.micronaut.controllers

import example.micronaut.models.Item
import example.micronaut.models.Order
import io.micronaut.core.annotation.NonNull
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.exceptions.HttpStatusException
import io.micronaut.security.annotation.Secured
import io.micronaut.security.rules.SecurityRule

import jakarta.validation.Valid

@Controller("/orders")  // 
@Secured(SecurityRule.IS_AUTHENTICATED)  // 
class OrdersController {

    private final List<Order> orders = []

    @Get("/{id}")  // 
    Order findById(int id) {
        orders.stream()
                .filter(it -> it.id == id)
                .findFirst().orElse(null)
    }

    @Get  // 
    List<Order> getOrders() {
        orders
    }

    @Post  // 
    Order createOrder(@Body @Valid Order order) {
        if (order.itemIds == null || order.itemIds.isEmpty()) {
            throw new HttpStatusException(HttpStatus.BAD_REQUEST, "Items must be supplied")
        }

        def items = order.itemIds.stream().map(
                x -> Item.items.stream().filter(
                        y -> y.id == x
                ).findFirst().orElseThrow(
                        () -> new HttpStatusException(HttpStatus.BAD_REQUEST, String.format("Item with id %s doesn't exist", x))
                )).collect()

        BigDecimal total = items.stream().map(x->x.price).reduce(BigDecimal::add).orElse(new BigDecimal("0"))
        Order newOrder = new Order(orders.size() + 1, order.userId, items, null, total)

        orders.add(newOrder)
        newOrder
    }
}

1	The class is defined as a controller with the @Controller annotation mapped to the path `/orders`.
2	Annotate with `io.micronaut.security.Secured` to configure secured access. The `isAuthenticated()` expression will allow access only to authenticated users.
3	The @Get annotation maps the `findById` method to an HTTP GET request on `/orders/{id}`.
4	The @Get annotation maps the `getOrders` method to an HTTP GET request on `/orders`.
5	The @Post annotation maps the `createOrder` method to an HTTP POST request on `/orders`.

orders/groovy/src/main/groovy/example/micronaut/controllers/ItemsController.groovy

package example.micronaut.controllers

import example.micronaut.models.Item
import io.micronaut.core.annotation.NonNull
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.security.annotation.Secured
import io.micronaut.security.rules.SecurityRule

@Controller("/items")  // 
@Secured(SecurityRule.IS_AUTHENTICATED)  // 
class ItemsController {

    @Get("/{id}")  // 
    Item findById(int id) {
        Item.items.stream()
                .filter(it -> it.id == id)
                .findFirst().orElse(null)
    }

    @Get  // 
    List<Item> getItems() {
        Item.items
    }
}

1	The class is defined as a controller with the @Controller annotation mapped to the path `/items`.
2	Annotate with `io.micronaut.security.Secured` to configure secured access. The `isAuthenticated()` expression will allow access only to authenticated users.
3	The @Get annotation maps the `findById` method to an HTTP GET request on `/items/{id}`.
4	The @Get annotation maps the `getItems` method to an HTTP GET request on `/items`.

Create a package named models where you will put your data beans.

The previous OrdersController and ItemsController controller uses Order and Item objects to represent customer orders. Create the Order class:

orders/groovy/src/main/groovy/example/micronaut/models/Order.groovy

package example.micronaut.models

import com.fasterxml.jackson.annotation.JsonProperty
import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import io.micronaut.core.annotation.Creator
import io.micronaut.core.annotation.Nullable
import io.micronaut.serde.annotation.Serdeable

@CompileStatic
@EqualsAndHashCode
@Serdeable // 
class Order {

    @Nullable Integer id // 

    @JsonProperty("user_id") Integer userId

    @Nullable List<Item> items // 

    @JsonProperty("item_ids") @Nullable List<Integer> itemIds // 

    @Nullable BigDecimal total

    @Creator
    Order(Integer id,
         @JsonProperty("user_id") Integer userId,
         @Nullable List<Item> items,
         @JsonProperty("item_ids") @Nullable List<Integer> itemIds,
         @Nullable BigDecimal total
    ) {
        this.id = id
        this.userId = userId
        this.items = items
        this.itemIds = itemIds
        this.total = total
    }

}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.
2	ID will be generated by application.
3	The `List` of `Item` class will be populated by the server and will be only visible in server responses.
4	List of item_ids will be provided by client requests.

Create the Item class:

orders/groovy/src/main/groovy/example/micronaut/models/Item.groovy

package example.micronaut.models

import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import io.micronaut.core.annotation.Creator
import io.micronaut.serde.annotation.Serdeable


@CompileStatic
@EqualsAndHashCode
@Serdeable // 
class Item {

    Integer id
    String name
    BigDecimal price

    public static List<Item> items = [
            new Item(1, "Banana", new BigDecimal("1.5")),
            new Item(2, "Kiwi", new BigDecimal("2.5")),
            new Item(3, "Grape", new BigDecimal("1.25"))
    ]

    @Creator
    Item(Integer id,
         String name,
         BigDecimal price
    ) {
        this.id = id
        this.name = name
        this.price = price
    }
}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.

Create a package named auth where you will check basic authentication credentials.

The Credentials class will load and store credentials (username and password) from configuration files.

orders/groovy/src/main/groovy/example/micronaut/auth/Credentials.groovy

package example.micronaut.auth

import io.micronaut.context.annotation.ConfigurationProperties

@ConfigurationProperties("authentication-credentials") // 
class Credentials {
    String username
    String password
}

1	The `@ConfigurationProperties` annotation takes the configuration prefix.

The CredentialsChecker class, as name suggests, will check if provided credentials inside an HTTP request’s Authorization header are the same as those that are stored inside Credentials class that we created above.

orders/groovy/src/main/groovy/example/micronaut/auth/CredentialsChecker.groovy

package example.micronaut.auth

import io.micronaut.core.annotation.NonNull
import io.micronaut.core.annotation.Nullable
import io.micronaut.http.HttpRequest
import io.micronaut.security.authentication.AuthenticationFailureReason
import io.micronaut.security.authentication.AuthenticationRequest
import io.micronaut.security.authentication.AuthenticationResponse
import io.micronaut.security.authentication.provider.HttpRequestAuthenticationProvider
import jakarta.inject.Singleton

@Singleton // 
class CredentialsChecker<B> implements HttpRequestAuthenticationProvider<B> { // 

    private final Credentials credentials

    CredentialsChecker(Credentials credentials) {
        this.credentials = credentials
    }

    AuthenticationResponse authenticate(
            @Nullable HttpRequest<B> httpRequest,
            @NonNull AuthenticationRequest<String, String> authenticationRequest
    ) {
        return (authenticationRequest.getIdentity() == credentials.username && authenticationRequest.getSecret() == credentials.password)
                ? AuthenticationResponse.success(authenticationRequest.getIdentity())
                : AuthenticationResponse.failure(AuthenticationFailureReason.CREDENTIALS_DO_NOT_MATCH)
    }
}

1	Use `jakarta.inject.Singleton` to designate a class as a singleton.

Write tests to verify application logic

Create the OrderItemClient, a declarative Micronaut HTTP Client for testing:

orders/groovy/src/test/groovy/example/micronaut/OrderItemClient.groovy

package example.micronaut

import example.micronaut.models.Item
import example.micronaut.models.Order
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Header
import io.micronaut.http.annotation.Post
import io.micronaut.http.client.annotation.Client

@Client("/") // 
interface OrderItemClient {

    @Get("/orders/{id}")
    Order getOrderById(@Header String authorization, int id)

    @Post("/orders")
    Order createOrder(@Header String authorization, @Body Order order)

    @Get("/orders")
    List<Order> getOrders(@Header String authorization)

    @Get("/items")
    List<Item> getItems(@Header String authorization)

    @Get("/items/{id}")
    Item getItemsById(@Header String authorization, int id)

}

1	Use `@Client` to use declarative HTTP Clients. You can annotate interfaces or abstract classes. You can use the `id` member to provide a service identifier or specify the URL directly as the annotation’s value.

HealthTest checks that there is /health endpoint that is required for service discovery.

orders/groovy/src/test/groovy/example/micronaut/HealthSpec.groovy

package example.micronaut

import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpStatus
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest // 
class HealthTest extends Specification {

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

    void 'health endpoint exposed'() {
        when:
        def status = client.toBlocking().retrieve(HttpRequest.GET("/health"), HttpStatus.class)

        then:
        status == HttpStatus.OK
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.
2	Inject the `HttpClient` bean and point it to the embedded server.

ItemsControllerTest tests endpoints inside the ItemController.

orders/groovy/src/test/groovy/example/micronaut/ItemsControllerSpec.groovy

package example.micronaut

import example.micronaut.auth.Credentials
import example.micronaut.models.Item
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

import static io.micronaut.http.HttpStatus.UNAUTHORIZED

@MicronautTest // 
class ItemsControllerSpec extends Specification {

    @Inject
    OrderItemClient orderItemClient

    @Inject
    Credentials credentials

    void "unauthorized"() {

        when:
        orderItemClient.getItems("")

        then:
        HttpClientResponseException e = thrown()
        e.response.status == UNAUTHORIZED
        e.message.contains("Unauthorized")
    }

    void "get item"() {
        def authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())
        def itemId = 1

        when:
        Item item = orderItemClient.getItemsById(authHeader, itemId)

        then:
        itemId == item.id
        item.name == "Banana"
        item.price == new BigDecimal("1.5")
    }

    void "get items"() {
        def authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())
        def existingItemNames = ["Kiwi", "Banana", "Grape"]

        when:
        def items = orderItemClient.getItems(authHeader)

        then:
        items != null
        items.size() == 3
        items.stream().allMatch(y -> existingItemNames.stream().anyMatch(x -> x == y.name))
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.

OrdersControllerTest tests endpoints inside the OrdersController.

orders/groovy/src/test/groovy/example/micronaut/OrdersControllerSpec.groovy

package example.micronaut

import example.micronaut.auth.Credentials
import example.micronaut.models.Order
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

import static io.micronaut.http.HttpStatus.BAD_REQUEST
import static io.micronaut.http.HttpStatus.UNAUTHORIZED

@MicronautTest // 
class OrdersControllerSpec extends Specification {

    @Inject
    OrderItemClient orderItemClient

    @Inject
    Credentials credentials

    void "unauthorized"() {

        when:
        orderItemClient.getItems("")

        then:
        HttpClientResponseException e = thrown()
        e.response.status == UNAUTHORIZED
        e.message.contains("Unauthorized")
    }

    void "multiple order interaction"() {
        String authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())
        def userId = 1
        def itemIds = [1, 1, 2, 3]
        Order order = new Order(0, userId, null, itemIds, null)

        when:
        def createdOrder = orderItemClient.createOrder(authHeader, order)

        then:
        createdOrder.items != null
        createdOrder.items.size() == 4
        createdOrder.total == new BigDecimal("6.75")
        createdOrder.userId == userId

        when:
        def retrievedOrder = orderItemClient.getOrderById(authHeader, createdOrder.id)

        then:
        retrievedOrder.items != null
        retrievedOrder.items.size() == 4
        retrievedOrder.total == new BigDecimal("6.75")
        retrievedOrder.userId == userId

        when:
        def orders = orderItemClient.getOrders(authHeader)

        then:
        orders != null
        orders.stream().anyMatch(x -> x.userId == userId)
    }

    void "item doesn't exist"() {
        def authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())

        def  userId = 1
        def itemIds = [5]

        def order = new Order(0, userId, null, itemIds, null)

        when:
        orderItemClient.createOrder(authHeader, order)

        then:
        HttpClientResponseException e = thrown()
        e.response.status == BAD_REQUEST
        e.response.getBody(String.class).orElse("").contains("Item with id 5 doesn't exist")
    }

    void "order empty items"() {
        def authHeader = "Basic " + Base64.getEncoder().encodeToString((credentials.username + ":" + credentials.password).getBytes())

        def  userId = 1
        def itemIds = [5]

        def order = new Order(0, userId, null, null, null)

        when:
        orderItemClient.createOrder(authHeader, order)

        then:
        HttpClientResponseException e = thrown()
        e.response.status == BAD_REQUEST
        e.response.getBody(String.class).orElse("").contains("Items must be supplied")
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.

Edit application.properties so it contains:

orders/src/main/resources/application.properties

micronaut.application.name=orders
authentication-credentials.username=${username} 
authentication-credentials.password=${password}

1	Placeholder for username that will be populated by Kubernetes.
2	Placeholder for password that will be populated by Kubernetes.

Edit bootstrap.properties file in the resources directory to enable distributed configuration. Change it to the following:

orders/src/main/resources/bootstrap.properties

micronaut.application.name=orders
micronaut.config-client.enabled=true 
kubernetes.client.secrets.enabled=true 
kubernetes.client.secrets.use-api=true

1	Set `micronaut.config-client.enabled: true` to read and resolve configuration from distributed sources.
2	Set `kubernetes.client.secrets.enabled: true` to enable Kubernetes secrets as distributed source.
3	Set `kubernetes.client.secrets.use-api: true` to use Kubernetes API to fetch configuration.

Create src/main/resources/application-dev.properties. The Micronaut framework applies this configuration file only for the dev environment.

orders/src/main/resources/application-dev.properties

micronaut.server.port=8082 
authentication-credentials.username=test_username 
authentication-credentials.password=test_password

1	Configure the application to listen on port 8082.
2	Hardcoded username for development environment.
3	Hardcoded password for development environment.

Create a file named bootstrap-dev.properties to disable distributed configuration in the dev environment:

orders/src/main/resources/bootstrap-dev.properties

kubernetes.client.secrets.enabled=false

1	Disable Kubernetes secrets client.

Create a file named application-test.properties to be used in the test environment:

orders/src/test/resources/application-test.properties

micronaut.application.name=orders
authentication-credentials.username=test_username 
authentication-credentials.password=test_password

1	Hardcoded username for development environment.
2	Hardcoded password for development environment.

Run the unit test:

orders

./mvnw test

Running the application

Run the orders microservice:

orders

MICRONAUT_ENVIRONMENTS=dev ./mvnw mn:run

14:28:34.034 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 499ms. Server Running: http://localhost:8082

API (Gateway) Microservice

Create the api microservice using the Micronaut Command Line Interface or with Micronaut Launch.

mn create-app         \
   --features=discovery-kubernetes,management,kubernetes,serialization-jackson,http-client \
   --build=maven           \
   --lang=groovy             \
   --jdk=21            \
    example.micronaut.api

Note	If you don’t specify the `--build` argument, Gradle with the Kotlin DSL is used as the build tool. If you don’t specify the `--lang` argument, Java is used as the language. If you don’t specify the `--test` argument, JUnit is used for Java and Kotlin, and Spock is used for Groovy.

If you use Micronaut Launch, select Micronaut Application as application type and add the yaml, discovery-kubernetes, management, kubernetes, serialization-jackson, mockito, graalvm and http-client features.

The previous command creates a directory named api containing a Micronaut application with a package named example.micronaut.

Note	If you have an existing Micronaut application and want to add the functionality described here, you can view the dependency and configuration changes from the specified features, and apply those changes to your application.

Diff

Create a package named controllers and create a GatewayController class to handle incoming HTTP requests to the api microservice:

api/groovy/src/main/groovy/example/micronaut/controllers/GatewayController.groovy

package example.micronaut.controllers

import example.micronaut.clients.OrdersClient
import example.micronaut.clients.UsersClient
import example.micronaut.models.Item
import example.micronaut.models.Order
import example.micronaut.models.User
import io.micronaut.core.annotation.NonNull
import io.micronaut.http.HttpStatus
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Controller
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.exceptions.HttpStatusException
import io.micronaut.scheduling.TaskExecutors
import io.micronaut.scheduling.annotation.ExecuteOn

import jakarta.validation.Valid

@Controller("/api") // 
@ExecuteOn(TaskExecutors.BLOCKING) // 
class GatewayController {

    private final OrdersClient ordersClient
    private final UsersClient userClient

    GatewayController(OrdersClient ordersClient, UsersClient userClient) {
        this.ordersClient = ordersClient
        this.userClient = userClient
    }

    @Get("/users/{id}") // 
    User getUserById(int id) {
        userClient.getById(id)
    }

    @Get("/orders/{id}") // 
    Order getOrdersById(int id) {
        def order = ordersClient.getOrderById(id)
        new Order(order.id, null, getUserById(order.userId), order.items, order.itemIds, order.total)
    }

    @Get("/items/{id}") // 
    Item getItemsById(int id) {
        ordersClient.getItemsById(id)
    }

    @Get("/users") // 
    List<User> getUsers() {
        userClient.getUsers()
    }

    @Get("/items") // 
    List<Item> getItems() {
        ordersClient.getItems()
    }

    @Get("/orders") // 
    List<Order> getOrders() {
        def orders = []
        ordersClient.getOrders().each {
            x -> orders.add(new Order(x.id, null, getUserById(x.userId), x.items, x.itemIds, x.total))
        }
        orders
    }

    @Post("/orders") // 
    Order createOrder(@Body @Valid Order order) {
        User user = getUserById(order.userId)
        if (user == null) {
            throw new HttpStatusException(HttpStatus.BAD_REQUEST, String.format("User with id %s doesn't exist", order.userId))
        }
        def createdOrder = ordersClient.createOrder(order)
        new Order(createdOrder.id, null, user, createdOrder.items, createdOrder.itemIds , createdOrder.total)
    }

    @Post("/users")  // 
    User createUser(@Body @NonNull User user) {
        userClient.createUser(user)
    }

}

1	The class is defined as a controller with the @Controller annotation mapped to the path `/api`.
2	It is critical that any blocking I/O operations (such as fetching the data from the database) are offloaded to a separate thread pool that does not block the Event loop.
3	The @Get annotation maps the `getUserById` method to an HTTP GET request on `/users/{id}`.
4	The @Get annotation maps the `getOrdersById` method to an HTTP GET request on `/orders/{id}`.
5	The @Get annotation maps the `getItemsById` method to an HTTP GET request on `/items/{id}`.
6	The @Get annotation maps the `getUsers` method to an HTTP GET request on `/users`.
7	The @Get annotation maps the `getItems` method to an HTTP GET request on `/items`.
8	The @Get annotation maps the `getOrders` method to an HTTP GET request on `/orders`.
9	The @Post annotation maps the `createUser` method to an HTTP POST request on `/users`.
10	The @Post annotation maps the `createOrder` method to an HTTP POST request on `/orders`.

Create a package named models where you will put your data beans.

The previous GatewayController and ItemsController controller uses User, Order and Item to represent customer orders. Create the User class:

api/groovy/src/main/groovy/example/micronaut/models/User.groovy

package example.micronaut.models

import com.fasterxml.jackson.annotation.JsonProperty
import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import io.micronaut.core.annotation.Creator
import io.micronaut.core.annotation.Nullable
import io.micronaut.serde.annotation.Serdeable

import jakarta.validation.constraints.NotBlank

@CompileStatic
@EqualsAndHashCode
@Serdeable // 
class User {
    @Nullable Integer id // 

    @NotBlank @JsonProperty("first_name")
    String firstName

    @NotBlank @JsonProperty("last_name")
    String lastName

    @NotBlank
    String username

    @Creator
    User(Integer id,
         @NotBlank @JsonProperty("first_name") String firstName,
         @NotBlank @JsonProperty("last_name") String lastName,
         @NotBlank String username
    ) {
        this.id = id
        this.firstName = firstName
        this.lastName = lastName
        this.username = username
    }
}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.

Create the Order class:

api/groovy/src/main/groovy/example/micronaut/models/Order.groovy

package example.micronaut.models

import com.fasterxml.jackson.annotation.JsonProperty
import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import io.micronaut.core.annotation.Creator
import io.micronaut.core.annotation.Nullable
import io.micronaut.serde.annotation.Serdeable

import jakarta.validation.constraints.NotBlank

@CompileStatic
@EqualsAndHashCode
@Serdeable // 
class Order {
    @Nullable Integer id // 

    @NotBlank @Nullable @JsonProperty("user_id") Integer userId

    @Nullable User user

    @Nullable List<Item> items // 

    @NotBlank @Nullable @JsonProperty("item_ids") List<Integer> itemIds // 

    @Nullable BigDecimal total

    @Creator
    Order(Integer id,
          @NotBlank @Nullable @JsonProperty("user_id") Integer userId,
          @Nullable User user,
          @Nullable List<Item> items,
          @NotBlank @JsonProperty("item_ids")
          @Nullable List<Integer> itemIds,
          @Nullable BigDecimal total
    ) {
        this.id = id
        this.userId = userId
        this.user = user
        this.items = items
        this.itemIds = itemIds
        this.total = total
    }

}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.

Create the Item class:

api/groovy/src/main/groovy/example/micronaut/models/Item.groovy

package example.micronaut.models

import groovy.transform.CompileStatic
import groovy.transform.EqualsAndHashCode
import io.micronaut.core.annotation.Creator
import io.micronaut.serde.annotation.Serdeable


@CompileStatic
@EqualsAndHashCode
@Serdeable // 
class Item {

    Integer id
    String name
    BigDecimal price

    public static List<Item> items = [
            new Item(1, "Banana", new BigDecimal("1.5")),
            new Item(2, "Kiwi", new BigDecimal("2.5")),
            new Item(3, "Grape", new BigDecimal("1.25"))
    ]

    @Creator
    Item(Integer id,
         String name,
         BigDecimal price
    ) {
        this.id = id
        this.name = name
        this.price = price
    }
}

1	Declare the `@Serdeable` annotation at the type level in your source code to allow the type to be serialized or deserialized.

Create a package named clients where you will put the HTTP Clients to call the users and orders microservices.

Create a UsersClient for the users microservice.

api/groovy/src/main/groovy/example/micronaut/clients/UsersClient.groovy

package example.micronaut.clients

import example.micronaut.models.User
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.client.annotation.Client

@Client("users") // 
interface UsersClient {
    @Get("/users/{id}")
    User getById(int id)

    @Post("/users")
    User createUser(@Body User user)

    @Get("/users")
    List<User> getUsers()
}

1	Use `@Client` to use declarative HTTP Clients. You can annotate interfaces or abstract classes. You can use the `id` member to provide a service identifier or specify the URL directly as the annotation’s value.

Create an OrdersClient for the orders microservice.

api/groovy/src/main/groovy/example/micronaut/clients/OrdersClient.groovy

package example.micronaut.clients

import example.micronaut.models.Item
import example.micronaut.models.Order
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.client.annotation.Client

@Client("orders") // 
interface OrdersClient {

    @Get("/orders/{id}")
    Order getOrderById(int id)

    @Post("/orders")
    Order createOrder(@Body Order order)

    @Get("/orders")
    List<Order> getOrders()

    @Get("/items")
    List<Item> getItems()

    @Get("/items/{id}")
    Item getItemsById(int id)
}

1	Use `@Client` to use declarative HTTP Clients. You can annotate interfaces or abstract classes. You can use the `id` member to provide a service identifier or specify the URL directly as the annotation’s value.

Create a package named auth where we will check basic authentication credentials.

Create a Credentials class that will load the username and password from configuration that will be needed for comparison.

api/groovy/src/main/groovy/example/micronaut/auth/Credentials.groovy

package example.micronaut.auth

import io.micronaut.context.annotation.ConfigurationProperties

@ConfigurationProperties("authentication-credentials") // 
class Credentials {
    String username
    String password
}

1	The `@ConfigurationProperties` annotation takes the configuration prefix.

Create an AuthClientFilter class that is a client filter applied to every client. It adds basic authentication header with credentials that are stored in the Credentials class.

api/groovy/src/main/groovy/example/micronaut/auth/AuthClientFilter.groovy

package example.micronaut.auth

import io.micronaut.http.HttpResponse
import io.micronaut.http.MutableHttpRequest
import io.micronaut.http.annotation.Filter
import io.micronaut.http.filter.ClientFilterChain
import io.micronaut.http.filter.HttpClientFilter
import org.reactivestreams.Publisher

@Filter(Filter.MATCH_ALL_PATTERN)
class AuthClientFilter implements HttpClientFilter {

    private final Credentials credentials

    AuthClientFilter(Credentials credentials) {
        this.credentials = credentials
    }

    @Override
    Publisher<? extends HttpResponse<?>> doFilter(MutableHttpRequest<?> request, ClientFilterChain chain) {
        chain.proceed(request.basicAuth(credentials.username, credentials.password))
    }
}

Create a class named ErrorExceptionHandler in the example.micronaut package. ErrorExceptionHandler will propagate errors from the orders and users microservices.

api/groovy/src/main/groovy/example/micronaut/ErrorExceptionHandler.groovy

package example.micronaut

import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpResponse
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.http.server.exceptions.ExceptionHandler
import io.micronaut.http.server.exceptions.response.ErrorContext
import io.micronaut.http.server.exceptions.response.ErrorResponseProcessor
import jakarta.inject.Singleton

@Singleton // 
class ErrorExceptionHandler implements ExceptionHandler<HttpClientResponseException, HttpResponse<?>> {

    private final ErrorResponseProcessor<?> errorResponseProcessor;

    ErrorExceptionHandler(ErrorResponseProcessor<?> errorResponseProcessor) {
        this.errorResponseProcessor = errorResponseProcessor;
    }

    @Override
    HttpResponse handle(HttpRequest request, HttpClientResponseException e) {
        errorResponseProcessor.processResponse(ErrorContext.builder(request)
                .cause(e)
                .errorMessage(e.response.getBody(String.class).orElse(null))
                .build(), HttpResponse.status(e.status));
    }
}

1	Use `jakarta.inject.Singleton` to designate a class as a singleton.

Write tests to verify application logic

Create a GatewayClient, a declarative Micronaut HTTP Client for testing:

api/groovy/src/test/groovy/example/micronaut/GatewayClient.groovy

package example.micronaut

import example.micronaut.models.Item
import example.micronaut.models.Order
import example.micronaut.models.User
import io.micronaut.http.annotation.Body
import io.micronaut.http.annotation.Get
import io.micronaut.http.annotation.Post
import io.micronaut.http.client.annotation.Client

@Client("/") // 
interface GatewayClient {

    @Get("/api/items/{id}")
    Item getItemById(int id)

    @Get("/api/orders/{id}")
    Order getOrderById(int id)

    @Get("/api/users/{id}")
    User getUsersById(int id)

    @Get("/api/users")
    List<User> getUsers()

    @Get("/api/items")
    List<Item> getItems()

    @Get("/api/orders")
    List<Order> getOrders()

    @Post("/api/orders")
    Order createOrder(@Body Order order)

    @Post("/api/users")
    User createUser(@Body User user)

}

1	Use `@Client` to use declarative HTTP Clients. You can annotate interfaces or abstract classes. You can use the `id` member to provide a service identifier or specify the URL directly as the annotation’s value.

HealthTest checks that there is /health endpoint that is required for service discovery.

api/groovy/src/test/groovy/example/micronaut/HealthSpec.groovy

package example.micronaut

import io.micronaut.http.HttpRequest
import io.micronaut.http.HttpStatus
import io.micronaut.http.client.HttpClient
import io.micronaut.http.client.annotation.Client
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest // 
class HealthSpec extends Specification {

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

    void 'health endpoint exposed'() {
        when:
        def status = client.toBlocking().retrieve(HttpRequest.GET("/health"), HttpStatus.class)

        then:
        status == HttpStatus.OK
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.
2	Inject the `HttpClient` bean and point it to the embedded server.

GatewayControllerTest tests endpoints inside the GatewayController.

api/groovy/src/test/groovy/example/micronaut/GatewayControllerSpec.groovy

package example.micronaut

import example.micronaut.clients.OrdersClient
import example.micronaut.clients.UsersClient
import example.micronaut.models.Item
import example.micronaut.models.Order
import example.micronaut.models.User
import io.micronaut.http.HttpResponse
import io.micronaut.http.HttpStatus
import io.micronaut.http.client.exceptions.HttpClientResponseException
import io.micronaut.test.annotation.MockBean
import io.micronaut.test.extensions.spock.annotation.MicronautTest
import jakarta.inject.Inject
import spock.lang.Specification

@MicronautTest // 
class GatewayControllerSpec extends Specification {

    @Inject
    OrdersClient ordersClient

    @Inject
    UsersClient usersClient

    @Inject
    GatewayClient gatewayClient


    @MockBean(OrdersClient.class)
    OrdersClient ordersClient() {
        return Mock(OrdersClient.class)
    }

    @MockBean(UsersClient.class)
    UsersClient usersClient() {
        return Mock(UsersClient.class)
    }

    void 'get item by id'() {
        given:
        def itemId = 1
        def item = new Item(itemId, "test", BigDecimal.ONE)

        when:
        def retrievedItem = gatewayClient.getItemById(1)

        then:
        1 * ordersClient.getItemsById(1) >> item

        item.id == retrievedItem.id
        item.name == retrievedItem.name
        item.price == retrievedItem.price
    }

    void 'get order by id'() {
        given:
        def order = new Order(1, 2, null, null, new ArrayList<>(), null)
        def user = new User(order.userId, "firstName", "lastName", "test")

        when:
        def retrievedOrder = gatewayClient.getOrderById(order.id)

        then:
        1 * ordersClient.getOrderById(1) >> order
        1 * usersClient.getById(user.id) >> user

        order.id == retrievedOrder.id
        order.userId == retrievedOrder.user.id
        retrievedOrder.userId == null
        user.username == retrievedOrder.user.username
    }

    void 'get user by id'() {
        given:
        def user = new User(1, "firstName", "lastName", "test")

        when:
        def retrievedUser = gatewayClient.getUsersById(user.id)

        then:
        1 * usersClient.getById(user.id) >> user
        user.id == retrievedUser.id
        user.username == retrievedUser.username
    }

    void 'get users'() {
        given:
        def user = new User(1, "firstName", "lastName", "test")

        when:
        def users = gatewayClient.getUsers()

        then:
        1 * usersClient.getUsers() >> [user]
        users.size() == 1
        user.id == users[0].id
        user.username == users[0].username
    }

    void 'get items'() {
        given:
        def item = new Item(1, "test", BigDecimal.ONE)

        when:
        def items = gatewayClient.getItems()

        then:
        1 * ordersClient.getItems() >> [item]
        items.size() == 1
        item.id == items[0].id
        item.name == items[0].name
        item.price == items[0].price
    }

    void 'get orders'() {
        given:
        def order = new Order(1, 2, null, null, new ArrayList<>(), null)
        def user = new User(order.userId, "firstName", "lastName", "test")

        when:
        def orders = gatewayClient.getOrders()

        then:
        1 * ordersClient.getOrders() >> [order]
        1 * usersClient.getById(user.id) >> user

        orders.size() == 1
        order.id == orders[0].id
        order.userId == orders[0].user.id
        orders[0].userId == null
        user.username == orders[0].user.username
    }

    void 'create user'() {
        given:
        def user = new User(0, "firstName", "lastName", "username")

        when:
        def createdUser = gatewayClient.createUser(user)

        then:
        1 * usersClient.createUser(_) >> user

        user.firstName == createdUser.firstName
        user.lastName == createdUser.lastName
        user.username == createdUser.username

    }

    void 'create order'() {
        given:
        def order = new Order(1, 2, null, null, new ArrayList<>(), null)
        def user = new User(order.userId, "firstName", "lastName", "test")

        when:
        def createdOrder = gatewayClient.createOrder(order)

        then:
        1 * usersClient.getById(user.id) >> user
        1 * ordersClient.createOrder(_) >> order
        order.id == createdOrder.id
        createdOrder.userId == null
        order.userId == createdOrder.user.id
        user.username == createdOrder.user.username
    }

    void 'create order user doesnt exists'() {
        given:
        def order = new Order(1, 2, null, null, new ArrayList<>(), null)

        when:
        gatewayClient.createOrder(order)

        then:
        1 * usersClient.getById(_) >> null

        HttpClientResponseException e = thrown()
        e.response.status == HttpStatus.BAD_REQUEST
        e.response.getBody(String.class).orElse("").contains("User with id 2 doesn't exist")


    }

    void 'exception handler'() {
        given:
        def user = new User(1, "firstname", "lastname", "username")
        def message = "Test error message"

        when:
        gatewayClient.createUser(user)

        then:
        1 * usersClient.createUser(_) >> {throw new HttpClientResponseException("Test", HttpResponse.badRequest(message))}

        HttpClientResponseException e = thrown()
        e.response.status == HttpStatus.BAD_REQUEST
        e.response.getBody(String.class).orElse("").contains(message)
    }

}

1	Annotate the class with `@MicronautTest` so the Micronaut framework will initialize the application context and the embedded server. More info.

Edit application.properties

api/src/main/resources/application.properties

micronaut.application.name=api
authentication-credentials.username=${username} 
authentication-credentials.password=${password}

1	Placeholder for username that will be populated by Kubernetes.
2	Placeholder for password that will be populated by Kubernetes.

Edit the bootstrap.properties file in the resources directory to enable distributed configuration so it looks like the following:

api/src/main/resources/bootstrap.properties

micronaut.application.name=api
micronaut.config-client.enabled=true 
kubernetes.client.secrets.enabled=true 
kubernetes.client.secrets.use-api=true

1	Set `micronaut.config-client.enabled: true` to read and resolve configuration from distributed sources.
2	Set `kubernetes.client.secrets.enabled: true` to enable Kubernetes secrets as a distributed source.
3	Set `kubernetes.client.secrets.use-api: true` to use the Kubernetes API to fetch configuration.

Create src/main/resources/application-dev.properties. The Micronaut framework applies this configuration file only for the dev environment.

api/src/main/resources/application-dev.properties

authentication-credentials.username=test_username 
authentication-credentials.password=test_password

1	Hardcoded username for development environment.
2	Hardcoded password for development environment.

Create a file named bootstrap-dev.properties to disable distributed configuration in the dev environment:

api/src/main/resources/bootstrap-dev.properties

micronaut.http.services.users.urls[0]=http://localhost:8081 
micronaut.http.services.orders.urls[0]=http://localhost:8082 
kubernetes.client.secrets.enabled=false

1	URL of the `users` microservice
2	URL of the `orders` microservice
3	Disable Kubernetes secrets client.

Create a file named application-test.properties to be used in the test environment:

api/src/test/resources/application-test.properties

authentication-credentials.username=test_username 
authentication-credentials.password=test_password

1	Hardcoded username for development environment.
2	Hardcoded password for development environment.

Run the unit test:

api

./mvnw test

Running the application

Run api microservice:

api

MICRONAUT_ENVIRONMENTS=dev ./mvnw mn:run

14:28:34.034 [main] INFO  io.micronaut.runtime.Micronaut - Startup completed in 499ms. Server Running: http://localhost:8080

Test integration between applications

Store the URL of the api microservice in the API_URL environment variable.

export API_URL=http://localhost:8080

Run a cURL command to create a new user via the api microservice:

curl -X "POST" "$API_URL/api/users" -H 'Content-Type: application/json; charset=utf-8' -d '{ "first_name": "Nemanja", "last_name": "Mikic", "username": "nmikic" }'

{"id":1,"username":"nmikic","first_name":"Nemanja","last_name":"Mikic"}

Run a cURL command to create a new order via the api microservice:

curl -X "POST" "$API_URL/api/orders" -H 'Content-Type: application/json; charset=utf-8' -d '{ "user_id": 1, "item_ids": [1,2] }'

{"id":1,"user":{"first_name":"Nemanja","last_name":"Mikic","id":1,"username":"nmikic"},"items":[{"id":1,"name":"Banana","price":1.5},{"id":2,"name":"Kiwi","price":2.5}],"total":4.0}

Run a cURL command to list created orders:

curl "$API_URL/api/orders" -H 'Content-Type: application/json; charset=utf-8'

[{"id":1,"user":{"first_name":"Nemanja","last_name":"Mikic","id":1,"username":"nmikic"},"items":[{"id":1,"name":"Banana","price":1.5},{"id":2,"name":"Kiwi","price":2.5}],"total":4.0}]

We can try to place an order for a user who doesn’t exist (with id 100). Run a cURL command:

curl -X "POST" "$API_URL/api/orders" -H 'Content-Type: application/json; charset=utf-8' -d '{ "user_id": 100, "item_ids": [1,2] }'

{"message":"Bad Request","_links":{"self":[{"href":"/api/orders","templated":false}]},"_embedded":{"errors":[{"message":"User with id 100 doesn't exist"}]}}

Kubernetes and the Micronaut framework

In this chapter we will first create the necessary Kubernetes resources for our microservices that will make them work properly then we will configure build container images and deploy each of the microservices that we created on the local Kubernetes cluster.

Create a file named auth.yml that will configure the service role for microservices that have secret configurations.

auth.yml

apiVersion: v1
kind: Namespace # 
metadata:
  name: micronaut-k8s
---
apiVersion: v1
kind: ServiceAccount # 
metadata:
  namespace: micronaut-k8s
  name: micronaut-service
---
kind: Role # 
apiVersion: rbac.authorization.k8s.io/v1
metadata:
  namespace: micronaut-k8s
  name: micronaut_service_role
rules:
  - apiGroups: [""]
    resources: ["services", "endpoints", "configmaps", "secrets", "pods"]
    verbs: ["get", "watch", "list"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding # 
metadata:
  namespace: micronaut-k8s
  name: micronaut_service_role_bind
subjects:
  - kind: ServiceAccount
    name: micronaut-service
roleRef:
  kind: Role
  name: micronaut_service_role
  apiGroup: rbac.authorization.k8s.io
---
apiVersion: v1
kind: Secret # 
metadata:
  namespace: micronaut-k8s
  name: mysecret
type: Opaque
data:
  username: YWRtaW4= # 
  password: bWljcm9uYXV0aXNhd2Vzb21l #

1	We create a namespace named `micronaut-k8s`.
2	We create a service account named `micronaut-service`.
3	We create a role named `micronaut_service_role`.
4	We bind the `micronaut_service_role` role to the `micronaut-service` service account.
5	We create a secret named `mysecret`.
6	Base64 value of the username secret that will be used by the microservices.
7	Base64 value of the password secret that will be used by the microservices.

Run the next command to create the resources described above:

kubectl apply -f auth.yml

Before we start deploying each service, ensure that Docker daemon is configured to use Kubernetes. If you are using Minikube run the next command to switch the docker daemon to use Minikube.

eval $(minikube docker-env)

Users Microservice

Build a Docker image of the users service with the name users.

Edit the file named k8s.yml inside the users microservice.

/users/k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: micronaut-k8s
  name: "users"
spec:
  selector:
    matchLabels:
      app: "users"
  template:
    metadata:
      labels:
        app: "users"
    spec:
      serviceAccountName: micronaut-service # 
      containers:
        - name: "users"
          image: users # 
          imagePullPolicy: Never # 
          ports:
            - name: http
              containerPort: 8080
          readinessProbe:
            httpGet:
              path: /health/readiness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 3
          livenessProbe:
            httpGet:
              path: /health/liveness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 3
            failureThreshold: 10
---
apiVersion: v1
kind: Service
metadata:
  namespace: micronaut-k8s
  name: "users" # 
spec:
  selector:
    app: "users"
  type: NodePort
  ports:
    - protocol: "TCP"
      port: 8080  #

1	The service name that we created in the auth.yml file.
2	The name of the container image for deployment.
3	The imagePullPolicy is set to Never. We will always use the local image that we built in the previous step.
4	Name of a service, required for service discovery.
5	Micronaut default port on which application is running.

Run the next command to create the resources described above:

kubectl apply -f users/k8s.yml

deployment.apps/users created
service/users created

Orders Microservice

Build a Docker image of the orders service with the name orders.

Edit the file named k8s.yml inside the orders microservice.

/orders/k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: micronaut-k8s
  name: "orders"
spec:
  selector:
    matchLabels:
      app: "orders"
  template:
    metadata:
      labels:
        app: "orders"
    spec:
      serviceAccountName: micronaut-service  # 
      containers:
        - name: "orders"
          image: orders  # 
          imagePullPolicy: Never  # 
          ports:
            - name: http
              containerPort: 8080
          readinessProbe:
            httpGet:
              path: /health/readiness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 3
          livenessProbe:
            httpGet:
              path: /health/liveness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 3
            failureThreshold: 10
---
apiVersion: v1
kind: Service
metadata:
  namespace: micronaut-k8s
  name: "orders"  # 
spec:
  selector:
    app: "orders"
  type: NodePort
  ports:
    - protocol: "TCP"
      port: 8080  #

1	The service name that we created in the auth.yml file.
2	The name of the container image for deployment.
3	The imagePullPolicy is set to Never. We will always use the local image that we built in the previous step.
4	Name of a service, required for service discovery.
5	Micronaut default port on which application is running.

Run the next command to create the resources described above:

kubectl apply -f orders/k8s.yml

API (Gateway) Microservice

Build a Docker image of the api service with the name api.

Edit the file named k8s.yml inside the api microservice.

/api/k8s.yml

apiVersion: apps/v1
kind: Deployment
metadata:
  namespace: micronaut-k8s
  name: "api"
spec:
  selector:
    matchLabels:
      app: "api"
  template:
    metadata:
      labels:
        app: "api"
    spec:
      serviceAccountName: micronaut-service # 
      containers:
        - name: "api"
          image: api  # 
          imagePullPolicy: Never  # 
          ports:
            - name: http
              containerPort: 8080
          readinessProbe:
            httpGet:
              path: /health/readiness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 3
          livenessProbe:
            httpGet:
              path: /health/liveness
              port: 8080
            initialDelaySeconds: 5
            timeoutSeconds: 3
            failureThreshold: 10
---
apiVersion: v1
kind: Service
metadata:
  namespace: micronaut-k8s
  name: "api"  # 
spec:
  selector:
    app: "api"
  type: LoadBalancer
  ports:
    - protocol: "TCP"
      port: 8080  #

1	The service name that we created in the auth.yml file.
2	The name of the container image for deployment.
3	The imagePullPolicy is set to Never. We will always use the local image that we built in the previous step.
4	Name of a service, required for service discovery.
5	Micronaut default port on which application is running.

Run the next command to create the resources described above:

kubectl apply -f api/k8s.yml

Test integration between applications deployed on Kubernetes

Run the next command to check status of the pods and make sure that all of them have the status "Running":

kubectl get pods -n=micronaut-k8s

NAME                      READY   STATUS    RESTARTS   AGE
api-774fd667b9-dmws4      1/1     Running   0          24s
orders-74ff4fcbc4-dnfbw   1/1     Running   0          19s
users-9f46dd7c6-vs8z7     1/1     Running   0          13s

Run the next command to check the status of the microservices:

kubectl get services -n=micronaut-k8s

Minikube

For Minikube the output should be similar to the following:

NAME     TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
api      LoadBalancer   10.110.42.201    <pending>     8080:32601/TCP   18s
orders   NodePort       10.105.43.19     <none>        8080:31033/TCP   21s
users    NodePort       10.104.130.114   <none>        8080:31482/TCP   26s

Note	By default, the EXTERNAL-IP address of the LoadBalancer service inside Minikube will be in the <pending> state. If you want to assign an external IP, you have to run the `minikube tunnel` command.

Run the next command to retrieve the URL of the api microservice:

export API_URL=$(minikube service api -n=micronaut-k8s --url)

Docker Desktop

For Docker Desktop’s Kubernetes integration the output should be similar to the following. Notice the external-ip is localhost:

NAME     TYPE           CLUSTER-IP       EXTERNAL-IP   PORT(S)          AGE
api      LoadBalancer   10.108.205.248   localhost     8080:31516/TCP   9m23s
orders   NodePort       10.98.120.224    <none>        8080:31566/TCP   9m39s
users    NodePort       10.109.155.86    <none>        8080:30545/TCP   10m

So for Docker Desktop the API_URL should be set to http://localhost:8080.

Run a cURL command to create a new user via the api microservice:

curl -X "POST" "$API_URL/api/users" -H 'Content-Type: application/json; charset=utf-8' -d '{ "first_name": "Nemanja", "last_name": "Mikic", "username": "nmikic" }'

{"id":1,"username":"nmikic","first_name":"Nemanja","last_name":"Mikic"}

Run a cURL command to create a new order via the api microservice:

curl -X "POST" "$API_URL/api/orders" -H 'Content-Type: application/json; charset=utf-8' -d '{ "user_id": 1, "item_ids": [1,2] }'

{"id":1,"user":{"first_name":"Nemanja","last_name":"Mikic","id":1,"username":"nmikic"},"items":[{"id":1,"name":"Banana","price":1.5},{"id":2,"name":"Kiwi","price":2.5}],"total":4.0}

Run a cURL command to list created orders:

curl "$API_URL/api/orders" -H 'Content-Type: application/json; charset=utf-8'

[{"id":1,"user":{"first_name":"Nemanja","last_name":"Mikic","id":1,"username":"nmikic"},"items":[{"id":1,"name":"Banana","price":1.5},{"id":2,"name":"Kiwi","price":2.5}],"total":4.0}]

We can try to place an order for a user who doesn’t exist (with id 100). Run a cURL command:

curl -X "POST" "$API_URL/api/orders" -H 'Content-Type: application/json; charset=utf-8' -d '{ "user_id": 100, "item_ids": [1,2] }'

{"message":"Bad Request","_links":{"self":[{"href":"/api/orders","templated":false}]},"_embedded":{"errors":[{"message":"User with id 100 doesn't exist"}]}}

Cleaning Up

To delete all resources that were created in this guide, run the next command.

kubectl delete namespaces micronaut-k8s

Next Steps

License

Note	All guides are released with an Apache License 2.0 for the code and a Creative Commons Attribution 4.0 license for the writing and media (images).