MICROSERVICES ARCHITECTURE
Unit -2

• Microservices architecture (often shortened to
microservices) refers to an architectural style for
developing applications.
• Microservices allow a large application to be
separated into smaller independent parts, with
each part having its own realm of responsibility.
To serve a single user request, a microservices-
based application can call on many internal
microservices to compose its response.

• Containers are a well-suited microservices
architecture example, since they let you focus
on developing the services without worrying
about the dependencies.
• Modern cloud-native applications are usually
built as microservices using containers.

• A microservices architecture is a type of
application architecture where the
application is developed as a collection of
services.
• It provides the framework to develop,
deploy, and maintain microservices
architecture diagrams and services
independently.

monolithic architecture
• A monolithic architecture is the traditional
unified model for the design of
a software program. Monolithic, in this
context, means "composed all in one piece."
According to the Cambridge dictionary,
the adjective monolithic also means both "too
large" and "unable to be changed.

Defining Monolithic Architecture
• Monolithic architecture is a unified development
model for software applications. It has three
components:
– Client-side user interface
– Server-side application
– Data interface
• All three parts interact with a single database. Software
built on this model operates with one base of code. As
a result, whenever stakeholders want to make updates
or changes, they access the same set of code. This can
have ripple effects that impact user-side performance.

Monolithic architecture for software
explained
• Monolithic software is designed to be self-
contained, wherein the program's
components or functions are tightly coupled
rather than loosely coupled, like in modular
software programs.
• In a monolithic architecture, each component
and its associated components must all be
present for code to be executed
or compiled and for the software to run.

• Monolithic applications are single-tiered,
which means multiple components are
combined into one large application.
Consequently, they tend to have
large codebases, which can be cumbersome to
manage over time.

• Furthermore, if one program component must be
updated, other elements may also require rewriting,
and the whole application has to be recompiled and
tested.
• The process can be time-consuming and may limit the
agility and speed of software development teams.
Despite these issues, the approach is still in use
because it does offer some advantages.
• Also, many early applications were developed as
monolithic software, so the approach cannot be
completely disregarded when those applications are
still in use and require updates.

Key components of monolithic applications
Monolithic applications typically consist of multiple components
that are interconnected to form one large application. These
components may include these features:
• Authorization. To authorize a user and allow them to use
the application.
• Presentation. To handle Hypertext Transfer
Protocol requests and respond with Hypertext Markup
Language, Extensible Markup Language or JavaScript Object
Notation.
• Business logic. The underlying business logic that drives the
application's functionality and features.
• Database layer. Includes the data access objects that access
the application's database.
• Application integration. Controls and manages the
application's integration with other services or data
sources.

Disadvantage:
• Large and Complex Applications:
For large and complex application in monolithic, it is difficult for maintenance
because they are dependent on each other.
• Slow Development:
It is because, for modify an application we have to redeploy whole application
instead of updates part. It takes more time or slow development.
• Unscalable:
Each copy of the application will access the hole data which make more
memory consumption. We cannot scale each component independently.
• Unreliable:
If one services goes down, then it affects all the services provided by the
application. It is because all services of applications are connected to each
other.
• Inflexible:
Really difficult to adopt new technology.It is because we have to change hole
application technology.

Microservices architectural
• In recent years, the rise of the internet and the
ubiquity of mobile computing have made it
necessary for application developers to design
their applications focusing on a lightweight, self-
contained component.
• Developers need to deploy applications quickly
and make changes to the application without a
complete redeployment. This has led to a new
development paradigm called “microservices,”

Microservices architectural style
• A microservices architecture consists of a
collection of small, autonomous services. Each
service is self-contained and should
implement a single business capability within
a bounded context. A bounded context is a
natural division within a business and provides
an explicit boundary within which a domain
model exists.

Microservice provide
• Highly maintainable and testable
• Loosely coupled
• Independently deployable
• Organized around business capabilities
• Owned by a small team
The microservice architecture enables the rapid,
frequent and reliable delivery of large, complex
applications. It also enables an organization to
evolve its technology stack.

• Microservices architecture was developed to
overcome monolithic architectural approaches to
application development challenges and
difficulties.
• Applications running on microservices
architecture are deconstructed and separated
into smaller units (microservices) that the client
can access using an API gateway. These
microservices are each independently deployable
but can communicate with one another when
necessary.

