Nebrass Lamouchi - Playing with Java Microservices on Kubernetes and OpenShift

Playing with Java Microservices on Kubernetes and OpenShift will teach you how to build and design microservices using Java and the Spring platform.

This book covers topics related to creating Java microservices and deploy them to Kubernetes and OpenShift.

Traditionally, Java developers have been used to developing large, complex monolithic applications. The experience of developing and deploying monoliths has been always slow and painful. This book will help Java developers to quickly get started with the features and the concerns of the microservices architecture. It will introduce Docker, Kubernetes and OpenShift to help them deploying their microservices.

The book is written for Java developers who wants to build microservices using the Spring Boot/Cloud stack and who wants to deploy them to Kubernetes and OpenShift.

You will be guided on how to install the appropriate tools to work properly. For those who are new to Enterprise Development using Spring Boot, you will be introduced to its core principles and main features thru a deep step-by-step tutorial on many components. For experts, this book offers some recipes that illustrate how to split monoliths and implement microservices and deploy them as containers to Kubernetes and OpenShift.

The following are some of the key challenges that we will address in this book:

• Introducing Spring Boot/Cloud for beginners
• Splitting a monolith using the Domain Driven Design approach
• Implementing the cloud & microservices patterns
• Rethinking the deployment process
• Introducing containerization, Docker, Kubernetes and OpenShift

By the end of reading this book, you will have practical hands-on experience of building microservices using Spring Boot/Cloud and you will master deploying them as containers to Kubernetes and OpenShift.

Chapter 1, Introduction to the Monolithic architecture, provides an introduction to the Monolithic architecture with a focus on its advantages and drawbacks.

Chapter 2, Coding the Monolithic application, offers a step-by-step tutorial for modeling and creating the monolith using Maven, Java 8 & Spring Boot 2.x.

Chapter 3, Upgrading the Monolithic application, lists some upgrades for our Monolithic application such as changing the DBMS..

Chapter 4, Building & Deploying the Monolithic application, covers how to build and package our example application before showing how to deploy it in the runtime environment.

Chapter 5, Microservices Architecture Pattern, presents the drawbacks of the Monolith architecture pattern and shows the motivations for seeking something new, like the Microservices architecture pattern.

Chapter 6, Splitting the Monolith: Bombarding the domain, presents the Domain Driven Design concepts to successfully understand the Business Domain of the Monolithic Application, to be able to split it into sub-domains.

Chapter 7, Applying DDD to the code, shows how to apply all the DDD concepts to the Monolithic Application source code and to successfully split the monolith into Bounded Contexts.

Chapter 8: Meeting the microservices concerns and patterns, covers a deep presentation of the concerns and the cloud patterns related to the Microservices Architecture Pattern.

Chapter 9: Implementing the patterns, shows how to implement the presented cloud patterns using Java & Spring Boot/Cloud stack.

Chapter 10: Building the standalone microservices, covers how to build our real standlone business microservices.

Chapter 11. Getting started with Docker, presents the containerization and Docker technology.

Chapter 12. Getting started with Kubernetes, presents in deep the greatest container orchestrator: Kubernetes

Chapter 13: The Kubernetes style, shows how to apply the Kubberentes concepts and features to our microservices.

Chapter 14: Getting started with Openshift, presents OpenShift Container Platform, a Kubernetes based PaaS.

As this book is published online, I will be providing regular updates for chapters, adding new ones, covering more items, etc..

If you want that I write about any item of the Java/Kubernetes ecosystem, feel free to get in touch with me directly on .

The source code of this book is available on my Github:

• https://github.com/nebrass/playing-with-java-microservices-monolith-example
• https://github.com/nebrass/playing-with-java-microservices-book-code

Lets imagine that we are developing an e-commerce backend application using Java & Spring Boot. Our e-commerce will have different clients including desktop browsers, mobile browsers and native mobile applications. The application can expose many APIs to be used by 3rd parties. The application handles many requests by executing business logic; accessing a database; exchanging messages with a broker and returning HTTP responses.

The e-commerce has many modules managing customers, orders, products, reviews, carts, authentication, etc..

Many team of developers are working on our application. Every team is working on a module.

Our application is a Java EE application. It is deployed as a huge WAR file that is wrapping all e-commerce modules. To deliver our application, the project manager has to be sure that all teams have delivered all the code of each module; if one of the teams had some delays for any reason, all the application will be delayed for sure, as it cannot be delivered with unfinished parts.
> How can we solve this ?

Our technical stack is somehow sexy :D almost all Java Developers love working with Java 8 and Spring Boot. So when recruiting a new developer, we expect that our new developer will be happy to start working on the e-commerce. But does this will be true ? Our developer will be happy to meet all the code of the e-commerce when he is coming to work on the products module only ? Does this additional complexity is mandatory ?