Have you ever had any doubts about how to start your microservices-based application from scratch? Or how to break down your monolith into many microservices?

Usually, the answers to these questions are not unique, not even likely, which is not helpful at all. What brings another question: is there any safe and solid path that I can follow to have success on my microservices projects?

You bet! Microservices have some specific design patterns that can be a life saving for any project, and this post will show you some of the best of them.

If you are much more a visual person (or would like to see all the code here really working), check its related video:

When using microservice for your projects it's important to do it in the right way and using the right approach, no matter if you are breaking down your monolith or starting a new project using microservice from scratch.

When doing it using design patterns, you'll be able to not only do it properly but also with less effort.

And of course, there are a lot of design partners for microservices. If you ever checked the content of Chris Richardson (which I recommend 100%) you know that he has mapped something around 40 to 50 microservices patterns. That's a lot! And so useful.

Today I'll cover five of them here and they are:

• Externalized Configurations
• Circuit Breaker
• Health Check
• Distributed Tracing
• API Metrics

Creating the project

I create my projects using the site: http://code.quarkus.io

If you do the same, configure your project with your preferences and choose these extensions:

• REST Client
• SmallRye Fault Tolerance
• SmallRye Health
• SmallRye OpenTracing
• SmallRye Metrics

When you are ready, click the "Generate your application" button, download the file, and unzip it.

Externalized Configuration

This is the code of an endpoint that is using an externalized configuration:

https://gist.github.com/eldermoraes/76185aedf5610a0b5f1194121765b3e6

If you compile and execute this code just as it is here, it will print:

Hello, Optional

Because it can't find the "config" property anywhere. So let's add it to your applications.properties file (available in the "resources" folder if you created your project as stated in the previous section):

https://gist.github.com/eldermoraes/7f8c7ce96ea751e44f5ddc2ab24a2ae0

Now, if you compile and execute your code again, it will print:

Hello, Config

It's better because it's getting the value from a config property, but it's still not so good because the property it's still inside the project. So let's move it to the environment.

If you are running your project using the Quarkus plugin for Maven you probably did something like this:

mvn compile quarkus:dev

So do it instead:

mvn compile quarkus:dev -Dconfig=Quarkus

Now if you execute the code it will print:

Hello, Quarkus

This externalized configuration can be at your container, your server, your cluster, wherever your application is running, It will get the configuration from the environment.

Circuit Breaker

Imagine in your house where you have your electrical circuit where all the outlets and lights and are connected. And the circuit is closed because everything is going well.

But once you have some problem inside the circuit (a short circuit, overload, etc), it will open. That way the energy will not flow inside the circuit anymore, keep this energy problem away from your home appliances.

The same happens when we are using microservices and apply the circuit breaker pattern. Once you have some failing microservice the circuit will open. By doing this it will not start a cascade of failing inside your "circuit" (=your microservices that are communicating to each other). 

For example, if you have a microservice giving a timeout error, the circuit will open and it will return an error right away, with no needing to all incoming requests to wait for the timeout to happen.

So, let's do it. This is the code of another endpoint that is using a circuit breaker design pattern:

https://gist.github.com/eldermoraes/f239294539d40d07a1282c2e93fd3227

The proposal here is to show you how to design a microservice using a circuit breaker pattern. So we have a service that is returning a timeout exception. Let's break it down for better understanding:

• @Timeout - defines a timeout limit for this microservice
• @Fallback - defines a method to be used in case of failure (note that the method is implemented at the end of the code with the name "fallback")
• @CircuitBreaker - defines that on every 4 requests (requestVolumeThreshold), if we have 50% of them failing (failureRatio) the circuit will open. Then it should wait 2 seconds (delay) and try to close back the circuit. If it has 2 requests that perform successfully (successThreshold) it will keep closed. Otherwise, it will open and try again after 2 seconds (delay). 

So imagine that you have thousands of requests coming to this microservice and getting this exception. Without this circuit breaker implementation, all those requests would wait until timeout unnecessarily, which would create a huge queue of requests waiting for a response that will not come. That's when a cascade failure happens.

By giving an exception right away you give the requester service to handle it properly and faster.

Health Check API

One of the key aspects of the Cloud Native approach is that your service should be observable. And one of the features you should implement the health checks probes.

There are two probes that you will implement:

