Battle Of The Microservice Frameworks: Micronaut versus Quarkus edition!

What issues do Micronaut and Quarkus address?
• Lower memory footprint, faster startup
• Ahead-Of-Time (AOT) compilation
• Capability to build native images with GraalVM
• Designed from the ground up with
microservices in mind
• Built-in support for Fault Tolerance
• Monitoring / metrics
• Service discovery
• Cloud deployment

Project source
Website
Start/ Backed by
Github stars
#Contributors
Build tools
Languages
First Commit
github: micronaut-
project/micronaut-
core
micronaut.io
ObjectComputing
2.9K
163
Maven, Gradle
Java, Kotlin, Groovy
2017-03-16
github:
quarkusio/quarkus
quarkus.io
Red Hat
2.9K
175
Maven, Gradle
Java, Kotlin, Scala
2018-06-22

Round 1: Getting started
Round 2: Programming model
Round 3: Database persistency
Round 4: Test support
Round 5: Native images, startup and heap
The match

Conference application
Conference API
Conference Service
Conference RepositoryCountryClient
H2External country service
http(s)
GET /conferences
POST /conferences
{ “name”: “Devoxx”}
{ “name”: “Devoxx”}
{ “name”: “Devoxx”,
“countryName”: “Belgium”}
{ “countryName”: “Belgium”}/conf/{name}/country
GET /conferences-with-country

Let’s start the applications!
mvn compile quarkus:dev
mvn package exec:exec
(or start the main class)
8100
8101

REST Controller
@Path("/conferences")
public class ConferenceResource {
@Inject
ConferenceService conferenceService;
@GET
@Produces(MediaType.APPLICATION_JSON)
public List<Conference> getAll() {
return conferenceService.getAll();
}
@POST
@Consumes(MediaType.APPLICATION_JSON)
public void create(Conference conference) {
conferenceService.create(conference);
}
@Controller("/conferences")
public class ConferenceController {
@Inject
ConferenceService conferenceService;
@Get
@Produces(MediaType.APPLICATION_JSON)
return conferenceService.getAll();
}
@Post
@Consumes(MediaType.APPLICATION_JSON)
conferenceService.create(conference);
}
Conference API
Conference Service
RepoCountryClient

Conference service
@Singleton
public class ConferenceService {
@Inject
private ConferenceRepository conferenceRepository;
@Inject
CountryClient countryClient;
return conferenceRepository.findAll();
}
conferenceRepository.save(conference);
}
@Singleton
public class ConferenceService {
@Inject
private ConferenceRepository conferenceRepository;
@Inject
@RestClient
CountryClient countryClient;
return conferenceRepository.findAll();
}
conferenceRepository.save(conference);
}
Conference API
Conference Service
RepoCountryClient

@Path("/")
@RegisterRestClient
@Retry(maxRetries = 3, delay = 2)
@CircuitBreaker(successThreshold = 1)
public interface CountryClient {
@GET
@Path("/conferences/{name}/country")
Country getCountry(@PathParam("name") String name);
@Client("${country.service.url}")
@Retryable(attempts = “3", delay = "1s")
@CircuitBreaker(reset = "20s")
public interface CountryClient {
@Get("/conferences/{name}/country")
Country getCountry(String name);
mypackage.CountryClient/mp-rest/url=http://localhost:9000/
mypackage.CountryClient/mp-rest/scope=javax.inject.Singleton
country.service.url=http://localhost:9000/
application.properties application.properties / yml
Conference API
Conference Service
RepoCountryClient
REST client

Configuration
app.helloMessage=Hi there! app.helloMessage=Hi there!
application.properties application.properties / application.yml
@ConfigProperty(name = "app.helloMessage",
defaultValue="hello default!")
String helloMessage;
@ConfigProperties(prefix = "app")
public class ConferenceConfiguration {
@Size(min= 5)
public String helloMessage;
}
@Value("${app.helloMessage:hello default!}")
@ConfigurationProperties("app")
public class ConferenceConfiguration {
@Size(min = 5)
public String helloMessage;
}
@Property("app.helloMessage")

Configuration profiles
app.hello-message=Hi there!
%dev.app.hello-message=Hi from dev!
%test.app.hello-message=Hi from test!
%custom.app.hello-message=Hi from custom!
app.hello-message=Hi there!
application.properties application.properties / application.yml
• dev – during quarkus:dev unless
overridden
• test- during tests
• prod – default profile
• custom
mvnw quarkus:dev –Dquarkus.profile=test
application-test.properties / application-test.yml
app.hello-message=Hi from test!
mvnw exec:exec -Dmicronaut.environments=test

Custom Configuration
Create service file
/META-
INF/services/org.eclipse.microprofile.config.spi.ConfigSour
ce
public class CustomConfigSource implements ConfigSource {
@Override
public Map<String, String> getProperties() {
//my own implementation
return null;
}
@Override
public String getValue(String s) {
//my own implementation
return null;
}
@Override
public String getName() {
return "CustomConfigSource";
}
}
<dependency>
<groupId>io.micronaut</groupId>
<artifactId>micronaut-discovery-client</artifactId>
</dependency>
spring:
cloud:
config:
enabled: true
uri: http://localhost:8888/
micronaut:
config-client:
enabled: true
• HashiCorp Consul & Vault Support
• AWS Parameter Store Support
• Spring Cloud config server Support

JP
@Singleton
public class ConferenceRepository {
@Inject
EntityManager entityManager;
@Transactional
public List<Conference> findAll() {
TypedQuery<Conference> query = entityManager
.createQuery("select c from Conference c",
Conference.class);
return query.getResultList();
}
@Transactional
public void save(final Conference conference) {
entityManager.persist(conference);
}
}
@Singleton
public class ConferenceRepository {
@Inject
EntityManager entityManager;
@Transactional
TypedQuery<Conference> query = entityManager
.createQuery("select c from Conference c",
Conference.class);
return query.getResultList();
}
@Transactional
entityManager.persist(conference);
}
}
JPA persistency Conference API
Conference Service
RepoCountryClient

Improved Quarkus persistency with Panache
@Entity
public class Conference extends PanacheEntity {
private String name;
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
@Singleton
public class ConferencePanacheRepository {
return Conference.listAll();
}
@Transactional
conference.persist();
}
}

