Everything you should know about Microservices

Microservices are a simplified approach to the modular application development. Reputed companies like Netflix, Amazon, Uber, Paypal, and eBay software products run on microservices. Rather than depending on monolithic architecture, developers can focus on microservices to build large applications as a combination of small services.

In a monolithic architecture, all software components are interconnected and interdependent. If any component or single application’s function fails, the complete application could go down. Imagine you have a web application including functions like payment, history, and log in. If “history” function consumes more memory, the entire application would have to experience the same issue.

Unlike monolithic architecture, microservices break the large software projects into independent, loosely coupled, and smaller modules. In Microservices, the small programs are combined to deliver the functionalities of a large monolithic app.

Read further to understand what exactly microservices are, its benefits and challenges associated with it and what can be done to overcome the challenges.

What are Microservices

Microservices is a service-oriented architecture wherein applications are developed as a collection of small autonomous services, modeled around a business domain. Every service in the microservice architecture is self-contained and implements a unique business functionality. Each microservice is responsible for its data model, and microservices can communicate effortlessly through multiple instances. So, failure in one service does not affect the entire application.

How Microservices Architecture works?

Depending on the scale and business requirements of an application, a microservice architecture could contain the following components-

API Gateway- API Gateway is an entry point for the clients. Clients need to call API gateway, which forwards the call to the specific services on the back end. API gateway could aggregate the responses from different services and return the response to the client.

Microservices- Microservices are divided into small services that perform a certain business capability like user registration, current orders, or wish list.

Database- Microservices can either share the same database or they can have the independent and isolated database.

Inter-microservices communication-Microservices can use various kinds of protocols like REST or Messaging to interact with each other.

Benefits of Microservices

1. Isolated Components- Microservices architecture allows developers to build loosely-coupled services which can be developed, modified, and scaled individually.
2. Easy-to-change technology stack- Unlike monolithic architecture, technology stack can be changed without interfering with other services. Development teams can choose a new stack for each microservice.
3. Organized around business capabilities- Microservices enable developers to build products instead of projects. The development team can emphasize on developing business functionality rather than writing code from scratch. Moreover, the same service can be reused in more than one application. For example, a microservice to handle login can be reused in any SaaS application.
4. Cross-functional and autonomous teams- Developing a complex monolithic application can be a complicated task if you have extended teams or multiple divisions around the globe. Microservices allow the developers to work autonomously and make changes independently.
5. Improved speed and productivity- The microservice architecture overcomes the problem of speed and productivity by breaking down applications into smaller services which can be developed quickly. Different teams can continue to work on various components without waiting for another team to finish a chunk of work.
6. Flexibility in using technologies- Microservices architecture enables decoupled services written in different programming languages to exist together as a single application.
7. Better Fault isolation: A failure/fault in one microservice does not affect the functioning of other microservices in an application.
8. Easy to understand: Every microservice has a smaller code base, which is easier to understand.
9. Better Scalling: By using the microservices, the efforts required to discover slow bottlenecks in the application can be reduced. It enables for each microservices to be scaled to resolve identified bottlenecks offering for a better overall user experience.
10. Real time processing support: The publish-subscribe framework at the core of the microservices architecture allows the processing of the data in real time while giving direct output.

Apart from the considerable benefits of Microservices architecture, there are certain drawbacks a development team may come across while building applications using microservices. Let’s understand the existing challenges and how can we resolve it.

Challenges and Recommendations

1. Tracing- While moving from the monolithic architecture to the microservices, tracing could become extremely difficult. If updates made in one service affect the other services in the application, it takes a lot of time to trace the impact of a request made on the other services.

Recommendation- It is better to maintain the records of logs with timestamps to overcome the problems of tracing. Keeping the logs would help developers to find out the issues quickly.

If developers also use different programming languages to build different services, it may deviate them while tracing the services to fix the issues. Another way to get over the problem is to stick to one programming language while building an application using microservices.

2. Logging Standards- Microservices execute on multiple hosts. So, developers may need to handle various services running on different machines to run a single business requirement. It causes the log messages generated by microservices to distribute across multiple hosts. To troubleshoot any issue, a developer needs to go to different hosts and search all logs, which is a cumbersome and time-consuming process.

Recommendation- It is recommended that generated logs should not be distributed across multiple hosts. Instead, it is better to send the logs to an external, centralized location. Developers can easily fetch the log information from a single place. Cloud providers like CloudWatch offer services for storing and monitoring logs if developers use AWS environment for hosting the applications.

3. Security- In a monolithic application, processes communicate with each other locally. But an application built using microservices architecture has multiple services dispersed in a multi-cloud environment. Every specific functionality, which has to communicate externally through APIs increases the attack surface if proper security mechanism is not implemented while building the apps.