• Liveness probe: it will "say" if your microservice is alive or not
• Readiness probe: it will "say" if you microservice is ready to handle requests or not

Usually, your liveness probe won't have too much complexity, so here it is an example of implementation:

https://gist.github.com/eldermoraes/2460cbc362dd87f1a7c47b7de5f96ede

So what makes a class to be your liveness probe:

• To implement the HealthCheck interface
• Be annotated with @Liveness 

Now to the readiness probe. Imagine that you microservice have some required dependency before start answering requests (access some database, third party service, a message queue, etc); here it is where you should validate if this dependency is available/ready before start handling requests:

https://gist.github.com/eldermoraes/5c12dc31ad703b9deec17428bff2af2e

Let's break this code down:

• Interface implementation: the same as for liveness (HealthCheck interface)
• Annotation: @Readiness
• call() implementation: here I made this probe to validate if my blog (http://eldermoraes.com) is up and running. If so, the readiness will be "up". If not, will be "down".

How do these probes work on a Kubernetes cluster?

(I'm assuming that you are writing microservices to be managed in some orchestrated environment and that Kubernetes is the standard option for it today).

• Liveness probe: if it returns a status code (HTTP) different of 2xx, the node manager will kill the pod (where the container is) and will replace it with a brand new one
• Readiness probe: if it returns a status code of 2xx, the manager will start sending requests to it. If not, it will hold on until it is… ready! :-)

Distributed Tracing

This is the easiest one.

https://gist.github.com/eldermoraes/3f78f330ea080a44236a25fe835accf3

You just need to annotate the class/method you would like to trace with @Traced. Now you just need some tracing tool (Kiali, Zipkin, etc).

Side note: for me, this is a great example of the advantages of using standards. It will ease your life in many ways.

Metrics API

Here is a class with some metrics being collected:

https://gist.github.com/eldermoraes/8538cc2306ffb00f330060950c3a3108

Breaking it down:

• @Counted: will collect statistics related to the frequency of calling to this method
• @Timed: will collect statistics related to the time consumed by this method

To see it working, just call these methods many times and then call this URL:

http://localhost:8080/metrics/application

That's it!

I hope it's useful for you. Remember, when we are using standards, we have a lot of heavy lifting of our coding being reduced by the standard. So that's why I like MicroProfile, especially when using it with Quarkus, which gives me a lot of productivity with its developer mode (and, of course, its crazy fast startup).

So this combination between MicroProfile and Quarkus is amazing!

If you tried to implement some of these design patterns, leave your comment here and tell me how it was your experience. And if you have any questions, I’ll be more than happy to answer them!

And then came a crazy month and just now I had the opportunity to write a few lines about it! :-)

So, straight to the point, what you should know about the book (in case you have any interest in it).

Target audience

Java developers working on enterprise applications and that would like to get the best from the Jakarta EE platform.

Topics covered

I'm sure this is one of the most complete books of this field, and I'm saying it based on the covered topics:

• Server-side development
• Building services with RESTful features
• Web and client-server communication
• Security in the enterprise architecture
• Jakarta EE standards (and how does it save you time on a daily basis)
• Deployment and management using some of the best Jakarta EE application servers
• Microservices with Jakarta EE and Eclipse MicroProfile
• CI/CD
• Multithreading
• Event-driven for reactive applications
• Jakarta EE, containers & cloud computing

Style and approach

The book has the word "cookbook" on its name for a reason: it follows a 100% practical approach, with almost all working code available in the book (we only omitted the imports for the sake of the space).

And talking about the source code being available, it is really available on my Github: https://github.com/eldermoraes/javaee8-cookbook

PRs and Stars are welcomed! :-)

Bonus content

The book has an appendix that would be worthy of another book! I tell the readers how sharing knowledge has changed my career for good and how you can apply what I've learned in your own career.

Surprise, surprise

In the first 24 hours of its release, this book simply reached the 1st place at Amazon among other Java releases! Wow!

Of course, I'm more than happy and honored for such a warm welcome given to my baby... :-)

If you are interested in it, we are in the very last days of the special price in celebration of its release. You can take a look here http://book.eldermoraes.com

Leave your comments if you need any clarification about it. See you!

I've just recorded a live coding where I covered some of the main APIs to have your microservice up and running and also being able to be managed.

