From Monolith to Microservices: Tracing the Architecture Evolution

Introduction

The rapid growth of software scale and business complexity has driven higher demands for performance, throughput, stability, and scalability. This pressure has spawned new architectural concepts such as distributed systems, SOA, microservices, and middle platforms.

Architecture Evolution

1. Monolithic Architecture

All code runs in a single process, offering simple development and no distributed overhead, but suffers from tight coupling, difficult maintenance, poor scalability, and forced simultaneous deployments.

2. Vertical Splitting

Large systems are divided by business domains (e.g., flash sale, fresh produce, supermarket), allowing independent deployment and maintenance, but increasing storage complexity and code duplication.

3. Distributed Services

Business functions are further modularized into independent services, reducing duplication and improving reuse. However, this introduces challenges such as data consistency across services, increased architectural complexity, and network overhead.

4. Microservice Architecture

Microservices extend distributed services by breaking them into many small, independently deployable units. Key benefits include language‑agnostic development, low coupling, rapid market response, and fine‑grained scaling, while drawbacks involve higher development difficulty, increased operational cost, and network latency.

5. Service‑Oriented Architecture (SOA)

SOA defines components as services with well‑defined interfaces, laying the groundwork for later microservice implementations.

Microservice Development Versions

1. Centralized Proxy – Nginx (V1.0)

Manual service registration and discovery via configuration files.

Basic load‑balancing (round‑robin, weight, hash).

Simple client implementation.

2. Embedded Client – Consul (V2.0)

Automatic service registration and discovery.

Health checks and automatic removal of unhealthy instances.

Client‑side load balancing.

3. Service Mesh (V3.0)

Sidecar proxies manage service registration, discovery, and traffic control. The control plane orchestrates all sidecars. Adoption is still limited to large enterprises.

Essential Microservice Technology Stack

Service Communication

WebService, WCF, WebAPI, ASHX/ASPX provide cross‑platform and cross‑language HTTP communication.

Process Communication

Net Remoting (Windows‑only).

gRPC – high‑performance, open‑source RPC framework (recommended).

API Gateway – Ocelot

Ocelot, an open‑source .NET Core gateway, offers routing, request aggregation, service discovery, authentication, rate limiting, circuit breaking, and built‑in load balancing.

Authentication & Authorization

IdentityServer4 implements OpenID Connect and OAuth2.0 for ASP.NET Core applications.

Project: https://github.com/IdentityServer/IdentityServer4

Transient Fault Handling

Polly provides resilience policies such as retry, circuit‑breaker, timeout, and fallback for .NET applications.

Project: https://github.com/App-vNext/Polly

Distributed Tracing

SkyAPM‑dotnet offers application performance monitoring for microservices.

Project: https://github.com/SkyAPM/SkyAPM-dotnet

Logging

Exceptionless – real‑time log collection for .NET, ASP.NET Core, etc.

ELK/Elastic Stack – Elasticsearch, Logstash, Kibana, and Beats for centralized log management.

Exceptionless: https://github.com/exceptionless/Exceptionless

Configuration Center

Apollo (by Ctrip) provides centralized configuration management for Java and .NET clients.

Project: https://github.com/ctripcorp/apollo/

Distributed Locks

Consul, Redis (recommended), Zookeeper, database‑based locks.

Distributed Transactions

2PC, 3PC, TCC, local message tables (RabbitMQ recommended), Saga pattern.

Containerization

Docker packages applications and dependencies into portable images, enabling consistent deployment across environments.

Container Orchestration

Kubernetes automates deployment, scaling, and management of containerized applications, providing built‑in load balancing and self‑healing.

CI/CD

Jenkins offers a user‑friendly interface for continuous integration and automated testing.

Conclusion

The author records the learning journey of microservice architecture, summarizing each technology component and planning deeper exploration of each in future projects.