Recommendation– Implementing authentication or validation to API calls could minimize the security risks. Using SHA-256 and SSL as a security layer for the services that communicate externally with the client interface could help to prevent security attacks.

4. Programming Language- Since microservices architecture allows developers to build a business capability independently, programmers prefer using different programming languages for various services. Using different styles makes the deployment very difficult. Moreover, it becomes hard to switch developers between the development phase.

Recommendation- If developers stick to one programming language for all services, the deployment process becomes more efficient.

5. API Versioning- Every time a change is made in any service, a developer has to deploy a new version. Each function in the application might need to maintain versioning to interact with each other seamlessly.

Recommendation- To get rid of multiple versions, it is advisable to use API gateway or CNAMEs, creating an alternate domain name, which redirects all requests to the new instance, saving developers from updating the instance every time the version is updated. If the versions are adequately maintained, a developer can move back to the older version whenever required.

6. UI elements- Every service works differently to provide the information that should be displayed to the user. Adding a logic on the client-side to render that data on the view might be a complicated task and can make the application’s performance slow especially if the data is in a tremendous amount.

Recommendation- To overcome the problem, developers can add a layer between the services and the client-side. This layer will act as a service, which will render UI elements for all views in the application.

7. Communication between microservices- When a client sends a request through HTTP protocol, it receives a response in return. If this response is dependent on the interaction between the microservices through HTTP, then it might result in a higher response time.

Recommendation- Using a network call such as AMQP (Advanced Message Queuing Protocol) instead of REST API for internal communication between microservices could minimize the response time.

8. Log Formats- Every service maintains their logs with different formats. Managing different logs make it difficult for the developers to trace the issues.

Recommendation- It is advisable to standardize the log formats for all services. For example, using the same requestID for all logs corresponding to one request across all the services could make the logs easy to understand and traceable for the developers.

Here are some of the examples of Microservices Architecture:

Publication Example – Magazine company

Magazine Publication could have the following microservices-
Author- who writes the content for the magazine

Editors- who edit and approves the content written by the author

Legal Team- an individual or a group of individuals, who approves everything

Photographers- who clicks and publishes the pictures

Readers / Consumers- a user who uses the application for reading the magazine.

Microservices like editors, authors, photographer, and legal team are deployed on the admin website portal, while the customer microservice is deployed on the mobile app.

Architecture for the magazine publication app could look like-

Logistics Example – Movers and Packers Services

Movers and Packers app could have the following microservices-

Customer- who requests relocation services

Carrier- who accepts or rejects it

Driver- moves the physical load from start to end.Microservices such as customer and carrier are deployed on the admin website portal, while the driver microservice is deployed on the mobile app.

Architecture for the Movers and Packers Services app could look like-

Large-scale companies using microservices-
Amazon

Amazon works on thousands of microservices like orders, login, wish-lists, and payment gateways. The components are mini-applications performing a single business functionality. Microservices are built around different business capabilities. Every service manages its data and data model.

Microservices require a small team to be focused on a simple task. Jeff Bezos, Amazon’s CEO created the two-pizza rule, the ideal size for a microservice team. Amazon’s microservices are run by two-pizza teams, meaning the team size could not be larger than what two pizzas could feed. Amazon is leveraging the capability of microservices to build and manage a flexible system.

Netflix
Netflix is the first company to implement microservices architecture on a large scale. The Netflix application handles more than 2 billion API edge requests every day. 500+ microservices manage all API requests. Netflix decided to move to the cloud-based microservices architecture for scalability. Earlier, they were unable to deploy data centers to keep up the growth rate. With the increasing number of users, they adopted microservices architecture to accelerate the deployment and development of its services and platforms.

Uber
Uber began its journey using a monolithic architecture while building an application for a single city. Implementing a monolithic approach to develop small-scale applications seemed an easier task. But when core domain models started to grow and new features were built, tightly-coupled components made deployment difficult. So, they decided to break up the monolith into multiple services, each running its business functionality.

Uber has split its monolithic application into different microservices such as passenger, driver, trip, billing, payments, and notifications. Every component is connected to each other via REST API, but failure in one component never affects the functioning of other components.

A Microservices Architecture is a logical response to the drawbacks of monolithic applications. Though microservices architecture enables development teams to build robust solutions, it is not useful when a small application needs to be developed. Switching the existing monolithic systems with the microservices architecture can help deploy high-performance enterprise applications.

At LeewayHertz, our team of experts follows the microservices architecture to build enterprise-grade scalable applications.