A Quick Guide to Microservice Architectures

Microservices explained in just a few minutes.

Microservices are a popular architectural paradigm that addresses the limitations and drawbacks of legacy applications. To understand the foundation of microservices, we need to take a look at the history and evolution of application design: from monolithic to multi-tier to microservice-based architectures.

The Monolithic Era

A straightforward way to build a simple application is to design it as a single piece of code encapsulating data storage and access, business logic, processes, and user interfaces. That used to be the way applications and systems were designed and built in the early days. Soon, however, this all-in-one code model showed its limits when building complex, intricate systems. Since everything is tangled together, it becomes quickly difficult to maintain, evolve, and scale such applications.

The Rise of Multi-Tier Architecture

Software engineers proposed a solution to this complexity problem: the multi-tier architecture, where application components are separated into layers based on technical functions. A common model is the three-tier architecture. It consists of three logical layers:

• Presentation Layer: Covers all the code and components responsible for the interaction with users through visual interfaces.
• Logical Layer: Encompasses all the business logic and processes relative to the business functions.
• Data Layer: Deals with storing, accessing, and retrieving data when needed.

While separating logic and data into different layers made things better, it was still a centralized way of designing applications and didn't quite address the challenges associated with complex applications and systems.

A Paradigm Shift for Modern Complexity

Application complexity has been exponentially growing with the advent of global, high-growth web and mobile applications. Maintaining, evolving, and scaling very complex applications, like Amazon's e-commerce website or Google's search engine, required a design paradigm shift.

Here again, the best way to tackle complexity is by decomposing it into manageable chunks. That is why software engineers decided to break apart the logic and data layers into smaller pieces called microservices. Every microservice deals with one business function end-to-end, independently from other microservices. Microservices present simple, easy-to-understand APIs and communicate with each other through lightweight, common protocols such as HTTP or message queues.

Benefits of a Microservice Approach

When an application is architected as microservices, different teams can work separately and independently on different microservices, building new functions and evolving business capabilities without impacting other teams and business functions. Theoretically, teams could even use different programming languages and deploy their microservices to different infrastructures. However, for cost reduction, efficiency improvement, and operational optimization reasons, most organizations limit team choices to a set of approved tools, infrastructure providers, and programming languages.

The Challenges of Distributed Systems

As applications continue evolving and growing, the number of microservices inside an organization could expand to tens, hundreds, or even thousands. As this happens, complexity starts creeping in again. For example, if a microservice instance fails in production, it could generate a cascade of outages within other microservices. Since the architecture is highly distributed, it can become difficult to identify the root cause and fix it in a timely manner.

The software engineering community has been creating and inventing numerous new tools to tackle and contain the ever-growing complexity of highly distributed, microservice-based systems. Some of the popular solutions include:

• Containerization: Helps deploy microservices in minimalist, self-contained runtimes such as Docker containers.
• Container Orchestration Systems: Manage container life cycles, such as Kubernetes.
• Pipeline Automation: For CI/CD.
• Asynchronous Messaging: Further decouples microservices by providing message brokers and queues.
• Application Performance Monitoring (APM) Tools: To track microservice performance.
• Logging and Audit Tools: Help keep track of everything happening within the system.

A Final Note

We need to understand that microservices are not a magic bullet that fixes all application design and development problems. Applications are still designed as monolithic when they are relatively simple, with a limited number of users, and not fast-evolving. Remember that highly distributed systems are hard.