Software delivery
organizations across the globe has adopted continuous delivery as a central
practice to build high quality software faster, with less stress and effort.
One of the goals of continuous delivery is to make deployments as boring as
possible. To assure that we need to deploy often and find errors as soon as
possible before delivering the software to end user, continuous delivery
promotes certain architectural approaches of a platform. Releasing often, with
small changes, is extremely difficult task to perform for a complex application
with a huge monolithic architecture. The idea of rearranging the software
architecture into smaller, focused, domain-specific applications composed of
microservices has gained a lot of popularity in the last 2-3 years.
Microservices are a
new software development pattern emerging from recent trends in technology and
practice. A microservice is an independent, self-contained process that
provides a single business capability. Different Microservices act in concert
as one larger system by communicating to each other using a language agnostic
API. In microservice architecture each service is highly decoupled from each
other and are created in mind to focus on one problem domain.
Monolithic and the problem for continuous
delivery
Traditional monolithic
applications are built as a single unit, where all the functionality is pulled
into a single process and is replicated across multiple servers. The single
application is responsible for all functionality including handling requests,
authentication, executing business/ domain logic, persistence, logging,
exception handling etc. Due to this behavior its makes it hard to add a small
change in the system that involves building, testing and deploying the entire
application. Scalability and availability involves running multiple instances
of this application behind a load balancer on multiple servers even though the
bottleneck lays in a single component in the application. As a result, updating
monolithic applications become time-consuming activity that needs to have a lot
of coordination between people involved in multiple functions and departments.
Apart from the issues
related to deployment and scalability, there are some other challenges that
this kind of architecture brings when the application grows in size.
A large code base makes
it hard for all the developers to understand and modify the application. This
makes the code base harder to manage and difficult to add new features which
also results in bad quality creeping in as time progress. The team is forced to
stick on the technology stack which was chosen at the time of starting the
development and commit to the stack for a long-term. This also introduces
dividing engineering teams at an organization level to focus on specific
functional areas, like UI team , database teams etc. The coordination,
development and deployment processes becomes harder with this structure which
takes the teams a step backward in their journey towards practices like DevOps,
continuous delivery etc.
How microservices helps?
In contrast to
Monolithic applications, microservices makes independent management of business
functionality by separating the functionality into smaller services that can be
independently deployed, tested and scaled. With microservices scaling and
deploying each service can be done independently without affecting the other
parts of the system, by creating instances of these services across containers
or virtual machines. In short a Microservice can be summarized as
“Applications composed
of small, independently versioned, and scalable customer-focused services that
provides a unique business capability and communicate with each other over
standard protocols with well-defined interfaces.”
In the microservice
approach the application is divided into smaller parts that communicate with
each other with lightweight mechanisms like REST, message brokers etc.
Due to the highly
evolving business needs, software applications needs to be build considering
high scalability and availability to respond to the needs of customers in an
agile way. This is only possible if, making change to a service is less
expensive and risky. Microservices make this possible due to the fact that each
service is operationally encapsulated by other services and are independently
deployable without affecting the other services in the infrastructure. This
makes easier for development teams to apply the changes and test them
independently faster than ever.
Free white paper
The white paper
addresses the common characteristics and challenges with solutions to your
journey towards refactoring a monolithic to a microservice. You can download
the complete article from this link.
No comments:
Post a Comment