Micronaut Data
@Repository
public interface ConferenceCrudRepository extends CrudRepository<Conference, Long> {
List<Conference> findByName(String name);
List<Conference> listOrderByName();
List<Conference> listOrderByNameDesc();
List<Conference> findTop3ByNameLike(String name);
}
@Repository
}
@JdbcRepository
List<Conference> findByName(String name);
List<Conference> listOrderByName();
List<Conference> listOrderByNameDesc();
List<Conference> findTop3ByNameLike(String name);
}
No more
JPA / Hibernate needed!

Integration testing
@MicronautTest(environments = { "test" })
public class ConferenceITTest {
@Inject
EmbeddedServer embeddedServer;
@Test
@Transactional
public void testConferences() {
Conference conference = new Conference();
conference.setName("Devoxx");
given().body(conference)
.port(embeddedServer.getPort())
.contentType("application/json")
.when()
.post("/conferences")
.then()
.statusCode(200);
given().port(embeddedServer.getPort())
.when()
.get("/conferences")
.then()
.extract()
.path("[0].name")
.equals(“Devoxx");
}
application-test.yml
micronaut:
server:
port: -1
@QuarkusTest
public class ConferenceIT {
@Test
@Transactional
public void testConferences() {
Conference conference = new Conference();
conference.setName("Devoxx");
given().body(conference)
.contentType("application/json")
.when()
.post("/conferences")
.then()
.statusCode(204);
given()
.when()
.get("/conferences")
.then()
.extract()
.path("[0].name")
.equals("Devoxx");
}
quarkus.http.test-port=0
application.properties

Integration testing with Quarkus
@QuarkusTest
public class ConferenceIT {
@Inject
ConferenceResource conferenceResource;
@Test
public void testConferenceInternal() {
conferenceResource.getAll();
}
}
Testing internally
@Mock
@ApplicationScoped
@RestClient
public class MockCountryClient implements CountryClient {
@Override
public Country getCountryOfConference(String name) {
Country country = new Country();
country.setName("Belgium");
return country;
}
}
Mocking
@MicronautTest(environments = { "test" })
public class ConferenceITTest {
@Inject
private ConferenceController conferenceController;
@Test
public void testConferencesInternal() {
conferenceController.getAll();
}
@MockBean(CountryClient.class)
CountryClient countryClient() {
final CountryClient mock = Mockito.mock(CountryClient.class);
Country country = new Country();
country.setName("Belgium");
when(mock.getCountryOfConference(isA(String.class)))
.thenReturn(country);
return mock;
}

Integration testing native images
@SubstrateTest
public class NativeConferenceResourceIT extends ConferenceIT {
// Execute the same tests but in native mode.
}

Building native images with GraalVM
./mvnw package –Pnative –Dnative-
image.docker-build=true
docker build -f
src/main/docker/Dockerfile.native –t
conference-service-quarkus .
./mvnw package
docker build . –t
conference-service-micronaut
Include feature native-imageNo additional actions needed

Let’s run the applications!
JVM: port 8100
Native: port 8200
JVM: port 8101
Native: port 8201
docker run -i --rm -p 8200:8080
conference-service-quarkus
docker run -i --rm -p 8201:8080
conference-service-quarkus-micronaut

https://medium.com/graalvm/lightweight-cloud-native-java-
applications-35d56bc45673
Research Oleg Šelajev (@shelajev)

Summary
• Small images, faster startup,
lowest mem usage
• Microprofile Programming
model
• Really fast release cycle
• Close to Spring’s programming model
• Feels little more mature
• Micronaut Data
• More extensive support for existing
cloud environments
• Could do with a nicer
persistency solution
• Few of out-of-the-box
monitoring
• I’d like an initializer site!

MichelSchudel
https://github.com/MichelSchudel/conference-service-quarkus
https://github.com/MichelSchudel/conference-service-micronaut

Battle Of The Microservice Frameworks: Micronaut versus Quarkus edition!

More Related Content

What's hot (20)

Similar to Battle Of The Microservice Frameworks: Micronaut versus Quarkus edition! (20)

More from Michel Schudel (16)

Recently uploaded (20)

Battle Of The Microservice Frameworks: Micronaut versus Quarkus edition!

Editor's Notes