December 30, 2020

What Are Microservices and Why Are They Important? Understanding Microservices

Microservices are a service-oriented architectural design in which applications are developed as a series of individual modules, or services, as opposed to writing an entire application in a single block of code.

Microservices, as we know them today, evolved in response to the issues and constraints of monolithic applications. Because monolithic applications tend to grow in size and scope over time, the tight coupling between components leads to slower, more challenging deployments.

As such, monoliths take on a high risk of failure, which increases every time a feature is deployed.

Microservice architecture is often achieved by decoupling a monolithic application into independent modules that each contain the components necessary to execute a single business function. These services typically communicate with each other using language-agnostic APIs like REST.

Each deployment can take several months, or even an entire year, which limits the number of features an organization can release to users. Additionally, monolithic applications make it hard to reuse and replace individual components because any change made — big or small — has an impact on the entire application.

In this article, we’ll answer the questions about what microservices are and why they are important, and discuss how microservices differs from monolithic architectures. We’ll also look at the pros, cons, and when it makes sense to pursue this initiative.

What Are the Types of Microservices?

There are two main types of microservices: stateless and stateful. The core difference between the two comes down to whether the services retain records of communication between each module or not. Here, we’ll quickly break down the pros and cons of each.

Stateless Microservices

One of the main types of microservices, stateless microservices, is ideal for distributed systems. In this case, each request is treated as an independent unit with no context from previous iterations. The benefit is that stateless components can easily be replaced, without the risk of passing on problems lurking inside the old code.

Stateless microservices don’t keep records of session state between requests. This means that if some part of a service instance is removed, it won’t impact the processing logic for that service.

Stateful Microservices

On the flipside, stateful services are a type of microservices that stores session information right there in the code. This way, when two or more services communicate, they automatically keep a record of services performed.

While there is a wide range of use cases in which stateless services make sense, there are just as many reasons organizations need to retain that information.

For example, something like stateless online banking wouldn’t work, as the services wouldn’t keep historical records of deposits and withdrawals — presenting some serious problems for end-users.

What Are Microservices Used for?

The short answer is, microservices are used to address the issues associated with monolithic applications.

Because services are small in scope and feature a modular design made up of several loosely-coupled components, organizations gain increased fault tolerance and faster deployment times, which in turn enables continuous improvements and frequent feature releases.

Characteristics Of A Microservices Architecture

To answer the questions, you might look toward some of the defining characteristics of this architectural style.

While there will be considerable variation between individual applications, here are some qualities you’ll find in a successful microservices software system.

  • Services should communicate over the network by utilizing technology-agnostic protocols.
  • Each service is built with a business goal in mind.
  • All services are independently deployable.
  • Services should be able to leverage polyglot programming and persistence.
  • A microservices architecture should be modular. Each service should be small in size, and contain all
  • elements required to complete its function independently.
  • The organizational culture should embrace strong Agile, DevOps, and CI/CD practices to enable automation of testing and deployment.
  • A microservices architecture should include decentralized governance and data management.
  • Microservices are failure resistant and fault-tolerant.

Free Whitepaper

Making Microservices Work for Your Organization

Download Now!

Monolithic Vs Service-Oriented Vs Microservices

When the concept of microservices first began to appear, people had trouble understanding the differences between microservices and service-oriented architecture. On the surface, microservices and SOA architecture patterns look rather similar, but there are some significant differences between the two.

Monolithic, service-oriented, and microservices architectures vary considerably in their granularity, which plays a vital role in software architecture. The reason for this is related to the degree of coupling and cohesion that coarse-grained and fine-grained architectures provide.

Coupling is a term that refers to the degree of interdependence between software modules. Tighter coupling between modules offers the benefit of less fault resistance, but also makes it more difficult to update or reuse individual modules.

Cohesion refers to how well the individual elements within an application work together. As a general rule, developers should aim to build loosely-coupled, highly-cohesive software systems. The reason being, highly-cohesive systems tend to be more robust, reliable, and reusable than those with low cohesion.

A loosely-coupled and highly-cohesive architecture makes multiple processes much easier for the entire team, including design, testing, monitoring, and deployment.

The graphic below offers a visual representation of the granularity offered by monolithic, service-oriented, and microservices architectures.

Monolithic vs SOA vs Microservices Structure

Monolithic vs SOA vs Microservices Conceptually

Monolithic applications represent the worst-case scenario when considering cohesion and coupling. A monolithic application is a single-tiered architecture where multiple layers are tightly coupled, and multiple components run in the same process. A single data store is utilized throughout the application.

Monolithic applications also exhibit very low cohesion, as the entire application is made from a single block of code and is deployed as a unit. Monolithic architectures require the entire program to be recompiled and deployed every time a change is made due to their inherent interdependencies.

