From Monolith to Microservices: A Complete Evolution Guide

Architecture Evolution

Monolithic Architecture

All code runs in a single process. Advantages: simple development, no network overhead, unified management. Disadvantages: hard to maintain, difficult upgrades, tight coupling, poor scalability, single‑point failure, and inability to use heterogeneous technologies.

Vertical Split

Large systems are divided by business domains (e.g., flash‑sale, fresh food, supermarket). Each domain runs in its own process, enabling independent deployment and maintenance. Advantages: independent deployment, modularity. Disadvantages: increased storage complexity, code duplication; each module remains monolithic.

Distributed Services

Business logic is split into independent services that communicate across processes. This reduces code duplication but introduces challenges such as data consistency, increased operational cost, and network overhead. Guiding principle: “don’t over‑distribute”.

Microservice Architecture

Microservices are a refined form of distributed services where each service is small, independently deployable, and language‑agnostic. Key characteristics include high availability, horizontal/vertical scalability, and the ability to use different languages or versions for each module.

Service‑Oriented Architecture (SOA)

SOA defines a component model that splits applications into services with well‑defined interfaces and protocols.

Microservice Development Versions

Version 1.0 – Centralized Proxy (Nginx) – Manual configuration for service registration and discovery; simple client implementation.

Version 2.0 – Embedded Client (Consul) – Automatic registration, health checks, and client‑side load balancing; more complex client code.

Version 3.0 – Service Mesh – Sidecar proxies manage registration, discovery, and traffic; still emerging and mainly used by large companies.

Essential Technology Stack for Microservices

Service Communication : WebService, WCF, WebAPI, ASHX/ASPX – supports active triggers, data serialization, cross‑platform and cross‑language calls, and HTTP firewall traversal.

Process Communication : Net Remoting (Windows only) and gRPC (high‑performance, open‑source, HTTP/2 based).

API Gateway (Ocelot) : .NET Core open‑source gateway offering routing, aggregation, service discovery, authentication, rate limiting, circuit breaking, and built‑in load balancing. Documentation: https://ocelot.readthedocs.io/en/latest/index.html.

Authentication & Authorization : IdentityServer4 implements OpenID Connect and OAuth2.0 for ASP.NET Core. Repository: https://github.com/IdentityServer/IdentityServer4.

Transient Fault Handling : Polly library provides retry, circuit‑breaker, timeout, and fallback policies. Repository: https://github.com/App-vNext/Polly.

Distributed Tracing : SkyAPM visualizes request flows across services. Repository: https://github.com/SkyAPM/SkyAPM-dotnet.

Logging : Centralized logging with Exceptionless (real‑time log collection) and the Elastic Stack (Elasticsearch, Logstash, Kibana, Beats). Repos: https://github.com/exceptionless/Exceptionless.

Configuration Center : Apollo (by Ctrip) provides centralized, real‑time configuration management with permission and workflow controls. Repository: https://github.com/ctripcorp/apollo/.

Distributed Locks : Implementations include Consul, Redis (recommended), Zookeeper, and relational databases.

Distributed Transactions : Approaches include 2PC, 3PC, TCC, local message tables (RabbitMQ recommended), and the Saga pattern.

Containerization : Docker packages applications and dependencies into portable images; runs on Linux and Windows.

Container Orchestration : Kubernetes automates deployment, scaling, and management of containerized workloads.

CI/CD : Jenkins provides continuous integration and automated build/test pipelines.

Key Concepts and Practices

Service Discovery & Governance : Early versions relied on manual Nginx proxy configuration; later versions use Consul for automatic registration and health checks; Service Mesh adds sidecar proxies for fine‑grained traffic control.

Scalability & High Availability : Horizontal scaling via load balancers (Nginx, Consul, Service Mesh) and container orchestration (Kubernetes) ensures fault tolerance.

Observability : Combine distributed tracing (SkyAPM), centralized logging (Exceptionless/ELK), and metrics collection to monitor system health.

Resilience : Use Polly for retry and circuit‑breaker patterns; design idempotent services to tolerate transient failures.

Security : Centralize authentication/authorization with IdentityServer4 to protect APIs across multiple client types (web, mobile, desktop).