Introduction
Application development has been the backbone of the computer
revolution. Information systems have traditionally been developed with
the help of horizontally scalable transactional database management
system built using monolithic software. The main intention of the
microservice architecture is to overcome this deficit in the monolithic
architecture and make the system more scalable. In a microservice
architecture, many collaborating microservices work together to form the
application. These collaborating microservices have no centralized
control and based on the business requirements a full-stack
implementation of any language and hardware can be used to implement the
business logic.
Microservice architecture can be defined as an approach of developing a
suite of small services working on a single application. These services
can communicate with each other using simple light-weight protocols such
as HTTP resource API and each service runs independently in its own
process.
Monolithic architecture on the other hand, is a single codebase that
implements all of the services required for the application and
communicated with the external resources using or consumers via
interfaces such as Web Services, HTML pages or REST API. The
applications developed using monolithic architecture can include many
different services that are tightly coupled in a monolithic codebase
which may cause difficulty in working together as a team as code
conflict is on the main issues that developers face while working as a
team on a single monolithic software using version control.
The microservice architecture relies on technology heterogeneity, where
each service can use different technology while still being able to be
seamlessly integrated to fulfill business requirements. If a
microservice fails the entire system does not fail only the particular
service that the microservice provides will fail and the rest of the
application will still be up and running whereas, in monolithic
architecture if a service fails the entire system bugs out and unusable.
The biggest and most useful advantage of the microservice architecture
is that of its scalable nature. Only the services that need to be scaled
can be scaled whereas in a monolithic architecture the entire
application needs to be scaled which can cause more hardware usage.
Microservice architecture is adapted highly in the software world due to
its ease of deployment as it can be integrated with any deployment
service such as cloudfoundry or docker without affecting the performance
of other services. The microservice architecture can be formed in such a
way that multiple people can work on different parts of the application
without affecting the security policy as the number of people working on
a service can be contained.
In this paper, we focus mainly on developing a simple application using
the microservice architecture while dwelling on the details of the
service discovery mechanism, eureka server and integrating with an
in-memory database called H2.