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.
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.
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.
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 dissects Nacos 2.0's UDP‑based service‑instance change notification, explaining client‑side listening, UDP port registration, server‑side storage, push logic, acknowledgment handling, and current design limitations, all backed by concrete Java code snippets.
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.
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.
This article provides a comprehensive overview of microservices, explaining their definition, core characteristics, advantages and drawbacks, suitable organizational contexts, and the essential technical components such as service discovery, API gateways, configuration centers, communication protocols, monitoring, circuit breaking, and container orchestration platforms.
This guide walks you through installing Nacos Server from source, starting it in standalone mode, using its management console, registering services and configurations via curl, and finally integrating Nacos with a Spring Cloud application for service discovery and config management.
This article reviews the seven‑year evolution of Ctrip's microservice service‑registry from manual data maintenance through an etcd‑based solution to the self‑developed Artemis system, detailing its architecture, consistent‑hash data partitioning, high‑availability design, and second‑level instance up/down mechanisms.
This article introduces Govern Service, a low‑cost SDK for service registration, discovery, and configuration built on Redis, and walks through Maven dependencies, provider and consumer implementations, YAML configuration, and configuration management with code examples.
This article provides an in‑depth overview of microservice architecture, covering its definition, historical development, differences from monolithic and SOA approaches, core characteristics, practical implementation concerns such as API gateways, inter‑service communication, service discovery, fault tolerance, common design patterns, advantages, drawbacks, and a shift in thinking required for successful adoption.
The guide shows how to download and start Nacos, configure Spring Cloud Alibaba projects for service registration and discovery, create provider and consumer services with load‑balanced RestTemplate or OpenFeign calls, and use Nacos as a dynamic configuration center with refresh‑scope support.
The article explains how network jitter can cause service registries to mistakenly drop providers, and presents heartbeat‑switch protection, node‑removal thresholds, and a static‑registry approach to keep consumer requests stable while minimizing latency and avalanche effects.
This article explains how TSF Mesh adapts Istio‑based service‑mesh capabilities to support both container and virtual‑machine workloads by redesigning application deployment, sidecar injection, traffic hijacking, and service registration/discovery, providing detailed architectural changes and code examples for enterprise‑grade service governance.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, contrast with monolithic development, core characteristics, distinctions from SOA, practical implementation steps, common design patterns, advantages, challenges, and recommended reading resources.
This article explains the architecture and core mechanisms of Eureka, a service registry used in Spring Cloud micro‑service environments, covering server components such as Lease and caching, client registration and discovery processes, self‑preservation mode, consistency trade‑offs, and comparisons with other discovery solutions.
This article explains internal service communication patterns, covering request/response and asynchronous messaging, their implementations, message formats, RPC and REST principles, service discovery methods, channel types, and key considerations for choosing a message‑queue component.
This article explains how Kubernetes Headless Services and DNS can be used to discover and connect to the IP addresses of all Pods behind a Service, with a step‑by‑step example using a MongoDB replica set.
This article reviews Nacos' evolution from its 1.x architecture—highlighting its five-layer design and service discovery issues—to the 2.0 version that introduces long‑connection RPC, a new client‑centric model, and improved performance, while also outlining upcoming roadmap plans.
This article provides a comprehensive overview of the Dubbo Java RPC framework, covering its historical evolution, protocol design, registry and clustering mechanisms, extensibility via SPI, generic invocation, and upcoming cloud‑native and reactive programming developments.
Spring Cloud provides a comprehensive suite of tools—including Eureka, Ribbon, Feign, Hystrix, and Zuul—that simplify service discovery, load balancing, fault tolerance, and routing, enabling developers to efficiently build, manage, and scale microservice architectures illustrated through an e‑commerce order‑processing scenario.
This article explains Nacos's service discovery model, including its multi‑layer namespace‑group‑service‑cluster‑instance structure, practical code examples for registering services and instances, customization options, isolation strategies, and both pull and push discovery mechanisms for robust microservice architectures.
This article provides a concise yet comprehensive overview of Kubernetes, covering its core architecture, the workflow of creating deployments, pod fundamentals, scaling and rolling updates, networking basics, service discovery, and external access methods such as NodePort, LoadBalancer, and Ingress.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, differences from monolithic and SOA approaches, core characteristics, practical implementation steps, common design patterns, advantages and challenges, and a mindset shift toward DevOps and Docker.
This article explains what microservice architecture is, its history, how it differs from monolithic and SOA approaches, outlines its key characteristics, practical implementation steps, common design patterns, advantages and disadvantages, and the mindset shift required for successful adoption.
This guide walks through configuring Spring Boot 2.3.9 with Spring Cloud Hoxton to register services in Zookeeper, set up provider and consumer applications, and achieve client‑side load balancing using Spring Cloud LoadBalancer.
Upgrading a Dubbo consumer from 2.6.6 to 2.7.3 can break version matching with providers, leading to “No provider” errors, and the article explains the root cause, code differences, and why the 2.7.7 fix may still fail.
This article explains how UCloud's Serverless container product Cube integrates Virtual Kubelet with Kubernetes, why kube-proxy is unsuitable for lightweight serverless VMs, and how an eBPF‑based Rust proxy (cproxy) provides efficient service discovery and superior performance across different service scales.