Have fun!

Don't hesitate to leave your comments!

This is the most viewed post of this blog, so I believe it deserves an update now in 2020! Its first version was written back in 2017.

There's a lot of different opinions in this kind of lists, and there will be always somebody or something missing... just don't be too passionate or take things personally, ok?! ;-)

******************************************************

We all have to agree: there are tons of tons of information shared through social media. It's no different on Twitter.

When we talk about staying tuned with some technology, it's important to have some kind of focus. Otherwise, you could end up confused or, worst, getting bad and/or wrong information.

For these reasons I have a small but incredible list of people/accounts that I use to follow on Twitter to get really good information about Jakarta EE.

If you are passionate about Jakarta EE like me, I truly hope this list may be helpful to you. If you are not, I hope you enjoy as well! ;-)

Important: the list isn't a ranking, so don't judge the account by the position at the list. In fact, don't judge anyone by anything...

Jakarta EE - @JakartaEE

The official Jakarta EE handle.

Wayne Beaton - @waynebeaton

Wayne is a Director of Open Source Projects at the Eclipse Foundation. Undoubtedly, Jakarta EE is one of the biggest projects at Eclipse today (if not the biggest one), so it's important to stay tunned with Wayne has to say.

Adam Bien - @AdamBien

Adam works as a freelancer with Java since JDK 1.0, with Servlets/EJB since 1.0 and before the advent of J2EE in several large-scale applications. He is an architect and developer (with usually 20/80 distribution) in Java (SE / EE / FX) projects. He has written several books about JavaFX, J2EE, and Java EE, and he is the author of Real World Java EE Patterns—Rethinking Best Practices and Real World Java EE Night Hacks—Dissecting The Business Tier.

He is also a Java Champion, NetBeans Dream Team Founding Member, Oracle ACE Director, Java Developer of the Year 2010 and has a huge amount of nominations as JavaOne Rockstar.

Kevin Sutter - @kwsutter

Kevin Sutter is the lead architect for the Jakarta EE and JPA solutions for WebSphere Application Server and the WebSphere Liberty Profile. He is also very active with Java and open-source strategies as they relate to IBM’s application middleware.

Ivar Grimstad - @ivar_grimstad

Ivar Grimstad is Java Champion, JUG Leader, JCP Spec Lead, EC and EG Member, NetBeans Dream Team and International Speaker.

He is the PMC (Project Management Committee) Lead of EE4J and Jakarta EE Developer Advocate at Eclipse Foundation.

David Blevins - @dblevins

David Blevins is the founder of Tomitribe and a veteran of open source Jakarta EE. He has been both implementing and defining Enterprise Java specifications for more than 10 years and has a strong drive to see it simple, testable, and as light as Java SE. Blevins is cofounder of OpenEJB (1999), Geronimo (2003), and TomEE (2011). He is a member of the EJB 3.0, EJB 3.1, EJB 3.2, Java EE 6, Java EE 7, and Java EE 8 Security Expert Groups, and a member of the Apache Software Foundation. Blevins is a contributing author to Component-Based Software Engineering: Putting the Pieces Together (Addison Wesley). Blevins is also a regular speaker at JavaOne, Devoxx, ApacheCon, OSCon, JAX, and other Java-focused conferences.

Otavio Santana - @otaviojava

Otávio Santana is a developer and enthusiast of open source. He is an evangelist and practitioner of agile philosophy and polyglot development in Brazil. Santana is a JUG leader of JavaBahia and SouJava, and a strong supporter of Java communities in Brazil, where he also leads the BrasilJUGs initiative to incorporate Brazilian JUGs into joint activities.

He is also the co-creator of Jakarta NoSQL, a Java framework that streamlines the integration of Java applications with NoSQL databases. It defines a set of APIs to interact with NoSQL databases and provides a standard implementation for most NoSQL databases. This helps to achieve very low coupling with the underlying NoSQL technologies used.

Java Champions - @Java_Champions

Well, why the Java Champions handle is here? Because many Java Champions are Jakarta EE experts, so following the official Twitter is nice to be in touch with what they are saying about it.

Alex Theedom - @alextheedom

Trainer, Java Champion, Jakarta EE spec committee, author of Jakarta EE books and courses. Conference speaker and blogger.

