This article explains the purpose of a service registry in micro‑service architectures, introduces the CAP theorem, categorises registration approaches, and compares major products such as Eureka, Consul, Nacos and Zookeeper, highlighting their consistency, availability, and operational trade‑offs.
This article explores the challenges of building a unified observability data platform for hybrid‑cloud microservices, examines six common data‑island scenarios, and presents DeepFlow's AutoTagging and MultistageCodec techniques that dramatically reduce tagging overhead and storage costs while enabling seamless cross‑data correlation.
This article explains how to build a high‑concurrency Netty long‑connection server cluster using Redis publish/subscribe to forward messages across nodes, detailing the background, technology choices, architecture, and implementation steps for a microservice‑based backend system.
The article details the architecture, challenges, and solutions of ByteDance's wallet asset platform that unified reward issuance, display, and usage across eight applications during the 2022 Spring Festival, covering high‑traffic order processing, token‑based asynchronous settlement, budget control, stability mechanisms, and future evolution.
This article explains why microservice architecture improves flexibility and scalability, outlines a clear learning roadmap, and details essential components such as Docker, orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, tracing, data persistence, caching, and cloud providers, helping readers start or migrate to microservices.
This article explains how service registration centers decouple providers and consumers in microservice architectures, discusses the CAP theorem trade‑offs, categorizes registration approaches, and compares popular solutions such as Eureka, Consul, Nacos, CoreDNS, and ZooKeeper across key features and integration aspects.
The article offers a practical, step‑by‑step guide for small‑to‑medium full‑stack projects using Serverless—detailing why to choose it, preferring Tencent Cloud event functions with code deployment, adopting a lightweight custom PHP framework, organizing work by API with test‑driven development, and streamlining deployment via a one‑click GUI tool for rapid, cost‑effective iteration.
The article explains the challenges of authentication in microservice architectures and compares several solutions—including CAS single sign‑on, distributed session with Redis, client‑side token with JWT, and a recommended Spring Cloud + Spring Security + OAuth2 + JWT approach—detailing their workflows, advantages, and drawbacks.
The article details the background, architecture, early challenges, redesign principles, business and technical issues, and future plans of JD Daojia's product governance system, illustrating how a micro‑service based backend platform detects and resolves compliance problems such as sensitive words, inaccurate weight, and image violations.
This guide explains how to leverage Zadig v1.11.0’s environment self‑test mode to create isolated developer sub‑environments for large‑scale microservice projects, using Istio’s traffic routing and SkyWalking tracing, detailing prerequisite components, configuration of a PiggyMetrics Spring Boot example, and step‑by‑step verification via Kubernetes commands and curl requests.
This article shares the author’s experience and reflections on software architecture, covering its definition, iterative evolution, closed‑loop feedback design, microservice adoption, the impact of organizational culture, and the mindset and soft skills required of modern architects.
The article explains microservices architecture, detailing its defining characteristics, the role of domain‑driven design and bounded contexts, how aggregates and context mapping help define service boundaries, and discusses communication patterns, eventual consistency, event‑storming, and the backend‑for‑frontend approach for building resilient, loosely‑coupled systems.
This article describes the motivation, micro‑service architecture, code implementation, V1.0 browser‑based NLP prototype, V2.0 AI‑enhanced version with BM25 and BERT, integration with ChatUI, DingTalk bot, command‑based automation, and future plans for the internal intelligent QA chatbot named Jarvis.
This article details how a Java Spring Boot microservice's response time was reduced from 5‑6 seconds to under one second by applying gzip compression, parallel data fetching, short‑lived caching, MySQL index tuning, and JVM G1 garbage‑collector adjustments.
This article explains how microservice architecture leverages Domain‑Driven Design concepts such as bounded contexts and aggregates, uses context mapping and Event Storming to define service boundaries, and discusses communication patterns, eventual consistency, and Backend‑for‑Frontend design to build resilient, loosely‑coupled distributed systems.
This article explains the concept of cloud native, its definition by the CNCF, the history of containers and Docker, the role of Kubernetes as the orchestration backbone, and related technologies such as micro‑services, service mesh, immutable infrastructure and declarative APIs, highlighting their business value and evolution.
The article explains how micro‑service architectures create data‑consistency challenges that require distributed transaction strategies, compares strong‑consistency protocols like 2PC/3PC with eventual‑consistency approaches such as TCC and Saga patterns, and discusses their trade‑offs, implementation complexity, and suitability for real‑world scenarios like a points‑based sign‑in system.
This article explains Spring Cloud's role in building distributed micro‑service systems, illustrates an e‑commerce order‑payment scenario, and details the core components Eureka, Feign, Ribbon, Hystrix, and Zuul, showing how they work together for service registration, discovery, load balancing, fault tolerance, and API routing.
This article analyzes the challenges of aggregating multiple RPC calls in e‑commerce app backends, explains simple and complex concurrency scenarios, introduces grouped concurrency scheduling, and presents a self‑driven concurrency model that automates dependency handling to improve response latency and maintainability.
This article uses Taobao as a case study to trace the evolution of server‑side architecture from a single‑machine setup to a cloud‑native, micro‑service ecosystem, detailing each scaling stage, the associated technologies, and design principles needed to handle tens of millions of concurrent users.
The article explains how to design resilient distributed systems by minimizing inter‑component dependencies, duplicating or denormalizing data, isolating failures with SLAs, protecting callers and callees, and adding buffers such as asynchronous messaging and elastic scaling to handle random faults as systems grow.
The article explains the AKF principle for microservice design, detailing how X‑axis horizontal replication, Y‑axis functional splitting, and Z‑axis data‑centric partitioning address single‑point failures, capacity limits, and performance bottlenecks by employing master‑master, master‑slave, and master‑backup replication patterns.
YouLai Mall is an open‑source full‑stack e‑commerce solution built with Spring Boot 2.4, Spring Cloud, Vue, element‑ui and uni‑app, offering microservice back‑ends, a management portal, WeChat mini‑program and mobile app, with detailed deployment instructions and source code links for rapid development.
This article explains how microservice architecture differs from traditional service‑oriented designs, outlines its key characteristics, and shows how Domain‑Driven Design, bounded contexts, aggregates, context mapping, and event‑storming can be used to define clear service boundaries and build resilient, loosely‑coupled systems.
This article explains a lightweight environment‑coloring solution for microservice architectures that binds color tags to instances, propagates them through HTTP headers, and uses dynamic routing to isolate test environments, reduce configuration overhead, and improve troubleshooting while supporting both HTTP and WZP protocols.
The article explains how to address single‑node limitations by clustering servers using the AKF microservice splitting principle, detailing X‑axis horizontal replication, Y‑axis business‑oriented partitioning, and Z‑axis data‑source segmentation to achieve scalable, fault‑tolerant backend architectures.
This article explains the role of Eureka as a service registry in Spring Cloud, describing its functions, architecture, components such as Eureka Server and client, and how it enables service registration, discovery, load balancing, and fault tolerance for microservices.
This article outlines Huolala's journey through five architectural stages—monolith, RPC, SOA, microservices, and service mesh—detailing the motivations, challenges, and technical choices such as Dubbo, Spring Cloud, and Istio that shaped its high‑availability, cloud‑native backend platform.
This article provides an in‑depth overview of modern backend architecture, covering microservice fundamentals, service mesh concepts, observability pillars, messaging queue choices, and practical design considerations such as service registration, configuration centers, and security mechanisms.
This article details the five‑year evolution of a commercial advertising platform, the performance and architectural challenges it faced, the step‑by‑step Go‑based microservice reconstruction, and the resulting tenfold improvements in capacity, latency, and cost efficiency.
This article walks through the step‑by‑step evolution of a high‑traffic e‑commerce site—from a single‑machine setup to cloud‑native microservices—detailing each architectural milestone, the technologies involved, and the design principles that guide scaling from hundreds to millions of concurrent users.
This article examines five popular service registries—Zookeeper, Eureka, Nacos, Consul, and ETCD—explaining their core concepts, architecture, CAP trade‑offs, health‑check mechanisms, multi‑data‑center support, and provides guidance on selecting the most suitable registry for different technology stacks and availability requirements.
This article traces Taobao’s architectural evolution—from a single‑machine setup to distributed clusters, caching layers, load‑balancing proxies, database sharding, microservices, ESB, containerization, and finally cloud‑native deployment—highlighting the technologies and design principles that enable scaling from hundreds to tens of millions of concurrent users.
This article outlines the key microservice design patterns—including decomposition, integration, event‑driven, saga, and observability techniques—while explaining their goals, principles, and practical considerations such as database per service, CQRS, and cross‑cutting concerns like health checks and circuit breakers.
This article examines the challenges of high‑cost test case maintenance and low‑efficiency regression, then details how HTTP and microservice traffic replication, automatic seed case generation, and integrated CI/CD‑driven interface and process automation can dramatically improve testing speed, coverage, and quality.
This article outlines the step‑by‑step evolution of a high‑traffic e‑commerce backend—from a single‑machine setup to cloud‑native microservices—illustrating the technologies and design principles needed to scale from hundreds to tens of millions of concurrent users.
Using Taobao as a case study, this article traces the step‑by‑step evolution of a high‑traffic backend—from a single‑machine setup through database sharding, caching, load balancing, microservices, containerization, and finally cloud deployment—highlighting the technologies and design principles that enable scaling to millions of concurrent users.
This article explains how to achieve graceful service shutdown and various deployment techniques such as blue‑green, rolling, and canary releases using Spring Cloud, Eureka, and related actuator endpoints, providing code examples and practical guidance for maintaining uninterrupted user experience during upgrades.
This article walks through constructing a welfare‑center microservice using Domain‑Driven Design, detailing a four‑layer architecture, strict naming conventions for POJOs, method naming rules, code‑style guidelines, directory layout, and concrete Java examples for adapters, services, domain objects, and infrastructure components.
This article examines real‑world load‑balancing implementations for ultra‑high traffic cases such as Alibaba's Double 11 shopping festival, China's 12306 railway ticketing system, WeChat's red‑packet service, and Douyin's Spring Festival gala, highlighting architectural principles, DPDK usage, ECMP routing, session synchronization, SET‑based sharding, and service‑mesh techniques.
This article walks through Domain‑Driven Design fundamentals, distinguishes strategic and tactical design, introduces the four‑color modeling archetypes, and demonstrates their application in an e‑commerce microservice case study, highlighting how DDD bridges business requirements and code architecture.
This article explains the concept of Proxyless Service Mesh, compares it with traditional sidecar‑based meshes, outlines its advantages and drawbacks, and details how the Dubbo-go framework integrates with Istio to provide interface‑level service discovery, traffic management, and cloud‑native tooling.
This comprehensive technical tutorial demonstrates how to implement and configure core Dapr features, including publish/subscribe messaging, resource bindings, virtual actors, distributed tracing, secrets management, and dynamic configuration, using Java applications deployed on Kubernetes with practical code examples and command-line instructions.
During the Chinese New Year, the author reflects on the declining state of Chinese football and draws parallels to large‑scale digital transformation projects, exploring how component‑based, cloud‑native architecture and domain‑driven design can address the complexities of enterprise business systems, improve modularity, and enable rapid, resilient evolution.
This guide walks you through setting up distributed logging for microservices using Spring Cloud Sleuth for tracing, Zipkin as the tracing server, and the ELK stack for log collection and visualization, covering configuration, code examples, and log querying.
This article explains the Nacos architecture, the principles of service registration and discovery, and how Spring Cloud integrates with Nacos through auto‑configuration, heartbeat mechanisms, and dynamic address updates, providing a comprehensive guide for building cloud‑native microservices.
This article explains how to achieve a full‑link gray (canary) release in a Spring Cloud Alibaba microservice architecture by marking traffic at the gateway, propagating the gray tag through request headers, customizing Ribbon load‑balancing, and configuring Nacos metadata for selective service routing.
This article introduces Tencent's open‑source Polaris platform, explains its core concepts and features such as service discovery, load balancing, circuit breaking, and dynamic routing, and shares practical experiences of deploying Polaris in Qidian's microservice environment.
This article outlines the core high‑availability techniques—system splitting, decoupling, asynchronous processing, retry, compensation, backup, multi‑active strategies, isolation, rate limiting, circuit breaking, and degradation—providing practical guidance for designing resilient, scalable backend architectures in large‑scale internet applications.
This article explores two common microservice authentication and authorization architectures, compares a dedicated auth server versus gateway‑handled OAuth2 flows, and provides a step‑by‑step implementation using Spring Cloud Gateway, Spring Authorization Server, Spring Security, OpenID Connect, and token relay techniques to secure resources.
The article explains how to address single‑point failures and capacity limits in server clusters by applying the AKF principle, detailing X‑axis horizontal replication, Y‑axis business‑function splitting, and Z‑axis data‑access splitting to achieve robust, scalable microservice architectures.
This article explains what microservices are, how they differ from traditional monolithic apps, illustrates their benefits and drawbacks with an Amazon product‑page example, describes containers and Docker, and shows why Kubernetes is a natural platform for managing microservice‑based systems.
This article uses Taobao as a case study to trace the step‑by‑step evolution of a high‑traffic backend system—from a single‑machine setup through caching, load balancing, database sharding, microservices, ESB, containerization, and finally cloud‑native deployment—while highlighting the key technologies and design principles at each stage.
This article presents sixteen practical Spring Boot best‑practice recommendations—including custom BOM management, auto‑configuration, project initialization with Spring Initializr, clean controller design, service layering, database isolation, constructor injection, logging, testing, and configuration externalization—to help developers build maintainable, high‑quality microservices efficiently.
This article examines how Service Mesh and API Gateway differ in responsibilities, explores the east‑west versus north‑south traffic concepts, discusses two implementation philosophies, and traces the evolving integration of sidecars, BFF, and unified gateway solutions in modern microservice architectures.
The article explains how to address single‑point failures, limited capacity, and performance bottlenecks when scaling a single‑node service by introducing the AKF microservice design principle—X‑axis horizontal replication, Y‑axis functional separation, and Z‑axis data‑driven partitioning—detailing each split type with diagrams and practical considerations.
This article chronicles Lyft's evolution from a PHP monolith to a Python and Go microservice architecture, detailing the development and testing environments—including Devbox, Onebox, integration testing, pre‑release staging, and the migration to Kubernetes—while highlighting the scalability and productivity challenges faced as the service count grew to hundreds.
This article outlines essential architectural practices for high‑concurrency systems, covering load‑balancing strategies, distributed microservice design, caching mechanisms, database sharding, asynchronous message queues, and CDN usage to achieve scalable and resilient backend services.
This article compares popular API gateways such as Nginx, Zuul, Spring Cloud Gateway, Kong, and Traefik, explains their core features and selection criteria, and details a custom Traefik‑based microservice gateway architecture built with Etcd and Go.
This article compares three popular open‑source message brokers—RabbitMQ, Kafka, and Redis—examining their scalability, persistence, consumer models, and ideal use cases to help developers select the most suitable asynchronous communication solution for their microservice architecture.
This article presents sixteen essential Spring Boot best practices—from managing dependencies with a custom BOM and leveraging auto‑configuration, to structuring packages, using constructor injection, handling concurrency, externalizing configuration, and comprehensive testing—helping developers build maintainable, high‑performance Java microservices.
This article explains microservice fundamentals, their advantages, and how to design data architectures that support independent services, covering database-per-service versus shared databases, polyglot persistence, scaling strategies, and a detailed MongoDB case study with practical guidelines.
This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, detailing strategic and tactical patterns, bounded contexts, domain events, and the translation of domain models into microservice architectures, while highlighting the benefits of clear communication and modular design.
Kratos v2 is a lightweight, highly pluggable Go microservice framework that replaces the monolithic v1 design with a toolbox of interchangeable components—such as transport, middleware, logging, configuration, and service discovery—organized in a DDD‑inspired layout and extensible via protobuf‑defined plugins.
This article presents sixteen practical Spring Boot best‑practice recommendations—from managing dependencies with custom BOMs and leveraging auto‑configuration to structuring packages, handling concurrency, externalizing configuration, and adopting testing strategies—aimed at building clean, maintainable microservices.
This guide explains how to set up distributed logging for microservices using Spring Cloud Sleuth for tracing, Zipkin as a trace UI, and the ELK stack (Elasticsearch, Logstash, Kibana) for log collection, storage, and visualization, including detailed configuration and code examples.
The article argues that launching a brand‑new project using microservices often incurs excessive infrastructure, cultural, and operational costs that outweigh the touted benefits, and suggests that a well‑designed modular monolith can be a more pragmatic alternative for many teams.
This whitepaper explains Google’s BeyondProd security framework, detailing how cloud‑native microservice architectures replace traditional perimeter models with zero‑trust principles, mutual authentication, service mesh, and automated tooling such as ALTS, Binary Authorization, and gVisor to protect workloads across shared infrastructure.
This article guides readers through the evolution from a monolithic e‑commerce application to a highly available, scalable, low‑latency event‑driven microservices architecture, covering design patterns, principles, API gateway, BFF, service aggregation, CQRS, event sourcing, and technology stack choices such as Kafka and Cassandra.
This article details the architecture, core services, user interfaces, and technical challenges of Baidu's product promotion system, explaining the roles of traffic owners and advertisers, the CPS billing model, dynamic library reporting, and database batch‑write optimizations for high‑throughput e‑commerce scenarios.
This article shares sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOM management and auto‑configuration to proper package layout, constructor injection, concurrency awareness, externalized configuration, logging, testing, and global exception handling—to help developers build clean, maintainable Java microservices.
This article explains how to design a service registry that enables service registration, discovery, high availability, and dynamic handling of service instances in a microservice architecture, covering registration methods, consumer/provider interaction, push/pull mechanisms, long‑polling, and heartbeat health checks.
This guide explains how to use Alibaba Cloud's Application High Availability Service (AHAS) to monitor QPS, define granular rate‑limiting rules, prevent abuse, isolate upstream failures, and protect both HTTP and non‑HTTP workloads in microservice architectures.
This article explains how Sohu Smart Media built a high‑performance tracing system for microservices by integrating Zipkin for data collection with StarRocks for storage and analytics, covering architecture, data models, SQL queries, Flink processing, and real‑world results that boost observability and engineering efficiency.
This article walks through the step‑by‑step evolution of a basic single‑server e‑commerce system into a large‑scale, distributed architecture, explaining core concepts, each architectural upgrade, the technologies involved, and key design principles for building scalable, high‑availability services.
This article explains the concept of cloud native, its origins in CNCF, the evolution of containers, Docker and Kubernetes, the role of micro‑services, service mesh, immutable infrastructure and declarative APIs, and highlights the key benefits such as rapid iteration, automated deployment and independent scalability.
This comprehensive guide walks you through evolving a monolithic e‑commerce application into a highly available, scalable, low‑latency, event‑driven microservices system capable of handling millions of requests, covering design patterns, principles, best practices, and technology choices.
This article explains the necessity of a unified account management system for enterprise applications, defines key authentication terms, outlines the background and goals of token-based security, details the OAuth2 password‑grant flow with JWT, and discusses technical choices, interface design, and token renewal processes.
From early monolithic MVC setups to growth‑stage distributed systems and finally fully cloud‑native microservice architectures, this article outlines each phase’s characteristics, technology choices, scaling strategies, and operational practices such as CDN, load balancing, Redis Cluster, Kubernetes auto‑scaling, and unified configuration management.
Zhihu describes its journey from a custom Kodor RPC framework to a full Istio service‑mesh deployment, detailing the background challenges, Consul‑based service discovery, migration strategy, traffic management, platform tooling, and the numerous operational pitfalls encountered along the way.
This article provides a comprehensive overview of the microservice ecosystem built on Spring Cloud Alibaba, detailing essential modules such as service registration, discovery, load balancing, configuration, messaging, gateway, circuit breaking, distributed tracing, and transaction management, and includes practical code snippets and configuration examples for each component.
This article explains how the Finder system combines multi‑language code‑coverage collection, differential analysis, and call‑graph tracing to provide fine‑grained testing metrics, automate test‑case identification, and support continuous quality assurance across complex backend and frontend projects.
This article walks through the fundamentals of Apache Dubbo, covering its service discovery, RPC communication, traffic management, configuration, and deployment architecture, and provides a step‑by‑step SpringBoot implementation of a simple RPC service with Zookeeper registration, including code snippets for provider, consumer, and controller.
This article outlines the three‑stage evolution of software architecture—from early monolithic MVC systems, through growth‑phase optimizations with CDN, load balancing, and caching, to fully distributed cloud‑native designs featuring microservices, elastic scaling, DevOps pipelines, and unified configuration, illustrating key technologies and best practices.
This article outlines the step‑by‑step evolution of Taobao's backend architecture—from a single‑machine setup to distributed clusters, caching, load balancing, database sharding, microservices, containerization, and finally cloud‑native deployment—highlighting the technologies and design principles involved at each stage.
This article walks through Taobao’s journey from a single‑server setup to a cloud‑native, micro‑service architecture capable of handling tens of millions of concurrent requests, explaining each scaling step, the technologies involved, and key design principles for high‑availability systems.
This article explains microservice fundamentals, outlines their advantages, and provides detailed guidance on data design, database selection, and scaling techniques—including decoupling, lightweight APIs, DevOps CI/CD, polyglot persistence, and sharding—to help architects build robust, flexible microservice systems.
This article explains the principles of microservices architecture, the role of bounded contexts and domain‑driven design, and practical techniques such as context mapping, event storming, and BFF patterns for defining service boundaries, handling communication, and achieving resilient, loosely‑coupled systems.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, differences from monolithic development, key characteristics, comparison with SOA, practical implementation steps, common design patterns, and the pros and cons of adopting microservices in modern software systems.
The fourth‑edition Cloud‑Native Technology Survey (2021‑2022) analyzes how banks, insurers, securities firms and payment providers adopt containers, Kubernetes, micro‑services and hybrid‑cloud solutions, revealing adoption rates, pain points, security concerns and strategic recommendations for the financial industry’s digital transformation.
NextRPC is a multi‑stage RPC model that delivers partial responses over multiple network channels, improving latency and conversion in Taobao’s transaction and recommendation services; it employs a hybrid asynchronous streaming and parallel execution architecture with client‑side orchestration and server‑side sub‑request handling, achieving over 5% UV lift and up to 25% recommendation uplift.
This comprehensive guide explains the definition of software architecture, its essential concepts, layered classifications, various architecture levels, evolution from monolith to microservices, common pitfalls, and metrics for evaluating architectural soundness, providing practical insights for architects and developers alike.
This article provides an extensive introduction to software architecture, covering its definition, essential concepts such as systems, subsystems, modules, components, and frameworks, various architectural layers and classifications, architectural levels, strategic versus tactical design, evolution from monoliths to micro‑services, common pitfalls, measurement criteria, and recommended learning resources.
This article traces Airbnb's architectural journey from a single‑Ruby‑on‑Rails monolith through a microservices era to its current hybrid micro‑macro service model, highlighting the motivations, challenges, and engineering practices that shaped each transition.
This article introduces microservice concepts, explains GoKit's architecture and onion model, and walks through building a simple calculation service in Go, progressively adding logging, metrics, and middleware using the decorator pattern to achieve a clean, decoupled three‑layer design.
The article examines the practical difficulties of integrating services within a microservice architecture—such as circular dependencies, third‑party system coupling, and non‑idempotent APIs—and proposes concrete design principles like one‑way dependencies, minimal redundant data, façade services, idempotency, and contract testing to preserve system health.
This tutorial walks you through OpenFeign in Spring Cloud, explaining its purpose, differences from Feign, setup steps, various parameter passing methods, timeout handling, logging enhancement, HTTP client replacement, GZIP compression, and circuit‑breaker integration with Sentinel, all illustrated with code snippets and diagrams.
The article details Meituan's five‑year journey in instant logistics, describing how distributed, high‑concurrency system architecture evolved through layered upgrades, microservices, fault‑tolerance mechanisms, AI‑driven optimization, and AIOps platforms to achieve scalability, low latency, high availability, and cost efficiency.
Meituan’s instant logistics platform evolved from vertical services to a micro‑service, distributed architecture that handles massive order‑rider matching, ultra‑low latency, and high availability, leveraging AI for pricing, ETA, scheduling, and employing robust scaling, consistency, and disaster‑recovery techniques.
The article describes Meituan's five‑year journey in instant logistics, detailing how its distributed, high‑concurrency architecture has evolved through layered upgrades, micro‑service adoption, and AI integration to achieve low latency, high availability, cost efficiency, and scalability while addressing challenges such as massive order matching, peak traffic, data consistency, and fault tolerance.
