This article explains the fundamental concepts of API gateways, their design motivations, key architectural components such as routing, service registration, load balancing, resilience, and security, and provides a comparative overview of popular open‑source implementations like OpenResty, Kong, Zuul, and Spring Cloud Gateway.
This article provides a detailed overview of Spring Cloud fundamentals, including microservice architecture, core components, service discovery, load balancing, circuit breaking with Hystrix, differences between Eureka and Zookeeper, and practical usage of Ribbon, Feign, and Spring Cloud Bus, aimed at helping developers prepare for interview questions.
This article explores a range of advanced registry‑center capabilities—including console UI, service configuration, event tracing, topology mapping, traffic control, health‑check extensions, graceful release, framework adaptation, and DNS‑based discovery—to illustrate how to make a service registry more powerful and flexible.
This article walks through the evolution of an online supermarket from a simple monolithic web app to a fully fledged microservice architecture, detailing the motivations, design decisions, component breakdown, common pitfalls, and essential practices such as monitoring, tracing, logging, service discovery, resilience patterns, testing, and the role of service meshes.
This article explains Nacos's architecture, the principles of service registration, how Spring Cloud integrates Nacos via auto‑configuration, the implementation of NacosServiceRegistry, heartbeat mechanisms, registration workflows, provider address queries, and the dynamic service address perception using subscription and HostReactor.
This article explains Nacos's core components, the principles of service registration and health checking, how Spring Cloud integrates Nacos via ServiceRegistry and AutoServiceRegistration, the implementation details of NacosServiceRegistry, heartbeat mechanisms, and dynamic service address discovery using HostReactor.
This article provides a comprehensive overview of Kubernetes architecture, explaining the roles of the master and node components, the deployment creation process, pod fundamentals, service discovery, networking mechanisms, and how micro‑services are orchestrated within a cloud‑native environment.
This article explains how to assemble a production‑grade service registry by analyzing requirements, defining registration/discovery interfaces, comparing push and health‑check mechanisms, selecting long‑connection technologies, and choosing data‑storage and high‑availability strategies, all illustrated with JSON examples and design guidelines.
This article explains the Nacos architecture, its components, and how Spring Cloud integrates with Nacos for service registration, health checking, and dynamic service discovery, detailing the underlying mechanisms, code implementations, and the role of heartbeats in maintaining service health.
This article provides a detailed introduction to etcd, covering its purpose as a highly‑available distributed key‑value store, core Raft‑based architecture, key concepts, common application scenarios, step‑by‑step installation and cluster deployment, as well as essential command‑line operations for managing data, backups, and cluster members.
This article explains how native Kubernetes objects—ClusterIP services, CoreDNS, and kube-proxy—work together to provide reliable service-to-service communication within a cluster, covering traditional IP-based approaches, the Kubernetes network model, DNS-based service discovery, and traffic routing via DNAT.
This article explains the fundamentals of service governance in distributed systems, covering RPC communication, common anomalies, replica types, design principles, performance metrics, and the architecture and workflow of RPC frameworks, while also detailing key practices such as registration, discovery, load balancing, traffic shaping, version compatibility, circuit breaking, degradation, and rate limiting.
This article walks through the complete design of a service registry—from requirement analysis and interface definition to push mechanisms, health‑check strategies, long‑connection technology choices, data storage options, and high‑availability considerations—providing a practical blueprint for building a production‑grade registry.
This article provides a detailed introduction to etcd, covering its purpose as a highly available distributed key‑value store, core concepts like Raft consensus, key features, common use cases such as service discovery and configuration management, step‑by‑step installation for single‑node and cluster deployments, and essential etcdctl commands for managing data and cluster members.
Cloud NativeConfiguration ManagementDistributed Systems
This article compares monolithic and microservice architectures, outlines their respective strengths and weaknesses, explains gateway design, service registration/discovery mechanisms, and reviews open‑source solutions for API gateways, service registries, and configuration centers, providing a comprehensive guide for backend engineers.
This article provides a comprehensive overview of Spring Cloud’s core modules—including Eureka, Zuul, Ribbon, Hystrix, Feign, and Config—explains their roles in microservice architecture, compares Eureka with alternatives such as Nacos, ZooKeeper, Consul, and Etcd, and offers guidance on using service registries and API gateways in cloud‑native environments.
This article walks through the fundamental concepts of Kubernetes, explaining how the master node communicates with workers, how pods are scheduled onto nodes, where cluster state is stored, how services expose pods externally, and how replication controllers enable dynamic scaling.
This article provides a detailed analysis of Nacos as a service registry, covering its architecture, registration and discovery processes, health‑checking, Raft‑based consistency, Spring Cloud integration, and practical code examples for developers building micro‑service systems.
This article explains why microservice architecture is preferred over monolithic applications, outlines a clear learning roadmap, and details essential concerns such as Docker, container orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, distributed tracing, data persistence, caching, and cloud providers.
This article explores how Eureka’s heartbeat mechanism works in microservice architectures, comparing it to the Tang dynasty tribute system, and details who sends the heartbeat, its interval, the sending process, server handling, and the actions performed after receipt, with code examples and thread‑pool configuration.
This article explains the service discovery and configuration push mechanisms of Alibaba Cloud's managed Istio‑compatible service mesh ASM, demonstrates practical experiments with Sidecar clusters, shows how VirtualService rewrites work across mesh‑in and mesh‑out services, and provides step‑by‑step guidance to enable selective service discovery for performance optimization.
This article explains what Eureka is, describes its core concepts such as registration, renewal, fetching registries, cancellation and eviction, and provides step‑by‑step instructions with code to set up a Eureka server, a service provider and a consumer using Spring Cloud, illustrating load‑balancing and cache‑refresh behavior.
This article explains the Eureka heartbeat mechanism in microservice architectures, covering who sends the heartbeat, its scheduling interval, the request construction, server-side handling, and how the lease information is updated to determine service liveness.
This article demonstrates how to migrate a Spring Cloud microservice architecture from Eureka to Nacos using a dual‑registration/dual‑subscription model, covering configuration changes, code adjustments, graceful shutdown, load‑balancing behavior, and step‑by‑step deployment procedures.
This article provides a comprehensive overview of Kubernetes, covering container operation fundamentals, multi‑site deployment models, service discovery mechanisms, shared pod resources, common CNI plugins, layered load‑balancing approaches, isolation dimensions, and essential network model principles for large‑scale clusters.
This article provides a comprehensive overview of Kubernetes architecture, covering its core components, service discovery methods, pod shared resources, common CNI plugins, multi‑layer load balancing, isolation dimensions, and network model principles that enable scalable, high‑availability container operations.
This article provides a comprehensive overview of Kubernetes architecture, covering container operations, multi‑center deployment, service discovery mechanisms, shared Pod resources, common CNI plugins, multi‑layer load balancing, isolation dimensions, and network model principles.
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 explains how to achieve elegant service shutdown and various gray‑release strategies—including /shutdown, /pause, /service‑registry endpoints and EurekaAutoServiceRegistration—while also covering blue‑green, rolling, and canary deployments for zero‑downtime upgrades.
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 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 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 explains the core concepts, roles, and essential functions of service registries, compares five popular solutions—Zookeeper, Eureka, Nacos, Consul, and ETCD—examining their architectures, consistency models, health checks, multi‑data‑center support, and provides guidance for selecting the most suitable registry for your microservice ecosystem.
This article explains the internal DNS challenges of VIP‑based service routing, compares intrusive SDK‑based and non‑intrusive DNS approaches, and details how PolarisMesh supports both centralized and distributed DNS implementations, including their capabilities, configuration steps, and future enhancements.
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 article explains Kubernetes service discovery by first covering essential networking concepts, then detailing how Services provide stable endpoints, how they register with cluster DNS, how Endpoints track healthy Pods, and how kube-proxy routes traffic using iptables or IPVS to ensure reliable intra‑cluster communication.
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.
Service DiscoverySpring Cloud Alibabacircuit breaker
This article explains Kubernetes service discovery by first covering essential networking concepts, then detailing how Services provide stable endpoints, how they register with cluster DNS, and how kube-proxy and iptables/IPVS route traffic to dynamic Pods.
This article explains Kubernetes service discovery by first covering essential network concepts, then detailing how Services, Endpoints, and kube-proxy work together to provide stable, load‑balanced communication between dynamic Pods in a cloud‑native environment.
This article explains the fundamentals of RPC communication, detailing its roles, step‑by‑step call flow, underlying technologies, differences from local function calls, and compares major RPC frameworks while highlighting how it contrasts with RESTful APIs in microservice architectures.
This article explains the Nacos architecture, including its provider, consumer, name server, and server components, and details how Spring Cloud integrates with Nacos for service registration, heartbeat monitoring, and dynamic service discovery using Open API, SDK, and Raft-based consistency protocols.
This article provides a comprehensive overview of Kubernetes, covering its purpose for container operations, key functions, core components, multi‑center deployment, service discovery methods, pod resource sharing, common CNI plugins, load‑balancing layers, isolation dimensions, network model principles, and IP address classifications.
This article explains the typical architecture of RPC frameworks, detailing the roles of servers, registries, and clients, the core functions of service discovery, serialization, and network transport, and surveys popular implementations such as RMI, Thrift, gRPC, Dubbo, and others.
This article provides a concise overview of Kubernetes, covering its master‑node architecture, core components, deployment workflow, pod fundamentals, container orchestration patterns, scaling and rolling updates, as well as internal and external service networking mechanisms.
This article explains what etcd is, its origins, core features such as simplicity, security, speed, and reliability, and details eight practical scenarios—including service discovery, messaging, load balancing, distributed coordination, locks, queues, monitoring, and leader election—showing why it often outperforms Zookeeper in cloud‑native environments.
This guide provides a comprehensive overview of the Tars microservice framework, covering its core concepts, deployment methods across various environments, configuration management, service discovery, logging, monitoring, and operational features such as gray releases and circuit‑breaker strategies.
This article explains how to design and implement a microservice‑based PaaS platform using Docker containers, Spring Cloud Netflix components such as Zuul, Eureka, and Hystrix, covering service gateway routing, registration and discovery, deployment, fault tolerance, and dynamic configuration.
This tutorial walks through the fundamentals of service registration and discovery in microservice architectures, comparing Eureka, Zookeeper, Consul, and Etcd, and provides step‑by‑step Spring Cloud implementations for both Eureka and Consul with code samples and configuration details.
This article explains the fundamentals of Remote Procedure Call (RPC), walks through the complete request‑response flow, and provides a step‑by‑step Java implementation using Spring, custom XML namespaces, Netty for network communication, and Zookeeper for service registration and discovery.
This article explains the concepts, architecture, and workflow of service registration and discovery in microservice systems, outlines the roles of providers, consumers, and registries, and compares popular registration centers such as Eureka, ZooKeeper, and Consul to help you choose the right solution for your environment.
This article walks through a real‑world Kubernetes outage caused by DNS and Nacos client bugs, explains the chain of failures, and presents a failure‑oriented design that adds push‑empty protection and outlier removal using Alibaba Cloud MSE to keep microservices highly available.
This article explains the concepts, pros and cons of monolithic and microservice architectures, details the design of API gateways, outlines service registration and discovery mechanisms, and introduces open‑source configuration center solutions for modern backend systems.
This article presents a comprehensive roadmap for adopting microservice architecture, explaining why it is chosen, outlining essential concerns such as Docker, container orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, tracing, data persistence, caching, and cloud providers, and recommending popular tools for each component.
This article explores various service health‑checking techniques in microservice environments, detailing how consumers, providers, and registration centers can identify unhealthy nodes through passive and active checks, heartbeat mechanisms, TCP connection monitoring, and registration‑center probing, while weighing trade‑offs in reliability, timeliness, and resource consumption.
The article explains how Prometheus uses service discovery to automatically locate monitoring targets in large‑scale environments such as Kubernetes, describing file‑based, API‑query, and DNS‑record approaches, and provides example configuration snippets and validation commands.
This guide outlines why microservice architecture is preferred for large applications, presents a clear learning roadmap, and details each critical concern—such as Docker, orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, tracing, persistence, caching, and cloud providers—along with recommended tools.
This guide explains how Tencent's open‑source PolarisMesh service mesh can be combined with the Go implementation of gRPC to add service discovery, health checking, dynamic routing, circuit breaking, graceful shutdown, and traffic limiting, providing step‑by‑step code examples and integration architecture.
This article details the design and implementation of the Apex API gateway at Tencent, covering its architecture, dynamic routing, multi‑protocol support, distributed rate limiting, circuit breaking, service discovery, data masking, orchestration, testing automation, push services, observability, and future roadmap.
This article explains why microservice architecture is preferred over monolithic applications, outlines a learning roadmap, and details essential concerns such as Docker, container orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, tracing, persistence, caching, and cloud providers.
This article walks through a real‑world microservice outage, analyzes the risk chain, presents four high‑availability strategies, details service‑discovery and configuration‑management HA designs, and provides a step‑by‑step Kubernetes demo with code, monitoring, fault injection and results.
This article explains Nacos's architecture, the principles of service registration, how Spring Cloud integrates Nacos during startup, the implementation details of NacosServiceRegistry, heartbeat mechanisms, and dynamic service address discovery, providing a comprehensive guide for building resilient microservices.
This article provides a comprehensive overview of Spring Cloud's core modules—including service discovery with Eureka, client‑side load balancing via Ribbon, declarative REST calls using OpenFeign, fault tolerance with Hystrix, API gateway features of Zuul, centralized configuration with Config, and dynamic updates through Spring Cloud Bus—illustrated with diagrams and code examples.
This article explains how Kubernetes implements service discovery by detailing the underlying pod network, the role of Services as stable endpoints, the registration process via CoreDNS, the creation of Endpoints objects, and how kube-proxy routes traffic using iptables or IPVS.
This article explains what microservices are, how they communicate, compares Spring Cloud with Dubbo, outlines the relationship between Spring Boot and Spring Cloud, describes circuit breaking and service degradation, lists pros and cons, and compares Eureka and Zookeeper for service discovery.
This article provides a comprehensive overview of microservices, covering its origin, core architectural principles, key characteristics, advantages and drawbacks, suitable organizational contexts, and essential technical components such as service discovery, gateways, configuration centers, monitoring, circuit breaking, and container orchestration.
Service Discoveryarchitecturecontainer orchestration
This article provides a comprehensive overview of Kubernetes architecture, covering its core components, multi‑center deployment, service discovery mechanisms, pod resource sharing, common CNI plugins, load‑balancing layers, isolation dimensions, network model principles, and detailed IP address classifications.
This article walks through the Eureka dashboard’s System Status section, explains the meaning of each displayed metric, describes how the self‑preservation mode works and how to enable or disable it, and reviews cluster and instance information shown in a local Eureka cluster.
This article provides a comprehensive overview of microservices architecture, covering its definition, key characteristics, advantages and drawbacks, suitable organizational contexts, core components such as service discovery, gateways, configuration centers, monitoring, circuit breaking, as well as containerization and orchestration technologies.
This article provides a comprehensive technical overview of Spring Cloud, detailing its core modules such as Eureka, Zuul, Ribbon, Hystrix, Feign, and Config, analyzing registry and API‑gateway usage patterns, and comparing Eureka with alternatives like Nacos, ZooKeeper, Consul, and Etcd.
API gatewayCompetitive AnalysisConfiguration Management
This article provides a comprehensive overview of Spring Cloud's microservice architecture, detailing its core components such as Eureka, Zuul, Ribbon, Hystrix, Feign, and Config, comparing registration center alternatives, and explaining how these tools enable service discovery, load balancing, fault tolerance, and distributed configuration in cloud‑native applications.
This article provides a comprehensive overview of Spring Cloud’s core modules—including Eureka, Zuul, Ribbon, Hystrix, Feign, and Config—explains their roles in microservice architectures, compares registration centers such as Nacos, ZooKeeper, Consul and Etcd, and discusses best practices for API gateways and service discovery.
This article examines the five mainstream service registry centers—Zookeeper, Eureka, Consul, Nacos, and Kubernetes—explaining why a registry is needed, how they work, load‑balancing strategies, and provides practical criteria for choosing the most suitable solution in microservice architectures.
Tencent Cloud has open‑sourced Polaris Mesh, a cloud‑native service discovery and governance platform that registers over one million services, manages billions of instances, and processes trillions of daily API calls, offering unified registration, traffic routing, circuit breaking, access control, and mesh capabilities via SDK and sidecar modes, with an expanding roadmap and community invitation.
Tencent Cloud announced the open‑source release of Polaris Mesh, a high‑performance service‑mesh platform that unifies service discovery, traffic routing, fault tolerance, access control, and mesh capabilities, offering a scalable solution for enterprises transitioning to micro‑service architectures.
This article explains the purpose and components of RPC registration centers, analyzes Zookeeper's implementation and its limitations, recounts a real-world service‑mesh outage caused by Zookeeper, and discusses criteria for choosing a high‑availability, scalable, and disaster‑tolerant service registry solution.
This article explains the internal architecture of Nacos, its role as a service registry in Spring Cloud, the registration and heartbeat mechanisms, and how clients dynamically discover service instances using both Open API and SDK approaches.
This article explains the concept of load balancing, demonstrates how to register multiple Spring Cloud services, use DiscoveryClient and Feign for service calls, configure RestTemplate with @LoadBalanced, and dive into the source code of LoadBalancerInterceptor and RibbonLoadBalancerClient to customize load‑balancing strategies.
This article dissects Nacos client’s service subscription flow, detailing how the periodic UpdateTask triggers event registration, processes ServiceInfo, and uses NotifyCenter with DefaultPublisher to publish InstancesChangeEvent through a guarded thread and blocking queue mechanism.
This article demonstrates how to configure Spring Cloud Gateway with service discovery, two routing methods, integrate Hystrix for circuit breaking, implement global and custom token filters, and apply Redis‑based rate limiting, providing complete code snippets and configuration examples for a robust backend microservice architecture.
This article explains the difference between Nacos temporary (ephemeral) and persistent instances, how to configure them via Spring Cloud, their impact on health‑checking and service removal, and why the protection threshold uses both modes to prevent cascade failures in high‑traffic scenarios.
This article explains the proxy design pattern, demonstrates its static implementation with Java code, and shows how Nacos Client leverages a custom proxy delegate to switch between HTTP and gRPC protocols, highlighting structural roles, practical usage, and differences from the decorator pattern.
Youzan’s service registration and discovery architecture progressed from fine‑grained interface‑level registration on Etcd, through an intermediate application‑level discovery layer using Istio Pilot and the Tether sidecar, to a fully application‑level, sidecar‑driven model with CRD metadata, enabling scalable, cloud‑native multi‑region service mesh.
This article examines how Nacos leverages Java's reflection mechanism to instantiate its NamingService, explains the fundamentals of reflection, compares alternative approaches, and analyzes the architectural reasons behind choosing reflection in the Nacos client design.
This article provides a comprehensive overview of Kubernetes, covering its purpose for container operations, core components, multi‑site high‑availability design, service discovery mechanisms, pod resource sharing, common CNI plugins, layered load balancing, isolation dimensions, network model principles, and IP address classifications.
This article explains the simple factory pattern, compares its standard definition with Nacos's implementation, and walks through concrete Java examples showing how NacosFactory, NamingFactory, and related services create instances in the Nacos client.
This guide walks through creating a lightweight service registration and discovery mechanism using Spring Boot 2.2.10, Zookeeper 3.6.2, and Java, covering environment setup, Maven dependencies, configuration files, core Java classes, and a test controller to verify dynamic service lists.
This article explains Nacos's health‑check and heartbeat mechanism in detail, covering the client‑side heartbeat scheduling, metadata configuration, server‑side beat reception, instance health evaluation, and the periodic health‑check tasks that mark or remove unhealthy instances.
Apache Dubbo 3 modernizes the popular Java RPC framework by adopting cloud‑native principles, introducing an application‑level service discovery model, a next‑generation Triple RPC protocol, and seamless Kubernetes integration, while preserving its proven ease of use and performance benefits for large‑scale microservice deployments.
The article explains how Apache Dubbo 3 adapts to the cloud‑native era by introducing an application‑level service discovery model, the next‑generation Triple RPC protocol, and deep Kubernetes integration, highlighting performance gains, cross‑language support, and flexible deployment options for modern microservices.
This article explains how CoreDNS resolves both internal and external domain names in a Kubernetes cluster, demonstrates nslookup and host queries, shows how to capture DNS traffic with tcpdump, and analyzes the impact of the ndots setting on name resolution behavior.
The article analyzes the limitations of using ZooKeeper for service discovery, compares it with Alibaba's ConfigServer, discusses CAP trade‑offs, scalability, health‑check design, disaster recovery, and provides practical guidance on when to choose alternative registration solutions.
The article evaluates whether Kubernetes alone can replace traditional microservice frameworks by examining gateway choices, native service discovery, load balancing, circuit breaking, configuration management, and concluding that a hybrid approach often yields the best trade‑off between DevOps efficiency and business logic focus.
This article details a real‑world incident where a brief DNS resolution failure triggered a fatal bug in Nacos client 1.4.1, causing heart‑beat loss and complete service shutdown, and explains the root cause, code analysis, and recommended upgrades.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, comparison with monolithic and SOA approaches, core characteristics, practical implementation steps, common design patterns, advantages, challenges, and the mindset shift required for successful adoption.
This article explains the evolution from monolithic to microservice architectures, defines microservices, compares Spring Cloud and Dubbo solutions, and provides a detailed overview of Spring Cloud’s core components such as Eureka, Ribbon, Feign, Hystrix, Zuul, Gateway, Config, Bus, OAuth2, and Sleuth, illustrated with diagrams.
This article details the background, goals, architectural analysis, migration scope, step‑by‑step containerization process, code‑level challenges, and post‑migration results of moving a large‑scale live‑classroom platform from virtual machines to a Kubernetes‑based container environment, highlighting performance, reliability, and operational improvements.
This tutorial demonstrates how to configure Spring Cloud Gateway with service discovery, integrate Hystrix for circuit breaking, implement global and custom route filters, and apply Redis-based rate limiting, providing complete Maven dependencies, Java code examples, and YAML configurations for a robust microservice gateway.
This article examines why enterprises end up with multiple service registries, outlines two architectural strategies—embedding multi‑registry support in services or synchronizing registries—and compares their trade‑offs to recommend the most stable approach for microservice governance.
Service DiscoveryService Governancemultiple-registries
This article provides a comprehensive overview of Kubernetes, covering its core components, container operations, service discovery layers, pod shared resources, common CNI plugins, multi‑layer load balancing, isolation dimensions, network model principles, and various IP address categories for large‑scale deployments.