OmniFaces - @OmniFaces

OmniFaces is a utility library for JSF 2 that focusses on utilities that ease everyday tasks with the standard JSF API. OmniFaces is a response to frequently recurring problems encountered during ages of professional JSF development and from questions being asked on Stack Overflow.

Dmitry Kornilov - @m0mus

Dmitry has over 20 years of experience in design and implementation of complex software systems, defining systems architecture, team leading and project management. He has worked as project leader of EclipseLink and Yasson and as spec lead of JSON-P and JSON-B specifications.

Steve Millidge - @l33tj4v4

Steve is the Founder and Director of Payara and C2B2 Consulting. Having used Java extensively since pre1.0, Steve has over 15 years’ experience as a field-based Professional Service Consultant along with extensive knowledge of Java middleware.

Before running his own business, Steve worked for Oracle as a Principal Consultant in Oracle’s Technology Architecture Practice, specializing in Business Process Integration and scalable n-tier component architectures.

Emily Jiang - @emilyfhjiang

Emily is a Java Champion and has been working on MicroProfile since 2016. She also leads the specifications of MicroProfile Config, Fault Tolerance and Service Mesh. She works for IBM as Liberty Architect for MicroProfile and CDI and is heavily involved in Java EE implementation in Liberty releases.

Arjan Tijms - @arjan_tijms

Arjan is a Jakarta EE committer and member of the Jakarta EE Steering Committee.

MicroProfile - @MicroProfileIO

MicroProfile is a baseline platform definition that optimizes Enterprise Java for a microservices architecture and delivers application portability across multiple MicroProfile runtimes. The initially planned baseline is JAX-RS + CDI + JSON-P, with the intent of the community having an active role in the MicroProfile definition and roadmap.

Sebastian Daschner - @DaschnerS

Sebastian has been working with Java enterprise software development for many years. Besides his work for clients, he set a high priority in educating developers in conference presentations, video courses, and training. He believes that teaching others not only greatly improves their situation but also educates yourself.

David Heffelfinger - @ensode

David R. Heffelfinger is an independent consultant based in the greater Washington DC area. He has authored several books on Java EE and related technologies. Heffelfinger has been architecting, designing, and developing software professionally since 1995. He has been using Java as his primary programming language since 1996. He has worked on many large-scale projects for several clients, including the US Department of Homeland Security, Freddie Mac, Fannie Mae, and the US Department of Defense. He has a master's degree in software engineering from Southern Methodist University, Dallas, Texas. Heffelfinger is a frequent speaker at Java conferences such as Oracle Code One (forme JavaOne).

John Clingan - @jclingan

John is Product Manager at Red Hat and an ex Java EE PM. He is also a MicroProfile co-founder.

Josh Juneau - @javajuneau

Josh Juneau works as an application developer, system analyst, and database administrator. He is active in many fields of application development but primarily focuses on Jakarta EE. Juneau is a technical writer for Oracle Technology Network, Java Magazine, and Apress. He is a member of the NetBeans Dream Team, the JCP, and a part of the JSR 372 Expert Group. He enjoys working with the Java community—he is the director of meetings for the Chicago Java User Group.

Tanja Obradovic - @TanjaEclipse

Tanja is the Jakarta EE Program Manager at Eclipse Foundation.

An airhacks.fm podcast conversation with Elder Moraes (@elderjava) about Java EE at JavaONE, why Java EE at all, enjoying boring stuff, Java EE for pet projects, thinking freely about business problems, no distractions, servlets and JSPs, Java as career choice, Jakarta EE opinions, Oracle's Java EE stewardship, Java EE 8 being late, Jakarta EE should remain boring, Jakarta EE and profiles, an idea for a Jakarta EE profile creation process, Eclipse Foundation and agility, the pace of MicroProfile, thoughts on Cloud Native, Java EE in Cloud Native environments, Sebastian Daschner and successful Java EE careers, Java EE impact on startups, ES 6, TypeScript, thoughts on serverless, future of Jakarta EE, JVM overhead and microservices, GraalVM and Nashorn, JavaONE vs Oracle Code, Java EE 8 recipes in the Java EE 8 Cookbook.

Checkout: eldermoraes.com, GitHub and @elderjava.

Subscribe to airhacks.fm podcast via: RSS iTunes