With the proliferation of online applications, their architectures need to
continuously evolve to make them stand out in the multitude of similar apps.
Applications must be highly available and resilient while running on cloud
environments. To ensure a consistent user experience, organizations need to frequently
roll out updates, even multiple times in a day. However, monolithic web
applications that serve up HTML to desktop browsers cannot cope with such
regular updates and hamper developers’ productivity.
This led to the need for a new architecture: Microservices.
Let’s see what it stands for ?
Microservice Overview
Microservices is a way of breaking large software
projects into loosely coupled modules that communicate with each other through
simple APIs.
Microservices architecture involves developing applications
as a suite of multiple independent modular services with each of them serving a
unique purpose. Each of these services runs a particular process and
communicates internally with other modules to serve a business goal.
Let’s dig deeper and understand why microservices architecture is needed.
Need of
Microservices Architecture:
An independent application may have different individual modules that cater to
the different business or technical needs. For a low-scale application with low
complexity, the processing of overall tasks isn’t difficult when all modules
are present in the same application. In fact, this improves program debugging
speed and ensures a high level of execution efficiency.
However, as the scale of an independent application increases, these benefits
soon fade away. With business expansion
and changing needs, application backend gradually becomes too complex for
developers to manually handle and scale. You need the ability to internally
restructure your application based on changing requirements by adding,
removing, or changing modules. Dead code appears and restructuring becomes more
difficult. Minor changes may often impact the entire application. In this case,
to resize or upgrade any module, you have to resize or upgrade all modules in
the application. The program's external dependencies become increasingly
complex and the scope of automated testing falls.
To address all of these shortcomings, microservice architecture was developed.
Let’s see how they bring value to your development process and application
efficiency.
Microservices
Advantages
An application is made up of multiple services, where each service handles one
set of tasks. In microservice architecture, these multiple services communicate
with each other using web protocols, such as HTTP or JSON. Microservice
advantages are:
- Resilient: Independent
services are easy to discard. During an upgrade, you can easily replace an old
service instance with a new one. - Easy-to-enhance: The
code becomes easy to change, overwrite, and discard as per the requirement. - Ease-of-deployment:
Deployment or rollback of independent modules become easier
and faster without any impact on the remaining system. - Improved Fault Isolation: Failure
of a single module doesn’t affect other modules present in the application. - Individual
Services Scalability: Demanding modules or services can
be easily scaled up without any need of scaling up the whole application. - Hybrid
Programming Support: Gives flexibility to select the
most appropriate technologies for individual services without any impact on
other services. - Simplified
Development Process: Independent modules can be assigned
to different teams/groups to make the overall development process easier and
convenient.
Needless to
say, Microservices definitely make your life easier, but there are some
drawbacks too.
Microservices:
A silver bullet?
Although the name includes the qualifier, "micro,"
its implementation requires manual efforts. If you do not have a complete
understanding of the business field and are unaware of the true business needs,
the management of multiple services along with numerous relevant processes
becomes a daunting task. Besides, the number of processes grows when load
balancing and messaging middleware are added. Management, operation, and
orchestration of all these services become cumbersome. In addition, you need a
DevOps expert for implementation and management of these architectures, which
adds to overall overhead.
As microservice architecture acts a distributed system, a certain level of
complexity gets added. Also, it can lead to several issues, including network
latency, fault tolerance, message serialization, and asynchronicity.
As the number of service instances constantly changes,
data traffic fluctuations significantly increase with the complexity of
monitoring and log analysis. There are many open source monitoring and log
solutions, but it is not easy to construct and customize a set of personalized
solutions.
This demands for an all-in-one platform to address
your non-functional needs, such as high availability, monitoring, and logs to
make it easy to implement and manage a microservices architecture.
The best way to run a microservices application architecture is to use application containers. Container
technology allows you to create a standard image from an application and its
dependencies, and use this image throughout the process from development
through testing to the production environment. DevOps fills in the gap between
development and O&M.
Alibaba Cloud, with its efficient container service,
is becoming the cornerstone for innovation and enabler for microservices
architecture.
Alibaba
Cloud Container Service: Comprehensive Platform to Create and Operate
Microservices
It is a fully managed cloud container management service that
enables you to efficiently run and manage Docker applications on a distributed
cluster of Alibaba Cloud ECS instances. It replaces the need to install,
operate, and scale your container cluster infrastructure.
In this series of articles, we will explore the use of Spring Cloud in the
creation of microservice applications on the Alibaba Cloud Container Service.
Let’s firstly explore the basics of Spring Cloud and
Netflix.
Spring
Cloud and Netflix Overview
Spring Cloud is
a project in Spring framework that provides development capabilities for common
modules in distributed systems. These capabilities are configuration management
(Config Server), service discovery (Eureka), service fusion (Hystrix),
intelligent routing (Zuul), and Netflix OSS-based encapsulations.
Using annotation statements, we can easily use Netflix open source products
in Spring
Boot applications to create microservices
applications with production-level availability.
Building Microservices Applications: Sample Code
We
are creating a complete microservices application in a virtual scenario which
can run locally on Docker or be deployed on the Alibaba Cloud container
service. View the sample code.
Comprehending
Service-oriented Applications
In our simulated scenario, we break down an
enterprise's internal applications into multiple services and enable them to
communicate with each other via API calls.
”Foo” and ”bar” are two basic services that use an
intranet to access other services via APIs, but do not provide external service
over the Internet. “Foobar” as a single application provides external services
and must call both foo and bar services during processing.
Inter-Services
Logical Architecture Diagram
Provided by discovery-server, the service discovery
mechanism is based on Eureka. As discovery server is independent of the
business, developers can simply use Docker images.
The foobar service provides external service by registering
with the intelligent application routing gateway service. The gateway is based
on Zuul and because its code is independent of the business, developers can
simply use a Docker image. However, Zuul uses configuration files to describe
the URL access modes corresponding to different services, and developers will
need to change the image configuration files to actually use it or mount a
volume to implement configuration file sharing and modification.
The foo, bar, and foobar code contains Eureka and
Ribbon Client to provide Eureka self-registration and Eureka query
capabilities, while Ribbon implements client load balancing.
During operation, each service is elastically scaled
based on its load and may be composed of multiple running instances. During
startup, all service instances are automatically registered with the Eureka
Server. Inter-service discovery also uses the Eureka Server to fetch instance
information and select an instance to access based on the automatic decision of
the Ribbon Client. We do not use centralized load balancing, but discover and
balance load through the clients.