The middle ground between a monolithic and microservice architecture is a service-oriented architecture or SOA. SOAs are similar to microservices in that they move away from the monolith model and break the application into a series of modules, each with their own specific function. Like microservices, SOAs are much smaller in scope than a typical monolith. But, like monoliths, SOAs operate using a single data store.

While focused around individual services, SOA modules are coarser-grained than the modules within a microservices architecture, where each service operates independently and has its own data store.

Service-oriented modules all communicate through an enterprise service bus. This means that an influx of requests could back up the entire application and cause delays on the user side. It’s also possible that an enterprise serial bus could become a single point of failure that puts the entire application at risk of downtime, security threats, or both.

As a result, SOAs do offer higher cohesion than a monolithic application but are more tightly coupled than microservices. Check out our post on microservice vs. SOA architectures for a closer look at the differences between the two service-oriented solutions.

Example of Communication in Microservice, SOA, and Monolithic Architectures

How Microservices Communicate

Microservices offer both the loosest coupling and highest cohesion, as compared to SOAs and monolithic applications. With each service responsible for every element involved in its functionality, messaging, and data storage, microservices are designed to facilitate DevOps and CI/CD due to their autonomous, independently deployable modules.

Comparison of Monolithic, SOA, and Microservices

Monolithic Service-Oriented Microservices
Size Highly interdependent services Smaller interdependent services Very small function-oriented independent services
Granularity Single unit – Tightly coupled with low cohesion Moderately coupled with moderate cohesion Loosely coupled with high cohesion
Ease of Deployment Must build and redeploy the entire application Requires modifying the monolith Can independently build and deploy each service
Remote Call Overhead Low/None communication overhead Low communication overhead High communication overhead, many remote calls
Speed of Deployment Very slow deployment speeds Slow deployment speeds Rapid and continuous deployment
Persistence All services in a monolithic application share data storage All services in SOA share data storage Each service is free to choose its own data storage
Ease of On-boarding Difficult to onboard new developers Semi-difficult to onboard new developers Easy to onboard new developers
Polyglot Programming Implement a single technology stack Can utilize different technology stacks per service Can utilize various technology stacks per service
Communication Method Many methods exist Communicates through an enterprise service bus Communicate with lightweight protocols like REST
Scalability Can be very challenging to scale as the application becomes larger Can be challenging to scale Extremely scalable through the use of containers

What Are Microservices Used For? Key Benefits Explained

Here, we’ll quickly go through the primary benefits offered by a microservices architecture. For a deeper dive, read our article on the advantages of microservices.

When a microservice architecture is built to support specific use cases and is implemented properly, organizations stand to see massive improvements compared to a monolithic architecture, including:

  • Improved modularity. Organizations now have a program that is easier to understand, develop, and test. This simplifies the process of onboarding new developers, as there is no longer the need to include every single service in the initial training phase.
  • Sets the stage for continuous improvement. Microservices help companies leverage the advantages offered by Agile, DevOps, and CI/CD methodologies.
  • Independent services. Because microservice modules are developed and deployed independently, organizations can make quick changes to a single service, roll back buggy updates, and implement customer feedback, as needed. As a result, companies can reduce risk and improve deployment speeds.
  • Language agnostic. Developers can write code in any programming language, allowing them to build services using the language that delivers the best results for that use case.
  • Every service has its own storage solution. Each service can have very different needs when it comes to data storage. As applications become larger and the volume of data grows, the data sets can have very different characteristics and processing requirements. Microservices allow you to choose the best data storage implementation to address the specific need of the service in order to achieve the end goal.
  • Enables team autonomy. A small cross-functional team can manage each service, enabling greater autonomy, distributed leadership, and decentralization.
  • Designed for the cloud. Microservices help teams leverage the scalability and flexibility of the cloud.
  • Massive reduction in unused functionality over monolithic applications. Isolating and resolving issues is much simpler because they can be isolated to a single service.
  • High degree of fault isolation. A change or failure in one service will not impact other services.

Disadvantages Of A Microservices Architecture

Despite the long list of benefits that come from decoupling monolithic applications into flexible, scalable microservices, there are some potential disadvantages to microservices you should know about before launching an initiative.

Many of the issues linked to microservices come out of the complexities introduced when adding more and more independent services to an application.

Some of these challenges include the following:

  • While each service is easier to understand, develop, and deploy, the big picture becomes more complicated.
  • More communication is required between services. This means that organizations will likely see overhead costs rise, and when implemented incorrectly, they will see an increase in network congestion and latency.
  • Network security becomes increasingly complex, as more services are added to an application, requiring teams to secure all communication points that exist between services.
  • DevOps maturity is required to overcome the complexities involved with handling communication and automated deployment, as well as the testing and monitoring of microservices.

