What’s the Difference?
Your years of hard work has finally started paying off well and your company is incessantly booking profit margins and getting well-acclaimed clients from far and wide. But as it has been rightly said, ‘With great power comes even greater responsibility’, you too are getting too many projects. And that’s where your whole problem started, deciding towards the architecture upon which the code base should stand, for now, and for years together to come.
You have been a real player in the monolithic architecture but with the growing demands and the rapid influx of new requirements, you are struggling to make a correct decision, between the legacy, monolithic architecture, that you’ve been using and are a master of, or the microservices architecture, which has created a real buzz for some time. Read on further to find out what rationale you should have in choosing the latter and not the former, and how the transition could be a very smooth one.
What is Monolithic Software?
First things first, as the name implies, Mono means one, and hence, monolithic software means having all the models and designs under one roof. Simply put, here you would be able to find all the features under one single codebase, viz the client side, server side, etc.
Example of Monolithic Software
A typical example includes those of an online movie booking service, where the login from the client side, authorization from the server, fetching of available seats, displaying them and finally booking and storing the information in some database, all happen in a single shot. The whole procedure is driven by one enormous codebase.
Depicting a Typical Monolithic Software with an Activity Diagram.
Advantages of Monolithic Software
As you can see, there is clarity in the above system, and the flow is straight forward. Some reasons why people stick to this type is because Monolithic Software is:
- Simple to develop.
- Simple to test.
- Simple to deploy. It is because of the fact that you simply have to copy the packaged application to a server.
- Simple to scale horizontally by running multiple copies behind a load balancer.
Disadvantages of Monolithic Software
However, as we tend to scale out, that is where Monolithic Software betrays us. The disadvantages are:
- Limitation in size and complexity.
- Often, the applications are too large and complex to fully understand and make changes fast and correctly.
- Difficult to scale when different modules have conflicting resource requirements.
- Reliability is a very big concern. Bug in any small module can potentially bring down the entire process.
What Is Microservices Architecture?
So, now that we know where Monolithic Software has shortcomings, we may move on to Microservices architecture, which simply applies the concept of breaking down a relatively big problem into subproblems and then solving them.
Here the main focus is on dividing the known bigger application into a set of smaller, interconnected services, all of which rely on one other.
Examples of Microservices
Consider the above example of the online movie booking system again, but with a twist. Here, we can expect the same services as end users, but this is achieved with the help of Microservices in the backend. How?
Here, the same portal which lets users log in, select and perform a plethora of activities is subdivided. Each subdivision is called as a module and performs a specific function. So, although the user sails through the whole process of booking the ticket in exactly the same manner as before, for a Monolithic Software, a whole lot of difference lies under the hood.
Advantages of Microservices
Alright, many would be overwhelmed with how to manage all resources and bundle all in one single application, and why to use this service in the first place itself. There are a lot of places where Microservices has an edge over Monolithic Software system :
- Specialization: With each of the modules specifically designed for one purpose alone, fault detection and isolation is relatively easy.
- Loose Coupling: Easier to recompose and reconfigure to serve the purposes of different apps. Allow for fast, independent delivery of individual parts within a larger, integrated system
- Better Performance: Depending on how they are organized, microservices can have serious performance advantages and lower latency in many cases.
- Robustness: Since Microservices enable parallel development and have the concept called hard-to-cross-boundary, we have to make mistakes at multiple levels to actually let a fault creep in our system, the overall system is said to be fault resistant at a phenomenal level.
Disadvantages of Microservices
- Interdependence: With each modules being interacting and sending information to and fro, there is a natural case of modules being interdependent on one another at a much higher scale. This especially creates interoperability issues during testing and deployment phases.
- Increased Interoperational Costs: Microservices are generally deployed on their own virtual machines or containers, owing to ease of usage. These operations require a certain level of skill and hence, the need of experts. Frequent container management requests along with these mentioned works result in a spike of the costs.
What’s the difference between a microservices architecture and a typical monolithic architecture?
Typically, Microservices come into picture when the solution we want requires breaking up of the whole system into smaller components and designing each of them separately, and where it would be very difficult to do the same in one single module, if not impossible.
Monolithic architecture, on the other hand, finds use cases where the whole of the architecture can be fit in one single go, without any breaking up of the application, and the implementation we are looking at is relatively simple.
When to use microservices vs monolithic software?
Holistically weighing down a number of factors ranging from time, budget constraints, team size and the scale we are eyeing, the basic question boils down to whether we are looking at a system where Scalability is going to be a big concern in the near future, coupled with the system we have at hand being too complex. If the answer is a yes, we should go ahead with a microservices based solution.
How to decide when to break monolithic code into microservices?
Although in most cases it totally depends upon the use case and varies significantly from one use case to another, an informed decision helps in such cases.
- Quick, Independent Service Delivery is ensured where we have fast, independent delivery of individual parts within a larger, integrated system.
- Sub-Section Efficiency means out of 100k lines of code, specific portions need to be highly efficient and possess low latency. This feature is easily available with Microservices.
- When Vision for Scalability is evident from the very beginning, we opt for such solutions wherein the whole team gets in the habit of developing smaller services right from the beginning.
Security Risks When Moving Monolithic Apps to Microservices
There is an increased risk of security threats while moving monolithic apps to microservices. In microservices, the services are dispersed. There are more ports that are open, more APIs are exposed and the authentication becomes even more difficult as it has to happen at multiple levels.
The Development and Operations converge here (or the so-called, DevOps). To limit the timeline, lesser time is given towards testing and this may result in the release of applications that have not been thoroughly tested before they go live. Many of those applications may include security vulnerabilities. These vulnerabilities are only realized once security has been compromised, which is then too late.
Adding to that, controlled and authorized access to the APIs is essential. The principle of least privilege should be enforced to control access on a needs basis. Access to the internals of the services should be made off-limits to prevent human error.
Microservices are the future if one has to be in the market for long, with scalability at the back of their mind. Hence, embracing it is the only option for properly modernizing your application. However, with that, we need to adapt our security to meet these changes and be par so as to not deter the benefits of microservices.