Microservices

For many years now we have been building systems and getting better at it. Several technologies, architectural patterns, and best practices have emerged over those years. Microservices is one of those architectural patterns which has emerged from the world of domain-driven design, continuous delivery, platform and infrastructure automation, scalable systems, polyglot programming, and persistence.

What is Microservices?

It is an architectural style which is autonomous, independently deployable services collaborate together to form an application.

They should be optimally small, but there is no official size limit. Many teams try to keep it as small as possible(like 100 lines of code), but the benefits of microservices still apply even if the application is a bit large.

Monolith: It is a software application that has all of its code in a single codebase. The build artifact is generally a single process that runs on a single server or machine and keeps all of its data in a single database.

The development of an environment for monolith typically uses a single consistent technology such as what programming language or SDK you use.

Benefits of Monolith architecture: 

Simplicity: One codebase. Easy to find things.

Deployment: One application to replace.

Disadvantage: It is difficult to scale. It is generally meant for small teams. If the project grows larger than the difficulty arises in maintaining the application. Even if you have modularized your application well, these modules will get too entangled that it becomes difficult to update the app easily.

A single line change requires an entire application to be redeployed, which causes additional regression and it's risky. This also requires a lot of downtimes.

Horizontal scaling often not possible and hence you have to go for vertical scaling(to install costly and powerful servers). Also, the whole application has to be scaled together instead of a single component.

It’s a legacy technology. The whole codebase has to be updated to include any new technology. This reduces agility.

Distributed Monoliths

Even if your services which are separated different components and are interacting over the internet, it is still not a microservice, as it is accessing a single shared database and they are all tightly coupled to each other such a way that you have to deploy them all together. Any new changes often require changes to multiple components.

Benefits of microservices

1. As Microservices are separated into smaller pieces each piece can be owned and maintained by a separate team. In this way, a microservice is easier to understand. for sizing microservice should be small enough so that it can easily be rewritten and the old code can be thrown away.
2. Microservices allow us the Flexibility to use new technologies without the need to upgrade the complete system in a single go. This also allows us to use the right tool for our needs. Eg. One microservice can use a relational database while the other can use a document database.
3. Since they are loosely coupled they can be deployed independently. This causes low downtime and high-frequency deployment. The risk of breaking the complete application is low because of loose coupling.
4. This is cost-effective and easily scalable.
5. Easy to adapt to change of technology or design. Also, they are reusable.

Disadvantages of microservices

Along with many advantages of microservices there comes some disadvantages too. so before deciding that the microservice architecture is a good fit, you should be aware about some of the challenges which microservices bring along.

1. Developer Productivity

Developer productivity is a major concern when working with microservices as you have to think about how the developers will work with different components of the service. Do they have to download the complete service and configure each and every project?  Along with this testing of the microservices also has to be managed in context with the whole application as well as individually.

2. Complex Interactions

The communication between different microservices  also needs to be managed as we do not want the communication between different services to be over-complex and time-consuming.

3. Deployment

Deploying individual microservice is easier and safer when compared to deploying a monolithic application but this process gets complicated when it comes to many microservices. In this scenario, the process has to be automated so that the chances of error should be less.

4. Monitoring

Monitoring and logging has to be proper for microservices because in case of an error we do not want to debug and check the logs for each and every individual microservice and hence a centralized logging system has to be defined. 

So this is all about a basic introduction to microservices to get a basic idea about it.

In the next post, I will come with a live example of the same.