Mastering Microservices: From Monolith to Scalable Cloud‑Native Architecture

Overview

Microservices is an architectural style that splits a large application into small, autonomous, loosely‑coupled services, each handling a specific business function and communicating via lightweight protocols such as HTTP. The evolution typically follows Monolith → Service‑oriented → Microservices.

What is a Microservice?

A microservice can be developed, deployed and scaled independently, making the system more flexible, scalable and maintainable.

Challenges of Microservices

Increased system complexity due to many services.

Communication overhead between services.

Data consistency and distributed transaction management.

Deployment and operation complexity.

Higher team communication and coordination costs.

Service governance and version management.

Inherent distributed‑system difficulties (latency, consistency, fault tolerance).

Popular Open‑Source Solutions

Dubbo – a high‑performance Java RPC framework originally from Alibaba.

Spring Cloud Netflix – integrates Netflix OSS components (Eureka, Ribbon, Hystrix, Zuul, etc.).

Spring Cloud Alibaba – Alibaba’s ecosystem (Nacos, Sentinel, RocketMQ, etc.).

Comparison of the Three Solutions

Key differences include development language (all Java), service governance completeness, registration & discovery mechanisms (Eureka/Consul for Netflix, Nacos for Alibaba), load‑balancing strategies, RPC vs REST calls, circuit‑breaker implementations, configuration centers, API gateways, distributed transaction support, rate‑limiting, tracing, mesh support, community activity and maturity.

Service Registry

A registry stores service metadata to enable service discovery and registration. Core functions are service registration, discovery, load balancing, fault recovery, and governance.

Spring Cloud Registry Options

Eureka – Netflix’s service‑discovery framework.

Consul – HashiCorp’s distributed service discovery and configuration tool.

ZooKeeper – Apache’s coordination service.

Nacos – Alibaba’s dynamic service discovery and configuration platform.

etcd – CoreOS’s distributed key‑value store.

Configuration Center

Centralizes configuration (e.g., DB URLs, ports, log levels) to avoid per‑instance manual changes, reducing operational cost.

Spring Cloud Config – stores configs in Git/SVN.

ZooKeeper – can be used as a config store.

Consul – provides KV store for configs.

etcd – distributed KV store.

Apollo – Ctrip’s open‑source config center.

Nacos – also offers configuration management.

Nacos Configuration Mechanism

Config storage (default Derby, optional MySQL).

Clients register config on startup.

Clients pull config via API.

Clients can listen for changes (push on update).

Remote Call

HTTP vs RPC

HTTP is an application‑layer protocol focused on request‑response semantics, typically using text‑based payloads (JSON, XML). RPC abstracts method invocation, can use various transports (TCP, UDP) and binary formats (ProtoBuf, Hessian).

Feign vs Dubbo

Feign is a declarative HTTP client integrated with Spring Cloud, while Dubbo is a full‑stack RPC framework offering service registration, discovery, load balancing, fault tolerance, and more.

Feign Details

Feign simplifies HTTP calls with annotations and can integrate Ribbon for client‑side load balancing and Hystrix for circuit breaking.

<code>@FeignClient(name = "example", url = "https://api.example.com")
public interface ExampleService {
    @GetMapping("/endpoint")
    String getEndpointData();
}</code>

First‑Call Latency

Ribbon’s lazy loading causes the first Feign call to be slower; pre‑warming the client mitigates this.

<code>ribbon:
  eager-load:
    enabled: true
    clients: service-1
</code>

Authentication Propagation

<code>@Configuration
public class FeignClientConfig {
    @Bean
    public RequestInterceptor requestInterceptor() {
        return template -> template.header("Authorization", "Bearer " + getToken());
    }
    private String getToken() { return "your_token"; }
}
</code>

Load Balancing Algorithms

Round Robin

Weighted Round Robin

Random

Weighted Random

Least Connection

Hash

Service Resilience

Circuit Breaker & Fallback (Hystrix example)

<code>import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;
@Service
public class MyService {
    @HystrixCommand(fallbackMethod = "fallbackMethod")
    public String myServiceMethod() {
        // actual service logic
    }
    public String fallbackMethod() {
        // fallback logic
    }
}
</code>

Sentinel Rate Limiting

<code>@SentinelResource(blockHandler = "blockHandlerForGetUser")
public User getUserById(String id) {
    throw new RuntimeException("getUserById command failed");
}
public User blockHandlerForGetUser(String id, BlockException ex) {
    return new User("admin");
}
</code>

<code>List&lt;FlowRule&gt; rules = new ArrayList<>();
FlowRule rule1 = new FlowRule();
rule1.setResource(resource);
rule1.setCount(20);
rule1.setGrade(RuleConstant.FLOW_GRADE_QPS);
rule1.setLimitApp("default");
rules.add(rule1);
FlowRuleManager.loadRules(rules);
</code>

API Gateway

An API gateway provides unified entry, routing, load balancing, security, caching, monitoring, protocol conversion, and version management for backend services.

Spring Cloud Gateway Core Concepts

Route – defines match rules and target URI.

Predicate – conditions to apply filters.

Filter – request/response processing.

Distributed Tracing

Tracing helps locate failures across many services and optimize performance. Common solutions include Zipkin, Jaeger, SkyWalking, and Pinpoint, typically integrated via Spring Cloud Sleuth.

Distributed Transactions (Seata)

Seata supports AT, TCC, SAGA, and XA modes, using a transaction coordinator, manager, and resource manager to achieve two‑phase commit.

Monitoring & Alerting

Prometheus scrapes metrics from services; Grafana visualizes them and defines alerts.

Log Collection

The ELK stack (Elasticsearch, Logstash, Kibana) collects, stores, and visualizes logs. Alternatives include Fluentd, Graylog, Loki, Filebeat, and cloud‑provider solutions.

In interviews, Spring Cloud Netflix is the most discussed microservice solution, followed by Spring Cloud Alibaba; Dubbo is often treated as an RPC framework.