• Breaking down an application into
microservices allows for faster development,
easier bug detection and resolution, smoother
maintenance, flexibility, and higher availability
and scalability.

How does Microservices Architecture
work?
• Microservices architecture focuses on
classifying the otherwise large, bulky
applications.
• Each microservice addresses an application’s
particular aspect and function, such as
logging, data search, and more. Multiple such
microservices come together to form one
efficient application.

• This intuitive, functional division of an application
offers several benefits. The client can use the user
interface to generate requests.
• At the same time, one or more microservices are
commissioned through the API gateway to
perform the requested task.
• As a result, even larger complex problems that
require a combination of microservices can be
solved relatively easily.

• Besides for the services themselves, some other
components appear in a typical microservices
architecture:
• Management/orchestration. This component is
responsible for placing services on nodes,
identifying failures, rebalancing services across
nodes, and so forth.
• Typically this component is an off-the-shelf
technology such as Kubernetes, rather than
something custom built.

• API Gateway. The API gateway is the entry
point for clients. Instead of calling services
directly, clients call the API gateway, which
forwards the call to the appropriate services
on the back end.

Advantages of using an API gateway include
• It decouples clients from services. Services can
be versioned or refactored without needing to
update all of the clients.
• Services can use messaging protocols that are
not web friendly, such as AMQP.
• The API Gateway can perform other cross-
cutting functions such as authentication,
logging, SSL termination, and load balancing.
• Out-of-the-box policies, like for throttling,
caching, transformation, or validation.

Key benefits of microservices
architecture
• About 87% of those who have adapted to the
microservices architecture believe that it
could soon become the favorite application of
executives and project managers as it is now
of developers.
• They are in tune with how the corporate
owners intend to build, run and maintain their
teams.

• Using microservices architecture in application
development can be highly beneficial. Below
are some of its key benefits.

• Requires less development effort to scale up
• Provide better scalability
• Can be deployed independently
• Microservices offer improved fault isolation
• No dependence on one Tech Stack
• Small, focused teams
• Small code base

• Mix of technologies
• Data isolation

Challenges
• The benefits of microservices don't come for free.
Here are some of the challenges to consider
before embarking on a microservices
architecture.
• Complexity
• Development and testing
• Lack of governance
• Network congestion and latency
• Data integrity

• Management
• Versioning
• Skill set

Microservices tools
• Building a microservices architecture requires
a mix of tools and processes to perform the
core building tasks and support the overall
framework. Some of these tools are listed
below.

Disadvantages of Microservices
• Higher Complexity
• Increased Network Traffic
• Increased Development Time
• Limited Reuse of Code
• Dependency on DevOps
• Difficult in Global Testing and Debugging
• Communication between services is complex
• Large vs small product companies

Higher Complexity
• Although microservices offer many
advantages, they also come with a higher
degree of complexity. This complexity can be a
major challenge for organizations that are not
used to working with microservices.
Additionally, because microservices are so
independent, it can be difficult to track down
errors and resolve them.

• Increased Network Traffic
• Since microservices are designed to be self-
contained, they rely heavily on the network to
communicate with each other. This can result
in slower response times (network latency)
and increased network traffic. In addition, it
can be difficult to track down errors that occur
when multiple microservices are
communicating with each other.

• Increased Development Time
• Microservices also require more development
time than monolithic applications since
microservices are more complicated and require
more coordination. Additionally, because
microservices are deployed independently, it can
take longer to get them all up and running. Also,
developers need to be familiar with multiple
technologies in order to work on a microservice-
based application.

• Limited Reuse of Code
• Microservices also have a limited ability to
reuse code, which can lead to increased
development time and costs because
microservices are typically written in multiple
programming languages and use different
technology stacks. Therefore, it can be
challenging to share code between
microservices.

• Dependency on DevOps
• In order to be successful with microservices,
organizations need to have a strong DevOps
team in place. This is due to the fact DevOps is
responsible for deploying and managing
microservices. Without a good DevOps team,
it can be difficult to successfully implement
and manage a microservice-based application.

• Difficult in Global Testing and Debugging
• Testing and debugging a microservice-based
application can be difficult because the
application is spread out across multiple
servers and devices. In order to effectively test
and debug an application, you need to have
access to all of the servers and devices that
are part of the system. This can be difficult to
do in a large, distributed system.