Microservice Architecture is one of the new buzzes in the software architecture arena. There are a lot of questions, confusions and contradictions about this pattern. Here I am trying to summarize the entire concept which might seems a bit over simplification. But yet it can be a very good starting point of understanding the basic concepts.
The Traditional Architecture (The Monolith)
Let us start with the way we’ve been developing our software. Considering a simple e-commerce store front application where it is able to take orders from customers, verifies inventory, available credit and ships item.
We might assume the following:
- It has both mobile and web interface
- It has the API to expose the services to some third party applications
- It has the ability to handle http requests and therefore deployed in a web server like IIS or Apache
- It has the ability to executing business logic
- It has access to relational database like MS SQL or Oracle
- And many more
Therefore, the application might have the following architecture:
- A Store Front UI (Mobile/ Web/ Desktop)
- Accounting Service
- Inventory Service
- Shipping Service
- Business Layer
- Data Access Layer
- And whatever you think feasible
Fig: A Traditional Monolithic Architecture
This application would be a simple monolithic one which can be deployed at IIS or Apache web server or whatsoever you prefer for. A hardware or software load balancer can be incorporated to scaling up and improve availability as well.
Now consider the advantages that we have with this architecture:
- Simple and quick development cycle
- Easy to deploy
- Easy to scale
However, once the application becoming to grow, more and more modules are adding on it will be:
- Difficult to maintain the large code base
- Take more time to introduce new developers
- Bulky IDE
- Difficult to patching update
- Continuous deployment require rigorous testing
- Stuck to the technology
Now let us think it on a different way. Instead of having everything all together (like the way we’ve described above) it might be designed in other approach where:
- It is designed as a set of loosely coupled, collaborating services
- Each of the services consist of its own business logic and database
- The services can run independently or/ and interdependently with other third party services
Fig: Microservice Architecture
The benefits this architecture will provide:
- Easier for a developer to get in
- More responsive IDE
- Easier to deploy new version of any service
- Easier to scaling development between different teams
- Eliminate the technology stuck
- Improved fault isolation
Anyway, nothing comes without disadvantages and the drawbacks are:
- Developers have to deal with the additional complexity of distributed system
- Deployment is still an issue due to the complex nature of managing different service types
- Requires more effort on integration testing
Characteristics of Microservice
So far we’ve a basic understandings of both the architectures. Let us try to define Microservice. From James Lewis and martin Fowler:
“In short, the Microservice architectural style is an approach to developing a single application as a suite of small services, each running in its own process and communicating with lightweight mechanisms, often an HTTP resource API. These services are built around business capabilities and independently deployable by fully automated deployment machinery. There is a bare minimum of centralized management of these services, which may be written in different programming languages and use different data storage technologies.”
Well enough? Hard to get the definition? Let us put things in a simpler way. Instead of having a formal definition let us try to define the characteristics of Microservice:
- Componentization via Services – The service must be independently upgradeable and replaceable.
- Organized around Business Capabilities – The team must be sufficiently capable of delivering the end user business needs themselves, no segregation of team considering like UI developer, DBA and so on.
- Products not Projects – A team developing the product will own the product for its full lifetime, no project ownership but product.
- Smart endpoints and dumb pipes – No enterprise service bus (ESB), the endpoint should be intelligent to handle end to end requirements.
- Decentralized Governance – Managing of services along with the underlying technology are not standardized centrally. Each service development team have their own choices to go with the exact need for that service.
- Decentralized Data Management – No central database for all the services. Each service talks to their own database.
- Infrastructure Automation – Unlike monolith automation of infrastructure is an utmost requirement for continuous delivery and integration.
- Design for failure – Need to be designed so that any service failure can respond to other as graceful as possible.
- Evolutionary Design – Enable application developer to control changes in their services without slowing down handling change requirement.
Monolith vs Microservice
Now let us try to differentiate both the architecture in the easiest form. The big advantage of Monolith is, it is simple and relatively easy to use. We are used to with this architecture for so long and it is proven to work for. However, when the question of continuous deployment comes in, Microservice is easy to deploy. If we want to upgrade a monolith we’ve to upgrade the entire thing. Whereas, Microservice can do the upgrade only for the components that is require to upgrade. This becomes crucial when continuous upgradation is a part of development, upgrades are happening not once in a month but almost every week and even every day.
Another great advantage of Microservice is availability. If one of our services goes down, still we can run the other services. However, the tradeoff here is the consistency. It is always harder to maintain consistency for Microservice compare to Monolith. There is a lot of components communicating each other through network layers and one mess can mess the whole.
In monolith it is easier to refactor between modules. But yes we’ve to understand the module boundary perfectly to do so. But still if we’ve some issue we can easily do the refactor. But for Microservice doing inter module refactoring means a lot. It’s not only copying the class and objects from here to there but it means to change at the different service layer. However, it turns to the point that Microservice ensures to preserve modularity because we are bound to do so. It is kind of a discipline that forces us to keep the modularity.
Last but not least, Microservice helps to go for multiple platform. We can have one module written on C# and the other in Java or whatsoever is suitable for. Which is almost not easily practicable in Monolith.
Microservice and SOA
The major question on this arena is that are Microservice just SOA? Before answering this let us try to revisit what SOA means? From Don Box:
“There are four tenets of service-orientation
- Boundaries are explicit
- Services are autonomous
- Services share schema and contract, not class
- Service compatibility is based on policy”
For Microservice the first two tenets are satisfied with the real emphasis on the second. In fact, we can consider Service Oriented Architecture (SOA) is something like our enterprise service bus which is a very broad terminology and Microservice is just a subset of SOA.
So, that’s all! A bit over simplification of Microservice Architecture but I think it can be a very good starting point. If we compare with Monolith it is all about the tradeoff we want to make. We just cannot come in a conclusion that the Monolith era is over, rather we should say that Microservice comes with the answer of few burning questions of Monolith. However, you should go for Microservice if you really need it. It is not a fancy type of thing that you explore at your production without proper planning.
Happy Micro servicing 🙂