Microservices - Definition & Overview

Microservices are an important innovation in application development and deployment. The microservice application architecture represents a new approach to software development where developers build the application as a set of modular components or services, each with a specific task or business objective. Each of these modular components is known as a microservice, and microservices can interface with each other using Application Programming Interfaces (APIs).

Microservices have gained popularity in recent years as an alternative to the more traditional monolithic software architectures that developers used in the past. Software developers have adopted the microservices architecture and approach as a means of improving the process of building, testing and delivering software. New paradigms in software development such as continuous delivery (CD) and the use of containers also support the microservices architecture model.

Software architecture refers to the basic structure and organization of an application from the perspective of developers. Software developers implement a software architecture by defining the software elements required to facilitate the application's function, the relations between those elements, and the properties of the various elements and relations that make up the application.

There are many types of software architectures that developers may choose to design or implement, but perhaps the best-known and most frequently compared alternative to the microservices architecture is the monolithic software architecture. We can compare three types of software architecture to further understand how microservices are implemented.

Monolithic Software Architecture

Monolithic architecture is a software development method used to create a single-tiered application where the user interface and data access code are combined into a single program on a single platform. A monolithic software application is a single executable that can perform every task needed to deliver a specific function.

Monolithic applications are defined by the absence of modularity - the entire system functions as a whole, rather than as a system of parts. Monolithic applications are also self-contained, meaning that they exist independently from other computing applications and are typically not designed to communicate with other applications directly.

Service-oriented Architecture (SOA)

Microservices are a specific example of a service-oriented software architecture. SOA is a strategy or methodology for software architecture design where application components are used to supply specific services to other applications over a network, using an agreed or specified communication protocol or APIs.

In the SOA paradigm, a service is defined as a functional unit of code that performs a specific tasked, and that can be remotely and independently accessed and updated by software developers. Services are self-contained to facilitate individual access and they may consist of other underlying services working together to deliver the required task or function.

Microservices Software Architecture

Microservices are a variation on the existing service-oriented architecture model. Just like in SOA, microservice applications use specific application components to deliver services to other parts of the application over a network. The key difference between microservice architectures and SOA are granularity and the implementation of lightweight protocols to manage communication between services.

Granularity

Granularity is a key consideration in the software development process. In defining the microservice architecture, development teams should determine how many microservices are required to deliver an application and how large or complicated each microservice should be. Developers want to divide applications into more parts to increase modularity and enable continuous delivery, but dividing the application into too many parts can result in excessive runtime overhead and complexity.

Lightweight Protocols

Streamlined and simplified communication between microservices is necessary to ensure that an application comprised of many microservices can execute tasks in a reasonable amount of time. Software developers use lightweight communication protocols, such as HTTP resource APIs, to ensure that microservices running their own individualized process can communicate with each other efficiently. Some software developers are using a new technology called "Service Mesh" to streamline and secure data transfer between microservices that make up an application.

The microservices architecture is used to build flexible software systems that can be independently deployed. The term "microservices" was established in 2012 by a group of software architect who had all begun experiment with a fine grained approach to SOA that could be deployed at scale.

Over time, the benefits associated with microservices have become more important to software developers as the community moves towards new ways of conducting development, including continuous delivery and DevOps. Key benefits of microservices architectures include enhanced scalability, availability, modularity and maintainability of the application.

Scalability

With microservice-based applications, individual components of the application can be scaled as necessary without the need to scale all of the components together (as in monolithic applications). When scaling a monolithic application, developers have no choice but to deploy multiple instances of the entire application with no regard for which parts of the application are generating the excess demand. Developers that use microservices architecture can scale demand for individual services on an as-needed basis, which significantly reduces the overall resource cost associated with increased user-ship.

Availability

When applications are designed in the microservices architecture, applications benefit from increased availability and up-time. In a monolithic structure, the entire application will probably fail if any singular part of the code is broken. With the microservices architecture, the use of individualized and compartmentalized application components means that when a service fails, the rest of the services in the application are still operational. As a result, the failure or deactivation of a single service does not cause the entire application to fail.

Modularity

Software developers that use the microservices architecture benefit from the modularity that it offers. A modular application consists of individual components that can be selectively deployed, modified, or toggled on/off. An additional benefit to microservices is that they can be re-packaged and re-deployed into new applications where the same function is required. This means that a software development company can re-purpose individual modules of code for new applications without needing to rewrite them.

Maintainability

Applications that use the microservices architecture are easier and less costly to maintain compared to those that employ monolithic application architectures. If an individual microservice needs to be updated, it can be toggled off, updated and re-deployed without making the entire application unavailable.

Each microservice is connected to a single business function, and each contains only a fraction of the code of the entire application. This makes it easier for developers to trace a known error back to the relevant source code, more easily understand what the code is doing, and fix the problem without negatively impacting other microservices.