java

Crafting Symphony: Mastering Microservices with Micronaut and Micrometer

Crafting an Observability Wonderland with Micronaut and Micrometer

Crafting Symphony: Mastering Microservices with Micronaut and Micrometer

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.

Keywords: Micronaut,Microservices,Java,Micrometer,Observability,Prometheus,Docker,Zipkin,Service Discovery,Consul



Similar Posts
Blog Image
Are You Still Using These 7 Outdated Java Techniques? Time for an Upgrade!

Java evolves: embrace newer versions, try-with-resources, generics, Stream API, Optional, lambdas, and new Date-Time API. Modernize code for better readability, performance, and maintainability.

Blog Image
Are Null Values Sneakier Than Schrödinger's Cat? Discover Java's Secret Weapon!

Ditching NullPointerExceptions: How Optional Transforms Your Java Coding Journey

Blog Image
Spring Boot API Wizardry: Keep Users Happy Amid Changes

Navigating the Nuances of Seamless API Evolution in Spring Boot

Blog Image
Micronaut Unleashed: Mastering Microservices with Sub-Apps and API Gateways

Micronaut's sub-applications and API gateway enable modular microservices architecture. Break down services, route requests, scale gradually. Offers flexibility, composability, and easier management of distributed systems. Challenges include data consistency and monitoring.

Blog Image
Turbocharge Your Java Code with JUnit's Speed Demons

Turbocharge Your Java Code: Wrangle Every Millisecond with Assertive and Preemptive Timeout Magic

Blog Image
Speed Up Your Spring Boot: Turbo Charge with GraalVM

Turn Your Spring Boot Apps into Blazing Fast Executables with GraalVM