With the right tools, processes, and preparation, organizations can overcome the challenges presented by microservices and start reaping the benefits.

What Are Microservices Used For? And When Should Organizations Make the Migration?

A microservices architecture isn’t the right choice for every organization or every application.

If you’re building a new application from scratch, we often recommend starting with a monolith application as a proof of concept.

After determining whether the application is a success, the next step would be to decouple the monolith into microservices to support future growth.

Monolithic applications offer greater simplicity when it comes to communication, security, and monitoring, as compared to microservices. And they often come with lower overhead and latency costs, as microservices increase the volume of remote calls.

For these reasons, we recommend that start-ups at least consider the pros and cons of building a new application on a microservices architecture.

The thing is, monolithic applications aren’t necessarily slow or outdated. Most of the problems associated with this architecture come when the application reaches a certain size.

As applications scale, a microservices architecture begins to make more sense. The advantages start to outweigh the complexity and additional overhead costs they bring to the table.

Culture also plays a major role in whether an initiative will succeed or not. Below, we’ll go over the cultural factors that can help determine whether your organization is ready to move toward this model.

Has Reached Agile Maturity

For organizations accustomed to working within a structured hierarchy and decentralized departments, microservices require significant cultural change. Before companies can begin a microservices initiative, they must master the Agile methodology, which depends on lean-thinking, cross-departmental collaboration, distributed leadership, accountability, and team autonomy.

By embracing Agile, organizations can prevent the bottlenecks that occur when a few key stakeholders hold the lion’s share of knowledge and influence.

This enables faster decision-making and helps teams avoid losing progress when a key team member leaves or changes roles. Instead, knowledge is distributed throughout the organization, enabling greater collaboration and a goal-driven, shared-values process.

Embraces Continuous Deployment and DevOps

Microservices are designed to work within the framework of methodologies such as CI/CD and DevOps. Because of their small size and independence, companies that use this architecture can bring new features to market at a faster rate than their peers using monolithic or SOA patterns.

To fully realize the benefits offered by microservices and reduce the challenges caused by increases in complexity, organizations need clearly defined CI/CD and DevOps processes in place, as well as automated testing, monitoring, and deployment.

How to Assess What Microservices are Used for in the Context of Your Business

  • Does making small changes to my application require me to perform expensive and timely redeployment of the entire software suite?
  • Could my internal and external users benefit from features being deployed in a timelier manner?
  • Will faster deployments help us reach market faster and make us more competitive in our space?
  • Will decoupling our current application strengthen our system and result in increased reliability?
  • Does our monolithic application host a large amount of functionality that is unneeded?
  • Is our current application able to effectively utilize the scalability and flexibility offered by the cloud?
  • Do certain services need to be able to scale rapidly and on-demand?
  • Could you benefit from leveraging the features of multiple programming languages for specific parts of your application?
  • Are you dealing with large amounts of data that have heterogeneous characteristics where individual services could benefit from utilizing their own data store?

Polyglot Persistence In Microservices

In a monolithic and SOA architecture, a single data store must be utilized across all services.

Unfortunately, the large data volumes involved in larger applications feature data that have extremely varied characteristics and requirements for processing. A single data store is often not the ideal approach to structure and process all the sets of data that can be collected by an application.

In a microservices architecture, each service is able to utilize its own data store, leaving developers free to choose the database type that best fits the characteristics and processing requirements of the service.

The ability of an application to choose different database technologies for individual services is known as polyglot persistence.

Below is an example of what data persistence looks like in a monolithic, service-oriented, and microservices architectures.

Polyglot Persistence of Microservices

Microservices Containers And Orchestration

Containers allow individual services to be deployed independently, and without the unnecessary requirement of having to deploy a full embedded OS as with virtual machines. With containers, services are encapsulated with a lightweight run-time environment. Each container includes everything required for the service to run.

This makes containers a good fit for microservices as it increases the speed at which applications can be deployed, increases fault resistance, and enables them to work across platforms. By far the most popular tool for building, storing, and running containers is Docker.

Ok, so you have your containers. Now what? Now you will need a centralized way to efficiently arrange, coordinate, and manage your services to align with business requests. This is accomplished with a container orchestration tool. These tools enable systems to scale automatically and reduces the time required to deploy multiple instances of a single application.

There are several container orchestration tools on the market. Currently, the most popular container orchestration tool is Kubernetes. Kubernetes is often used in conjunction with Docker to orchestrate Docker containers.

Now that you know the answers to what are microservices and why are they important, you might start looking into an initiative of your own.

3Pillar Global draws on deep experience in using microservices as an integral part of the digital products we create for our clients. Contact us today to learn more.