Imagine you’re building a house. Each room has its own purpose, its own design, and its own special features that all work together to make a functioning, liveable space. Now think about a big application. It’s a lot like that house, but instead of rooms, you’ve got microservices. And each microservice has its own job, weaving together to create one powerful application.

One of the hottest tools for making sure everything runs like a well-oiled machine, especially for Java-based microservices, is Micronaut. This tool has an arsenal of features specifically crafted to help with observability and manageability. And when you’re talking about keeping an eye on your system metrics and performance data, Micrometer within Micronaut becomes your best friend.

Setting up Micrometer with Micronaut is your first step. If you’re using Gradle for your project, sprinkle these dependencies into your build.gradle file:

dependencies {
    implementation "io.micronaut:micronaut-micrometer-core"
    implementation "io.micronaut:micronaut-micrometer-registry-prometheus"
}

Or if Maven is your thing, then you’ll pop these into your pom.xml file:

<dependency>
    <groupId>io.micronaut</groupId>
    <artifactId>micronaut-micrometer-core</artifactId>
</dependency>
<dependency>
    <groupId>io.micronaut</groupId>
    <artifactId>micronaut-micrometer-registry-prometheus</artifactId>
</dependency>

Got that done? Sweet. Now you need to let Micrometer know where to send its metrics. Think of this as setting the delivery address for your data. Dive into your configuration file, which could be application.yml or application.properties:

micronaut:
  metrics:
    enabled: true
    export:
      prometheus:
        enabled: true
        step: PT1M
        descriptions: true

This chunk of configuration magic tells Micrometer to start collecting metrics and send them over to Prometheus.

Next on your checklist: run Prometheus. The easiest way is often through Docker:

docker run -d -p 9090:9090 -v /path/to/prometheus.yml:/etc/prometheus/prometheus.yml prometheus

Your prometheus.yml needs a scrape configuration like this:

scrape_configs:
  - job_name: 'micronaut'
    scrape_interval: 10s
    static_configs:
      - targets: ['localhost:8080']

With Prometheus up and running, you can start visualizing your metrics. It’s like having a control room for your microservices. But metrics aren’t the only piece of the puzzle. Micronaut comes with built-in endpoints to help you monitor and manage your application. These include:

• Metrics Endpoint: /metrics shows all the juicy details.
• Health Endpoint: /health gives a snapshot of your app’s wellbeing.
• Info Endpoint: /info holds app details.
• Beans Endpoint: /beans lists all the app’s beans.
• Refresh Endpoint: /refresh lets you refresh the configuration.

Feel free to poke around at http://localhost:8080/{endpoint}.

Sometimes, built-in metrics aren’t enough. You might need to track something specific—like the number of times an endpoint gets hit. Enter custom metrics. Here’s a little Java snippet for that:

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;

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

    private final Counter counter;

    public HelloController(MeterRegistry meterRegistry) {
        this.counter = meterRegistry.counter("hello.requests");
    }

    @Get
    public String index() {
        counter.increment();
        return "Hello World";
    }
}

Now, every time /hello is called, hello.requests tally goes up.

But wait, there’s more! Observing your microservices wouldn’t be complete without distributed tracing. Zipkin can be your go-to here. Plug these dependencies in: Gradle:

dependencies {
    implementation "io.micronaut:micronaut-tracing"
    runtime "io.zipkin.brave:brave-instrumentation-http"
    runtime "io.zipkin.reporter2:zipkin-reporter"
    implementation "io.opentracing.brave:brave-opentracing"
}

Maven:

<dependency>
    <groupId>io.micronaut</groupId>
    <artifactId>micronaut-tracing</artifactId>
</dependency>
<dependency>
    <groupId>io.zipkin.brave</groupId>
    <artifactId>brave-instrumentation-http</artifactId>
</dependency>
<dependency>
    <groupId>io.zipkin.reporter2</groupId>
    <artifactId>zipkin-reporter</artifactId>
</dependency>
<dependency>
    <groupId>io.opentracing.brave</groupId>
    <artifactId>brave-opentracing</artifactId>
</dependency>

Configuring Zipkin is a breeze:

tracing:
  zipkin:
    http:
      url: http://localhost:9411
    enabled: true
    sampler:
      probability: 1

Run the Zipkin server with Docker:

docker run -d -p 9411:9411 openzipkin/zipkin

Use annotations to trace your endpoints:

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.tracing.annotation.ContinueSpan;
import io.micronaut.tracing.annotation.SpanTag;

@Controller("/maps")
public class MapsController {

    @Get("/{provider}")
    @ContinueSpan
    public List map(@SpanTag("maps.provider") String provider, @SpanTag("maps.src") String src, @SpanTag("maps.dest") String dest) {
        // Your logic here
        return directions;
    }
}

Zipkin will show you a detailed trace of your API calls, making life way simpler when troubleshooting.

Then there’s the topic of service discovery and client-side load balancing. These are crucial for scaling and managing microservices. Micronaut effortlessly supports various service discovery systems like Consul, Eureka, and Kubernetes.

For Consul, include this dependency: Gradle:

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

Maven:

<dependency>
    <groupId>io.micronaut</groupId>
    <artifactId>micronaut-discovery-client</artifactId>
</dependency>

Configure Consul in application.yml:

consul:
  client:
    registration:
      enabled: true

And in bootstrap.yml:

consul:
  client:
    registration:
      enabled: true
    defaultZone: "dc1"

Micronaut’s declaration-based HTTP client plays well with service discovery. Here’s a mini example:

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

import java.util.List;

@Client(id = "employee-service", path = "/employees")
public interface EmployeeClient {

    @Get("/department/{departmentId}")
    List findByDepartment(Long departmentId);
}

This client will automatically find and balance requests across multiple instances of employee-service.

In summary, keeping tabs on and managing microservices using Micronaut and Micrometer makes observability robust and scalable. Built-in metrics, custom tracking, distributed tracing with Zipkin, and service discovery using Consul are all part of the package, ensuring your microservices setup is top-notch. With its user-friendly configuration and powerful features, Micronaut emerges as a stellar choice for building modern, cloud-native applications.