Microservice is an architectural approach for software that is designed to speed up development cycles and support scalability. In this approach, the software is composed of small independent services that communicate over well-architected APIs.
In a monolithic architecture, all the components are tightly coupled and run as a single service. Here, the entire architecture has to be scaled if any one component of the application experiences a spike in demand. This architecture type increases the difficulty level to implement new ideas in the application.
Fig 1. Monolithic vs. Microservices Architecture
In Microservices architecture, each component is a small application
that has its own hexagonal architecture. It is
an architectural style that structures an application as a collection
of services that are loosely coupled and independently deployable.
Features of Microservices
- In Microservices architecture, each component can be changed, upgraded or replaced individually without affecting the functionality of other components.
- Microservices architecture follows the decentralized data management, where each service has its own view on data models.
- In Microservices architecture, there is no need to share any of the component code or implementation with other components. Any communication between components can be done via well-defined APIs.
- Microservices architecture behaves like a black box because each component hide the details of complexity from other components.
- Microservices architecture can also improve the quality of code as the whole application is running into small and well-defined components
- In Microservices architecture, each component is properly decoupled so it can be scaled horizontally and independently from each other and it never faces the downtime during the scaling process because in horizontal scaling more components are added to the existing pool instead of increasing the capacity of each component
- Microservices architecture makes it easy to try out new ideas and roll it back with the help of continuous integration and continuous delivery, if something undesired happens.
- With Microservices architecture, applications can handle total service failure by degrading the functionality instead of crashing the entire application.
The Process of migration
from a Monolithic architecture to Microservices architecture is complex and
requires to release code dependencies going down to the database layer.
In a Microservices
environment, testing is complex due to different services and their integrations.
architecture application is broken down into small components. It is difficult
to find the root cause of the problem when something goes wrong because issue may
not lie within the component that fails, but a dependency.
The diagram below shows
the Serverless Microservices architecture where the complete solution is built
without managing any server. This also eliminates the operational efforts of
running and monitoring the servers.
Lambda will handle
everything required to run and scale the execution to meet actual demand with
high availability. Lambda supports several programming languages and it can be
called directly from any web or mobile applications.
Fig 2. Serverless Microservices
In the architecture
diagram, Lambda is integrated with API Gateway. Synchronous calls from API
gateway to AWS Lambda enables the application to operate as serverless. AWS
Lambda will store all the data in a fully managed NoSQL database called
DynamoDB and all the static data will be stored in S3 Bucket.
It can be said that
Microservices architecture is designed to overcome the challenges of
traditional monolithic architectures seen in enterprise applications. It allows
collaboration between operations and development teams of any organization leading
to DevOps and is a preferred choice nowadays.
AWS offers multiple
managed services that can help engineers build Microservices architectures and minimize architectural and